The main concept used when exporting IDL objects for use in a client application is that of a wrapper object. A wrapper object is a native-language object (COM or Java) that exposes an IDL object’s behavior to a client. The client interacts with an instance of the wrapper object using native-language constructs and native-language data types.
A wrapper object is built using the Export Bridge Assistant, in which you can choose which methods and properties of the IDL object to expose to the client. During the wrapper creation, you must specify the language-dependent variable types for all the parameters of the methods and properties to be exported. This is required since IDL has dynamically typed variables, whereas Java and COM do not. You can leave some properties or methods unimplemented in the wrapper object. For more information, see Using the Export Bridge Assistant.
When the Assistant exports an IDL object, it creates a language-specific wrapper object for the IDL object. The wrapper exposes methods and properties of the underlying IDL object it wraps, and the client interacts with the wrapper. When the client calls a method or modifies a property on a wrapper object, it is translated through a series of abstraction layers, and the underlying IDL object’s method is called or property modified.
Every wrapper object has a collection of stock methods that are common to all wrapper objects as described in this document. Additionally, the underlying abstraction layers also handle creating the IDL object in another process. This use of multiple processes provides for IDL object pooling and isolation. For more information on these processes, see IDL Access.
For COM object wrappers, a .dll file is created for nondrawable objects; an .ocx file is created for drawable objects. In addition, a .tlb file is generated. The user registers the component and references the COM type library and property accessors (put/get) on the objects using native language constructs. A COM wrapper provides an IDispatch-based interface for client use.
For Java object wrappers, java files (.java) and class files (.class) are created. The user references the Java class definition in their code projects and calls methods and property accessors (set/get) on the objects using native language constructs. The Java wrapper is exposed as a standard Java object.
The actual use of the generated wrapper objects depends on the structure and patterns used for the client environment. For more information, see Using Exported COM Objects and Using Exported Java Objects.
IDL Connector Objects and Custom Wrapper Objects
Access to IDL functionality from an external programming environment is available through connector and custom wrapper objects. The prebuilt connector wrapper object provides the ability to communicate with the IDL process from and external application. A custom wrapper object incorporates the functionality of your own IDL object.
The connector object (distributed with IDL) provides access to IDL’s processing capabilities through a number of methods that let you communicate with the IDL process. Using these methods, you can:
- Create and destroy instances of the connector object in your application
- Pass data to and retrieve data from IDL
- Get and set the IDL process name (see IDL Access for more information)
- Execute IDL commands
Although the connector object does not provide support for graphics, it provides an easy way to access the processing power of IDL in an external environment. See Stock COM Wrapper Methods and Stock Java Wrapper Methods for complete language-specific method reference information. For examples using the connector object, see Using the Connector Object.
Note: There are no stock properties.
Custom Wrapper Objects
A custom wrapper object is an IDL object that is exported using the Export Bridge Assistant. A custom wrapper object contains the stock methods (referenced above) in addition to the specific methods and properties of the IDL object being wrapped. For information about how to create an IDL object that can be successfully exported, see Writing IDL Objects for Exporting. Examples of creating and using custom objects are available in:
For more information, see Java Wrapper Objects.
Drawable and Nondrawable Objects
Custom wrapper objects can encapsulate either drawable or nondrawable IDL objects. To create a custom drawable wrapper object, the IDL source object must subclass from an IDLitWindow, IDLgrWindow, or IDLitDirectWindow visualization class and implement a set of callback routines for event handling. When events are detected for that window object, the callback methods are called with the information specific to the event detected. By subclassing from one of the drawable objects, a visualization written for use in an iTool visualization, Object Graphics display, or Direct Graphics display will seamlessly operate in an external environment via an export bridge. See Exporting Drawable Objects for important information about creating and using drawable objects.
Nondrawable IDL objects are not derived from the IDLitWindow, IDLgrWindow, or IDLitDirectWindow classes and do not render to the screen. Nondrawable IDL objects do not have to inherit from any superclass, though derivation from IDLitComponent is necessary to fire IDL notifications.
Note: Java drawable objects are not supported on macOS.