|
|
As today's software organizations move toward open systems development in X/Motif, object-oriented programming is rapidly becoming standard. The promised benefits? Portable, well-engineered systems that are easily maintained and reusable across projects. Shortened development cycles. An overall increase in productivitythe ability to deliver more applications in less time, and with less effort .
Yet few organizations are really obtaining these benefits. They're finding that object-oriented development is often less straightforward than they thought, and that it can require just as much time and effort as more traditional methods. Most tools claiming to support the process tend merely to offer nods in its direction, providing "cut and paste" interface builders or generating C++ code at the back end.
Today's engineers need a comprehensive, full-featured solution that supports an object-oriented approach throughout the entire life cycle of GUI application development-from concept, through design and development, to the generation of code that truly mirrors an application's object-oriented design.
That solution is TeleUSE. Aonix' latest release of the renowned TeleUSE User Interface Management System (UIMS) provides all the tools developers need to interactively design and build fully object-oriented, Motif-based GUIs in C, C++, UIL or Ada95 supporting Motif 1.2 and X11R5. You can use TeleUSE to generate C code, UIL, Ada95, or C++ classes that map directly to your designs.
TeleUSE Highlights:
- User Interface Templates with Multilevel
Encapsulation for flexibility and simplicity in reusing objects in
other areas
- Rules-Based, Event-Driven Callback Script Modules drastically reduce the amount of time and work required to write callback
code in reusable modules
- "X Windows Smart" Debugging for rapid and
efficient debugging of callback code
- C++ Class Generation lets you work smarter by
providing full access to GUI components (such as reuse, subclasses,
instantiation, etc.)
- Generation of Reusable Software Components
means that you can get your job done faster by selecting from a library of GUI
object s
- Advanced Application Building automates the
build process and allows for customization and third-party tools integration
- World-Class Open Systems Support from Aonix
for ease and flexibility in creating portable and distributed applications
-
Advanced Graphical Widgets for TeleUSE - TeleUSE includes a comprehensive integration kit for Quest Software's Motif Widget Products. The XRT family of widgets (object-oriented
software libraries) for Motif is used by thousands of professional developers
around the world to build informative, attractive and functional
user-interfaces.
TeleUSE radically reduces the learning curve associated with C++ development,
helps engineers deliver mission-critical GUIs in a fraction of the time required
currently, vastly improves product maintenance, and fosters teamwork and
widespread reuse. In short, TeleUSE is the solution companies need to help them
complete the shift to object-oriented software methodologies-and to fully
realize the rewards of this new approach.
Click here to see a TeleUSE system diagram.
Check out these exciting TeleUSE Product Family options:

TeleUSE Features
-
User Interface Templates with Multilevel Encapsulation
^ RETURN TO TOP ^
TeleUSE's
Visual Interactive Presentation (VIP) tool allows you to easily design
object-oriented widget templates-screen elements, screens, or groups of
screens that can be reused within or across applications. A developer needing
a control panel, for example, can simply use an existing control panel
template, and this new object will inherit the widgets, resource values, and
methods defined in the template. Templates can be viewed and edited either
through the VIP tool or within the outline-oriented tree editor, which
displays a template's components as nodes in a tree hierarchy.
Not only does the system support true inheritance across all instances of a
template, but with TeleUSE, a template's designer can use the object-oriented
mechanism of encapsulation, or data hiding, to selectively control which
information in a template will be revealed to its users. Users can access and
change particular template parameters, add certain nodes to a template, or
directly edit selected nodes-all without seeing any information that is not
absolutely necessary to the operation at hand.
The benefits? Encapsulation gives the designer flexibility in providing for
a template's reuse. It shields users from complex or irrelevant information,
so they can quickly use even large templates in different application
contexts. And features that are integral to the original template design are
protected-and maintained through all instances of the template-to enforce
changing corporate standards.
-
Rules-Based, Event-Driven Callback Scripts
^ RETURN TO TOP ^
One of the most powerful features of TeleUSE is its Dialog Manager, which
lets you specify, manage, and control the dynamic, or dialog, code that
connects the GUI to the application code. You do so not through painstaking
hard-coding of callbacks and events-although this option is available should
you so choose-but rather by writing simple, object-oriented callback scripts
that define the rules to be used when given events occur. The scripts are
high-level abstractions of the X and Motif library routines. Ordinarily
written from scratch, these scriptsfully insulate you from the nuances and
complexities of the underlying window system. They let you accomplish all the
callbacks and event handling your application needs in a fraction of the time,
and with a fraction of the instructions, required by direct low level coding.
You can master the scripts' use and syntax in less than three days of
training-and they're not just easy to write, but easy to read as well. At any
time during development or maintenance, you can locate needed changes in
moments and make those changes with a few keystrokes. In generating C or C++
code from your dialog files, TeleUSE handles memory management automatically.
And the files are broken into object-oriented dialog modules that can be
instantiated, like UI templates, as classes-which means that they can be
created, augmented, and modified on the fly, during runtime.
-
"X Windows Smart" Debugging
^ RETURN TO TOP ^
TeleUSE's graphical, interactive Dialog Debugger traces callback code as
it is associated with X events, offering a significant advantage over
general-purpose C and C++ debuggers. And you can run the Dialog Debugger in
concert with popular third-party tools, such as those from CenterLine
Software, to debug dialog and application code simultaneously.
-
C++ Class Generation
^ RETURN TO TOP ^
TeleUSE generates true C++ classes that are directly mapped to your
design, and these classes then create and manage Motif user interface
elements. With this capability, TeleUSE's VIP tool becomes a visual C++ class
designer, from which you can specify callbacks as member functions. You are,
in effect, defining C++ objects that tightly integrate the presentation (data)
and dialog (behavior) components of your application. The results? First, you
can instantiate and change widget templates dynamically, at runtime, just as
easily as during a VIP session. And second, because TeleUSE implements the key
components of an application and its interface as C++ classes-using Motif
widgets as primitives-you enjoy true tool support for the optimal C++/Motif
programming techniques defined by Doug Young in his highly-regarded book
Object-Oriented Programming With C++ and OSF/Motif.* Your applications and
their components are extremely easy to reuse, and the effort required for
product maintenance is reduced dramatically.
-
Automatic Generation of Reusable Software Components
^ RETURN TO TOP ^
The User Interface (UI) Builder of TeleUSE can build not only fully
executable applications but reusable software components-that package visible
portions of an interface with their associated dynamic behavior. You can
quickly
create a repository of these components and use them repeatedly as fully
operational building blocks for larger applications. The result? Engineers in
your organization need no longer spend time "reinventing the wheel." Shared
reusable components make it easy to establish core technologies, then use them
to produce any number of different products. And the benefits accrue over
time. With each new development effort, new components are added to the
repository, which only expands the ability to share work among projects-and to
further reduce development cycles.
-
Advanced Application Building
^ RETURN TO TOP ^
The UI Builder offers a wide range of hooks into third-party tools and
configuration management systems, along with over 100 file switches for
customizing the automated build process. You can, for example, run dialog
scripts in interpreted mode, for rapid prototyping, testing, and changing the
interface during runtime. And again, the UI Builder can build not only fully
executable applications but cohesive, shared software components that can be
reused across development projects.
-
World-Class Open Systems Support from Aonix
^ RETURN TO TOP ^
|

|