There have now been over 10000 downloads of NVDA 0.6p2 since its release on 7 August, less than three months ago. At the time of this writing, there have been 10459 downloads. Thank you to all of you for your support. NVDA certainly wouldn't be what it is without the fantastic community that surrounds it.

Probably the most exciting happening last week was the promised merge of initial support for braille displays into the main NVDA code. There is still a lot of work to do, but the current implementation is quite useable. There were quite a few changes after the merge to fix issues and allow braille display support to be included in binary snapshots. Also, Mick added a driver for Freedom Scientific Focus/Pacmate displays, which means these can now be used without installing BRLTTY. There is one particular optimisation yet to be done which should vastly improve the performance of the braille code when the focus changes. Code needs to be added to allow keys on displays to trigger scripts in NVDA so that, for example, pressing a key will move to the previous line. (Scrolling and cursor routing is already possible, but this is currently supported directly in the drivers.) NVDA currently cannot display control fields when reading documents in braille, which means that you cannot identify links, form fields, etc. on web pages. These are just a few of the currently known issues; I'm sure there are many more to be discovered. Nevertheless, it is very exciting to finally have support for braille displays in NVDA. Happy testing!

On a related note, I  created an installer for the Windows version of BRLTTY using  NSIS. Aside from copying BRLTTY to the system, this installer automatically installs and starts BRLTTY as a service. It does not currently provide any facilities for GUI configuration of BRLTTY. You can download an installer for BRLTTY 3.10-2.

The virtual buffer library refactoring saga continued. Although we had initially intended to integrate the virtual buffer in-process injection code with NVDAHelper, Mick discovered that this was not going to be practical due to the virtual buffer library being separate from NVDAHelper. In order for our initial idea to work, the code needs to be integrated at some level, particularly the build process. Going forward, we will probably end up merging the virtual buffer library into NVDAHelper. This is unfortunate in some ways, as it means that it cannot be distributed as a separate package which is immediately useable by other projects, but it is becoming too difficult to maintain it as a separate library, primarily due to its in-process nature. People will certainly still be able to borrow and reuse the code. All of this aside, Mick was able to successfully create a test virtual buffer and interact with it from another process using the new library. The Gecko back-end still needs to be adapted for the new library. Also, NVDA needs to be updated for the new library. This cannot be done until automatic virtual buffer pass-through is merged with the main code.

There are quite a few questions, problems, etc. that appear time and time again on the NVDA mailing lists. This finally prompted me to create some wiki articles to make this information more readily available.

• FAQ answers general frequently asked questions about NVDA.
• ApplicationSupport provides details about NVDA's support for specific applications, including commonly encountered problems and solutions.
• Troubleshooting provides information about and resolutions for problems commonly encountered by NVDA users.

These are rather limited in content at present, but hopefully, they will grow into useful resources for NVDA users. Please feel free to improve them!

The major addition to braille support last week was support for the review cursor. Braille can now be tethered to either the system focus/caret or the review position. When tethered to the review position, the display is updated when the review position changes and the routing keys move the review position if appropriate. Unfortunately, there is currently no user friendly way to change this tether mode; it must be done via the Python console. This will be resolved some time this week. Aside from review support, if a change occurs to an object which is being displayed, the display will be updated accordingly. I also added the ability to display messages which time out after a short period. These messages can be dismissed immediately by pressing a cursor routing key. Scrolling the display left or right causes the timeout to be reset to provide more time to read the message. Many of the scripts in the default appModule, such as NVDA+f12 to read the time/date, now display their messages in braille as well as speaking.

Braille display support is still being developed in a separate branch of the code. It has been difficult to decide when this code should be merged into the main NVDA code. There is still a lot of work to be done and BRLTTY is still quite difficult to set up for most users. On the other hand, there are no serious issues with the current code and I would like it to be tested as much as possible. Mick and I discussed this question at length last week. We decided that the current code will be merged as soon as a couple of issues are resolved. The first is to stop computation of braille when there is no braille display in use, as this is pointless and inefficient. Second, there needs to be a way to switch the cursor to which braille is tethered as discussed above. I will hopefully resolve these issues and merge braille support this week.

Mick's agonising endeavours with the virtual buffer library and RPC continue. We spent some time deciding on how RPC will fit into the library's architecture, as well as determining the programming interface for the library. Unfortunately, rather than Mick being able to dive straight into the implementation as we had hoped, he discovered some very frustrating problems. In technical terms, it seems that if you statically link the C/C++ runtime (which is what we have done previously), you cannot safely manipulate objects from any other dll other than the one in which they were created if they are managed internally in some way by the C/C++ runtime, even though the dlls might be dynamically linked. This probably includes most standard C++ classes and templates. The reason is that when the runtime is statically linked, a separate copy of the runtime is used and each maintains its own internal state separately. This was causing many seemingly random crashes and took quite some time to debug. This isn't a problem if all relevant dlls and applications are dynamically linked against the same runtime. However, this requires that the process into which we are injecting has access to the required runtime dll, which cannot be guaranteed because NVDA might be running portably and thus can't copy files to the Windows system directory. The only solution for us is to statically link the runtime and avoid passing such objects between dlls. If you didn't understand any of this (I bearly understand it myself!), suffice it to say that this is yet another exasperating, convoluted hurdle in a seemingly endless series of such hurdles. Nevertheless, we'll get there... eventually. :)

There were only a few minor changes to the main NVDA code last week:

• I added support for the recognized text field in SiRecognizer. This was simply a matter of mapping a window class name so that it was treated as a RichEdit control.
• I changed the way dialog text is presented. Previously, focus events were overridden to speak the dialog text, which obviously won't work for braille. Now, the dialog text becomes the description of the dialog. While this isn't noticeable to the user in most cases, it is cleaner and allows dialog text to be handled seemlessly by braille.
• I fixed an issue whereby the text of a property page was sometimes spoken twice. This occurred when the property page was inside a dialog and both the dialog and property page were entered; e.g. alt+tabbing out of and back into a dialog containing a property page.

The hack fest I mentioned last week will happen from 9 to 14 November. We haven't yet written an action plan for this.

The major highlight in the land of braille support last week was the implementation of initial support for braille in virtual buffers. The text of virtual buffers is displayed in braille when a virtual buffer gains focus. The virtual caret is tracked, and both scrolling the display and cursor routing can move the virtual caret. NVDA correctly switches between browsing the document and displaying the control with focus when pass through mode is disabled and enabled, respectively. Control field information, such as whether an element is a link, form field, etc., is not yet displayed. Also, controls cannot yet be activated by using the cursor routing keys. Finally, there were some minor fixes to braille in Windows command consoles.

In last week's update, I discussed Mick's work on using remote procedure call (RPC) for inter-process communication. Testing of RPC showed very promising results. Mick implemented NVDAController, a framework using RPC which enables external applications to trigger events inside NVDA appModules. Aside from being a useful feature, this allowed him to familiarise himself with RPC and served as a good practical test of RPC in NVDA. Although this functionality has been tested and does work, it is not yet enabled in NVDA, as its interface is still subject to change. Mick then began to work on converting the virtual buffer library to use RPC.

The major refactoring of the virtual buffer library over the last few weeks has transformed it into a package which differs vastly from the original library. It is almost a completely new library in many ways, as the interface has been rewritten and the package has been reorganised. Furthermore, the use of RPC has eliminated an entire layer of code. The end result for the user will be the same, but the code is very different. Therefore, we have decided to start a new code repository for the library and release it as a new version. Overall, the new version is much cleaner, more organised and better documented.

As usual, there were several minor changes to the main NVDA code that are nevertheless worth noting:

• I simplified and abstracted the tasks performed when moving the virtual caret in virtual buffers, which, aside from being cleaner, was necessary for braille support.
• Mick fixed problems with mouse tracking in Java objects.
• Mick changed the title command (NVDA+t) to report only the title instead of the entire object. If the foreground object has no name, the application's process name is used. I added the ability to spell the title and copy it to the clipboard.
• Aleksey Sadavoy made some improvements to the keyboard help mode, including the ability to read modifier keys when pressed alone and the ability to translate key names into other languages.

Aside from coding, Mick and I have been working on a presentation for next year's  CSUN conference. We are moving further in our transition towards using  Bazaar for our version control system. I have written some scripts to keep svn and bzr synchronised, and am in the process of getting Peter set up to use bzr. Finally, Mick and I are both making a presentation in Melbourne in November, so we are going to take the opportunity to have another hack fest.

I forgot to mention in the last update that Mick changed the way NVDA loads and unloads appModules. NVDA now associates appModules with process IDs, rather than window handles. This makes more sense, as an application is generally a single process. This change means that NVDA no longer needs to search for the main window of an application. Also, it is much more accurate in loading and unloading appModules at the appropriate times. For example, the NVDA appModule is now only loaded once instead of every time the NVDA menu is activated.

Last week, I continued work on implementing braille display support. It's coming along steadily, but there's still a lot to be done. In last week's report, I mentioned  a crash in the Windows version of brltty/brlapi. This issue was causing NVDA to lock up intermittently after pressing a key on the braille display. I implemented a temporary work around for this in NVDA which should prevent most of these lock ups, although it still needs to be fixed properly in brltty. I also disabled assertion errors from wx for now, as there is a bug in wx which causes spurious assertion errors to be raised regarding timers under certain circumstances. I improved braille configuration a little, including the addition of a configuration option for the cursor blink rate, although this isn't available in the Braille Settings dialog yet. The display of controls has now been improved so that they now include value, states, description, etc., although this code needs quite a bit more work.

Meanwhile, Mick finished his work on the storage component of the virtual buffer library; i.e. the portion responsible for maintaining the text of the document and answering requests for text in a flat representation. The storage component is now fully object oriented and all of the classes and methods are documented, which will make working with this code much easier for both ourselves and other developers in the future. The Mozilla Gecko back-end still needs to be updated to work with the new storage component.

After Mick finished working on the storage component, he began to consider the mechanism we use for inter-process communication (IPC); i.e. communicating queries and data between different processes. Currently, we use a mix of window messages and reading and writing from remote process memory, which is tedious to code and requires a lot of code duplication. These mechanisms are specific to Windows, which means that the virtual buffer library cannot be used on another operating system. Also, the virtual buffer library and NVDA's other in-process component (NVDAHelper) use completely different code for IPC. We are now considering a mechanism called  remote procedure call (RPC), which is designed to handle execution of functions in remote processes and transparently handles the transfer of necessary data between processes. Thus, it is much simpler to code and probably quite well suited to these tasks. NVDAHelper could be responsible for all IPC. NVDAHelper could inject the virtual buffer library into a remote process and set up RPC, thus removing all IPC code from the virtual buffer library and making it mostly platform independent. We also want to use RPC to enable applications to trigger events in NVDA, allowing applications which cannot provide information in other ways to communicate directly with NVDA. This is similar to the external APIs provided by some commercial screen readers, although it is potentially more powerful and flexible. Mick has begun work on a basic RPC implementation, which is looking promising so far.

Aside from these bigger endeavours, there have of course been other smaller changes to the main NVDA code. I made quite a few cosmetic fixes; e.g. fixing spelling errors in method names. Mick fixed a bug in the sapi4activeVoice synthesiser driver which was causing say all to fail. He fixed an issue in say all regarding bookmark values which may have caused certain synthesisers to crash. Mick also fixed a bug whereby no text was being read when reading with the mouse in Mozilla Gecko edit fields. I added events for virtual buffers which indicate when a user moves into or out of a virtual buffer. Aside from allowing for more logical coding of some existing functionality, these events are necessary for braille and may allow for other functionality in future. I also fixed an issue which meant that caret events were not being triggered on the focus object before the first focus change after NVDA was started. This meant that if you were focused on a Windows standard edit control when NVDA was started, text selection changes would not be spoken until the focus had changed at least once.