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

GalaxyTechnical Description


Galaxy: Addressing the Large-Scale Application Development Challenge

The Galaxy Application Environment breaks through the clutter with advanced, field-proven technology that provides a complete solution. Galaxy enables corporate and commercial application developers to build large-scale, distributed, mission-critical applications-one time and under budget.


Galaxy provides a comprehensive framework for building complex applications. Within this framework, Galaxy offers object-oriented libraries, tools, and services designed for building scalable, graphical, high-performance applications. Galaxy frees application developers from having to manage a different code base for various developers to build portable applications that can run across all major system platforms-UNIX, Windows, Windows NT, Macintosh, OpenVMS, and OS/2- without code changes and without compromising on functionality.

Galaxy’s unique architecture enables developers to meet the toughest challenges in the application backlog. Hundreds of organizations, across a broad spectrum of industries, have standardized on Galaxy for their next-generation strategic applications.

Galaxy Architecture and Technology

Galaxy is the result of several years of research and development directed at the problem of building large-scale, distributed, mission-critical applications. Through several generations, the Galaxy architecture has evolved to its current state of maturity. Galaxy’s elegant architecture is based on a set of advanced concepts, models, and technologies, which have been consistently implemented to create a development environment that is specifically tuned to building the most complex applications. These innovative elements of the Galaxy architecture are profiled below.


Galaxy Abstraction Model


An object-oriented abstraction model lies at the heart of Galaxy. The Galaxy architecture is built with multiple levels of abstraction, using native platform services—operating system services, network services, and window system services as a base. Galaxy’s abstractions start at the lowest level of each native service, building a foundation for the successive levels that support Galaxy’s comprehensive class libraries and manager frameworks. For example, the Galaxy Distributed Application Services (DAS) Session Manager and Service Manager build on the lower- transport-independent byte stream abstraction implemented by the Communication Manager. The DAS Datatag Manager builds on the data encapsulation/conversion abstraction provided by the Representation Manager, to enable platform and application-independent data representation over networks. Galaxy’s Confirmation Manager builds on the abstractions provided by the Dialog Manager, the Button Manager, and the Look-and-Feel Manager to offer a single platform-independent API for a richly functional user interface object. All Galaxy abstractions have been designed and implemented for very high performance.


Galaxy’s multi-level abstractions rest on the lowest level of each native service, ensuring excellent performance and functionality across platforms.

This architecture allows developers to work at a high or low level, as appropriate to the project. Multiple levels of abstraction carefully isolate the internals of Galaxy from the details of specific platform services, ensuring application portability and extensibility. The abstraction architecture replaces disparate native APIs with one consistent API, and produces one source tree for multiple platforms.


Galaxy “Ideal System” Model


The Galaxy “ideal system” model defines a uniform superset of application services-operating system services, window system services, and network services-across all system platforms, accessible through a common API. Galaxy also supports a superset of user interface objects to display any standard look-and-feel on any platform, under the control of the user. Galaxy provides a consistent set of services to the application, even when a native platform does not support a particular primitive function. For example, if the native platform’s available resources are unable to support the color requirements of an application, Galaxy can compensate by using closest-match colors, dithered colors, or even allocating a color map at runtime. Color mapping is based on the preferences set by the developer through the Galaxy Preference Manager. Galaxy also includes a rich set of user-level choosers which can be used instead of, or combined with, native choosers-without losing application portability.


Galaxy’s “ideal system” model enables developers to deliver powerful functionality on multiple platforms without having to “tune” the applications to each platform’s approach to managing colors, files, memory, images, events, strings, and other system services.

Galaxy applications are completely portable, yet are able to offer a consistently superior level of functionality and performance on every platform. Galaxy’s “ideal system” enables developers to construct complex, multiplatform, distributed applications, without having to “tune” the application to each platform’s approach to managing colors, files, memory, images, events, strings, and other system services.


Galaxy Command Model


The Galaxy command model is a fundamental element in the Galaxy architecture. The command model abstracts the relationship between an application’s functional logic and an application’s user interface, allowing the two elements of the application to be developed and managed separately. With the command model, a Galaxy application responds at runtime to a stream of commands from user interface objects, or other services, located anywhere on the network. This model uses Galaxy’s powerful runtime attribute-binding capabilities to allow a dynamic interaction between the application logic and Galaxy resources. The command model delivers the performance advantages of compiled code, enhanced with the flexibility of dynamic binding.


The command model abstracts the relationship between an application’s logic and user interface, allowing the two elements to be developed and managed separately. This model delivers the performance advantages of compiled code, enhanced with the flexibility of dynamic binding.

The command model addresses the limitations of the traditional model of coding user interface callbacks into application code. By separating application logic from user interface function, the developer can enhance Galaxy resources without modifying and recompiling user interface and application code. The command model is well-suited to the demands of building large-scale complex applications, which typically evolve through incremental development stages. Early versions of Galaxy applications scale smoothly to large-scale production applications, eliminating dead end prototyping efforts.


Galaxy Resource Model


Galaxy implements a robust resource model for efficiently managing the development, maintenance, and runtime use of Galaxy resources. Galaxy resources may include dialog windows, user interface objects, text, error messages, color images, internationalization and geometry management information, or other structured data. The resource model treats high-level items as persistent objects, storing them in a machine-independent binary form. This model provides a powerful abstraction that supports visual, incremental development of the graphical user interface, and eliminates the need to build and maintain a large code base for user interface and other application resources. In combination with the command model, the resource model helps break complex development projects into manageable components.


Galaxy Object - Orientation


Galaxy provides an advanced object-oriented development environment that offers the flexibility and productivity benefits of structured code reuse for both ANSI C and native C++. Typical Galaxy applications are built largely from standard and subclassed Galaxy objects. For example, Galaxy provides a set of powerful pre-built user interface objects, including a file chooser, color chooser, service chooser, style chooser, and font chooser, all of which are look-and-feel aware. New features can be easily added to these and other Galaxy objects, with out affecting existing object interfaces. Subclassing is the standard mechanism for extending Galaxy functionality.

Object-oriented functions for the C language are implemented through the Galaxy Class Manager. Galaxy/C++ classes are implemented as native C++ classes. In addition to providing support for a full range of static inheritance functions in the C and C++ languages, Galaxy supports dynamic inheritance for certain object types with both C and C++. Through the innovative use of object attributes and a powerful delegation model, Galaxy allows objects to be enhanced dynamically. This advanced functionality dramatically increases developer flexibility, while decreasing the code base required to construct complex, large-scale applications. Objects used early in a project can be extended and refined by subclassing, adding attributes, and delegating methods, for an efficient transition into production use. Galaxy’s mature object-orientation can significantly enhance application quality and developer productivity, without an extensive learning curve.


Imaging and Drawing Model


The Galaxy Imaging and Drawing Model are based on a powerful abstraction that assumes a target graphics output device with near-infinite resolution, unlimited colors, and algorithmic fonts. Galaxy renders the most accurate image depiction possible through a variety of operations, including error-diffusion dithering, resampling, and color mapping. Galaxy also provides high-performance off-screen bitmap rendering on every platform.

click to enlarge image

Galaxy’s Drawing model provides the closet possible match between screen and printer output, without special application coding.

Galaxy implements a state-of-the-art drawing model derived from Display PostScript that allows the developer to use the same drawing instructions for any raster device. Galaxy’s drawing model provides the closest possible match between screen and printer output, without special application coding. Galaxy directly supports monochrome, grayscale, color-mapped, and true-color displays of different depths, and a wide variety of hard copy output devices. Display PostScript provides scaling, rotation, or any sequence of 2-D transformations on any display or output device.




Galaxy applications are inherently internationalized and “locale-independent’’. The Galaxy internationalization model provides a set of abstractions and mechanisms that allow the developer to write one Galaxy application and deploy it worldwide with minimal effort (multibyte support comes with the Galaxy/International version). The developer simply substitutes the appropriate Galaxy resource file for each target country or locale and runs the application, without code changes. Internally, Galaxy uses a fixed-width processing character set. The processing character set is translated to an external character set through a powerful mechanism that uses transient objects called scribes. Scribes provide full encapsulation and handle string conversions internally, so the developer avoids explicitly managing buffers, copying, and allocating memory. Galaxy/International also supports native input methods and front-end processors on each platform.


Galaxy applications are inherently internationalized and “locale-independent”, and can be localized easily by substituting the appropriate Galaxy Resource File for each target country or locale, without changing code.

The Galaxy Application Environment provides a comprehensive, integrated development and runtime environment consisting of object-oriented libraries, distributed services, and visual tools. The distributed services consist of libraries, runtime services, and user interface components. The visual tools are applications built with the Galaxy libraries. The distributed services and tools are built with the same API used by Galaxy customers to develop applications.


Galaxy: Depth of Features and Functions


Galaxy offers unparalleled depth of features and functions. The completeness and architectural integrity of each element of the Galaxy environment directly addresses the requirements of mission-critical, distributed applications. Unlike other products, the design center for Galaxy has been, from its inception, the construction of large-scale applications. A set of Galaxy managers, selected from within each major category of managers, is profiled below to illustrate Galaxy’s depth and architectural consistency.

Depth of Features and Functions

Structural Foundation: Selected Mangers
Window System Abstractions/Graphical User Interface: Selected Managers
Operating System Abstractions: Selected Managers


Building Applications with Galaxy


Galaxy provides the developer with tools, libraries, and a structural framework designed to make building a complex, large-scale application a manageable undertaking. The design and modeling of a Galaxy application can be performed with any of the popular design methodologies and tools. Galaxy’s resource model and high-level managers replace tens of thousands of lines of code generated in traditional development environments. The typical Galaxy development team works with a combination of Galaxy tools and third party tools, allowing developers to use familiar tools in conjunction with Galaxy.


Galaxy Standard Dialogs


Galaxy provides a number of look-and-feel aware Standard Dialogs to ease the task of writing a style-guide compliant application. Galaxy Standard Dialogs comprise a set of ready-made higher-level objects that provide commonly required user-level application functionality. Standard Dialogs are built using standard Galaxy Managers and standard Galaxy API calls, so they also be easily modified and re-used to meet special project requirements.

Untitled Document

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