* Add a top level directory called extras to contain useful extra files that don't ft into the main part of the distribution.
* Added extras/NVDA CD, which includes the files used to build the NVDA CD distributed by NV Access at CSUN and other exhibitions.

New misc-deps package, version 2009-08-20-01: New NVDAHelper.

Update for comtypes 0.6.1.

speech.getControlFieldSpeech(): Speak embedded objects; e.g. in virtual buffers.

Base virtualBuffer TextInfo: fix some exceptions by making sure an empty string is returned rather than None for methods that return text.

nvdaHelperRemote: Don't skip NVDA's process when injecting winEvent hooks. This makes sure that typed characters etc will be announced in NVDA's process (menu, elements lists etc).

MSHTML TextInfo: if the document's body is editable, then fall back to using the selection's textRange. It seems for editable documents such as composing mail in Outlook Express, there are textAreas for each paragraph, though they are never focused as such.

virtual buffers:
* Events are no longer fired on a virtual buffer before it has completed loading. This is more correct and should fix some exceptions.
* When a virtual buffer first gains focus, it fakes a focus event on the focus object, as the loaded buffer will probably miss the first focus event.
* When handling the first object focus for a buffer, always treat it as if the caret has not yet been moved within the focus. This is necessary when the focused node is right at the start of the buffer, which is where the caret is initially located. Fixes the plain text composer in Windows Live Mail.

IAccessibleHandler.winEventCallback: only normalize Mozilla windows to their content window class if the event's childID is negative. Positive childIDs are probably for plugins such as Flash. This again allows NVDA to announce the focus as it moves around plugins in Mozilla documents.

mshtml vbuf backend: Fix a crash caused by certain image nodes under rare circumstances; e.g. French Google Advanced Search.

MSHTML TextInfo:
*Refactored 'expand' method.
*Always use an IHTMLTxtRange retreaved from the control for the TextInfo even if the selection or caret is requested. In these cases, fetch a bookmark for the selection and move the real textRange to it. This fixes problems where expanding to sentence or story would bleed the textRange out of the control.
Fixes #388.

speech.speakObject: if the object should have its TextInfo reported, report the line at the caret, rather than the readingChun.

virtual buffer elements list dialog: Due to user dissatisfaction, don't filter the tree when typing into it. Instead, implement our own code which immitates the search behaviour when typing into a list view. (We have to use our own code because tree views don't allow space to be passed to the search.) Also, for users that do want to filter the list, add a filter edit field which filters the items in the tree. Hopefully, this will allow for the best of both worlds.

New misc-deps package, version 2009-08-18-01: New NVDAHelper.

MSHTML  vbufBackend: make sure not to render passwords in to the buffer. IE doesn't change the characters in to stars, so the backend does it instead.

bzr ignores: Add lib64.

Python virtual buffer code: Changes to support formatting for Adobe Acrobat.

NVDAHelper: adobeAcrobat vbuf backend:
* Render formatting information with the text. This requires retrieving the text using IPDDomNode. Re #381.
* Render the name as a text field before focusable controls except links, buttons, radio buttons and check boxes. Links and buttons have the name as their text.
* Don't incorrectly render the name as the text of empty editable text fields.

Installer: bad idea to have the uninst log to try and make sure the install dir is deleted. Go back to what we used to do as this just took waaaaay too long.

NVDAHelper: VBufBackend_t::renderThread_winEventProcHook(): Copy the runningBackends set before iterating it, as it might be mutated by called functions during iteration, which is bad. Fixes crashes after closing windows containing virtual buffers.

MSHTML virtualBuffer: make sure that textAreas have the multiline state. Fixes #389

New misc-deps package, version 2009-08-17-01: new NVDAHelper.

Unification and refactor of NVDA's in-process code. (#385) This reduces duplicated code and will greatly ease future improvement and maintenance of this code. A large part of this work is that nvVBufLib is now part of NVDAHelper.
User visible changes:
* Official support for 64 bit editions of Windows! Specifically, in 64 bit applications, NVDA will now detect typed characters and virtual buffers are now supported. (#309)
* Exiting chm help embedded in an application (e.g. Wordpad in Windows XP) no longer causes a DEP error crash. (#375)
* Support for text attributes in MSHTML virtual buffers. (#386)
* Hr and textarea HTML elements are now rendered correctly into MSHTML virtual buffers. (#387)
* Closing a tab in IE8 no longer causes a crash.
* Crashes with sites that open and close new windows in quick succession are now fixed.
* Probably several other crashes fixed.

installer: no need to check for and remove the lib64 directory on installation as old installers never had this directory anyway. Start the uninstall log recording in the installation before setting outPath to the installDir so that the log will automatically remove it on uninstallation.

Update what's new.

Merge main.

nvdaHelper sconstruct file: do not include .exp or .lib files in the lib or lib64 directories when installing. However pdbs are still included, if compiled not as a release.

Remove pointless bzr ignore.

* uninstaller: Rename all files/dirs to a temporary name before deleting. This avoids any problems if files/dirs cannot be deleted and NVDA is then reinstalled without rebooting.
* installer: Add code for lib64. Similar to the above change, rename lib and lib64 to temporary names before deleting to avoid potential problems caused by old uninstallers.

logHandler.Logger.exception: Log a few other errors that we expect but can't do anything about as debugWarning instead of error.

* logHandler.Logger: Add a method named exception() to log exceptions at an appropriate level. This should be used when the caller is uncertain of the severity of an exception. For now, it logs all exceptions at level ERROR, except for call cancelled COM errors, which are logged at DEBUGWARNING, as they are expected if the watchdog detects a freeze.
* Use log.exception for exceptions caught at a high level; i.e. the core pump, eventHandler.executeEvent and scriptHandler.executeScript.

nvdaHelper sconstruct: refactor for better readability. Export specific variables to each SConscript rather than globally. Force installation of files to be performed after all other targets are built (so that nothing gets installed if the build some how fails). Only build nvdaHelperRemoteLoader for x64, and only build nvdaHelperLocal for x86. Install all targets of libraries and programs to the install dir, rather than just the first target of each (e.g. the dll or exe). This means that lib and lib64 will now contain dlls, libs, exps and pdbs. This is mostly useful if compiling a debug build. NVDA's setup.py should be changed to only copy dlls from the lib dirs.  Also for better management, get rid of vbufBackends/sconscript and list each backend individually in the sconstruct file.

nvdaHelper.py: assign stdout and stderr of remoteLoader to nul. Although not doing this works ok on Windows 7, Vista and XP need this.

setup.py: include lib64 in the distribution.

nvdaHelperRemote: fix a bug where an application could crash on exit if a hook was fired after global c++ objects in nvdaHelperRemote had been destroyed. For example sometimes in Wordpad when exiting a winEvent hook would be fired, yet the inProcess_registeredWinEventHooks map had been destroied, so calls to its begin() method would crash the application. To fix this inProcess_isInitialized was replaced with two variables: inProcess_isRunning and inProcess_wasInitializedOnce. This provides a way for code to work out if nothing has been initialized yet, if the inProcess code is currently running, or if the code is not running but it was in the past. In short it means that no  custom hook code can run after the inProcess code has terminated, which would have happened in dllMain ore before.

nvdaHelper: if compiling a release (release=1), make sure to define NDEBUG so that assertions are disabled. Also only perform debugging beeps if NDEBUG is not defined.

nvdaHelperRemote: replace some fprintf calls with MessageBox calls for easier debugging. ia2Support: make isIA2Initialized   specific to one process, rather than storing it in shared memory as only ia2Support_initialize and ia2Support_terminate make use of it now. Add some asseritions. nvdaHelperRemoteLoader: double check return codes of initialization and termination of nvdaHelperRemote for easier debugging.

nvdaHelper.py:  in initialize start nvdaHelperRemoteLoader if nvda is running on an x64 processor. In terminate close stdin of nvdaHelperRemoteLoader if it is running, and wait for it to exit. These changes finally allow NVDA to fully work with 64 bit applications. This means that NVDA will now be able to announce typed characters in 64 bit applications, and it will be able to use virtualBuffers in 64 bit applications. An example of where this was previously a problem was pressing f1 in Windows Explorer on a 64 bit OS -- NVDA was not able to read documents in Windows Help and Support Centre as it was 64 bit.

Change NVDA virtualBuffer classes to use a backend name instead of a  path to the backend dll, as nvdaHelperRemote now calculates the dll path, in order to keep it working in 64-bit processes.

nvdaHelper changes to help it more easily find other dlls.
*Provide a 'dllDirectory' variable in nvdaHelperRemote which is located in shared memory and contains the directory name of the dll when it was loaded.
*IA2Support code in remote: make use of dllDirectory when calculating the IA2DllPath.
*Rename shared memory segments in nvdaHelperRemote to names that are a little more up to date... hookManager disappeared a long time ago.
*vbuf interface (createBuffer function): rather than taking a backend path, take a backend name (let code calculate the actual dll path).
*Move declarations from remote/hookRegistration.h in to remote/nvdaHelperRemote.h and remove hookRegistration.h. Its probably easier just for code to include nvdaHelperRemote.h.

Added remoteLoader, which is code that makes a very simple program that initializes nvdaHelperRemote.dll, waits until its standard input is closed, and then terminates nvdaHelperRemote.dll and exits. The reason for this program is so that nvda is able to load 64-bit versions of nvdaHelperRemote.dll and the vbufBackends etc. All it needs to do is start nvdaHelperRemoteLoader and leave it running for the time it expects  64-bit applications to be hooked with nvdaHelperRemote.

nvdaHelper libraries can now be build for 64-bit systems. add TARGET_ARCH=x86_64 to the scons command. scons install TARGET_ARCH=x86_64 will also install 64-bit librarys in to ..\lib64 rather than ../lib. As the latest stable SCons is rather broken in regards to the MS Windows SDK, please use an SCons development version from the SCons svn repository. Also added a small fix to SCons in regard to the Windows SDK in site_scons/site_init.py.

mshtml backend:
 * Render <hr> node as separator (adding isBlock=true, IAccessible role of separator and space as its content)
 * Properly render <textarea> even if it contains no text data
Fixes #387.

Updated .bzrignore

Rather than using nmake Makefiles to control the building of nvdaHelper, instead use the SCons build system.
SCons is a darn powerful build system equivilant to autotools and make all in one, that is written in Python.

*An sconstruct file and sconscript files have been added to control the build. A site_scons directory has been added which contains some custom code for SCons (for now just a builder for MSRPC stubs -- by default SCons can only do full type libraries).
*make.opts and all Makefile files have been removed as they are no longer needed.
*interfaces\vbuf\vbuf.acf has been removed as it seems we never needed it anyway since we explicitly give a binding/context handle as the first argument to all methods.
*The pragma preprocesser command above dllMain in the code for each dll has been removed --  msvc seems to do fine with out it -- I must have been reading some ... very old ... instructions.

Notes:
1. Please read building.txt to learn how to now build nvdaHelper.
 2. There is no longer a need to build from an msvc environment command prompt.
3. There is no longer a need to run midl on ia2 and acrobatAccess before building the first time. However if it isn't run a full type library is generated as well as the stubs, no real way to turn this off yet.
4. By default a version with debugging symbols is generated, provide release=1 to generate a release version.

mshtml backend:
 * Fixed italic text attribute. Now it is reported by NVDA.
 * added more formatting attributes such as following: bold,underline,strikethrough,superscript,subscript etc.

 * MSHTML backend: implemented retrieving of text format attributes such as font name, size, style (thus style doesn't tested) as well as text align. It works pretty well for me in virtual buffers.

MSHTML backend:
 * Don't try to get node attributes if nodeName is not supported (comment or script).
Receive current style 'visibility' and 'display' directly, removing unnecessary catching in map (as those are not used by AT). When text formatting will be implemented, attributes can be directly added to the node.
 * node.cpp CDispatchChangeSink constructor: use initializers instead of assigning initial values manually.

Update bzr ignores.

Revert the suppression of the NVDA error sound when log level is info. We might suppress it later for final release versions.

Changes to nvdaHelper to fix some errors when applications exit. Code for initializing and terminating thread-specific code has been removed.  It was too hard to detect when some threads terminated (in most cases there was no way for the code to be accurately notified).
Instead code should only initialize and terminate process-wide.
These changes also finally seem to fix a major problem in Internet Explorer 8 where closing a tab would freeze both IE and NVDA.
Specific changes:
*nvdaHelperRemote: hook registrations can only now be made process-wide, rather than thread-wide.
*nvdaHelperRemote: remove inThread_initialize and inThread_terminate.
*nvdaHelperRemote typedCharacter and inputLangChange code:  provide a blah_inProcess_initialize and blah_inProcess_terminate functions which register and unregister hooks as the inThread_* code is now gone.
*VBufBackend_t: no longer provide a threadID when registering and unregistering windows hooks for use with renderThread_initialize and renderThread_terminate as thread-specific registration is now gone. These registrations happen process-wide, which in most cases is not too bad.
*nvdaHelperRemote hook registration code: when iterating through registered hooks and executing them, firstly copy the hooks to a temporary list and execute them from there. This stops major errors if a hook is unregistered inside the execution of a hook -- the iterator would get quite broken.

VBufBackend_t: a Windows timer is used to minimize the amount of rerenders of the content. However previously the timer was registered specific to the root window of the backend, so then the timerProc would look for a backend with the same rootWindow and timerID. But it seems that SetTimer when given a window, can not accept no predefined timerID (0). We definitly can not predefine one as its rather possible that the host application may have already used that value. So, go back to the way it was done in nvVBufLib where the timer is only specific to the thread (window is 0), as SetTimer then does allow a timerID of 0, and it happily generates one for us.  As its specific to the thread though, a renderThreadID member was added to the backend so that the timerProc can find a backend with a matching threadID, and then a matching timer ID. To make things a little nicer code-wise, the setting and killing of timers has been wrapped up in to two new methods: requestUpdate and cancelPendingUpdate.

adobeAcrobat virtual buffer: Fix the form field quick navigation key.

VBufBackend_t: as renderThread_initialize is virtual, its impossible for VBufBackend_t's constructor to directly or indirectly call it. So instead of the constructor hooking and initializing the renderring thread code, VBufBackend_t::initialize has been added. This must be called after instanciating a backend. The same with the destructor VBufBackend_t::terminate has been added, which must be called before destroy to delete the backend. This fixes an error where starting a backend would cause a C Runtime error 'Pure virtual function call'

change: The NVDA error sound is no longer played if the log level is set to info (the default). Most errors aren't significant for most users, so this sound is undesirable. The log level can easily be changed to hear the sound when debugging a particular problem.

VBufBackend_t::renderThread_callWndProcHook: the backend is pcwp->wParam, not wParam! Fixes a crash.

Remove all unicode defines from nvdaHelper files, as it is now defined by the root Makefile.

Converted AdobeAcrobat, Gecko and Mshtml VBufBackends to be compatible with the new changes to the base backend in vbufBase. This meant removing lots of duplicated hooking and timer code from each, plus fiddling around a bit with static methods etc, and for AdobeAcrobat and Gecko at least, remvoing dllMain etc as it is not needed for these backends.

VBufBase/Makefile: link vbufBase_static.lib against nvdaHelperRemote.lib, so that it can access the hook registration functions.

VBufBackend_t::invalidateSubtree: make this method public again rather than protected, as it seems you can not access a protected instance method from a static method of the same class. Plus, I guess its ok to make it public as then an AT would be able to refresh any particular part of the page they liked.

VBufBackend_t::renderThread_terminate: if there is a pending timer to be fired, kill it off.

VBufBackend_t: remove renderThreadIsInitialized member as its not used. runningBackends is checked for the particular backend instead.

Updated czech language file, italian user guide and added italian what's new document

base backend (VBufBackend_t): Make quite a few methods and data methods private as they should not be accessible from higher backend implementations. Also removed getRootDocHandle and getRootId, and instead made their respective variables public, but const -- they can never be changed after backend instanciation.

Remove ServProv.idl, which is no longer required.

Remove our comtypes ITypeLib.ReleaseTLibAttr monkey patch, as this is now fixed in comtypes.

Update for comtypes trunk r531. Specifically, comtypes now includes IServiceProvider and a Pythonic implementation of QueryService, so use that instead of our own implementation.

make.opts in root of nvdaHelper: define UNICODE in CFLAGS so that anything compiled in nvdaHelper is unicode. Specific defines of UNICODE can now be removed from any files containing it.

Base VBufBackend class restructure to share much of the hooking and timer code currently duplicated in each of the backend implementations.

One advantage of this change is that it makes backend implementations much simpler. Another advantage is that Backends will no longer assume an application only has one main thread, and backends will better manage when the root window of the backend is destroied while the backend still exists.

None of the backend implementations have been updated yet, so they currently will no longer compile until they are.

Specific changes:
*VBufBackend_t::invalidateSubtree: after marking the node as invalid, it sets a timer (if not already set) which will rerender the invalid content by calling update. Backend implementations no longer need to manually set timers or provide timerProc functions.
*Added VBufBackend_t::renderThread_initialize and VBufBackend_t::renderThread_terminate. These functions are virtual so can be extended.  These functions replace mainThreadSetup and mainThreadTerminate currently in backend implementations.
*The constructor and destructor now manage registration of necessary hooks, and also send a window message to the root window, so that renderThread_initialize and renderThread_terminate are executed in the rendering thread.
*The base backend uses a winEvent hook to detect the destruction of the root window, or any ancestor of the root window, and calls renderThread_terminate. This is useful so that any code a backend implementation may have that  relies upon the rootWindow existing has a chance to terminate when the window goes away. The base backend's destructor checks if renderThread_terminate has been called yet, and if not makes sure its executed in the renderThread.
*The base backend class (VBufBackend_t) has a static set called runningBackends which holds any currently running backends. base implementations of renderThread_initialize and renderThread_terminate manage the adding and removal of the backends.

AdobeAcrobat virtual buffer: Normalise the bold and italic Acrobat font flags in format fields. This means that bold and italic text is now reported in these buffers.

* XMLFormatting: Don't lower case attribute names in format fields. We already stopped doing this for control fields a while ago.
* base VirtualBufferTextInfo: Introduce a _normalizeFormatField() which is called for format fields just as _normalizeControlField() is called for control fields.

nvdaHelperRemote: the hook registration infrastructure makes sure it only ever executes a particular  registered hook once in the firing of a hook. Previously it was possible to register the same hook callback multiple times and have it therefore get called multiple times. Now registering a hook once works normally, but registering it multiple times just increases an internal reference count on that hook. Therefore  to unregister the hook, the unregister function must be called the same amount of times as the register function. Apart from stopping some confusion and abuse of nvdaHelperRemote, this change also helps in a future implementation of VBufBackend_t that would not be able to handle the same hook function being registered multiple times.

Restructure What's New document to make it easier to follow. Remove entries prior to version 0.5.

Merged main

nvda.pyw: Use winUser instead of win32gui. Removes dependency on win32gui.

winUser: Add FindWindow, MessageBox and PostMessage functions. Remove really old and obsolete sendMessage2 function.

virtual buffers: Catch and cleanly log errors when loading buffers.

virtual buffer refreshBuffer script: Don't send the key on to the application if there is no vbufHandle, as this is an NVDA key.

Updated brazilian portuguese, finnish, spanish, galician and russian language files

nvdaHelperRemote: all hook registration functions now take an optional threadID incase code needs to register a callback for a thread other than its own.

VBufStorage: create a new class called VBufStorage_textContainer_t. It is a wrapper around a stl wstring class that provides saftey when using it across CRTs. VBufStorage_buffer_t::getTextInRange now returns a pointer to a VBufStorage_textContainer_t which contains the text, rather than taking a string by reference. VBufRemote_getTextInRange: handle the change to VBufStorage_buffer_t::getTextInRange. This change stops a crash when trying to use the VBufBackends from nvdaHelperRemote. NVDA now seems to work quite ok with virtualBuffers via nvdaHelper.

VBufBackend_t: add a 'destroy' method which must be used to destroy/delete the backend after you are finnished with it. 'destroy' simply calls 'delete this'. Make ~VBufBackend_t() protected so that it is impossible to  delete the backend outside itself. This all is so that if you get a backend by calling createBackend, you don't then delete it yourself as doing this from another CRT would cause a crash most likely.  VBufRemote_destroyBuffer: use backend::destroy rather than deleting the backend.

make.opts of nvdaHelper: fix typo.

logHandler: We currently capture stdout and stderr for unhandled exceptions and warnings, but the formatting sucks and warnings are logged as errors. Therefore, override the default Python exception and warning handling hooks to use our logger. Python warnings are logged at level debugWarning.

appModuleHandler.AppModule.__init__: create a connection with nvdaHelperLocal and store it on the appModule as helperLocalBindingHandle. __del__ destroies the connection. Base virtualBuffer: make use of the appModule's helperLocalBindingHandle as the binding handle to pass to createBuffer. Change all calls to the old VBufClient to instead go to nvdaHelper.localLib. Also VBufRemote_ calls are now just VBuf_ calls. NVDA seems to run now, though nvdaHelperRemote is making apps crash when dealing with virtualBuffers... will sort out in a future commit.

nvdaHelper: add a 'install' target to the root Makefile, so that you can run nmake install and have it compile and install in to ../lib. Note though that xcopy will still ask you if you wish to overwrite the dlls if they already exist.

nvdaHelper.py: rather than loading nvdaHelper.dll and calling it helperLib, load both nvdaHelperRemote.dll and nvdaHelperLocal.dll and call them remoteLib and localLib respectivly.  in terminate just set the remoteLib and localLib to None rather than deleting them. Use winUser.WINEVENTjPROC as the ctypes WINFUNCTYPE rather than redefining it for the winEventHook function.

Merged main (which now contains lessFreezing branch)

User visible changes:
* fix: NVDA will now attempt to recover from some situations which would previously cause it to freeze completely. It may take up to 10 seconds for NVDA to detect and recover from such a freeze.
* new: Virtual buffers are now rendered in the background, allowing the user to interact with the system to some extent during the rendering process. The user will be notified that the document is being rendered if it takes longer than a second.
* new: If NVDA detects that it has frozen for some reason, it will automatically pass all keystrokes through so that the user has a better chance of recovering the system.

Important notes for developers:
* CoCallCancellationHandler has been refactored into a new module called watchdog.
* A lot of low level IAccessible code, including constants, has been moved into a new module called oleacc.

Update what's new.

Merge main.

Partial fix for ticket #376:  password characters can be read in Internet Explorer. Now NVDA will only report asterisk characterswhen navigating around a password field in Internet Explorer (in focus mode). A fix for broase mode (so that they do not get rendered in the virtualBuffer) must be worked on in the MSHTML vbufBackend.

Changed mshtml VBufBackend to build with nvdaHelper. When building nvdaHelper vbufBackend_mshtml.dll is now produced.

Changed adobeAcrobat vbufBackend to be compatible with nvdaHelper and integrated it in to the build system. When building nvdaHelper now vbufBackend_adobeAcrobat.dll is built.

Fix up Gecko_ia2 vbufBackend to build against the new nvdaHelper  system. Specifically: change some includes.  Change constructor to no longer take a storage buffer as an argument. change createBackend to no longer take a storageBuffer as an argument. Change any code to use the backend rather than backend->getStorageBuffer(). Change the Makefile so that the backend links against the static vbufBase lib.  Change the root vbufBackends Makefile to build gecko_ia2.  All these changes now means that the gecko_ia2 vbufBackend (vbufBackend_gecko_ia2.dll) gets compiled with everything else.

Move all VBufBackends to a vbufBackends dir in the root of NVDAHelper as they are really separate dlls. move all vbuf/base and vbuf/common files in to a vbufBase dir in the root of NVDAHelper and change the Makefile to build vbufBase_static.lib (which is a static library that contains all the vbufBase code, that backends should link against). Fix up a few things in vbufBase missed in previous commits such as getting rid of a few more VBUFLIBENTRy and libEntry.h mentions. Also remove any mention of storageBuffer member from vbufBackend, instead just use the vbufBackend object itself.

Move some docs etc out of vbuf and in to the root of NVDAHelper. building.txt will have to be rewritten a bit.

nvdaHelperRemote changes:
*Rather than using VBufContainer, VBufRemote now loads a backend dll and uses the dll's createBackend function, and then uses the created backend as the buffer for all of the rpc functions.  So it can eventually free the backend dll, it keeps a map of active backends to dll handles.
*rpcSrv: change the order of some code so it can compile again.
*Initialize and terminate rpcSrv in inProcess_initialize and inProcess_terminate.
*Compile in rpcSrv and VBufRemote when building nvdaHelperRemote.dll.
*Fix a typo in rpcSrv.h.
*Export the hook registration functions from nvdaHelperRemote.dll as the VBufBackend dlls may want to make use of them.

These changes finally mean that nvdaHelperRemote now contains an rpc server, plus an implementation of the VBuf interface.

Note that None of this code has been tested, though it does seem to compile ok. VBufLib and the backends still need to be worked on further, and properly integrated in to the nvdaHelper build system.

Again prepend VBufRemote to  the bufferHandle and nodeHandle types in the VBuf interface. It is annoying that midl's /prefix does not add the given prefix to these data types.

vbufLib changes:
*VBufBackend_t now inherits from VBufStorage_buffer_t.
*move lock member from VBufStorage_buffer_t to VBufBackend_t as storage by itself really has no need for locking.
*Make acquire and release methods on VBufLock_t virtual so they can be accessed from VBufRemote stub functions.
*Make most public methods on VBufStorage_buffer_t virtual so they can be accessed from VBufRemote stub functions.
*Remove all mentions of the VBUFLIBENTRY define, and remove libEntry.h. As VBufStorage will soon be compiled in to each backend there is no longer the need to hack dll exporting.
*Remove container.cpp and container.h (VBufContainer) as its no longer needed. VBufRemote stub functions will use a backend directly.