Ambiencia Products  
Galaxy 3.0
Galaxy 4.0
Technical Description
Structural Managers
User Interface
Operating System
Standard Dialogs
Building Applications
  More Information  

For more information about the products, please contact us at

Structural Foundation

Galaxy Structural Managers

Galaxy includes an advanced infrastructure that directly assists development teams in designing and building complex applications. Galaxy’s infrastructure consists of seventeen managers, plus other mechanisms, that boost application performance, eliminate redundant code, and allow the development team to build, test, and enhance a large-scale application quickly and efficiently. Selected Structural Managers are described below.



B-Tree Manager
Number Manager
Class Manager
Plane Geometry
Command Manager
Preference Manager
Date Manager
Regular Expression Manager
Debugging Manager
Manager Resource Manager
Dictionary Manager
Manager Representation Manager
Exception Manager
String Manager
Installation Manager
Undo Manager
Name Manager


The Dictionary Manager, Name Manager, and scribes are key parts of the Galaxy infrastructure. They are used extensively in Galaxy applications - and in Galaxy.


The Dictionary Manager offers a configurable hash table for applications that need quick, low-overhead keyed access to, and storage of, memory-resident data. Dictionaries are used heavily by the Command Manager to maximize efficiency and performance. Dictionaries help minimize coding overlaps between modules, and automatically resize when the number of elements in them exceed a threshold density, without developer intervention.

The Name Manager provides local and global name tables that are used to quickly and efficiently resolve string references without resorting to character level comparison. Name tables use pointers to the actual character contents of a string, enabling tables to resolve name references as quickly and far more intuitively than the integer comparison approach. Galaxy’s Name Manager also allows the runtime querying of object attributes.

Scribes are transient objects that provide full encapsulation of strings. Scribes handle string conversions internally, so the developer can avoid having to manage the details of converting strings between languages or formats. Scribes also offer a “lightweight” mechanism for generating a string from multiple scribes by concatenating a set of encapsulated scribes into a string.



Four "Core" object classes of the Galaxy Infrastructure.
Galaxy’s infrastructure also includes four “core” object classes: the instance class, the delegator object class, the object class, and the attributed object class.

The instance class implements a simple object with initialization and destruction semantics. The instance class can be used for building other object classes that require startup and shutdown semantics, but do not need the more extensive set of methods provided by the vobject class.

The delegator class implements a flexible model for dynamic inheritance of methods among certain Galaxy object types. A delegator object can implement a method itself, or ‘delegate’ the method to another object, allowing objects to dynamically inherit methods from other objects at runtime, without having to recompile. An object can be both a delegator and a delegate, and delegate objects can be shared among delegators. For example, a delegate class that reads and writes raw byte data could be shared by both a delegator that reads and writes integers and a delegator that reads and writes strings. With dynamic inheritance, object functions are not strictly limited by the inheritance hierarchy available at compile time, and backwards-compatible structural changes can be made to an application without disruption.

The object class provides the typical starting point for subclassing in Galaxy. All of the user interface classes provided by Galaxy inherit from the object class. The object class contains a rich set of message definitions for static or dynamic copying, resource management, and tagging.

The attributed object class implements an innovative model for dynamic inheritance of properties among Galaxy user interface objects. Attributes of objects in the user interface hierarchy have values that can be bound and queried by an application through the Command Manager. This abstraction allows attributed objects to be enhanced, moved, and even replaced at run time, without changing any application code.


Class Manager


The Class Manager provides a rich set of functions for defining classes, objects, methods, and inheritance using ANSI standard C. The Class Manager extends the C language with object-oriented capabilities normally associated with C++, such as subclassing, overloading, inheritance, polymorphism, and class determination. The Class Manager also provides some highly advanced additional capabilities, such as dynamic inheritance. Dynamic inheritance allows object relationships to be defined at runtime. The Class Manager augments the C language with the mechanisms to work with a variety of class types—from “lightweight” classes with initialization and destruction semantics to “heavy” classes with resource storage semantics—to assist in the development of custom classes. The Class Manager enables developers working in C to take advantage of the dynamic capabilities of attributed objects and delegator objects.


Command Manager


The Command Manager works in conjunction with the Class Manager to allow application code to be developed and managed separately from the implementation of the user interface. Dynamic attribute binding is the basis of the Command Manager. When a command is issued by an object, the object’s attributes are bundled with the command, so the application can determine the state of the object issuing the command. An application using the services of the Command Manager does not refer directly to user interface objects. Galaxy’s attribute binding mechanism resolves named command references automatically at runtime.
The linkage between the user interface and the actions implemented by the application is expressed visually in the Galaxy Visual Resource Builder by setting the object tag, without application code. The developer defines the actions the application can perform and “exports” these actions in the form of a dictionary of command names. There is a direct relationship between command names and user interface object tags. When a user interface object is activated by a user, the object builds a command on-the-fly, based on its tag and attribute dictionary, and issues a command with the same name as the issuing object. The application responds to the command, instead of to the user interface object. So, even if the user interface object is changed, as long as it issues the same command the application will make the appropriate response. This mechanism allows the developer to significantly change the behavior of an application without requiring changes to the source code and launching an entire edit, compile, link, debug cycle.


Resource Manager


The Resource Manager supplies a mechanism for the persistent storage of structured data in machine-independent binary files. Both applications and other Galaxy Managers use the Resource Manager to store and retrieve user interface objects, strings, graphics, and other Galaxy resources. Resource files can be created either through the Resource Manager API or by using the Galaxy Resource Environment. The entire user interface for an application will typically be stored in one or more resource files, making application test/debug, internationalization, and enhancements relatively straightforward. The Resource Manager can also be used to embed read-only resource files within an executable file, allowing an entire application to be delivered as a single executable file. Disk-based resource files are completely portable across machine architectures. Multi-byte values are stored in native form and translated when read on a new platform. The Resource Manager operates on eleven primitive resource types, each of which corresponds either to a C/C++ or a Galaxy data type. A resource file consists of a dictionary which holds resource components, including other dictionaries or arrays of resource components.


Representation Manager


The Representation Manager allows the developer to create and manipulate generic objects called scraps. Scraps encapsulate a piece of typed data and the information required to access and interpret that data. The Representation Manager provides a powerful abstraction that allows data stored in different formats, such as native integers, resource integers, preference integers, or network integers to be accessed and converted through a single API. Scrap classes inherit from the Instance class and the Delegator class. The Delegator class provides scraps with multiple inheritance capabilities that make the Representation Manager a highly flexible element in building a complex, high-performance application.
Representation Manager functionality underlies the Datatag Manager, which enables diverse applications to transact data across the network. Scraps can also be used to pass preference data to the Galaxy Preference Manager, or to access resources and resource files instead of using the Resource Manager API.

Untitled Document

Copyright © 2004 Ambiencia - All Rights Reserved | About Ambiencia | Terms of Use | Privacy Statement