I joined Mick in Melbourne on Sunday, 9 November for the third NVDA hack fest. Discussion during the hack fest included significant changes and additions to the design of NVDA, organisation of the source code, optimisation of the braille support, project management and policy, and solutions to some long-standing problems. See NVDAHackFestNov2008 for detailed technical notes on the major topics of discussion.

Aside from discussion, we did quite a bit of coding as we had hoped. The first item we tackled not long after I arrived was a rather long standing task that we've been putting off for months: the storage of voices and variants in the configuration file as unique identifiers instead of indices. This makes voice settings more reliable across systems and configuration changes. We had already begun work on this several days before, but there was still some work to be completed. We were very excited and relieved when we were finally able to merge the changes and declare this ticket fixed late on Sunday evening. (Amusingly enough, despite our excitement, we forgot to close the ticket until after the hack fest.)

Our next major undertaking was some changes to improve NVDA under Windows Vista. In earlier versions of Windows, it was tedious at best to run specific applications or tasks with administrative privileges, and therefore, it was common practice for some users (particularly home users) to simply always run with administrative privileges. Many applications, including NVDA, expect to be able to write to protected areas of the system, such as the Program Files directory. This is obviously a huge security hole. This is no longer the case in Windows Vista, which prefers that applications specify what privileges they require by way of an associated manifest. Applications which do not provide this information are run in a compatibility mode, wherein data written to protected locations is redirected to a "virtual store" writeable by the user. This is not ideal and can cause problems. We updated NVDA to provide a manifest, which means that NVDA now runs without this compatibility hack. This additionally required that we change NVDA to store all configuration data in the user's Application Data directory for installed copies. This also benefits Windows XP users, allowing individual users to have their own configurations and to save their configurations without administrative privileges. Furthermore, it is the first small step towards supporting User Access Control in Windows Vista.

Another significant change we implemented (which won't be noticeable to users) is that the default appModule is no longer a separate level through which scripts and events pass. Rather, all other appModules inherit from the default appModule class. This makes for a much clearer, object oriented design, allowing scripts and events to be overridden or extended with ease. It also cuts down the number of levels through which scripts and events must pass.

There were also several other minor bug fixes and changes, including some for braille and the new SAPI 4 driver.

On Wednesday evening, Mick, Mat and I attended a mini-expo on adaptive technology for Vision Australia staff. The mini-expo was attended by 9 suppliers and between 35 and 40 Vision Australia staff. Mick and I came prepared to demonstrate NVDA, including the all new braille display support. Mick also had Ubuntu Linux and Orca installed for demonstrations. Unfortunately, it was far too loud for demonstrations with speech, so most of the evening was spent talking to the various staff that approached us. We learnt that some staff are already recommending NVDA to users who cannot afford commercial screen readers and some of these users are using NVDA with great success. Unfortunately, NVDA is still not officially recognised by Vision Australia, perhaps due to our inability to offer direct technical support. Nevertheless, we are hoping this will change in time.

I returned to Brisbane early on Friday afternoon. Overall, we were quite happy with our achievements during the week. As well as the immediate benefits, these hack fests always help to revitalise our working relationship. On a personal level, it was also great to catch up again. Mick and I talk a lot on both IRC and the phone, but there's nothing quite like a face to face meeting. :)

I didn't have a chance to write a weekly update last week due to the promised hack fest, which I will discuss in another post.

Here are the noteworthy changes to NVDA in the week prior to the hack fest:

• Aleksey Sadovoy contributed a command (NVDA+c) to report the text on the Windows clipboard.
• Several enhancements to virtual buffer pass through were added:
  • Instead of virtual buffer pass through on and off, NVDA now reports focus mode and browse mode, respectively.
  • Pressing escape while in focus mode returns to browse mode.
  • NVDA can now switch to focus mode or browse mode as appropriate for the control under the virtual caret. This is also known as automatic virtual buffer pass through, which I described in a previous progress update.
• Mick wrote a new SAPI 4 driver, which replaces the old sapi4serotek and sapi4activeVoice drivers. This new driver should fix the issues encountered with the previous drivers.

There wasn't much noteworthy activity to report about last week, aside from NVDA 0.6p2 passing 10000 downloads, about which I already reported. The one noteworthy change in NVDA was Mick's introduction of an NVDA specific dialog which allows the user to edit the content of a cell in Microsoft Excel. This dialog appears when you press f2 to edit a cell. This is necessary because the formula bar in Microsoft Excel is inaccessible to NVDA. It is only a temporary solution until NVDA has display hooks which can track the text and cursor in the formula bar. Nevertheless, it does allow the user to edit cells in an accessible manner, which will be a welcome relief for some users.

For BRLTTY users, Samuel Thibault is now building the BRLTTY installer I reported about last week when he releases new Windows builds of BRLTTY, and the installer script is now in the BRLTTY svn repository. Thus, I have removed the installer files from the location I linked last week. Please download installers from Samuel's BRLTTY Windows builds.

Mick has started an article about what we will cover in the upcoming hack fest, which is less than a week away now! As always, there will be a lot of brain melting discussion, though we hope to do a little more coding this time. :) We are keen to involve other developers in these discussions, so let us know if you are interested.

Mick and I debated how to improve braille review. Currently, braille either moves the caret or the review position, but it is always tethered to one or the other; it cannot move freely. This is potentially undesirable in some circumstances. There are two possible solutions:

• Braille always moves the review cursor. The caret can optionally be moved when braille moves, but regardless, the review position will always be moved. The review cursor itself would never be displayed. The advantage of this is that no separate braille cursor or range is required. The disadvantage is that review bookmarks or the like would be required, as one might wish to move quickly between the caret and an arbitrary review point.
• Braille can move beyond either cursor, but either cursor can be moved to a braille position, either on demand or automatically. This requires the concept of an active braille cursor; i.e. whether braille is manipulating the caret or the review cursor. This probably allows for the most flexibility, but possibly makes fora steeper learning curve, as there is an additional cursor/range to consider.

We still can't reach a consensus on which is the better method, but we have ideas on how both could be implemented. :) We also discussed ways to work around some bugs in liblouis which are causing some annoying exceptions when text contains certain unicode characters.

Aside from this, we've spent a considerable amount of time writing presentation proposals for CSUN 2009, which we submitted today. Also, we've been trying to track down some annoying crashes with Firefox and NVDA that have been reported lately, but haven't had much success yet.

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.

Last week, I continued work on implementing braille display support. Early in the week, I introduced code to move the caret to the next or previous line when scrolling the display if it cannot be scrolled any further. I fixed a bug that Mick found in liblouis. Mick and I discussed how to handle the review cursor with regard to braille, although no code has been implemented yet. We spent some time investigating a crash in the Windows version of brltty/brlapi which has been bothering us for weeks. Although we now understand exactly how to reproduce it, we unfortunately don't know how to fix it. My week was divided by an extremely pleasant, relaxing two day holiday with my fiancée.

Mick continued his rather difficult work on the virtual buffer library. We spent several hours on Friday discussing a rather mind boggling piece of code which Mick had been struggling with for days, but we're hoping we finally have it straightened out now. :) He added the ability for the review cursor to review the text of a virtual buffer, rather than just reviewing the internal text of the object, which is not always useful to the user. This means that you can now navigate the buffer hierarchically using object navigation and the review cursor will move to the text at that point in the buffer. Mick also fixed a bug in the speaking of text selections which caused the selection to be read as two chunks instead of one in certain cases.

First of all, NVDA 0.6p2 is now almost at 6000 downloads (5973 at time of writing)! I'm amazed that it's continuing to increase by almost 1000 downloads a week.

I neglected to mention in my last update that Peter Vágner, primarily known for his fantastic work as our internationalisation coordinator (but also involved in other development), implemented initial code to move the mouse to the character under the review cursor in certain editable text controls. Previously, NVDA could only move the cursor to the centre of the current navigator object. This enhancement allows users to click on specific characters or the character under the cursor, which is necessary in certain situations. It may also be useful for communicating a specific point in a document to sighted observers.

Last week, I primarily continued my work on implementing braille display support in NVDA. When Mick attempted to test the work so far, we discovered that the liblouis Python bindings developed by Eitan Isaacson for Orca misbehave quite severely in Windows Vista. I spent hours on this issue and still could not fathom why this occurs, as they work fine for me in Windows XP and obviously work fine in Linux. I couldn't find anything in the code or build options that should cause problems under Windows Vista. We ended up developing our own bindings using ctypes. This will probably be easier in the longrun anyway, as maintaining and building Python C extensions can be tedious, especially under Windows. I spent quite some time working on some bugs in liblouis. During the week, liblouis 1.3.9 was released, which, among other changes, fixes some issues affecting NVDA which I raised not long before. Thanks, John! Towards the end of the week, I did some more work related to braille and editable text controls, as well as fixing some annoying bugs. My last piece of work for the week was implementing a very basic braille settings dialog, which currently allows the user to choose the braille display and translation table to be used.

As well as helping me to test braille support, Mick continued his refactoring of the virtual buffer library which I described in my last update. He is making steady progress, but there is still quite a bit to be done before a new version of the library containing these changes can be released.

During the arduous task of exasperatedly scouring logs, searching tickets and racking my brains in order to construct my previous, infrequent progress reports, I have promised myself several times that I will endeavour to write more frequent (perhaps even weekly!) progress updates to make the process somewhat less painful. Unfortunately, as is far too common for me in such matters, I've never ended up doing this. Still, there's no time like the present, and if I start now, I might even be able to keep it up.

This last week has been quite mind boggling for both Mick and I, although quite exciting for me in particular. I finally started the eagerly awaited task of implementing support for braille displays in NVDA late last week and have spent the majority of this week continuing this work. Frustratingly, much of the week was spent designing and implementing the core framework which I couldn't test in any realistic, practical situation. However, on Friday, I was finally able to see some of this work come to practical fruition. While certainly not ready for general usage, NVDA can now track the focus on a braille display, displaying the focus object and appropriate ancestors as it changes. You can scroll the display back and forward, and cursor routing keys can be used to activate objects. Where the focus is an editable text field, NVDA can display the text and track the caret, indicating (and optionally blinking) the caret in the appropriate position on the display. In these fields, cursor routing keys can be used to route the caret to the associated position. There is a long way still to go, but it's certainly very exciting to finally be well on the way to supporting braille displays in NVDA. NVDA uses the liblouis braille translation library, which allows for both contracted and uncontracted braille and includes tables for many braille codes. A driver is included for BRLTTY, which supports the vast majority of braille displays.

Meanwhile, Mick has been delving into the depths of the virtual buffer library once again. While investigating the task of implementing support for text formatting, he decided that the core design of the library needed to be restructured and simplified somewhat. Although the current code serves very well, it is not very object oriented and the way it handles text is somewhat convoluted at best, making changes and enhancements difficult. During this week, he has almost completed this rather daunting redesign and has also been taking the opportunity to document the code as he goes. These changes should not be noticeable to users once the work is done, but they will certainly make future work on the library much simpler. I too worked briefly on the virtual buffer library to write some utility code and fix an unexpected bug I discovered.

On another note, NVDA 0.6p2 is fast approaching 5000 downloads! :) It's at 4935 as I write this.

As usual, a great deal has happened in the last few months. Perhaps the most exciting happening for NVDA users was the release of NVDA 0.6p2, which we believe is a major step forward in stability and functionality for NVDA. As such, NVDA 0.6p2 is now the recommended release for most users. The old stable release, NVDA 0.5, is no longer recommended. This release followed the NVDA hack fest in June, which, as well as a lot of other important discussion, was when the decision to make this release was made.

Many people have asked how many times NVDA has been downloaded. We were obviously quite curious about this ourselves, but we never had a reliable way to count downloads, so we had no idea. Thus, just prior to the release of 0.6p2, I set up a download counter for NVDA releases. We were quite pleasantly astonished by the results. At the time of this writing, since 0.6p2 was released on 7 August, it has been downloaded 3640 times. On average, that's around 1000 downloads per week! It should be noted that this includes downloads of both the installer and the portable release and many users probably download both. The increase is obviously slowing now that the release has been available for a few weeks, but we were still pretty impressed. We honestly had no idea that the count would be this high. Thanks to all who have downloaded! :) The counter also tracks other information such as the country and browser of downloaders, but I haven't generated any statistics for those details yet.

After the release, I spent some time preparing for a presentation on NVDA for Info Vision 08. Info Vision 08 was an exhibition on assistive technology for the blind, visually impaired, deafblind and hearing and visually impaired held at the 7th General Assembly for the World Blind Union in Switzerland. The presentation, which I gave via Skype on 21 August, was quite successful, attracting a decent amount of interest. We will hopefully be able to make a recording available for download some time soon.

In terms of NVDA development, Mick and I have been working on several noteworthy changes to NVDA. We have been doing a lot of this work in different branches of the code, which enables us to make changes which may severely break some functionality without worrying about breaking the main code base used by users. The first of these involved changes to NVDA's audio output code, used primarily by the in-built eSpeak synthesiser. Aside from minor performance and stability improvements, these changes mean that if NVDA is set to use the default Windows output device, it will switch to the new default device if the default device changes. For example, NVDA can switch to a USB audio device automatically when it is connected. Also, the last chunk of audio is no longer cut off when using NVDA with eSpeak on a remote desktop server. This branch was merged into the main code base not long after 0.6p2 was released.

In another branch, we are developing support for multiple input desktops. This will allow NVDA to read secure screens such as the Windows logon screen, the Windows security screen and the UAC (user account control) dialogs in Windows Vista. This must be done quite differently for Windows XP and Vista, but we are working on solutions for both operating systems. So far, the work is looking quite promising and has already received positive feedback from some testers, but is not yet ready for most users.

In the past few weeks, Mick embarked on a major restructure of NVDA's document formatting code. While most of these changes are not particularly noticeable to the user, they will allow for simpler, more elegant additions to formatting support in future, including the ability to support it in virtual buffers. Also, formatting can now be queried and reported automatically in IAccessible2 text controls, including spelling errors in Mozilla Firefox and Thunderbird. This code was merged into the main code base a couple of days ago. Mick is now working on the virtual buffer library and will eventually implement support for formatting, which will complete the work for the Mozilla web access grant.

NVDA's virtual buffer pass through mode, which is equivalent to forms mode or similar in other screen readers, is a point of some controversy for many users. Users must enable virtual buffer pass through when they wish to interact directly with a control and then disable it to resume browsing the document. In terms of useability, one of the reasons for these dual modes of operation relates to quick navigation keys. A user needs to be able to disable the single letter quick navigation keys to type properly into a control. Also, the screen reader needs to have a way to determine when the cursor keys should move the real cursor in a form field and when they should move the virtual cursor. However, screen readers such as Orca and Serotek System Access have used a single mode of operation right from the start. Increasing requests from our users, followed by the introduction of auto forms mode in the recently released JAWS 10 public beta, motivated us to further investigate and work on this feature in NVDA in order to bring it in line with the majority of modern screen readers. Thus, I have been working on automatic virtual buffer pass through over the last couple of weeks. Again, the work is promising, but not yet complete.

Outside of NVDA, there has been some other noteworthy news over the past few months. 17 June saw the official release of Mozilla Firefox 3.0. This was an exciting release for NVDA users, as Firefox 3 includes some major accessibility enhancements which NVDA requires to provide its excellent access to Firefox. Also, the WebVisum Firefox extension was announced in July. WebVisum is a free accessibility extension which sports features such as community driven tagging and page enhancements, automated CAPTCHA solving (yay!), helper functions for easier page navigation, and numerous under the hood page tweaks designed to help screen reader users. Its user community is growing rapidly, and it of course works very well with NVDA! :) Marco Zehe wrote an excellent review of WebVisum.