Abstract:
A computer implemented method that allows C++ classes based on any particular class library to be generated from a standard User Interface Language (UIL) file generated by a variety of GUI builders. A programmer can then use these classes in a familiar manner rather than being forced to use the program framework favored by any particular GUI builder. The GUI builder may then be used as a tool to facilitate the creation of classes that are inherently graphical while leaving the programmer free to deal with the inherently non-graphical bulk of the program.

Description:
BACKGROUND 
     The present invention is related generally to software compilers, and more particularly, to a software compiler that converts user interface language (UIL) files generated using any graphical user interface (GUI) builder into application transportable class library objects that may be used in any application framework. 
     The prior art displaced by the present invention is the current state of graphic user interface (GUI) builder code. A variety of user interfaces have been developed that conform to different user interface standards, such as Motif, OpenLook, CUA, New Wave, and Macintosh, for example. Each user interface is a set of rules and conventions by which a computer system communicates with a person operating with it. GUI builders are designed to generate code that implements a particular user interface. 
     GUI builders are discussed in a number of patents such as U.S. Pat. No. 5,495,567 entitled &#34;Automatic Interface Layout Generator for Database Systems&#34;, U.S. Pat. No. 5,353,401 entitled &#34;Automatic Interface Layout Generator for Database Systems&#34;, U.S. Pat. No. 5,335,320 entitled &#34;Graphical User Interface Editing System&#34;, U.S. Pat. No. 5,384,911 entitled &#34;Method of Transferring Programs from Action Oriented GUI Paradigm to Object Oriented GUI Paradigm&#34;, U.S. Pat. No. 5,297,250 entitled &#34;Method of Generating Interfaces for use Applications that are Displayable on the Screen of a Data Processing System, and Apparatus for Performing the Method&#34;, U.S. Pat. No. 5,404,441 entitled &#34;Method and Apparatus for Automatically Generating a Graphical User Interface Control Program&#34;, U.S. Pat. No. 5,327,529 entitled &#34;Process of Designing User&#39;s Interfaces for Application Programs&#34;, and U.S. Pat. No. 5,347,629 entitled &#34;Graphical User Interface Including Updating of Multiple Panels Using What You See is What You Get (WYSIWYG) Editor&#34;. 
     Some currently available GUI builders can import class libraries, but no tool exists that can interface alternative GUI builders with multiple class libraries. Current GUI builders only allow the use of their own framework and do not produce independent plug-in widgets. Widgets are blocks of code that define graphical objects or desktop icons comprising the user interface. 
     Heretofore, developers have chosen one of three methods to develop general user interface (GUI) builder code. The first method is to custom code a display screen using primitive graphics (implemented using Motif widgets, for example). The second method is to use a display class library that maps a Motif primitive layer in a higher level of abstraction, and which may be achieved using commercial products such as &#34;views.h&#34; available from Rouge Wave or a &#34;Delphi MDISP library&#34; available from the assignee of the present invention). The third method is to use a commercial GUI builder development tool such as Builder Xcessory available from Integrated Computer Solutions (ICS), for example. 
     All three methods have advantages and disadvantages, but the most common approaches are the second method (class library) or third method (GUI builder). The first method is very time consuming, but allows the most flexibility in screen functionality design. 
     Most displays do not need functions beyond a commonly used standard set, including buttons, lists, and sliders, and the like, and the class library or GUI builder methods are the most efficient in generating them. The GUI builder excels at constructing simple screens with the disadvantage that it generates code that must use products produced by the vendor of the GUI builder for development and maintenance. The class library method allows development of maintainable code but is more labor intensive. 
     Accordingly, it is an objective of the present invention to provide for an improved software compiler that converts user interface language (UIL) files generated using any graphical user interface (GUI) builder into application transportable class library objects that may be used in any application framework. 
     SUMMARY OF THE INVENTION 
     To meet the above and other objectives, the present invention provides for a software compiler tool and method that combines features of a class library and a graphical user interface (GUI) builder. The software compiler tool takes an intermediate file created in a user interface language that is generated by a GUI builder (a UIL file) and compiles it into readable code that uses class library objects, such as HCL objects (Hughes Class Library objects), for example. The tool creates complex widgets that can be plugged into any application framework. 
     Using the software compiler tool and method, a graphical user interface builder program is used to create a user interface language (UIL) file. The UIL file is automatically translated into C++, utilizing class libraries defined in a configuration file. For example, a system implemented in accordance with the present invention transforms a graphical user interface file generated by a graphical user interface builder into a transportable class library object. The system comprises a computer, an executable program that runs on the computer and which performs a compilation, and a resource file read by the program that tailors the compilation for any particular C++ class library. 
     More particularly, the software compiler tool and method reads module.uil code generated by the graphical user interface builder. A widget hierarchy is built corresponding to the widget hierarchy created by the graphical user interface builder. Argument values are loaded into widgets of the widget hierarchy. Resource settings are then generated for the widgets. 
     The method may also generate a module.h file containing an interface to the complex widget in C++, and then generate a module.cc file containing the implementation of the complex widget in C++ including resource settings. The method may also generate a module.rc file containing a Motif-style resource description for the complex widget. The complex widget may also include references to other complex widgets previously created using otherModule.uil code generated by the graphical user interface builder. 
     The method may automatically create references to C++ classes corresponding to otherModule.h and otherModule.cc that were generated by compiling other complex widgets previously created using otherModule.uil code generated by the graphical user interface builder. In the method, C++ base classes may also be generated that correspond to moduleBase.h and module.cc, and wrapper classes corresponding to module.h and module.cc may be created wherein additional non-graphical functionality is programmed into the program. 
     The UIL software compiler tool allows developers to use any GUI builder to produce easy-to-read, transportable code widgets that may be used in any application framework. This is in direct contrast to most GUI builders which force the use of their own framework and thus reduce flexibility and increase dependency on their product. 
     Also the code produced by the present software compiler tool is readable, and thus allows code maintenance without need for the GUI builder used to develop the underlying code, which reduces maintenance costs. Another benefit of the present software compiler tool is that the code may be easily customized, something that is impossible with code produced by conventionally available GUI builders. 
     The present software compiler tool may be used to produce code generated using any software that makes use of GUI class libraries. The software compiler tool combines the best features of the class library and the GUI builder methods. The software compiler tool produces code that is maintainable, and that can be produced very easily and fast using any commercially available GUI builder. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     The various features and advantages of the present invention may be more readily understood with reference to the following detailed description taken in conjunction with the accompanying drawings, wherein like reference numerals designate like structural elements, and in which: 
     FIG. 1 illustrates the processing architecture of a software compiler in accordance with the principles of the present invention that converts user interface language (UIL) files generated using any general user interface (GUI) builder into application transportable class library objects that may be used in any application framework; and 
     FIG. 2 illustrates processing details of a first embodiment of the present software compiler; and 
     FIG. 3 illustrates processing details of a second embodiment of the present software compiler. 
    
    
     DETAILED DESCRIPTION 
     Referring to the drawing figures, FIG. 1 illustrates the processing architecture of a software compiler tool 10, method 10, or procedure 10 in accordance with the principles of the present invention. The software compiler tool 10 or method 10 converts user interface language (UIL) files 12 generated using any general user interface (GUI) builder 11 into application transportable class library objects 18 that may be used within different application frameworks. The present invention will be described with regard to its use with a specific GUI builder 11 known as &#34;Builder Xcessory&#34; available from Integrated Computer Solutions (ICS), but it is to be understood that it may be used with any available GUI builder 11 that can generate UIL code. The present software compiler tool 10 disclosed herein which is called HUH (Hughes Uil to Hcl converter) converts UIL files 12 generated by the Builder Accessory GUI builder (or other GUI builder) into class library objects 18, such as &#34;MDISP&#34; class library objects 18, for example, developed by the assignee of the present invention. MDISP class library objects 18, or similar objects, are well known to those skilled in the art. 
     Using the software compiler tool 10 or method 10, a graphical user interface builder 11 is used to create the user interface language (UIL) file 12. The UIL file 12 is automatically translated into C++, utilizing class library objects 18 defined in a configuration file. For example, a system corresponding to the tool 10 transforms the graphical user interface file generated by the graphical user interface builder 11 into a transportable class library object 18. The system 10 comprises a computer 19, an executable program 20 that runs on the computer 19 and which performs a compilation, and a resource file 17 read by the program 20 that tailors the compilation for any particular C++ class library. 
     The software compiler tool 10 or method 10 reads 13 the UIL file 12 (the module.uil code) generated by the graphical user interface builder 11. A widget hierarchy is built 14 corresponding to the widget hierarchy created by the graphical user interface builder 11. Argument values are loaded 15 into widgets of the widget hierarchy. Resource settings are then generated 16 for the widgets using data in the resource file 17. 
     As will be described in more detail below, the method 10 may also generate a module.h file containing an interface to the complex widget in C++, and then generate a module.cc file containing the implementation of the complex widget in C++ including resource settings. The method 10 may also generate a module.rc file containing a Motif-style resource description for the complex widget. The complex widget may also include references to other complex widgets previously created using otherModule.uil code generated by the graphical user interface builder 11. 
     The method 10 may automatically create references to C++ classes corresponding to otherModule.h and otherModule.cc that were generated by compiling other complex widgets previously created using otherModule.uil code generated by the graphical user interface builder 11. In the method 10, C++ base classes may also be generated that correspond to moduleBase.h and module.cc , and wrapper classes corresponding to module.h and module.cc may be created wherein additional non-graphical functionality is programmed into the program. 
     With reference to FIG. 2, it illustrates processing details of an embodiment of the software compiler tool 10. This embodiment of the software compiler tool 10 implements the following processing method 10 to create a program containing complex GUI widgets that uses class library objects 18. The graphical user interface builder 11 or program 11 is used to create 21 the user interface language (UIL) file 12, referred to as a MyClass.uil file 12. Other class files (MyOtherClass.uil) that have been previously created using the graphical user interface builder 11 may also be imported to create the UIL file 12. The software compiler tool 10 then automatically translates 22 the UIL file 12 into two files (MyClass.h and MyClass.cc). These two files correspond to header and source files, respectively, and which correspond to a C++ programming language representation of the UIL file 12. 
     The software compiler tool 10 automatically includes 23 (#Includes) an additional class file (MyOtherClass.h) in the translation performed in step 22 when the GUI builder 11 imported an additional UIL file 12 (MyOtherClass.uil). The MyClass.cc file is translated 24 into an object file (MyClass.o). A programmer then instances 25 MyClass to create a complex GUI widget. Optionally, other complex GUI widgets may be created 26 in the above manner. Finally, all complex GUI widgets are linked 27 into the program. The complex graphical user interface constructed in the above manner is used like any other class in the program to interact with a user. Callbacks contained within the linked program allow signals generated by the widgets in MyClass to tie directly to other objects in the program. 
     With reference to FIG. 3, it illustrates processing details of another embodiment of the software compiler tool 10. In this embodiment, the software compiler tool 10 implements the following processing method 10 to create a program containing complex GUI widgets that uses class library objects 18. As in the first embodiment, the graphical user interface builder 11 or program 11 is used to create 21 a user interface language (UIL) file 12 (MyClass.uil). The software compiler tool 10 automatically translates 22a the UIL file 12 into two files (MyClassBase.h and MyClassBase.cc) which correspond to header and source files. The software compiler tool 10 automatically includes 23a (#Includes) an additional class file (MyOtherClass.h) in the translation when the GUI builder 11 imported an additional UIL file 12 to create the MyClass.uil UIL file 12. The MyClassBase.cc file is translated 24a into an object file (MyClassBase.o). A programmer then subclasses 18 MyClassBase to create MyClass. The subclassing operation ties together various widgets to implement internal, non-graphical functionality. Callbacks are used internally for this purpose. 
     The programmer then instances 25 MyClass to create a complex GUI widget. Other complex GUI widgets may also be created 26 in the above manner. Finally, all complex GUI widgets are linked 27 into the program. 
     The software compiler tool 10 has been reduced to practice in an embodiment known to the assignee of the present invention as &#34;HUH&#34;, or Hughes UIL to HCL converter, which is referred to hereinbelow as the HUH method 10 or UHU procedure 10. The present invention will be described in a manner that should be well understood to those skilled in the art of object code programming. The description of the present invention presumes a general understanding of object code programming and GUI code builders 11, and in particular the workings of the Builder Xcessory GUI builder 11. 
     The code translation that is performed by the software compiler tool 10 is as follows. The basic translation of a UIL file interface into an application transportable class library object proceeds as follows. The procedure 10 
     huh myfile.uil. 
     is run. This procedure reads &#34;myfile.uil&#34; and generates files &#34;myfile.h&#34; and &#34;myfile.cc&#34;. 
     Top level widgets generated by the Builder Xcessory GUI builder 11, such as Application Shell, Top Level Shell, and Dialog Shell, for example, are not output to the UIL code file 12, except as comments that are formatted so that the Builder Accessory GUI builder 11 can see them. Directly below one of the top level shells is a single manager widget, such as a Form or Paned Window, for example. The manager widget represents the top level as far as the HUH procedure is concerned. For the purposes of this description, assume that the widget hierarchy of the UIL file 12 has been modeled in the Builder Xcessory GUI builder 11 is as follows: 
     
         ______________________________________Form myForm | +-&gt; MenuBar menuBar | | | +-&gt; CascadeButton cascadeButton &#34;File&#34; | | | | | +-&gt; PulldownMenu pulldownMenu | | | | | +-&gt; PushButton pushButton &#34;New&#34; | | +-&gt; PushButton pushButton1 &#34;Open&#34; | | +-&gt; PushButton pushButton2 &#34;Close&#34; | | | +-&gt; CascadeButton cascadeButton1 &#34;Edit&#34; | | | +-&gt; PulldownMenu pulldownMenu1 |  | |  +-&gt; PushButton pushButton3 &#34;Cut&#34; |  +-&gt; PushButton pushButton4 &#34;Copy&#34; |  +-&gt; PushButton pushButton5 &#34;Paste&#34; | +-&gt; RadioBox radioBox | | | +-&gt; ToggleButton toggleButton &#34;X&#34; | +-&gt; ToggleButton toggleButton1 &#34;Y&#34; | +-&gt; ToggleButton toggleButton2 &#34;Z&#34; | +-&gt; PushButton pushButton6 &#34;Do it&#34;______________________________________ 
    
     The HUH procedure generates the following .h file (including miscellaneous MDISP boilerplate such as DECLARE --  CLASS, constructors, and assignment operators not shown here): 
     
         ______________________________________#include &#34;DForm.h&#34;#include &#34;DMenuBar.h&#34;#include &#34;DPulldownMenu.h&#34;#include &#34;DPushBtn.h&#34;#include &#34;DRadioBox.h&#34;#include &#34;DToggleBtn.h&#34;class MyForm: public DFormpublic: virtual int create(const char *name,DWidget *parent,   int manage=1); DMenuBar *menuBar;  DPulldownMenu *cascadeButton;  DPushBtn *pushButton;  DPushBtn *pushButton1;  DPushBtn *pushButton2;  DPulldownMenu *cascadeButton1;  DPushBtn *pushButton3;  DPushBtn *pushButton4;  DPushBtn *pushButton5;  DRadioBox *radioBox;  DToggleBtn *toggleButton;  DToggleBtn *toggleButton1;  DToggleBtn *toggleButton2;  DPushBtn *pushButton6;};______________________________________ 
    
     Indentation is automatically used to show the widget hierarchy. The widget class names match the names used in the MDISP library. The name of the top level widget in the hierarchy is made into a class name by capitalizing the first character. 
     The HUH procedure generates a corresponding .cc file (including MDISP boilerplate such as DEFINE --  LOCAL --  CLASS, and bodies of constructor functions not shown here): 
     
         ______________________________________#include &#34;myfile.h&#34; int MyForm:: create(const char *name,DWidget *parent,int manage)  {   if (!DForm:: create(name,parent,0) return 0;   menuBar = new DMenuBar;   if (!menuBar-&gt;createMenuBar(&#34;menuBar&#34;,this,0,0,1)) return 0;   menuBar-&gt;x(100);   menuBar-&gt;y(100);    . . .   cascadeButton = new DPulldownMenu;   if (!cascadeButton-&gt;createMenu(&#34;cascadeButton&#34;,menuBar))   return 0;   cascadeButton-&gt;attachment()-&gt;setLabelString(&#34;File&#34;);    . . .   pushButton = new DPushBtn;   if (!pushButton-&gt;createPushButton    (&#34;pushButton&#34;,cascadeButton-&gt;menu(),0,0,1)) return 0;    pushButton-&gt;setLabelString(&#34;New&#34;);  if (manage)   manageChild();______________________________________ 
    
     In the first part of the &#34;create&#34; function, the widget hierarchy is built. Then argument values are loaded into widgets. 
     The normal mode for the HUH procedure is to hard code settings for all resources. This means that any changes to the settings by the Builder Xcessory GUI builder 11 requires not only executing the HUH procedure 27, but also recompiling the generated &#34;.cc&#34; files. 
     Alternatively, resource files 17 may be used: 
     huh -rc myfile.uil 
     The &#34;.h&#34;, &#34;.cc&#34;, and &#34;.rc&#34; files are generated but the &#34;.rc&#34; file contains resource settings of the form: 
     MyForm*cascadeButton.labelString: File 
     MyForm*pushButton.labelString: New 
       . . 
     MyForm*pushButton6.labelSTring: Do it 
     The &#34;.cc&#34; file no longer contains code to set these resources. Instead, the &#34;create&#34; function begins with the following call: 
     loadClassResources(name,parent,&#34;MyForm&#34;); 
     The call to &#34;loadClassResources&#34; causes a resource database to be searched for all lines of code that begin with the class name, in this case, &#34;MyForm&#34;. The appropriate actual resource lines with the proper widget hierarchy is generated on the fly for each instance of MyForm. 
     If the program is called &#34;myAppl&#34;, a resource file 17 called &#34;MyAppl&#34; is checked. This file may simply include all of the &#34;.rc&#34; files for all of the Builder Xcessory-generated classes used in the application: 
     #include &#34;MyClass.rc&#34; 
     #include &#34;MyOtherClass.rc&#34; 
       . . 
     Some resources cannot be set in a resource file 17. These include the &#34;leftWidget&#34;, &#34;rightWidget&#34;, &#34;menuHelpWidget&#34;, and &#34;pixmap&#34;, for example. It may also be desirable to have certain resources hard-coded. A configuration file loaded by the HUH procedure (described below) controls how these situations are handled. 
     When the HUH procedure is run, a new .rc file is generated although it is empty unless the -rc switch is used. New .h and cc files are only generated if they are different. Thus, a &#34;makefile&#34; contain rules for compiling the generated files as follows: 
     .INIT: file1.rc file2.rc . . . 
     %.rc: %.uil 
     huh -rc $&lt;. 
     That is, if the UIL file 12 changes, the .rc file is regenerated. By specifying all the .rc files in an .INIT rule, it is guaranteed that, if any UIL files 12 have changed, they are recompiled with the HUH procedure Then the rest of the &#34;make&#34; proceeds normally, checking the dates on the .h and .cc files which may or may not have been changed by the HUH procedure. 
     The HUH procedure depends on a resource file 17 called &#34;Huh&#34; which it located in either &#34;./Huh&#34;, &#34;˜/Huh&#34;, or using the environment variable &#34;HUH --  OPTIONS&#34;. This file shows how various Motif names found in UIL files 12 map into the MDISP objects 18. Comments in this file are preceded by &#34;#&#34; and are self-explanatory. 
     Resources in this file allow a programmer to control what MDISP class and associated &#34;create&#34; function is indicated by a Motif class, control what MDISP member function is indicated by a Motif argument name, and control what MDISP enumerator name is indicated by a Motif argument value name. If a Motif argument value has multiple translations depending on the Motif class, this may also be specified. The programmer indicates what Motif arguments apply &#34;→attachment()&#34; or &#34;→menu()&#34; to MDISP objects 18 in order to access the underlying Motif widgets, indicates what MDISP include files must be #included by the generated C++ code in order to accommodate what MDISP classes will be indicated by what Motif classes, indicates which Motif top level widget classes don&#39;t have a good translation to MDISP, and indicates where Builder Xcessory generates redundant information. 
     The programmer can indicate what Motif arguments should not be included in the resource file 17, indicate what Motif arguments should be deferred until all children of the associated widget are created, indicate what Motif arguments should be deferred until all children of the associated widget are created and which are set on the children (i.e. attachments), indicate what Motif arguments cannot be set by an MDISP function call, and indicate what Motif arguments should not be applied if they have a null value. 
     The programmer can indicate which classes require the &#34;createMenu&#34; function, indicate the create function to be used when a certain dialog type is specified, indicate where MDISP combines two levels of Motif widgets into a single class, indicate widgets that are unmanaged by default, and indicate which shell managers are called out by specific HUH switches. 
     As specified in the Huh file, some widgets are created with delayed management to make them behave better. The widget is created unmanaged and then managed after argument functions have been called and children have been defined. 
     Some arguments cannot be set after widget creation. Some widgets behave better if the arguments are loaded at creation time rather than afterwards. One way to achieve this is to use resource files 17. Another way is to move the argument function calls to just before the call to the &#34;create&#34; function. This mode may be set with the following switch: 
     -preload 
     If this switch has been set as the default, it may be cleared with the following switch: 
     -aftload. 
     In either case, arguments that require the use of &#34;→attachment&#34; are always loaded after widget creation. 
     When Pixmaps occur in the UIL file 12, appropriate XPM-3 format &#34;.xpm&#34; files are generated to hold the various pixmaps. These files are only updated when the contents change. 
     It may be desirable to protect various sub-widgets of MyForm. The -prot switch inserts &#34;protected:&#34; after the create function and changes the name of the class to MyWidgetBase. In this case, the user should derive MyWidget from MyWidgetBase and then set up whatever member functions are desired to control access to the sub-widgets. It also appends &#34;Base&#34; to the names of the &#34;.cc&#34; and &#34;.h&#34; files. 
     Normally, it is the programmer&#39;s responsibility to create the topLevel widget, usually derived from DWindow to contain the complex widget that is generated. The &#34;createDisplay&#34; function is overridden to allocate and create an instance of widgets. DWindow also installs callbacks and inserts code that causes MyWidgett to properly perform its function. For example: 
     
         ______________________________________class MyWidgetWindow: public DWindowpublic: MyWidget *myWidget; MyWidgetWindow() {  myWidget = new MyWidget; } virtual int createDisplay() {  return myWidget-&gt;create(&#34;MyWidget&#34;,this);  }};______________________________________ 
    
     Alternatively, the HUH procedure 27 can generate this code if the -win or -pop switch is specified, in which case, the above example is generated as follows: 
     
         ______________________________________  class MyForm: public DWindow // or DPopup  {  public:   virtual int createDisplay();   DForm *myForm   MenuBar *menuBar;    DPulldownMenu *cascadeButton;    DPushBtn *pushButton;    DPushBtn *pushButton1;    DPushBtn *pushButton2;    DPulldownMenu *cascadeButton1;    DPushBtn *pushButton3;    DPushBtn *pushButton4;    DPushBtn *pushButton5;    DRadioBox *radioBox;    DToggleBtn *toggleButton;    DToggleBtn *toggleButton1;    DToggleBtn *toggleButton2;   DPushBtn *pushButton6;  };______________________________________ 
    
     The classname (MyForm) is applied to the DWindow rather than to the DForm. 
     Builder Xcessory provides the ability to create and use classes within the context of some other widget hierarchy. It does this by using naming conventions and special directives in the UIL code which are commented out by &#34;!(BX)&#34; or &#34;!(CX)&#34;. If the &#34;-bx-&#34; switch is not set, The HUH procedure 27 reads past this kind of comment and interpret the special directives. 
     In Builder Xcessory, a class may be created as an independent widget hierarchy. An icon for the class then appears on a user pallet and may be instanced just as any other widget. If desired, this class may reside in a separate UIL file 12, in which case, The HUH procedure 27 assumes that that a separate UIL file 12 has been compiled and inputs #include&#39;s to the .h files generated by that compilation. 
     In &#34;Instance&#34; mode, Builder Xcessory allows a widget hierarchy to begin with an ApplicationShell. This shell should be appropriately named because a class based on DWindow is generated with this name, capitalizing the first character of the name. That is, if the hierarchy is as follows: 
     
         ______________________________________ApplicationShell myAppl|+-&gt; Form myForm |+-&gt; MenuBar menuBar| || +-&gt; CascadeButton cascadeButton &#34;File&#34;. . .______________________________________ 
    
     and the C++ class is generated as follows: 
     
         ______________________________________   class MyAppl: public DWindow   {   public:    virtual int createDisplay();    DForm *myForm;    DMenuBar *menuBar;     DPulldownMenu *cascadeButton;     . . .______________________________________ 
    
     Builder Xcessory allows import of classes defined in external UIL files 12. The main UIL file 12 contains directives such as: 
     include file `directory/filename.uil` 
     include file &#34;directory/filename.uil&#34; 
     and if that file contains any &#34;object&#34; definitions, it assumes that a corresponding `directory/filename.h` file exists to define any classes contained in the UIL file 12. 
     The &#34;-I&#34; switch may be used to indicate a directory to search if &#34;filename.uil&#34; does not have an explicit directory and is not found in the current directory: 
     huh -Idirectory1-Idirectory2 . . . 
     One directory may be specified per &#34;-I&#34;. Up to 16 &#34;-I&#34; may be specified in any given run. 
     Builder Xcessory uses a naming convention such that objects representing widgets internal to a class have names that are prefixed by the class name. A UIL object which has no direct references and which has a name beginning with an uppercase character (i.e. &#34;Classname&#34;) indicates a Builder Xcessory class. Widgets defined internal to that class have its Builder Xcessory name prefixed by &#34;classname --  &#34; (first character lowercase). If in Builder Xcessory, an instance of some other class occurs inside of this class, the HUH procedure 27 knows this by recognizing control names that begin with a different prefix. For example: 
     object A . . . { controls { . . . a --  form1; . . . }}; 
     object a --  form1 . . . { controls { . . . b --  button1; . . . }}; 
     translates to: 
     class A { . . . B *form1; . . . };, for example. 
     If &#34;receptors&#34; are used by Builder Xcessory to implement inheritance, two different prefixes occur in the controls. If one of the prefixes in the controls matches the prefix on the object or corresponds to a capitalized class name used as the object name, it indicates that the user had instanced another class but added to it. For example: 
     object B . . . { controls { . . . a --  form; XmName b --  form; }}; 
     translates to: 
     class B: . . . A { . . . DName *form; }; 
     If a new class is created from an old one nothing is added, and the HUH procedure 27 looks past comments having the form: 
     !(BX) BxNclass. . . =&#34;Classname&#34; 
     to find the actual class names involved. 
     Builder Xcessory allows one widget in a class to be specified as a &#34;receptor&#34;. That is, any widgets that are added in the derived class are created as children of the receptor widget. 
     A given resource of a class may be flagged as &#34;Exposed&#34;. Anywhere that class is instanced, alternate values may be set for any exposed resources. 
     If an exposed resource is normally set with a function called &#34;resourceName&#34; and the widget is called &#34;myWidget&#34;, the following public member function is generated in the header file: 
     int myWidgetResourceName(type arg) 
     { return myWidget→resourceName(arg); } 
     If an exposed resource is normally set with a function called &#34;setResourceName&#34; and the widget is called &#34;myWidget&#34;, the following member function is generated in the header file: 
     int setMyWidgetResourceName(type arg) 
     { return myWidget→setResourceName(arg); } 
     When a Dialog Shell is created in Builder Xcessory and it is made a member of one class or widget hierarchy, Builder Xcessory puts the information about the dialog shell in its comments. The HUH procedure 27 reads past the comments to find the connection between a dialog box and its parent widget. Dialog shells may be made to pop up by calling &#34;manageChild&#34; on the widget directly under the dialog shell widget. 
     A top level shell widget occurring in the middle of some other hierarchy is translated to DWindow but is created with the &#34;createTopLevelShell&#34; function to attach it to the hierarchy. The DWindow &#34;show&#34; or &#34;hide&#34; functions are called to make these windows visible or invisible. 
     If it is specified in Builder Xcessory that classes are to be read in, the UIL file 12 contains &#34;include&#34; directives. If those files in turn include other files, Builder Xcessory generates in the comments, although it should have placed it in the UIL code: 
     !(BX) read --  include file `filename` 
     The HUH procedure reads past the comment and treats it like a regular include. 
     The following switches are available in the HUH procedure 27: 
     -aftload 
     which sets most arguments just after widget creation. This is the default but it may be changed by -preload; 
     -bx 
     causes the given widget names to be used; 
     -Ipath 
     looks for include files in the directory specified by &#34;path&#34;; 
     -pop 
     generates a DPopup shell; 
     -preload 
     sets most arguments before widget creation rather than after; 
     -prot 
     generates protected classes; 
     -rc 
     generate a resource file 17 (&#34;myfile.rc&#34;). This removes the hard-coding of most arguments from the cc file. The .rc file is always generated but it is empty if the -rc switch is not set; and 
     -win 
     generates a DWindow shell. 
     Switches are set to on by default by setting the following environment variable: 
     setenv HUH --  DEFAULTS -Ipath1 -Ipath2 -rc . . . 
     Improvements to MDISP that support the present invention have been made. The improvements allow parameters to be set before creation of a widget. Arguments are set in DWidgets without having to first perform a &#34;create&#34;. If a &#34;create&#34; has not been done, arguments are buffered and then loaded at creation time. If argument lists are supplied by routines such as &#34;createPushButton&#34;, for example, these lists are merged with any buffered arguments. 
     This was implemented because some widgets behave better when pre-loaded or when set in a resource file 17. However, the MDISP improvement existing allows preloading by stepping outside of the member function syntax using Motif style &#34;XtArg&#34; lists. 
     One potential problem with &#34;preloading&#34; is that a class might preload arguments that are superseded when the class is instanced. This problem was solved by having the &#34;preload&#34; check for arguments already having been included in the list and discarding duplicates. Thus a user-defined class can be preloaded while achieving the correct behavior. 
     There are some things that cannot be set after creation, including &#34;items&#34; and &#34;itemCount&#34;. Preloading now allows these parameter functions to be called. 
     A new string converter is registered with Motif when DAppl or DApplShell creates are performed. This allows compound strings to be represented by an ordinary resource string using the following syntax: 
     ::[#tag][:t][:r][&#34;str&#34;] 
     where: 
     ::=indicates compound string. 
     tag=the font tag 
     :t=separator (if not seen no separator added to segment) 
     :r=right to left (if not seen left to right assumed) 
     &#34;str&#34;=the text of the string. 
     The components for the compound string can be repeated any number of times. 
     There is also a converter for XPM format pixmaps. This has been implemented in DXIcon so the following expression can be used: 
     DXIcon myIcon(xpm-array); 
     and then, for example: 
     
         ______________________________________ myWidget-&gt;backgroundPixmap(myIcon);XPM format is something like: /* XPM */ static char *name[] = { &#34;16 16 2 1&#34;, &#34;.c#000&#34;, &#34;X c #ffffffffffff&#34;,  &#34;....XXXX....XXXX&#34;,  &#34;....XXXX....XXXX&#34;,  &#34;....XXXX....XXXX&#34;,  &#34;....XXXX....XXXX&#34;,  &#34;XXXX....XXXX....&#34;,  &#34;XXXX....XXXX....&#34;,  &#34;XXXX....XXXX....&#34;,  &#34;XXXX....XXXX....&#34;,  &#34;....XXXX....XXXX&#34;,  &#34;....XXXX....XXXX&#34;,  &#34;....XXXX....XXXX&#34;,  &#34;....XXXX....XXXX&#34;,  &#34;XXXX....XXXX....&#34;,  &#34;XXXX....XXXX....&#34;,  &#34;XXXX....XXXX....&#34;,  &#34;XXXX....XXXX....&#34;, };______________________________________ 
    
     where: 
     The first string in the array is: 
     &#34;width height colors characters 
     indicating: 
     width--Number of pixels across the pixmap 
     height--Number of rows in the pixmap 
     colors--Number of color definitions 
     characters--Number of characters per pixel 
     The next &lt;colors&gt; strings indicate color definitions: 
     &#34;x c color&#34; 
     where: 
     x--&lt;characters&gt; representing a color 
     color--A color name such as White 
     --A color value such as #fff 
     The next height strings of length width*characters contain character codes for each pixel in the pixmap. 
     When a DXIcon is referenced for the first time in a &#34;pixmap&#34; argument function, a conversion operator causes a Pixmap to be generated. These conversions are defined in &#34;DConvert&#34;. A global symbol &#34;dApplShell&#34; is also defined there and is set by &#34;DAppl&#34; and &#34;DApplShell&#34; to be the display widget. This avoids the need to have a Widget passed as a parameter to the various conversion functions for reference purposes. 
     There was no direct provision in Motif to have resource files 17 that could handle classes. This has been remedied by the following function in &#34;DWidget.h&#34;: 
     loadClassResources(&#34;name&#34;,parent,&#34;cname&#34;); 
     This is called just before a &#34;create&#34; function to indicate that the widget that is created with &#34;name&#34; and &lt;parent&gt; belongs to class &#34;cname&#34;. This causes resource file 17 lines of the form: 
     cname.resource: value 
     or 
     cname*item.resource: value 
     to be applied to the complex widget that is created. 
     When creating a complex class called &#34;MyClass&#34;, a &#34;MyClass.h&#34; and &#34;MyClass.cc&#34; are usually created. In addition, a &#34;MyClass.rc&#34; may be created to set resources relative to the class as indicated above. 
     If a program is called &#34;myAppl&#34;, a resource file 17 called &#34;MyAppl&#34; is checked. This file may include all of the complex class resource files 17 used in the application: 
     #include &#34;MyClass.rc&#34; 
     #include &#34;MyOtherClass.rc&#34; 
       . . 
     The &#34;create&#34; function has been changed from two arguments to three: 
     create(&#34;name&#34;,parent,managed=1) 
     where the third argument indicates whether the widget is managed (default True). This change will not affect any normal uses of &#34;create&#34; but may affect complex classes which override &#34;create&#34;. 
     DLabel has a two argument &#34;setLabelString&#34; (with the second argument having a default). DDate, DDateTime had one argument &#34;setLabelString&#34;. All other &#34;set . . . LabelString&#34; functions had one argument. There was also a need to have a &#34;setLabelString&#34; in DWidget to handle several unaccounted-for cases. Since merely moving &#34;setLabelString&#34; to DWidget caused a conflict with the one argument versions in DDate and DDateTime, those were also changed to two argument (with the second defaulted). All other &#34;set . . . LabelString functions were likewise changed to the two argument form. If the second argument is default, the new converter in DConvert is invoked (via &#34;setString&#34; in DWidget) to enable a more sophisticated compound string capability (as described above). 
     A new set of functions has been added to support callbacks to member functions of arbitrary classes. Wherever a function such as &#34;myname&#34; exists to receive a callback such as &#34;XmNmynameCallback&#34;, there is now a function called &#34;mynameCb&#34; which may be called as follows: 
     mynameCb(function) 
     which calls a global &#34;function(Dwidget*,XtPointer)&#34; in response to the signal represented by &#34;myname&#34; or: 
     mynameCb(pointer,classname::function) 
     which calls &#34;pointer→function(DWidget*,XtPointer)&#34; in response to the signal represented by &#34;myname&#34;. 
     Thus, a software compiler that converts user interface language (UIL) files generated using any general user interface (GUI) builder into application transportable class library objects that may be used in any application framework has been disclosed. It is to be understood that the described embodiments are merely illustrative of some of the many specific embodiments which represent applications of the principles of the present invention. Clearly, numerous and other arrangements can be readily devised by those skilled in the art without departing from the scope of the invention.