|Run Java Demos
Run Mobile Demos
Download C/C++/.NET Demos
| Request Evaluation Copy
Request Web Conference
Customizing Look and Feel
Creating Custom Components
GLG Widgets FAQs
with Application Environment
C# / VB.NET
Data Integration and Supply
Unix and Linux
GLG's extensive library of dials and meters, gauges, charts, graphs, process control widgets and
components is built on top of the Toolkit's object engine - an approach
radically different from the traditional methods of creating
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.
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 simple resource-based
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.
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
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 required.
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
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
widgets to be deployed as one component, while each individual widget
on the page can be still be updated independently.
All components may be reused in different programming environments using a choice of C/C++, Java, C# .NET or ActiveX programming containers provided by the Toolkit for a variety of Unix/Linux and Windows platforms. Since each component is completely defined by its GLG drawing and has no source code, no porting is required.
The Toolkit provides a variety of native programming containers for integrating GLG components into users' applications: a Motif, Gtk or Qt widget for X/Unix/Linux environment, a custom control, an MFC class, a C# User Control or an ActiveX Control for Windows, and a Java bean for Java applications. The Java version of the Toolkit uses its own, 100% pure Java object engine, while the C# version implements the GLG object engine in C#. GLG's easy-to-use Programming API is provided for altering the appearance of components at run-time.
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 GLG Widgets FAQs.
The toolkit provides several
pre-built widget sets:
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
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
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.
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 Builder.
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.
created custom components can be integrated into the
Graphics Builder, in which case they will appear in the Builder's
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
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.
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
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.
Toolkit can be deployed using a variety of
programming environments, as well as the hardware and software
components may be deployed using either a cross-platform or a native
programming container. A cross-platform
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
bean and Java class library for the Java development, as well a
choice of a C# User Control or
Control for the C#
and VB.NET deployment are also provided. Click here for
information on available programming containers and deployment options.
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.
on the following links for more information on
specific topics of the GLG Programming API:
Integration with Application Environment
Data Integration and Supply
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 information.
components and the GLG Standard API are royalty-free and
can be distributed with your application with no run-time fees.
one of the links for more information:
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# User Control or an ActiveX Control.
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.
Professional Edition of the Builder can be used to create
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.