In displays built using the SL-GMSDraw Dynamic Graphic Editor, attributes of graphic objects automatically change to reflect the state of application-specific data variables according to dynamic properties attached to objects when the screens are built. For example, the color of a dynamic icon will change to red if the value it is displaying goes above a specified threshold.

It is easy to see from the features listed below that SL-GMS is different from any off-the-shelf package that may be available. At a glance, other products may seem to offer similar functionality, but look further and you will find there is simply no comparison. SL-GMS offers the superior solution to create your application's dynamic data displays.
SL-GMSRun-Time Library
in an MFC-based application

Robust Framework for Dynamic Graphics

The engine provides a robust library of basic functionality, both for the management of the dynamic graphics and also for the control of user interaction sequences and the overall application.

Proven, tested, and efficient mechanisms for storage of model files, for text handling and object extent processing, execution of dynamic properties, update and redraw optimizations, linkage to dynamic variables, and much more.

Easy Integration with Native Application Frameworks

The SL-GMSRun-Time Library is easily embedded within the most common user application frameworks.

It is a superb extension to the Microsoft Visual C++ and MFC framework for creating sophisticated Windows applications, fully integrating with user-created dialog windows and frameworks. It provides an excellent way to minimize the amount of specific Windows programming that must be maintained, yet reap all the benefits of operating within the Microsoft Windows framework, by providing many common functions in pre-defined classes.

Additionally, the SL-GMSRun-Time Library may be invoked from native MOTIF code, or from an application produced within a GUI builder.

Applications Supplied as Components

In the Windows environment, an SL-GMS application can be deployed as an ActiveX component, making its dynamic graphics displays available to any application which is implemented as an OLE container. An ActiveX Component application can be accessed in tools such as Internet Explorer, Visual Basic, and other Microsoft programs, such as Word.

Additionally, an SL-GMS application can be constructed as a Netscape Browser plug-in in either Windows or in UNIX/Motif.

It is also possible to provide an SL-GMS application as a Java Bean, so that it can be accessed from a Java applet.

Over 50 Dynamic Behaviors

SL-GMS provides a complete set of built-in dynamic graphics behaviors including: real-time movement, rotation, curvilinear path movement, color change, percent fill of irregular objects, visibility, scaling, labeling, and edge and line width and coloring.

In addition, users may define special types of dynamic properties in C or C++ (or other languages) for inclusion in their system. Many users make extensive use of this capability to both extend and to optimize the dynamic behaviors available.

Native Dynamic Control Objects

The SL-GMSRun-Time Library provides special support for a large set of native control objects in both the Windows and X-Window Motif programming environments. The types of controls supported include push buttons, radio/check buttons, text labels and editable text fields, scrolling text lists, scales (sliders), pull-down and pop-up menus, and many others.

Normally, to make use of these native control objects a great deal of system-dependent programming needs to be done. In SL-GMS, however, special support has been provided which makes it possible to include native control objects in a dynamic display with no programming at all.

Native control objects in SL-GMS are implemented as a special type of graphic primitive. They may be added to any SL-GMS model and can be connected to data variables just like other graphical objects in SL-GMS, without the need to learn or write specialized MOTIF or MFC code. This is because the callback functions necessary to use these objects are automatically supplied by SL-GMS and provide a built-in interface to functions and data just as other dynamic graphics objects do.

It is a very powerful way to build system-independent dialog windows without any direct programming.

SL-GMS allows graphical object hierarchies to be built by organizing graphical objects into "groups", which may contain other groups nested within them. Dynamic properties can be attached at any point in the hierarchy to control the objects within that branch of the hierarchy.

A collection of dynamic graphics objects is called a graphical "model" when it is saved to disk as a model file. A model can be used in two ways ... either as the description of a top-level dynamic graphics display screen, or as a smaller, reusable "submodel" component, which can be replicated multiple times in many screens.

The ability to "instance" submodels is perhaps the most valuable feature of SL-GMS. Each instance of a submodel can have its own attributes and be connected to independent dynamic variables. Complex dynamics can be attached to submodels.

When provided in a library of "palettes," submodels can be dropped into the drawing area and assigned to new variables in a pop-up window. This capability is a powerful mechanism for providing re-usability and minimizing screen construction and maintenance time.

Fast Pan/Zoom with Layering and Decluttering

The ability to zoom and pan over the graphical models in SL-GMS is highly developed and optimized. A variety of zooming and panning behaviors are readily available and easily provided in an SL-GMS application.

SL-GMS C++/Map and C++/Net include support for sophisticated layering and decluttering operations, providing a way to overlay complex background maps with large numbers of dynamic graphical objects.

Optimized Performance Functionality

The SL-GMS system has been highly optimized following years of performance monitoring, testing and enhancing.

In a large monitoring and control system, there may be several areas where performance needs to be optimized. In SL-GMS, multiple techniques for performance optimization are available to cover many different extreme cases. Some of these techniques are listed here:

• automatic caching of models and submodels, for fast memory access instead of disk
• handling of structure variables (tags) and arrays, commonly used data types
• user-definable action functions, so dynamics functionality can be optimized in code.
• double buffering on a per-object basis, permitting smooth animation with low overhead
• an efficient update mechanism that redraws only the elements that need to be changed

One of the most common requirements in a dynamic graphics control system is to determine from the process diagram models the list of variables that are to be monitored in an application and to control that list programmatically.

SL-GMS provides a number of variable registration techniques which make the task of associating variable lists with models easy.

BScalable Architecture

Able to support hundreds of screen-states and thousands of dynamic elements, SL-GMS has a scalable architecture designed to allow the efficient creation of application screens from a small prototype to the largest application. A simple, efficient interface handles numerous, as well as very large, data sets.

Utilities for Performance Testing and Debugging

SL-GMSRun is a multipurpose utility for debugging, performance testing, print output testing and automatic cycling of models in the selected directory.