From: Jamal Mazrui [email protected]

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/

Regards Steve
Email:  [email protected]
MSN Messenger:  [email protected]
Skype:  steve1963
Twitter:  steve9782
If you reply to this message it will be delivered to the original sender only. 
If your reply would benefit others on the list and your message is related to 
GW Micro, then please consider sending your message to [email protected] so 
the entire list will receive it.

GW-Info messages are archived at http://www.gwmicro.com/gwinfo. You can manage 
your list subscription at http://www.gwmicro.com/listserv.

Reply via email to