Now available at
http://EmpowermentZone.com/appsetup.exe

or .zip for a manual install

HomerApp
Version 1.0
May 2, 2010
Copyright 2010 by Jamal Mazrui
GNU Lesser General Public License (LGPL)

Distinguishing Features

The Homer application framework, HomerApp, is free, open source 
software
for rapid application development.  It 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.
----------

Layout by Code

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).
----------

.NET Platform

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.  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 a code editor and 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/


    VICUG-L is the Visually Impaired Computer User Group List.
Archived on the World Wide Web at
    http://listserv.icors.org/archives/vicug-l.html
    Signoff: [log in to unmask]
    Subscribe: [log in to unmask]