UIM/X Product Tour

This tour explores many of the features of UIM/X and highlights the unique architectural approach that has made UIM/X one of the leading GUI development tools for UNIX. It includes the following topics:

What's New

UIM/X Overview

UIM/X has been one of the leading UNIX GUI builders since the early 1990s. There are two primary reasons for this:

  • Open Standards - UIM/X provides an ANSI standard, C and C++ interpretive design environment, allowing developers to interactively create, modify and test GUIs with their underlying C or C++ application connected and running. From within the UIM/X environment, developers can dynamically switch between designing and previewing the working application without ever leaving the tool.
  • Support - UIM/X is marketed by leading OEMs, distributors and VARs. This assures customers that they will be productive in their use of UIM/X and have ready access to updates, third-party products and a large community of supportive professionals. Moreover, UIM/X users have easy access to the greatest accessory market available. For example, ICS's Motif extensions can be supplied pre-loaded with the purchase of a UIM/X license.

UIM/X Interpretive Design Environment

UIM/X is the only tool on the market that has an integral ANSI standard C/C++ interpreter. This feature allows the developer to design and preview a working application from a single environment, allowing:

  • True Object-Oriented Design - Developers can interactively build GUI classes that encapsulate behavior in standard C or C++ code during design time. In addition to full encapsulation, UIM/X supports full inheritance and polymorphism. Full object-oriented design, and specifically true encapsulation, facilitates separation of the interface logic from the application logic. This is necessary to ensure that generated interface code is portable across platforms.
  • Flexible Interpreter - The environment interprets source files and code snippets in C, C++ or any combination of the two languages.
  • Speed - The C++ interpreter is a fast, incremental interpreter, so you only evaluate your incremental changes as you progress with your design. Moreover, you can freely mix compiled and interpreted code to maximize performance without sacrificing iterative development flexibility.
  • Flexible Modes - UIM/X offers run mode in addition to interpretive mode, allowing the developer to build, compile and run the executable within the UIM/X environment.
  • Large-Scale Application Design - The interpreter enables developers to encapsulate GUI behavior within the definition of GUI components at design time. This offers the end user the flexibility to use the best combination of encapsulated behavior and global references to create large, scalable applications.
  • Full Application Life Cycle Support - There are enormous savings to be gained in using UIM/X when you consider the entire life cycle of an application. For example, with UIM/X you never have to modify the generated code. Therefore, when you want to enhance your code for subsequent releases, you simply load your GUI into UIM/X and start working. With other tools, developers are forced to modify the generated code in order to connect the callback behavior. The developer is therefore starting at square one when enhancing code for subsequent releases, since the modified source files are foreign to the tool.

Builder Engine Component Model

The UIM/X core architecture embodies a chassis design that provides developers the greatest flexibility in customizing, extending, or "shrinking" the tool to address their particular needs. The Builder Engine offers comprehensive access to UIM/X's internal API, which enables developers to easily extend UIM/X with foreign components, or allows them to turn-off and hide any of UIM/X's features and functions. No other tool on the market offers this level of extensibility. In short, the Builder Engine functionality allows developers to "build their own builder", addressing two primary customer requirements:

  • UIM/X as the Visual Development Capability of other Software Products - This requirement is driven by software manufacturers who want to embed GUI development capabilities in their software applications, in order to deliver customers a complete visual development environment. Several leading developers in the UNIX software community have adopted this strategy.
  • UIM/X as the Visual Development Component Framework for Enterprise Development - This requirement is driven by corporations who want a custom builder that comprehensively addresses their specific needs. The Builder Engine API enables this type of customer to extend UIM/X with third-party and custom components, in order to provide a single, consistent visual development environment for all of their development groups. In addition, UIM/X can be reconfigured to display only specific functionality to the end user. This feature, made possible by the Builder Engine API, enables corporate developers to enforce style guides automatically by internalizing standards within the tool. It also enables them to create simpler versions of UIM/X for use by less technical users.

Enterprise-wide Development

Within an enterprise environment, the development process encompasses many disciplines, involving individuals with a wide array of specialized talents and varying levels of technical expertise. An iterative development process within the enterprise therefore transcends departmental barriers, allowing groups to not only share ideas, but to share the data that contains these ideas. UIM/X is the only tool on the market that may be scaled down from a full-featured builder for Core Developers to a simpler Content Builder for Human Interface Designers. The various flavors of UIM/X have one important thing in common - the project file. Therefore, various levels of users can share ideas, working off the same foundation, which dramatically reduces the amount of work required during the cross-discipline iterative cycle. Two technologies unique to UIM/X facilitate this attribute of the builder: 

The Builder Engine enables developers to customize and deliver unique configurations of the UIM/X builder. This means Corporate Standards groups can make their rules intrinsic to the tool, while hiding and encapsulating lower level details. 

The Connection Editor offers a simple visual model for adding behavior to an interface. In its simplest form, the Connection Editor is ideal for the new or less technical user. When used by the Core Developer, the Visual Connections Editor scales into a full-featured Visual Code editor, providing the ability to insert C or C++ source code, function arguments and methods. 

Integrated C++ Interpreter

The interpreter is the heart of the UIM/X environment, enabling developers to preview working applications built in standard programming languages without ever leaving the tool. 

UIM/X 3.0 contains a robust ANSI-compliant C++ interpreter embedded in the UIM/X visual development environment. The new interpreter, a full superset of our C interpreter, is fully compatible with UIM/X 2.9 project files and provides a solid migration path to C++-based development. Users can now load C++ source files directly into the interpreter, enter C++ code into any of the UIM/X 3.0 code editors and easily augment UIM/X with pre-compiled C or C++ libraries using ICS's proven Builder Engine technology. 

The integrated C++ interpreter makes UIM/X 3.0 an excellent choice for C/C++ programmers of any skill level. New users will find that the Novice Mode provides a straightforward way to interactively learn and leverage advanced C++ concepts in a friendly and intuitive development environment. Professionals will realize increased productivity gains and avoid time consuming "compile-edit-debug" development cycles, because, as always, developers can make incremental changes to their GUI while their underlying application is connected and running. 

C/C++ Language Support - In today's competitive market, end-user applications are becoming increasingly complex. Users expect functionally complete solutions. For example, an electronic mail application must contain a spelling checker, a spreadsheet application must offer sophisticated graphing capability, a data-entry client must offer field validation and have the ability to talk to different databases engines, etc. How does one compete in such a market? 

The ability to compete effectively depends upon a number of elements, including the skill set of the development team, the effective usage of development tools and the actual programming language being used. A large percentage of packaged professional applications are being developed today in C++. The C++ industry has matured and can now gain leverage from a language that not only offers portability, but also has a wide range of development tools that make it easier to produce high quality, content rich applications. 

UIM/X 3.0 provides an excellent environment for C++-based application development. The integrated C++ interpreter works in conjunction with the different UIM/X user modes and editors to provide an environment that is suitable for developers of any skill level. 

For example, a new C++ user can use the Connection Editor to define application behavior without writing any code. The behavior can then be tested by entering Test Mode. Once the defined behavior has been verified, the user can select a menu option to generate and compile the finished C++ application - all without having to edit a single line of C++ code! 

More experienced users can use the integrated interpreter to assist them in learning the C++ language. C++ code can be entered directly into any of the UIM/X editors and then tested immediately by entering Test mode. Users do not have to wait for lengthy compiles to complete, only to find that the compile failed due to a missing ";". With UIM/X and the C++ interpreter, syntax errors are immediately identified. 

Flexible Usage Model - Having a C++ interpreter built into the development environment has so many benefits, the designers of UIM/X wanted to make sure that it was easy for users to access its power in as many ways as possible. For example, it is common to want a dialog to appear whose initial state can only be determined at runtime using a C++ expression. With UIM/X, it is possible to enter this C++ expression as a value in the Property Editor. When the dialog is created, the C++ expression is automatically evaluated. Alternatively, as shown below, the Interpreter Tool window can be used to evaluate a C++ statement. Files containing C++ source code can be loaded, and standard C++ header files can be loaded to define shared declarations. 

Builder Engine Extensible - As with previous versions of UIM/X, the development environment can be easily extended using the Builder Engine API. Any C or C++ library can have its functions and/or methods registered with the C++ interpreter. Likewise, visual and non-visual components can be integrated with UIM/X to further enhance the development environment. The benefit is that developers can utilize compiled C++ code anywhere desired. For example, they can interactively create a GUI class using the interpreter, and then utilize the compiled version for optimal performance once it is completed. 

UIM/X 2.9 Compatible - Since C++ is a superset of the C language, projects previously built with UIM/X 2.9 will be completely compatible with UIM/X 3.0. This will provide developers an excellent opportunity to migrate their legacy applications to C++. 

Full CDE Motif Coverage

The Common Desktop Environment (CDE) has arrived! CDE provides end users with a consistent look and feel across heterogeneous UNIX platforms. CDE Motif, the standardized Motif library shipped with CDE-enabled platforms, contains six additional widgets: spin box, combo box, terminal window, help dialog, quick help dialog and a text editor. 

UIM/X 3.0 provides complete support for these and other features found in the latest CDE Motif distribution, so you never have to go into the generated code and modify it to set properties that the tool does not handle. 

CDE Integration

UIM/X 3.0 has been designed to integrate with the new Common Desktop Environment. This offers a consistent, standard interface that is immediately recognizable by users of other CDE applications, making the navigation of UIM/X more intuitive, and enabling new users to quickly familiarize themselves with UIM/X's robust functionality. 

You can now launch both the Standard and Novice modes of UIM/X 3.0 from the CDE Workspace Manager, and access online help using standard CDE complaint help dialogs. 

CDE Motif Widgets - UIM/X 3.0 provides 100% coverage of the Motif toolkit, including the new widgets provided with CDE. With these additions, users can take the greatest advantage of the platform to create highly polished applications and maintain full CDE-compliance. UIM/X is the only tool on the market to fully support Motif. 

Menus - Full access is provided for CDE Motif Menubars, Popup menus and Option menus. UIM/X also provides a custom Menu Editor to make Menu layout and design even easier. 

Dialogs - The Motif toolkit provides many different kinds of dialogs to assist you in the design of your application. UIM/X provides full access to all of the available dialogs and their resources. 

Managers - UIM/X 3.0 provides access to the full complement of Motif Manager widgets. In addition, UIM/X's visual Constraint Editor enables users to visually specify Motif form constraints. 

Compound Objects - Compound objects are high-level component objects provided with UIM/X that enable users to rapidly produce user interfaces. For example, the Main Window component contains a window area and predefined menus. 

Gadgets - Gadgets are part of the Motif specification and provide developers with "lightweight" components that do not have the overhead associated with Motif widgets. They are typically used in interfaces that contain a large number of objects, or in Menus, where the added features of a Motif widget are not needed. UIM/X provides complete access to all available gadgets. 

Primitives - The UIM/X 3.0 palette is organized to provide convenient access to all of Motif's primitive widgets: arrow buttons, scrollbars, text entry fields, labels, lists, toggle buttons, separators and pushbuttons. 

Connection Editor

UIM/X 3.0 contains a new editor that allows users to visually connect and define application behavior. The Connection Editor displays a list of available actions and methods for each GUI object. For each of the actions you want performed, simply select the desired method and then the action that invokes it. Once selected, the editor automatically displays any parameters that need to be supplied to the method and allows them to be edited accordingly. When finished, enter Test Mode to activate the built-in C++ interpreter and try out the added behavior. 

This is just one of the many features that make UIM/X 3.0 an excellent choice for enterprise-wide development. 

The Visual Paradigm - UIM/X has always provided many visual editors that allow developers to graphically modify component properties, colors, form constraints, etc. In previous versions of UIM/X, application and GUI behavior were defined using either the Methods editor or the Property Editor. In addition to these editors, UIM/X 3.0 now extends its support of the visual paradigm through a new Connection Editor. 

The Connection Editor offers a new way of defining application behavior. It enables developers to graphically connect components using simple drag and drop operations. 

Scalable Usage Model - The Connection Editor supports a scalable usage model. It is ideal for new or infrequent users of UIM/X, as it enables sophisticated behavior to be added by simple drag and drop. Advanced users will also find this new editor an excellent productivity enhancement, as methods can take arguments and because they can use it in combination with the existing Callback editors for more sophisticated behavior definition. 

HotKey Activation - The Connection Editor can be opened from the Project Window menubar, from popup menus, or by dragging the mouse while holding down the shift key. 

Constraint Editor

UIM/X 3.0 contains a new editor that enables users to visually set Form constraints for Motif interfaces. By simplifying the usage model with this editor, UIM/X encourages developers to experiment, and therefore leverage, advanced geometry features in their own applications. As a result, interfaces produced using UIM/X 3.0 are highly polished, react intuitively to end-user interaction and are inexpensive to localize. 

The Constraint Editor allows full access to all of Motif's form constraints. 

What are Constraints? - The most common widget found in interfaces developed with Motif is the Form widget. The Form widget provides developers a mechanism, called constraints, that is used to manage the layout of a user interface. So, why are constraints needed? 

Consider the following: Suppose you need a dialog that allows each end user to enter his/her name, street address, city, state and zip code. Constraints can be used to control the individual resize behavior of each interface component. In this example, we are reasonably sure that the state text field can be kept small since it will contain at most two characters. Similarly, the zip code text field will contain at most 10 characters (a 9 digit zip code of the form 12345-6789). Therefore, when the interface window is resized, it makes sense for the name, city and address fields to grow, instead of the state and zip code fields. 

Visual Definition - In previous versions of UIM/X, a developer would use the Property Editor to define form constraints. Users can continue to use this method of editing constraints, but now there is even an easier way. UIM/X 3.0 contains a new visual editor called the Constraint Editor. Developers can now graphically edit and assign form constraints to individual components. Easy to use icons, representing bolts, pushpins and proportions are available to provide an intuitive editing environment, and to improve productivity. 

Method Editor

C/C++ Method Editor - UIM/X 3.0 is a class oriented builder. Each interface created with UIM/X is its own class. This makes it extremely easy to share interfaces with other developers, simplifies and encourages code reuse and reduces maintenance costs. 

To define interface behavior, UIM/X includes a Method Editor. Using this editor, developers can create methods that contain behavior specific to that interface. Once defined, users can access the methods using the Connection Editor to graphically connect interfaces together. 

New Layout - UIM/X 3.0 contains a new layout for the Methods Editor that makes it even easier to use. A new toolbar provides easy access to functions that enable the creation of property get/set methods and the duplication of existing methods. 

Method Options - The Method menu allows the user to select the type of method to create. General behavior methods are defined using the "Method" type, and methods that allow the getting and setting of properties use the "Get" and "Set" types, respectively. In addition, any properties that have get/set method pairs defined in the Method Editor become accessible from the Property Editor. 

Method Signature Options - New with UIM/X 3.0 is the ability to completely customize the signature of the methods entered. Previous versions of UIM/X required a standard CORBA compliant signature for all methods. Now, users can choose between "CORBA 2.0", "CORBA 1.1", or "No CORBA". This makes it convenient for defining behavior for visible objects as well as non-visual objects. 

Method Access Options - Advanced users can modify the UIM/X resource file to make this option menu visible. Users can then control the public access to methods entered. Users can choose from "Public", "Protected", or "Private". 

Virtual Method Options - Advanced users can modify the UIM/X resource file to make this option menu available. Users can specify whether or not a method is virtual or non-virtual. 

Enhanced User Interface

UIM/X 3.0 contains an enhanced user interface that makes it even easier to use. Every interface now contains an iconic toolbar, which improves developer productivity by providing quick shortcuts to all common operations. The new Bubble Help system offers useful reminders about icon definitions, and can be adjusted to fit novice as well as advanced users. Moreover, UIM/X's menus have been reorganized to provide convenient and consistent access to other commonly used editors. 

CDE Desktop Integration - UIM/X 3.0 provides full support for the Common Desktop Environment (CDE). The installation script registers UIM/X 3.0 as a Desktop Application. Once registered, UIM/X can be launched from the CDE Work Manager toolbar. 

Toolbars - Of the many new usability features included with UIM/X 3.0, the addition of iconic toolbars is perhaps the most noticeable. Users now have point and click access to the most commonly used functions. 

Bubble Help - Bubble Help serves as a handy reminder for icon definitions. This feature has been expanded to include more than just the Toolbar; it works in the Browser when using the new "Icon Mode", and also for icons in any open Palette window. Bubble Help can be turned on or off, and the delay can be customized to fit individual preferences. 

Organized Menus - Menus have been reorganized throughout the entire UIM/X development environment. Access to any UIM/X editor has been consolidated into a "Tools" submenu, where the tools have been grouped by the function they perform. Additional editing functions (such as align, arrange, cut, copy, paste, etc.) have also been reorganized for quick access. 

Integrated Online Help - UIM/X 3.0 has been redesigned to provide complete CDE-compliant online help. Users can search and navigate through a complete set of online documentation from within the UIM/X development environment.