Web / Mobile Demos:
ASP.NET or JSP (Server Side)
Download Desktop Demos: C/C++ / C# .NET / Java
| Request Evaluation Copy
Request Web Conference
Customizing Look and Feel
Creating Custom Components
GLG Widgets FAQs
||Integration with Application Environment
C# / VB.NET
Data Integration and Supply
Unix and Linux
C# / .NET
GLG's extensive library of dials and meters, gauges, charts, graphs, process control widgets
and other graphical components is built on top of the Toolkit's
object engine - an approach radically different from the
traditional methods of creating programming components.
Instead of writing a custom class or code for
each component, a component is just a drawing created using the Graphics Builder and
comprised of a collection of graphical objects which define the
graphical appearance of each widget. The connections between
objects in the drawing are also wired within the Builder to
define the component's logical behavior.
At run time, the component's drawing is loaded
into the GLG object engine, which renders the component on the
screen and handles user interaction according to the component
description defined in the drawing file. The GLG object engine is
encapsulated in a GLG Widget, which presents the user with a
Programming API for loading the component and updating it
with real-time data.
The obvious benefit of the GLG component design approach is component's portability: as soon as the GLG object engine is ported to a new platform or programming environment, all GLG widgets are immediately available. For example, all GLG widgets are available on a variety of hardware and software platforms, as well as in C/C++/C#/.NET and Java.
Since the components are built on top of the
Toolkit's vector graphics engine, they are screen-resolution
independent. When the control is resized, the graphics
inside it are resized as well to fit its new extent. The Toolkit
also handles flicker-free updates and all
platform-dependent details of the low-level graphics, so the
developer does not need to. A run-time choice of an OpenGL or a native GDI
renderer is also available, with no additional programming
The Graphics Builder may be
used to customize each component interactively. In addition to
changing the component's resources, it also allows the user to
edit the component's graphics directly, changing its shape or
adding/deleting new graphical objects to the component's drawing.
For example, it is possible to change the shape of a dial's needle
or to copy and paste it to add a second needle. Another example is
adding custom annotation labels to a graph, or adjusting the size
of its plotting area to leave more space for custom labels. The
Graphics Builder may also be used to create custom
dashboards and simulation
control panels that contain multiple widgets to be deployed
as one component, while each individual widget on the page can be
still be updated independently.
In addition to the widget containers for
integration with the platform's native programming environment, a
generic cross-platform API
is also provided. If the generic
API is used, the same source code may be compiled and run on
any supported C/C++ platform without any changes.
Click here for the
provides several pre-built widget sets:
Each widget set contains from ten to a hundred
widgets. Each widget is simply a drawing created with the Graphics Builder.
The component's drawing can be loaded into the Graphics Builder for browsing its resources or interactive editing. Since the component is a collection of graphical objects, it is extremely flexible. The control's appearance (colors, shapes and position of objects, etc.) can be changed interactively using the Builder's point and click interface, and a modified component can be saved for later use. More extensive customization, such as adding new labels, legends, and axes can also be performed. Click here for information on the Graphics Builder.
the visual appearance is encapsulated in the drawing, the
application does not have to be recompiled every time the drawing
changes. This enables fast prototyping by eliminating
time-consuming compile-link cycles.
All aspects of the
component may be completely customized with the Builder, which
eliminates the notion of a component's source code, since
the drawing serves as a complete description of the object's
appearance and behavior.
The Graphics Builder allows the developer to give custom names to a component's attributes. This provides an easy access to any component's attribute, which is not possible for code-based components, whereas only attributes that were handled in the code are accessible. Such named attributes become resources and can be accessed from the program at run-time to alter a component's appearance or to supply dynamic real-time data.
The Graphics Builder can also be used to create
panels or dashboards containing multiple controls. Simply create a
new canvas, drag-and-drop, position and resize controls using the
mouse, name each control to access its resources and save the
drawing. The control panel is now ready to be used in an
application. It can also be prototyped with simulated data in the
New custom components can be created from scratch using the Professional or Enterprise Editions of the Graphics Builder. It is also possible to use an existing component as a template and modify it. For example, a second needle may be added to a dial by copying the dial's needle and pasting the copy into the dial. After the second instance of the needle is renamed, it is ready to be driven by program's data. Since the needle object encapsulates all its controlling parameters, no extra work is necessary. The needle's dynamics parameters will have been copied. The simulation panel shown on the right uses avionic gauges widget set and is a good example of a custom component.
Newly created custom components can be integrated
into the Graphics Builder, in which case they will appear in the
Builder's component palette.
Custom components are not limited to graphs,
meters or dials. A custom component may be as complex as a dynamic
process control drawing used to
visualize the state of a chemical process. The parameters
controlling a drawing's dynamics are exported as resources and may
be used by the program to update the drawing with real-time data.
The Professional Edition of the Graphics Builder provides the functionality required to build such custom drawings from scratch. The Enterprise Edition of the Builder may be used to add custom events for handling elaborate user interaction, or to display object tooltips. Click here for information on the Builder's Editions.
GLG's easy-to-use Programming API is resource
based. Instead of learning a separate method for each of the
component's resources, a single SetResource method is used to set
any of its resources, even custom attributes created by the user.
All a programmer needs to know is the name of a given resource,
either an intuitive default such as FillColor, or a custom name
given to the resource by the developer.
The Toolkit can be deployed using a variety of
programming environments, as well as the hardware and software
platforms. GLG components may be deployed using either a
cross-platform or a native platform-specific programming
container. A cross-platform
C/C++ API may be used in a platform-independent way on both
Unix/Linux and Windows, enabling an application to be compiled and
run on any platform without any changes to its source code.
An MFC class
for Windows and a Motif, Gtk or
Qt widget for Unix/Linux provide native deployment
containers for the respective programming environments. A Java bean and Java class
library for the Java development, as well a choice of a C# User Control or an ActiveX Control for the C#
library provides a Web deployment option. Click here for more
information on available programming containers and deployment
The Programming API may be used to modify resources of components at run-time and animate the component with real-time data. It may also be used to handle user interaction. Click here for more information on using the API to supply data.
Click on the following links for more information
on specific topics of the GLG Programming API:
Integration with Application Environment
Data Integration and Supply
API allows the application to create and add objects to the
drawing programmatically. This is convenient if the nature of the
graphics or the number of objects is not known until run-time. The
Extended API may also be used to implement drawing editor
functionality (such as dragging objects with the mouse). Click here for more
GLG widget components and the GLG Standard API are royalty-free
and can be distributed with your application with no run-time
Select one of the links for more information:
The starter package for deploying GLG
widgets consists of a Widget Editor (the Limited or Basic Edition of the Graphics
Builder), one widget set, and one deployment option of your
choice, such as a C/C++ library, a Java class library, a C#
Additional widget sets may be added to the package as well.
Click here for detailed pricing information.
If you plan to create custom components, you will need the
Professional or Enterprise Edition of the Graphics Builder. The Professional
Edition of the Builder can be used to create custom
components and drawings from scratch. The Enterprise
Edition adds the capabilities for adding
custom events to objects for implementing sophisticated user
interaction logic. Click
here for more information on Builder Editions.