The AppWare Foundation: An Overview

Articles and Tips: article

MORGAN B. ADAIR
Senior Research Engineer
Systems Research Department

01 May 1994

The AppWare Foundation™ is a cross-platform application programming interface (API) that enables programmers to create cross-platform applications, independent of client operating system, user interface, and network services. The AppWare Foundation immediately benefits third-generation language (3GL) application developers by allowing them to support a variety of desktop platforms from a single application code base.

The Foundation of the AppWare Architecture
Goals of the AppWare Foundation
AppWare Foundation Architecture
Components of the AppWare Foundation
What's Next for the AppWare Foundation

The Foundation of the AppWare Architecture

The AppWare Foundation is a cross-platform Application Programming Interface (API) for developing cross-platform applications. The AppWare Foundation provides an interface to common operating system, user interface, and network services, regardless of the underlying operating system.

Figure 1 shows where the AppWare Foundation will fit into the AppWare architecture when all components of the architecture are complete. The Foundation provides an interface to services of the network and client operating systems, and graphical user interface (GUI). Developers currently can write applications directly to the AppWare Foundation API. In the future, you will be able to build applications by combining AppWare Loadable Modules (ALMs) written to the AppWare Foundation. You can port applications you have written to the AppWare Foundation between the operating systems supported by the Foundation by recompiling the application on the new platform. The AppWare Foundation currently supports Microsoft Windows, Macintosh, UnixWare, Sun Solaris, and HP-UX clients.

Figure 1: AppWare Architecture.

Goals of the AppWare Foundation

Novell had the following goals for the AppWare Foundation:

Hide the complexity of the client and network operating systems and GUI. As described above, the AppWare Foundation provides a common interface to the underlying systems. For example, the Foundation has a Window component that provides support for modal, modeless, and floating windows. Although there is a single programming interface for all supported platforms, applications running on each platform have the look and feel of the native platform.

Increase developer efficiency by creating a standard interface. Developers write an application once, then it can be recompiled for any client supported by the AppWare Foundation.

Match the performance of applications developed directly to the client operating system and GUI.

AppWare Foundation Architecture

In meeting the goals outlined above, the developers of the AppWare Foundation implemented an architecture with the attributes described below.

Layered Architecture

The AppWare Foundation has two layers: a C-interface API and a C++ object class library. Novell is working with Borland to produce the object class library, which will be jointly marketed as ObjectWindows for AppWare Foundation^O. Developers will have backwards compatibility with the popular Borland ObjectWindows Library (OWL 2.0) as the interface to the Foundation. ObjectWindows for AppWare Foundation will be compatible with Borland, Microsoft, Symantec, and GNU C++ compilers, and will provide application templates for improved code reusability, exceptions to improve application robustness, and multiple inheritance and object persistence features provided by the C++ programming language.

Scalable Architecture

In implementing components of the AppWare Foundation, its developers could have chosen to implement features common to all supported operating systems, or provide features of all client operating systems to each operating system. For example, text objects on Windows can have only one font. Text objects on Macintosh must be less than 32,000 characters. The developers of the AppWare Foundation could have implemented a text object that is limited to a single font and 32,000 characters. Or, they could have implemented a text object with multiple fonts and no character limit. The first approach imposes unacceptable feature limitations on components; the second approach essentially creates a virtual operating system on top of all supported client operating systems, which will be much less efficient than any of the clients.

The approach they took was to create a modular, scalable architecture. There is a basic text object that is limited to 32,000 characters and only one font, and a complex text object that allows multiple fonts and no character limitation. Developers can choose the text object appropriate to the application.

Superset Functionality

Taking the scalable architecture to its logical conclusion, the AppWare Foundation developers chose to implement a superset of the features of the supported client operating systems. If a useful feature exists on any supported operating system, the Foundation provides that feature on all client platforms, if it is reasonably feasible from a technical point of view. For example, the Foundation provides a Microsoft Windows-like implementation of child windows for both Macintosh and the supported Unix clients.

Another example of the AppWare Foundation's superset functionality is printing on Unix. The Foundation supplements Unix's limited printing support with its Print component, which provides a much-needed printing model.

Native Implementation

There are two basic approaches to implementing a portability toolkit like the AppWare Foundation: first, to develop a virtual machine or emulation package that executes the toolkit's object code; second, to implement each function in the target client's native code. The AppWare Foundation takes the second approach. The consequences of this approach are:

Applications developed using the AppWare Foundation run as efficiently as native applications.
Applications developed using the AppWare Foundation have the look and feel of natively-developed applications.
Applications can be ported incrementally to the AppWare Foundation, because Foundation code can coexist with code written for the underlying client operating system.

Components of the AppWare Foundation

The components of the AppWare Foundation are grouped into three series: Operating System Services, User Interface Series, and Network Connectivity Series. The following tables summarize the components in each series (in the version 1.80 release of the SDK).

Operating System Series Components

Component	Description
Character	Allows thedeveloper to deal with internationalizationissues relating to character encoding and types.
Data	Provides dataconversion functions similar to atoi, itoa,sprintf, and scanf. Also supports data structureslike buffers, lists, and trees.
Error	Error handlingfor device or media failures, media overflows.
File	Supports fileI/O, file and directory path manipulation,directory traversal, file copying, and aliases.
Font	Provides platform-independentfont selection and font sharing capabilities.
Graphics	Large set ofgraphics functions: lines, polygons, rects,text, patterns, icons, bitmaps, palettes.
Instance	Provides sharedfunctionality for all AppWare Foundation instances.
Key	Provides auniversal keycode interface, allowing programmersto code for various keyboards.
Memory	Routines forallocating, locking, unlocking, resizing,and deallocating application heap memory.
Module	Provides routinesfor creating shared libraries. Allows static,dynamic, and runtime linking of librariesand support for multitasking.
Pointer	Pointer/cursormanagement. Allows the developer to getand set the cursor position, as well as constrainthe cursor position.
Preference	Provides theability to access and modify preference settingsin application-specific files.
Print	Provides functionsto open and close print devices, set up pageand print options, and control documents and pagination.
Record	Manage fixed-or variable-size data storage records.
Resources	Enables theloading of user-defined resources and standard system resources.
System	Allows thedeveloper to query platform-specific attributes,including the number of screens and workstation information.

User Interface Series Components

Component	Description
Application	Manages globalinterface facilities, including system palettes,system notifications, and application menus.
Box	Supports boxesin the user interface, containing buttons and other objects.
Button	Supports single-,double-, and tri-state selection mechanisms.
Dialog	Provides functions,messages, and data structures used to create a variety of dialogs.
Display	Provides andinterface instance used to display static information to the user.
Edit Text	Supports andinterface object used as input device for entering and editing text.
Help	Support forcontinuous and user-requested online help.
Item	Facilitiesfor manipulating many data types in AppWare Foundation instances.
List	A list interfacefor both a data display and a single-dimension selection device.
Menu	Supports menubars, pop-up menus, option menus, and button menus.
Slider	Supports scrollbars, as well as input devices for selectingvalues within a programmer-defined range.
Standard Package	Supplies standarddialogs for selecting files, fonts, colors, printers.
Table	Provides aninterface for displaying, selecting, andediting data from a two-dimensional grid.
Void	Support forprogrammer-defined components.
Window	Support formodal, modeless, and floating windows.

Network Connectivity Series Components

Component	Description
Clipboard	Enables datatransfer within or between applications.
Pipe	Support forcreating, opening, querying, and closingnamed pipes for stream-oriented communication between tasks.
Task	Supports launching,executing, and enumerating tasks in a multitasking environment.

What's Next for the AppWare Foundation

The AppWare Foundation continues to evolve and develop. Some current and future developments include:

ObjectWindows for AppWare Foundation. Already mentioned, ObjectWindows for AppWare Foundation will provide a C++ class interface to the Foundation.
Directory services, messaging, and transaction monitoring components.
IBM AIX, OS/2, and WindowsNT support.

* Originally published in Novell AppNotes

Disclaimer

The origin of this information may be internal or external to Novell. While Novell makes all reasonable efforts to verify this information, Novell does not make explicit or implied claims to its validity.