sconstruct: Add certPassword option to specify the password for the private key in the certificate.
Fixes #1221.

What's New: Add a "Changes for Developers" which documents changes concerning developers.

Add support for mapping gestures to scripts anywhere in NVDA.
Currently, there are two global gesture maps: the user map and the locale map.
This allows users and locale maintainers to add new bindings and override existing bindings in a single file.
See the inputCore.GlobalGestureMap class for details.
The user map is stored in gestures.ini in the NVDA configuration directory.
The locale map is stored in locale\LANG\gestures.ini, where LANG is the language code.

Update What's New.

Implement loading of the locale gesture map.
This is stored in locale\lang\gestures.ini, where lang is the language code.
Also add some extra logging.

Add support for mapping gestures to scripts anywhere in NVDA.
Currently, there are two global gesture maps: the user map and the locale map.
This allows users and locale maintainers to add new bindings and override existing bindings in a single file.
See the inputCore.GlobalGestureMap class for details.
The user map is stored in gestures.ini in the NVDA configuration directory.
Loading of the locale map is not yet implemented.

Fixed hindi user guide so key commands are actually generated and the NVDA can be built.

Added hindi language file and user guide,
Added serbian user guide,
Updated italian language file,
Updated slovak language file and changes.

App modules no longer have key map files!
Instead, all gesture bindings are done in the app module itself. This keeps everything together in the one place, removes the appModules folder in the NVDA binary distribution (which only contains kbd files) and removes one stage of gesture mapping (which will be necessary to simplify future enhancements).
Note that desktop and laptop bindings, as well as bindings common to both, can all be provided in the same gesture map now, which eliminates another reason for these key map files.
The most common way to bind gestures is to use a magic __gestures dict on the class. bindGesture() can also be used on the instance. See the code doc for baseObject.ScriptableObject for more details.
It's not currently possible for users to override the in-built bindings. This is coming in future.

Source readme clarifications:
* Change "root of the NVDA source distribution/checkout" to just "root of the NVDA source distribution" to avoid confusion of "/" as a directory separator.
* Document that certFile expects a file in pfx format which must include the private key.

Correct the description for the current navigator object script in both NVDA and the english user guide. Input help now mentions that twice spells the information, and the user guide now mentions that 3 times copies it to the clibpard. Fixes #938.

Merge main.

setup.py: Fetch all data files in the call to setup() now. We no longer run generate.py from setup.py, so there's no need to delay this.

Changed the behaviour of the review follows caret option, so that  the review position will only move if the caret moves in the same object. Previously if the caret moved in any object, the review position would jump inside that object. Specific changes:
*NVDAObject.event_caret: only set the review position to the caret if the current navigator object is this object.
*VirtualBuffer._set_selection:  rather than unconditionally setting the review position to the new caret position, instead only do this if the current navigator object is the root of this virtualBuffer.
*TreeInterceptor._set_passthrough: if passthrough is turning on, and the focus is currently inside this treeInterceptor, and the review follows focus option is on, set the navigator object to the focus.
*TreeInterceptor._set_selection: if passthrough is turning off, and the navigator object is inside this treeInterceptor, and the review follows caret option is turned on,  set the navigator object to the root of this treeInterceptor.

Next release will be 2011.1.

sconstruct: Execute pygettext with the python executable, as not all systems will associate .py files with the interpreter.

Refactor the build process to allow anyone to prepare the source tree and create binary distributions, portable archives, installers, etc. with a simple command.
scons is used to facilitate this.
See the Building NVDA section of the source readme for details.

Notes:
* Of course, SCons is now required for anyone running from source.
* The nvdaHelper build process has now been incorporated into the new build process, so you do not need to run scons from source\NVDAHelper anymore.
* nvdaHelper builds will no longer be provided on the snapshots page. This means that the Windows SDK and several other dependencies are now required, as documented in the source readme.
* You should no longer run generate.py, setup.py or makensis directly. Instead, use scons as documented in the source readme.
* source\include and source\NVDAHelper have been moved out of the source directory.

sconstruct: Build the client archive relative to the extras\controllerClient directory.

sconstruct: pot no longer depends on sourceDir, as this depends on comInterfaces and nvdaHelper. Instead, just depend on *.py beneath sourceDir.

sconstruct: Rather than using normal scons mechanisms to create and remove _buildVersion.py*, do it as actions in the NVDADist builder. This is necessary because we want this to be removed immediately after NVDADist (not just when scons -c is run). Also, env.Clean() seems to make the file some sort of dependency, which causes problems for _buildVersion.pyc and _buildVersion.pyo which aren't scons targets.

Merged main

api.getReviewPosition(): Don't try to use a tree interceptor that isn't ready. Fixes exceptions when trying to use the review position in a document that hasn't finished loading yet.

Fix a bug where the "Use currently saved settings on the logon and other secure screens" button did not work if the systemConfig directory did not already exist, which is the case immediately after a clean install. Note that it did work after at least one secure screen appeared (as the directory gets created then).
Fixes #1194.

Hopefully fix exceptions when scripts are queued for objects in an app but the app closes before the scripts get executed.

Moved logLevel commandline option from NVDA's root sconstruct to nvdaHelper's, renaming it nvdaHelperLogLevel.

Added nvdaHelper/sconscript which for some reason was never added before, should have really be renamed from sconstruct.

Update bzr ignores.

Include nvdaHelper build dependencies in the source readme. Remove the separate nvdaHelper build instructions, as nvdaHelper is not built separately anymore.

nvda's root sconstruct: when cleaning _buildVersion.py, also get rid of  its .pyc and .pyo files as well.

Integrate generation of comTypes COM interfaces in to scons:
*Rename source/generate.py to source/generateComInterfaces.py, as that is all this file does now.
*NVDA's root sconstruct: generate comtypes COM interfaces in source/comInterfaces with the help of generateComInterfaces.py.
*source/setup.py: no longer call generate.py.

nvda root sconstruct: the release commandline option now only controls filenames and whether NVDA's Python will run optimized, it does not affect nvdaHelper. There is now a new scons commandline option called nvdaHelperDebug. If you set this to 1, then vdaHelper will be built with asertions enabled, debug symbols, it will use debug libraries, and it will not be optimized.

the output dir can now be specifically set on the commandline with outputDir=<dir>

gettext scons tool: import msgfmt and use it that way, rather than spauning a separate Python process each time its used. However to do this msgfmt.MESSAGES must be cleared after each use, and NVDA's root sconstruct must alert scons  that the gettextMoFile builder can not be run in parallel.

as txt2tags can not be run in parallel, make sure scons doesn't try, by making all the txt2tags target nodes  share a fake side effect.

Generate all archives and the pot etc in a directory called output to stop cluttering  NVDA's root directory, and also to make it easier for an automatic snapshot builder to collect up all created files. Also add a 'changes' target which  copies user_docs/en/changes.html to the putput directory as nvda_version_changes.html.

Move generation of html documentation from t2t files (including keyCommands)  from source/generate.py and into scons:
*Add a t2t scons tool in which provides a builder called txt2tags which converts a given t2t source file in to  an html file. Note that the real txt2tags module must be able to be imported by scons, so it either needs to be in Python's site-packages, or in nvda's root directory (not in source).
*Move keyCommandsDoc.py from source in to nvda's root directory.
*keyCommandsDoc: the maker now takes an output filename, not just an input file name.
*keyCommandsDoc: the maker now generates the output in a temporary file (for now the output filename with two underscores after) and then if successfull renames to the appropriate name.  The documentation for this function stated that the file was only generated if successfull, which was not the case.
*Ad a keyCommandsDoc tool function to nvda's root sconstruct which provides a builder called keyCommandsDoc which generates a keyCommands t2t from a given userGuide t2t.
*NVDA's root sconstruct: keyCommands.t2t files will be built from all userGuide.t2t files in user_docs, excluding  languages that are in a special keyCommandsLangBlacklist (this is currently cs and ja). The blacklisted languages do not have the newer format for their user guide.
*NVDA's root sconstruct: build html files from all t2t files in user_docs, including any keyCommands.t2t files.
*source/generate.py: remove now redundant code that generated keyCommands t2t files and converted t2t files to html files.

Updated spanish language file,
updated galician language file,
updated danish language file,
Updated polish language file,
Added serbian language file by Dejan Zubovic.

gettext scons tool:  execute msgfmt each time in a separate python process, as  if scons was building multiple files in parallel msgfmt would produce bad results as there is state kept at module level.

Move gettext mo file generation out of source/generate.py and in to scons:
*Added a gettext scons tool to site_scons/site_tools. This tool provides a gettextMoFile builder, which takes a gettext template file (.po) and compiles it using msgfmt to a .mo.
*NVDA root sconstruct: cause all of NVDA's po files to be compiled to mo files if source is being built.
*Removed locale compilation code from source/generate.py as its now redundant.

Integrate the building of nvdaHelper into NVDA's scons files:
*NVDA's new root sconstruct: declare and export clientDir, sourceLibDir and sourceLibDir64 variables, which can be used by nvdaHelper and client etc.
* Move source/include to include (at NVDA's root). also change all mentions of the path '#../include' to '#/include' in nvdaHelper's sconscript files.
* Move contents of nvdaHelper's site_scons to NVDA's root site_scons
*Move the nvdaHelper dir out of source and in to the root of NVDA.
* Rename nvdaHelper's sconstruct file to sconscript
* nvdaHelper's archBuild_sconscript: Remove the 'install' target, and at the same time no longer collect built targets to make them be required by the install target.
* NVDAHelper's sconscript (previously sconstruct):  no longer create a base environment from which to clone the arch-specific environments, instead Import  the environment called 'env' and clone from that.
*nvdaHelper's sconscript: import clientDir, sourceLibDir and sourceLibDir64, and pass arch-specific variants of these to archBuild_sconscript.
*nvdaHelper's archBuild_ssconscript: do not hardcode libInstallDir and clientInstallDir, instead import them (given by nvdaHelper's sconscript).
* Remove pointless print statements from NVDAHelper scons files
* Move the commandline variable declarations (such as targetArchitectures and logLevel) from nvdaHelper's archBuild_sconscript and in to NVDA's new root sconstruct.
* rename the 'isRelease' commandline variable in NVDA's new root sconstruct to 'release' to be compatible with nvdaHelper -- it uses it in quite a few places.
*NVDAHelper's remote, client and local sconscript files: change all mentions of the path '#interfaces' to '../interfaces' (we can no longer really use # as its now at NVDA's root.
*nvdaHelper's remote/apiHooks.cpp: explicitly include nvdaControllerInternal.h above common/log.h as for some reason now scons is failing to scan more than one level deep for implicit dependencies -- all other files including log.h already did this.
*NVDA's new root sconstruct: no longer build an nvdaHelper archive (its no longer needed)
*NVDA's new root sconstruct: there is now a target called 'client' which will build the nvda controller client archive.

Further notes:
*As dist (portable, installer etc) depends on source, any nvdaHelper related libs / EXEs that should be in source will automatically get built when needed.
*controller client will no longer get built just because the rest of nvdaHelper is built, unless you specifically tell scons to build the 'client' target.

nvdaHelper displayModel interface implementation of getWindowTextInRect: when collecting text from descendant windows, ignore windows that are invisible according to IsWindowVisible. This among other things stops text from other tabs bleeding through when reviewing a particular propertysheet in a multitabbed dialog (e.g. file / folder properties in Windows explorer).

Unneeded import.

Woops. Not called Tera Term Pro anymore.

Support for automatically reporting new text when it appears on the screen!
To avoid lag and spam, this must be enabled for individual controls using the LiveText and Terminal NVDAObject behaviors and the DisplayModelLiveText overlay class.
Specific support for mIRC, PuTTY, Tera Term Pro and SecureCRT has been included so far.
See those app modules for examples on how to do this for other applications.
Windows text consoles now use this new LiveText/Terminal behavior, which means they use the same monitoring code. This code is similar to the previous code in winConsoleHandler, but has been simplified and improved somewhat.

Update What's New.

Window NVDAObject: redraw(): RedrawWindow() takes client coordinates, not screen coordinates, so convert them first. Fixes failure to redraw some objects.

Remove unused stuff.

speech: Don't use globalVars.keyCounter to determine when to kill the speak spelling generator, as keyCounter is currently not set and this is a pretty dodgy way of doing this. Instead, cancel the speak spelling generator (if any) when cancelSpeech is called. Fixes spelling continuing later after being interrupted.
Fixes #1188.

Add code doc.

LiveText behavior: Minor fixes:
* Clear the event in startMonitoring() just in case it was left set when monitoring previously.
* If there is a stabilise delay, check if monitoring was stopped while waiting. This is unlikely but possible.

App module for SecureCRT which reads incoming text automatically.

WinConsole NVDAObject: Allow 30 ms for the text to stabilise.

LiveText behavior: Ignore single characters like we did in the old winConsoleHandler code, as these are probably typed characters.

Missing import.

LiveText behavior: Remove MIN_CHECK_NEW_INTERVAL and introduce STABILIZE_DELAY instead. This is the time to wait before fetching the text (i.e. before the text is considered stable) after a change event.

LiveText: When calculating new text, don't barf on empty lines.

LiveText monitor thread: Add some exception handling.

Cosmetic.

Check whether a console is dead every 100 ms and disconnect if so to allow it to close.
This used to be done in the console monitor thread, but it doesn't make much sense to do this in the LiveText monitor thread, so use a separate timer.

Remove IAccessible.ConsoleWindowClass NVDAObject, which isn't useful. It was only getting instantiated for the window accessible, which never gets focus.

winConsoleHandler.consoleWinEventHook(): Only fetch console screen buffer info if it is really needed.

Convert Windows Console support to use the new Terminal behavior.
There are a couple of regressions which I have yet to fix.
Also, moving to a console with object navigation no longer causes new text from that console to be spoken, which partially fixes #673.

LiveText behavior: Fix bug where startMonitoring() couldn't be called again even after stopMonitoring(). Also, startMonitoring() now just returns if monitoring has already been started and vice versa for stopMonitoring().

Merge main.

WinConsoleTextInfo: Override the clipboardText property instead of the copyToClipboard() method.

Remove unnecessary code.

Add app module for Tera Term, which automatically reads incoming text.

 gdiHooks: Since rectangles aren't usually useful for text change notifications due to the text changing before NVDA can fetch it, condense notifications even further to just one notification per window per notification interval. A rectangle is still provided in case it is useful, but it encompasses all updated rectangles, which may include text that wasn't updated.

Add an app module for PuTTY, which causes incoming text to be read automatically.

DisplayModelLiveText NVDAObject: Use EditableTextDisplayModelTextInfo, as this gives more accurate information regarding spacing and is needed for caret offset in terminals.

Terminal behavior: Inherit EditableText, as terminals need to handle caret navigation. Don't call super in loseFocus event, as there is no base event.

LiveText._calculateNewText(): Handle lines with different lengths when searching a changed line for the changed section of text. Also, optimise and simplify.

LiveText behavior: Don't report new text if report dynamic content changes is disabled.

Add app module for mIRC. This reads new output text automatically when the input field is focused.

Add NVDAObjects.Window.DisplayModelLiveText, which can be used for NVDAObjects which should automatically report new display text.

displayModel: Allow NVDAObjects to register for text change notifications using requestTextChangeNotifications().
The textChange event will be called on the object when the display text changes.

Add LiveText and Terminal behavior NVDAObjects to facilitate automatic reporting of new text for objects from which text can be retrieved and which notify of text changes, but do not specify the exact new text.
A background monitor thread is notified when the text changes and calculates the changed text using difflib.
This code is based on the monitor code in winConsoleHandler, but has been abstracted and significantly cleaned up. A future commit will probably start using this new code for winConsole.

Window NVDAObject: Add a redraw() method which redraws the display for this object using RedrawWindow().

eventHandler: Fix a typo introduced over a year and a half ago which meant that a particular event would only be executed once for a given object, even if the same event was queued multiple times for that object. This hopefully shouldn't have any effect at present, but it was definitely unintentional.

It seems that MSNHiddenWindowClass fires some events other than nameChange on some systems which cause WLM 2009 to exit on startup when we respond, so just ignore all events from this class.
Fixes #677.

msnmsgr app module: Fix another line we missed in the rename from MSNHistory to OldMSNHistory. Should hopefully fix automatic reporting in WLM 2009.
Fixes #988.

adobeAcrobat vbuf backend: Some nodes seem to report FontInfo_MixedInfo for IPDDomNode::GetFontInfo() but then report 0 for child count, which causes us to render the node as empty since there are no child nodes to render. One example is the links in the table of contents of the iPhone IOS 4.1 User Guide. To work around this, ignore FontInfo_MixedInfo in these cases and treat it like a node with no font info.

Merge main.

Refactor the build process to allow anyone to create binary distributions, portable archives, installers and gettext translation templates with a simple command, including setting the version number and signing with a supplied certificate file.
scons is used to facilitate this. All builds should now be done using scons at the top level of the source distribution.
See the updated instructions towards the bottom of the source readme for details on how to use this.
Note that you can no longer build an installer directly by using makensis.

Merged main

nvdaHelper: implement support in display models for scrolled windows by hooking ScrollWindow and ScrollWindowEx. This implementation makes use of displayModel_t::copyRectangle to move a given rectangle in a display model.

NVDAHelper: displayModel_t::copyrectangleToOtherModel: rewritten to support new features, allow it to propertly copy from/to the same model, and to be more understandable. Specific changes:
*Rename to "copyRectangle", as the destination model is optional, meaning that the copy could occure all in the one model.
*Rename the arguments otherModel, otherX and otherY to destModel, destX and destY respectivly.
*Move the destModel argument to the end as its optional.
*Rename the clearEntireRectangle argument to opaqueCopy.
*Add a removeFromSource argument, which if True means that  the copy should act like a move (i.e. the content is removed from the source model). This will hopefully be useful when implementing support for scrolling.
*Add an optional destClippingRect argument which allows you to provide a clipping rectangle which should clip all content being copied in to the destination model. Again useful for implementing scrolling support.
*Make copies of all the chunks before doing any clearing,rather than after,  so that copying from/to the same model correctly works. Both bltBlt and scrolling support need this.

nvdaHelper: hook all functions using apiHook_hookFunction_safe, at the same time catching and fixing some coding errors, which may have caused, or been the future cause of, some crashes. Specific code error fixes:
*ExtTextOutHelper: lpString must be const.
*TextOutA and TextOutW: the return type is int, not bool (lowercase), and lpString must be const.
*PolyTextOutW and PolyTextOutA: do not use our own custom WA_POLYTEXT template struct, instead  make the hookClass_PolyTextOut template class take the POLYTEXTA or POLYTEXTW as its template argument rather than just char or wchar_t. Although that sort of worked in the past, for actual verification of function signatures a custom struct can't be used.
  *ExtTextOutA and ExtTextOutW: lpString should be const, cbCount should be UINT not int, and lpdx should be INT (uppercase) not int (lowercase).

nvdaHelper: added a much safer way of hooking functions, that verifies the function signatures at compile time.
If using apiHook_hookFunction_safe it is now impossible to use the incorrect function signiture for the real function symbol, the real function variable, or the fake function symbol. They *must* match, or else it doesn't compile.
To now hook a function, do something like real_GetDesktopWindow=apiHook_hookFunction_safe("USER32",GetDesktopWindow,fake_GetDesktopWindow).
The only difference on the outside is that a real defined function symbol must be used as the real function name rather than a string. This does mean though that you must have the header file for the function in order to hook it. Either that or at least have defined it somewhere in the same file, though this would not be any more safer than the older method.
How it works internally:
apiHook_hookFunction_safe is a macro that takes 3 arguments: moduleName, realFunction and fakeFunction.
apiHook_hookFunction_safe calls apiHook_hookFunction_tpl with these arguments, plus a stringified version of the realFunction argument.
apiHook_hookFunction_tpl is a template function which takes a moduleName string, a realFunctionName string, a realFunction symbol, and a fakeFunction symbol. Its template argument is a typename called funcType, which it deduces from the realFunction and fakeFunction signatures, which must match. It also returns a symbol of type funcType, which again will match the other two function symbols.
apiHook_hookFunction_tpl calls the original apiHook_hookFunction, hooking the function in the normal way. The macro and the template are only there for safety purposes at compile time.
 The only limit to this new way of hooking is that the symbol hooked in the particular module must have exactly the same name as the symbol defined in the header file. Plus a header file should be available containing this symbol you are hooking. If these limits are a problem then apiHook_hookFunction can be used directly, but when possible it is very important to use the safer version.

A first go at supporting auto-announcement of new text in display models.
*NVDAControllerInternal RPC interface: added displayModelTextChangeNotify, which takes a window and 4 rectangle coordinates (left, top, right bottom) (in screen coordinates) which match the part of the window which has just been updated. A simple implementation in nvdaHelper.py so far just fetches and speaks the text in the given rectangle if the window is the window of the focus object. Note though that notifications do not yet happen by default they must be turned on for each window.
*displayModel RPC interface: add requestTextChangeNotificationsForWindow, which takes a window and a bool saying whether or not you need notifications. Note that the implementation of this function reference counts so that  many  parts of NVDA could all turn it on separately and also turn it off with out affecting the other code.
*nvdaHelper's gdiHooks: for every extTextOutHelper and bitblt call, take note of the rectangle that changed.  A timer that fires every 50 ms in NVDAHelperRemote's manager thread then collects these rectangles and fires a textChangeNotify back to NVDA for each one. When rectangles are queued at first,  any overlapping / adjacent rectangles are merged to cut down on the number of separate notifications.

Merge 2010.2. Change sfrom the fi and pl gettext (.po) files have not been merged due to conflicts.

Fix access to some Windows Security dialogs such as the dialog that appears when installing unsigned drivers.
It seems that custom window messages cannot be sent to these dialogs, so sending our custom ping message returns an access denied error, which causes IAccessibleHandler.accessibleObjectFromEvent() to fail.
This custom ping message was implemented to fix Windows Live Messenger 2009 exiting on startup (#677). Instead, just use WM_NULL (which can be sent to these dialogs) and implement a specific condition to ignore the problematic event from Messenger.

versionInfo: Set version to 2010.2.

Updated traditional chinese language file and user guide.

Merge main.

ScriptableObject: Don't store instance methods in the gesture map, as this causes circular references and therefore memory leaks. Instance methods are meant ot be generated on retrieval anyway. Therefore, store the function from the class and create the instance method when the script is retrieved.

Updated croatian language file.

Remove unneeded.

setup.py: Don't copy kbd files in appModules dir, as they no longer exist.

Remove unneeded code.