UIM/X: Guided 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.

Executive Overview

Overview
Interpretive Design
Native Cross-Platform Design
Builder Engine Component Model
Enterprise-wide Development

What's New

Integrated C++ Interpreter
Full CDE Motif Coverage
Connection Editor
Constraint Editor
Method Editor
Enhanced User Interface

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:

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.

Native Cross-Platform Design

The Cross-Platform Toolset (CPT) is a C++ class library of cross-platform GUI components, seamlessly integrated into UIM/X. We have taken a unique design point in the development of this tool, described as the "Four Pillars" of a sophisticated cross- platform design approach:

Technology - With the CPT, we offer a rich palette that addresses the union of the supported windowing toolkits (Motif, Win16, Win32, Win95, WinNT), rather than the intersection as other tools do.

Flexibility - CPT is fully extensible, offering a straightforward mechanism for third-party and custom class integration. Most other toolkits take the "Center of the Universe" approach and prohibit extensive integration with third-party or "alien" custom classes. The CPT approach encourages the integration of foreign classes, so that developers can implement UIM/X as a visual development environment that includes the union of standard windowing components, third-party components, and in-house custom components.

Portability - CPT is a C++ class library with implementations on the native windowing toolkits. Therefore, interfaces built with the CPT have the native Windows and native Motif look and feel for these platforms. By using a portable class library approach, we not only support the layout of the interface, but more importantly, we encapsulate and support the interface behavior as well. Moreover, the CPT approach offers developers a superset of native components, unlike other approaches which limit developers to a least common denominator component set or emulate the components entirely.

Polish - CPT provides the best approach for users who wish to create sophisticated, production-quality applications.

Reversing the "Center of the Universe Syndrome" - Cross-platform vendors have typically focused their efforts on producing pre-built components with a common API, which operate across windowing platforms. Historically, however, this turns out to satisfy only a fraction of a multi-faceted requirement. What happens when designers want to integrate any of the wide variety of third-party components into their environment? Or, how do designers integrate components that are custom built in different environments within their organization? What you'll find is that it is often very difficult - if not impossible - to integrate components built with different systems. Designers therefore become captive, only able to work with those components provided with the toolkit, or those that can be developed with the toolkit. This proprietary approach excludes the use of "best of breed" components and tools that are available on the general market, as well as those built in-house.

The ICS Approach - The first thing you will notice when you evaluate ICS's Cross-Platform Toolset (CPT) is that we have chosen a completely different design point than other approaches to cross-platform design. We start by providing a rich palette of pre-built cross-platform classes, which is not unlike traditional approaches. This is where the similarity ends. Peel one more layer off the onion and you will quickly discover that there is a great deal more freedom provided with our toolset, compared to the competition. With our unique Builder Engine component framework, developers can seamlessly integrate third-party classes and their own in-house components into the CPT environment, and mix and match these when building interfaces.

The second thing you'll notice when you evaluate our tool is that it truly adheres to an object-oriented approach. This means you can take advantage of one of OO programming's greatest attributes with respect to reuse: the ability to encapsulate behavior within the definition of the interface object. Many other approaches that position themselves as object-oriented fall short of this essential capability, and disregard all of the behavior characteristics when deploying the interface on alternate windowing platforms. As a result, the behavior is lost and has to be hand-coded on the target platform. This raises your lifecycle costs by an order of magnitude. With CPT, developers write the behavior code only once, and deploy the encapsulated components across all supported platforms.

This unparalled freedom made possible by our unique architecture places UIM/X CPT in a category of its own - an uncompromisingly standards-based, wholly adaptable and extensible approach to cross-platform design.

Three Governing Principles of Design - Briefly summarized, here are the three governing principles of design for all ICS products:

• Maintain uncompromising support of the prevailing standards (Motif, CORBA, ANSI, K&R, Windows, Java, etc.), with no proprietary layers.
• Create a Component Architecture. Adhere to a modular design with - to the maximum extent possible - open APIs to easily enable seamless integration of third-party and custom components and tools.
• Provide engineering tools that cover the entire life cycle of the application, which are also accessible without ever leaving the tool's environment.

The fact of the matter is that tools designed without the above principles in mind inevitably put developers in a position of compromise; whether it is having to settle for an insufficient subset of components for design purposes, or accepting that standards have been disregarded altogether in favor of a replacement layer for the native windowing systems.

It is has been our experience that developers of production-quality applications cannot afford these "short-cut" and "substitute" types of compromises.

What comes out of the box? - ICS Cross-Platform Components- The Cross-Platform Toolset is a C++ library of pre-built cross-platform interface classes with implementations on UNIX Motif, Windows, and Windows/NT. Integrated with UIM/X, the CPT enables users to develop applications on Motif and then deploy on Motif and the variety of Windows platforms. As illustrated below, an interface class is a native implementation of a GUI component. Having a single Public API, the class encapsulates both Display as well as Behavior characteristics.

A good example of the benefits of encapsulation can be found in the File Selection Box (FSB) - one of the GUI objects provided with the CPT. In the Motif implementation, the CPT GUI class encapsulates the Motif FSB, and therefore supports the behavior (dynamic sizing, internationalization, wildcard listing, etc.) that users have come to expect in Motif applications. On the Windows implementation, however, the FSB class encapsulates and conforms to the typical Windows presentation and behavior, which is a combination of a file list box, directory list box, and a text entry field. The importance of achieving this level of granularity is obvious, when you consider that the presentation and behavior of components on the various Windows platforms alone is often entirely different.

UIM/X with the Builder Engine - The Builder Engine is UIM/X's chassis that allows you to easily add and remove functionality to the UIM/X visual development environment. Provided with the Builder Engine are tools to automate the process of integrating components built with other systems into the framework. For example, the framework provides you with all the tools necessary to integrate your favorite cross-platform table widget into the UIM/X environment (in fact, this is the technology we used to integrate our own class library, the CPT). Likewise, you can seamlessly integrate your unique cross-platform controls that you have built in-house into UIM/X.

Moreover, due to the popularity of UIM/X with the Builder Engine (industry analysts rank UIM/X as having captured 74% of the UIMS market for Motif) you can buy a growing number of pre-packaged integrations of application-specific class libraries on the general market. The result is an interpretive visual design environment anchored by UIM/X, the industry's leading GUI builder, with component technologies from your choice of suppliers.

Component Models and Frameworks: A Hybrid Approach

Application frameworks are growing in acceptance and popularity. They tend to adopt the "Center of the Universe approach", however, and are therefore limiting to the enterprise developer who wants to employ the best of breed components for design purposes. Component models, on the other hand, provide developers with a chassis that ensures they can take advantage of all components built in compliance with the chassis. These component architectures, however, lack many of the objected-oriented benefits of an Application Framework.

ICS has adopted a hybrid approach. By providing a GUI framework with CPT, and a component model that allows the inclusion of foreign components in a straight forward manner, our users gain all the benefits of OO design: encapsulation, polymorphism, and inheritance. They also gain the flexibility to incorporate third-party and custom components into the GUI framework without the need to obtain source code.

This offers developers the best of both architectures, and facilitates the creation of highly polished, tightly integrated, cross-platform interfaces.

Legacy Conversion

UIM/X has a built-in translator to migrate legacy Motif interfaces to cross-platform interface components. Features of the translator include:

• Comprehensive utility to convert GUI layout.
• Automatic launch when a Motif project file is loaded.
• Conversion of Motif interfaces or UIM/X project files.
• Extensive map files to fine tune the conversion.
• Structured approach to converting GUI behavior.
• Platform-specific behavior code wrapped and positioned in the appropriate property slot.
• Utilities to convert known behavior to cross-platform behavior.

Summary of UIM/X's Cross-Platform Design

Feature	Description	Benefit
Rich Component Set	Native Dialogs, Controls, Templates	Full set of pre-built classes to develop "polished", production-quality interfaces.
Capabilities Superset	Additional controls that go beyond native toolkit base set	Increased productivity; minimized training & support costs.
Standards-based	UNIX Motif, CORBA, C, C++, Java, Win16, Win32s, Win 95, Win NT	Open, non-proprietary approach provides complete investment protection.
Fully Object-Oriented	Encapsulation, Polymorphism, Inheritance	True reusability provides significant life cycle cost savings.
Fully Extensible	Builder Engine architecture	Extend with your custom or purchased class libraries to create your own customized GUI development environment.
Fully Customizable	Builder Engine architecture	Deliver custom solutions to prototypers & developers at any skill level within enterprise; leverage existing resources.
Third-party classes available	DB classes, dynamic graphic classes, etc.	Use of "best of breed" components ensures superior applications; deliver solutions for niche markets.
Legacy Code Support	Utilities to convert existing code base for cross-platform implementation	Protects and leverages past investments.
Novice Mode Support	Simplified set of tools and pre-configured objects	New and less technical users can rapidly build fully functioning applications easily; significant productivity gains, training costs minimized.
Geometry Management	New Layout Class provides full Geometry Management for Motif and Windows	Increased productivity through ease of use.

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.

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.