----------
The Homer application framework, HomerApp, is designed to make it easy for developers to build sophisticated applications with a graphical user interface (GUI), and for end users to benefit from the friendliness and power of those applications. HomerApp is a support structure for applications with the following, noteworthy characteristics: multiple document interface, single instance, command line operation, configurable, scriptable, direct speech messages, convenient hotkeys, and help features. These are further explained as follows:
* Multiple document interface (MDI). MDI is a well-understood user interface, originally promoted by Microsoft Word, in which any number of child windows may be opened within a main application window. Each child window can host a separate document, though almost any content or functionality is possible within such a window, not just representing documents. Standard keyboard shortcuts include Control+Tab or Control+Shift+Tab for cycling to the next or prior child window, and Control+F4 to close the current one.
* Single instance. Since an MDI application hosts multiple windows, it is typically designed so that only a single instance runs in memory, that is, a subsequent attempt to launch the application will activate the one already present, rather than creating another copy in memory.
* Command line operation. With a single instance application, the executable file may repeatedly be run with command-line parameters that are passed to the existing instance. For example, the file name of a document may be passed as a parameter, and the application may respond by opening a new, child window containing that document. This is a common example with an editor-type application, but the developer can implement almost any functionality in response to an event informing the application that command-line parameters have been passed.
* Configurable. The user can specify preferences for how the application behaves in particular situations. The application remembers these configuration options in subsequent sessions of operation.
* Scriptable. More powerful configurability is possible through script files containing programming code that manipulates the application via an object model. Scripts may be distributed with the application, defined by the user, or developed by third parties.
* Direct speech messages. Users who operate an application nonvisually via a screen reader program can benefit from speech messages that directly communicate information. Such messages supplement, rather than replace, the information that is automatically spoken by default settings of the screen reader. For example, a notification placed on the status bar could be conveyed via direct speech as well, saving a nonvisual user from having to press a key to read that area. Although the notification would be automatically read by a screen reader if placed in a message box instead, that approach would then involve dismissing the message box and hearing extra verbiage related to changes in focus. HomerApp can automatically detect and produce speech via any of four screen reader APIs: JAWS, NVDA, System Access, and Window-Eyes.
* Convenient hotkeys. Every application task may be performed via the keyboard; No mouse operation is required. In addition, hotkeys serve as quick shortcuts to multiple sequences of keystrokes, e.g., to perform a task immediately without having to navigate the menu system.
* Help features. A context-sensitive tip is available for the control that currently has focus. A key describer mode allows one to check what keys will do without actually performing their functions. An alternate menu presents a complete, alphabetized list of all menu commands, hotkeys, and descriptions.
HomerApp enables a developer to easily create applications with the above characteristics. A sample application is included called "MDI Fruit Basket." This meets (and considerably exceeds) the specifications of a "fruit basket program," explained at the web site
http://FruitBasket.QuantumMyst.com
A fruit basket program is intended as a simple but nontrivial GUI, exhibiting how a developer may employ a particular programming language and platform, and how a user may experience the result. The length and complexity of code may be considered from a developer standpoint; the accessibility and performance of the program may be considered from a user standpoint. Basically, the user interface contains an edit box for entering a fruit name (e.g, apple), a listbox for collecting the fruit (the basket), and buttons to add or delete items. Obviously, such a program is not inherently useful, but it does offer an informative example of a development approach, with comparisons possible to other programs meeting the same criteria.
MDI Fruit Basket implements HomerApp features as follows:
* Multiple document interface. The application supports multiple windows and a menu system. To open a new fruit basket form (a dialog with the controls mentioned above), choose the File/New menu option or press Control+N.
* Single instance. Launch the program again. The existing instance will be activated instead of creating a new one.
* Command line operation. With either the initial or a subsequent run of the executable, pass two command-line parameters corresponding to the name of an event and the name of a control to handle the event. For example, pass "Click" and "Button_Delete" to click the Delete button of the current fruit basket form.
* Configurable. Choose Misc/Configuration Options or press Alt+Shift+C for a dialog that lets you determine whether duplicate fruit names may be added to the basket, and whether its content is sorted alphabetically. Notice that only Yes or No choices are accepted.
* Scriptable. Chose Edit/Script Menu or press Alt+Shift+F10 for a list of available scripts. Pick the one that adds three berries to the basket (blackberry, blueberry, and strawberry).
* Direct speech messages. Choose Help/Focus Tip or press Shift+F1 to hear a tip about the control with focus, a message that is also displayed visually on the status bar. Choose Query/Clipboard or press Alt+Apostrophe to hear the content of the clipboard.
* Convenient hotkeys. Besides other hotkeys mentioned, choose Navigate/Find Text or press Control+F to move to a control based on text it contains. The text may be either in the label or data of the control. For example, if the basket contains an apple, focus may be moved to it by searching for "basket" or "apple." Capitalization does not matter. Choose Navigate/Find Again or press F3 to search for the next match in the dialog, if any.
* Help features. Choose Help/Documentation or press F1 to open the documentation in your web browser. Choose Help/Key Describer or press Control+F1 for a mode in which keys are described. Choose Help/Alternate Menu or press Alt+F10 to pick from a listbox containing command descriptions. Each description is also displayed as a tip on the status bar when navigating the regular menu system. Choose Navigate/Control Menu or press Control+F10 to pick from a listbox with descriptions of controls in the current form. Focus is moved to the control that was picked, and its description also appears as a tip on the status bar.
HomerApp supports a development approach called "Layout by Code." This is an alternative to graphical tools for layout of GUI forms. Essentially, a series of function calls specify the sequence of controls on a form, and when to start a new band of them. No explicit pixel coordinates are needed for size and position; Intelligent, visually acceptable choices are automatically made. Each function call may optionally include initial data for the control and a help tip for users. The nonvisual developer does not have to contend with mouse-oriented design tools, or arithmetic calculations for placement of each control. The source code for MDI Fruit Basket illustrates this approach (in the file HomerApp.cs or HomerApp.vb).
As background, Layout by Code was originally implemented as a library in the AutoIt language
http://EmpowermentZone.com/lbc.zip
where it was used to build a database manager called DbDialog
http://EmpowermentZone.com/ddsetup.exe
A version of Layout by Code in the Python language
http://EmpowermentZone.com/pyLbc.zip
was used to develop a Twitter client called McTwit
http://EmpowermentZone.com/mtsetup.exe
The HomerApp framework and Homer.NET libraries grew out of the development of two applications in the C# language: a file and directory manager called FileDir
http://EmpowermentZone.com/dirsetup.exe
and a text and code editor called EdSharp
http://EmpowermentZone.com/edsetup.exe
Many of the functions in the HomerJax library originated in the following distributions:
the Homer Script Library for JAWS
http://EmpowermentZone.com/kitsetup.zip
the Homer Shared Object for Window-Eyes
https://www.gwmicro.com/Script_Central/Scripts/Script_Details/?scriptid=1036
and the HomerJax Script Component (for any COM client)
http://EmpowermentZone.com/HomerJax.zip
HomerApp relies on a set of libraries called Homer.NET, supporting any programming language that executes on a freely available platform called the ".NET Framework" or "Common Language Runtime" (CLR), version 2.0 or above (4.0 is the latest). The CLR is built into Windows Vista and above, and may be installed for Windows XP or Windows 98 from the Microsoft web site at
http://msdn.microsoft.com/en-us/netframework/aa731542.aspx
The CLR is also available for Macintosh and Linux operating systems from the Mono Project
http://mono-project.org
though some Windows-specific parts of Homer.NET are not compatible there. The most popular .NET languages are C# and Visual Basic. Source code for the sample application, MDI Fruit Basket, is provided in both these languages (MDIFruit.cs and MDIFruit.vb).
The Homer.NET libraries (also called assemblies) include many convenient functions for working with screen readers (HomerAcc.dll), web services (HomerJax.dll), ini files (HomerIni.dll), archive formats (HomerZip.dll), and GUI forms (HomerLbc.dll). Either GUI or console mode applications may be developed with the aid of Homer.NET libraries. This may be done either with or without the larger, HomerApp framework.
Homer.NET libraries may be modified and recompiled with batch files included in the distribution. These batch files call the C#, Visual Basic, or JScript .NET command-line compilers that are part of the .NET Framework 2.0 Software Development Kit (SDK), which is freely available at
http://msdn.microsoft.com/en-us/netframework/aa731542.aspx
.NET code may be written with any text editor, including EdSharp, which is freely available at
http://EmpowermentZone.com/edsetup.exe
The Microsoft Visual Studio integrated development environment (IDE) includes other developer tools. Express Editions are freely available at
http://www.microsoft.com/express/Windows/
Sharp Develop is an open source, cross platform IDE for .NET languages, available at
http://www.icsharpcode.net/opensource/sd/
The HomerApp installer, appsetup.exe, is build with the free Inno Setup software from
http://InnoSetup.org
The Inno Setup script file, appsetup.iss, provides instructions to the Inno Setup compiler for building the appsetup.exe installer. The file is well-commented to help developers adapt it for other installers. It creates Source and Help subdirectories of the application directory, containing source code and documentation files, respectively. The Homer.NET subdirectory is also created, containing the source code, binaries, and samples of the Homer.NET library.
The Source subdirectory includes the AppStamp utilities, which can enable a user to conveniently update an application from a web site. AppStamp is also available separately, including full documentation, at
http://EmpowermentZone.com/AppStamp.zip
The .NET Framework 2.0 will also be installed if not found, using a utility from the Microsoft Component Installer Software Development Kit, available at
http://www.microsoft.com/downloads/details.aspx?familyid=2A5E4EBC-651C-40AA-9525-1810AF47C317&displaylang=en
Development Notes
The latest version of HomerApp is available at
http://EmpowermentZone.com/appsetup.exe
or .zip for a manual install.
I welcome feedback on HomerApp, which helps it improve over time. When reporting a problem, the more specifics the better, including steps to reproduce it, if possible.
Jamal Mazrui
jamal@EmpowermentZone.com