

Xm++ Class Reference Manual

###########################


Copyright (c) 1994 Bernhard Strassl, Sabine Binder
Vienna User Interface Group
Institute for Applied Computer Science and Information Systems
University of Vienna, Austria


Contents
========

Xm++ Classes are described in the following order:

XmApp, XmManager, XmObject, Entry, CheckEntry, XmMenu, XmPopupMenu, XmDropdownMenu,
XmSubMenu, XmDialog, XmSystemDialog, XmMsgBox, XmPrompter, XmListPrompter, XmFileSelector,
XmControlPane, XmDialogPane, XmUserDialog, XmControl, XmGroupBox, XmPane, XmPaneArea,
XmToolbar, XmStatusbar, XmStaticText, XmStaticImage, XmPushButton, XmCheckBox,
XmRadioButton, XmValuator, XmEdit, XmListBox, XmComboBox, XmDialogWindow, XmWindow,
XmToolBox

Introduction
============

This manual was written for Xm++ application programmers. Therefore it contains only public 
member functions of Xm++ classes. Currently you only have the source code to learn about 
the internals of the framework. An extended version of this manual for programmers who want 
to extend Xm++ will contain additional information about private and protected member 
variables and functions and should be available in the future.

If a description of the return value of a Member function is omitted use the following rules:
*	A return type identical to the object's class means that the object returns a pointer to this.
*	Boolean or integer functions return a nonzero value (TRUE) on success, zero (FALSE) on 
failure.

### in front of a function name marks a function which is not implemented in the current 
release (but will be added in future versions of Xm++).

[] in a list of inherited member function means that this function should not be used 
with instances of the described subclass.

Inherited member functions are not listed for abstract classes.


class XmApp
===========

Description:
------------
This class is responsive for initialization on the underlying toolkit and manages the top level 
windows. An instance is automatically created by the main() function which is a part of the 
Xm++ library.

Member functions:
-----------------

void initialize();
  This function has to be implemented in the application's code and it must create at least one 
  toplevel window.

char* getName();
  Returns the program name (argv[0]).

char* getCmdArg(int index);
  Returns the command line argument with the given index or NULL if index > argcount.

char* xmPlusPlusVersion();
  Returns the library version number string.

XmObject* getMainObject();
  Returns the current toplevel window. (Defaults to the first window created by an application.)

bool setMainObject(XmObject*);
  Sets the current toplevel window. 

bool setCursor(char* cursorname);
  Sets the cursor shape to be used for all application windows. Valid cursornames are: "default", 
  "busy", "left-arrow", "up-arrow", "cross", "i-beam".


class XmManager
===============

Description:
------------
The superclass for all remaining Xm++ classes. It represents a non-windowed class as the 
general ancestor for all other classes which can have callback members. This allows - in the 
terminology of the MVC model - the creation of 'model classes' which are independend from 
any view/controller behavior inherited by all other classes.

Member functions:
-----------------

XmManager();
virtual ~XmManager();
  Constructor/Destructor.

XmWindow* window(char* name);
XmUserDialog* dialog(char* name);
XmDialogWindow* dialogWindow(char* name);
  These functions return a named window object of the appropriate type, or NULL if there is no 
  window with given name and type.

void changed(char* topic, XmObject* initiator = NULL);
  Calls the update(topic) function of each child window - this allows the notification of one 
  child's changes to all others without knowing about them (borrowed from MVC). If initiator is 
  specified this object is excepted from notification.


class XmObject (: public XmManager)
==============

Description:
------------
An abstract superclass for all windowed Xm++ object classes. It handles most of the general 
toolkit interfacing and implements a lot of virtual functions which are common for all 
displayable objects.

Member functions:
-----------------

XmObject* getParent();
  Returns the windowed parent of an object or NULL if the object has no parent. (Only 
  application windows can be created without specifying a parent.)

const char* getName();
  Returns the name of an object. Every Xm++ object must have a textual name, which is usually 
  specified as a constructor agument when creating it.

bool isNamed(char* name);
  Returns TRUE if name matches the objects name, FALSE otherwise. (An inline which helps to 
  avoids many strcmps troughout the application.)

Widget handle();
virtual Widget topHandle();
  These functions return toolkit widget handles (whatever this may be), they should usually not 
  be needed by an application programmer.

bool valid();
  A simple object integry check for debugging.

virtual bool realize();
  Displays an object after creating and initializing it. If called on a root of an object tree (i.e. 
  main window or dialog box) the entire tree will be realized.

virtual bool destroy();
  Destroys the external (toolkit) representation of a single Xm++ object or an object tree 
  without deleting the Xm++ object - normally not used by application programmers.

bool destroyOnDelete();
  Designates the automatic call of destroy() when the Xm++ object is deleted. This is not needed 
  for top level objects (instances of main window or dialog box classes). This function needs to 
  be used by the application programmer only in situations, where certain branches of an object 
  tree should be deleted.

bool hide();
  Temporarily hide the object (tree) presentation.

bool show();
  Restore hidden object (tree) presentation.

bool isRealized();
  Returns whether an object was ever realized.

bool isVisible();
  Returns whether an object is currently visible an the screen.

virtual bool move(int x, int y);
virtual bool resize(int width, int height);
virtual bool reframe(int x, int y, int width, int height);
  Positioning and sizing functions, the coordinate arguments are assumed to be absolute in 
  respect to the parent object (move/resize TO value).

bool getFrame(int& x, int& y, int& w, int& h);
  This function assignes the frame of an object to the given integer references.

bool setCallback(	XmManager* receiver,
			cbProc cbCode,
			bool setOrReset = TRUE,
			void* data = CB_OBJ_PTR	);
  The callback setup function. receiver is a pointer to the object whose callback member function 
  should be called, cbCode is a pointer to the callback member function of type 'void f(void*)'. 
  The following macro should be used to ensure a correct pointer to member in all supported 
  environments:

  CBK(class_name, function_name)

  This macro resolves usually in ((cbProc)&class_name::function_name) but some compilers (i.e. 
  gcc 2.5.X) require a different solution to accept Xm++ style callback usage.

  data is a value on which selects the parameter passed to the callback member. Possible values 
  are:

  value:		callback member called with:

  CB_NO_DATA		NULL pointer
  CB_XM_DATA		toolkit specific data (internal usage only)
  CB_XM_HANDLE		toolkit widget handle (internal usage only)
  CB_OBJ_NAME		a pointer to the triggering object's name 
  CB_OBJ_PTR		a pointer to the triggering object itself
  pointer		pointer to application data

  IMPORTANT: In the current implementation setting callbacks for a control is not possible 
  before it has been added to a parent object!

bool setBackgroundColor(char*);
bool setForegroundColor(char*);
  Sets an object's colors. Color names should conform to standard X11 colors (i.e. "white", 
  "lightGreen", "darkBlue", "grey30", etc.)

bool setCursor(char*);
  Sets object individual cursor shape. Possible values see XmApp::setCursor()

virtual void update(char*);
  This virtual function will be called when a manager of the receiving object has changed. 
  Default is to do nothing.


struct Entry
============

Description:
------------
  The one and only purpose of this struct is to hold the data for a single menu item. This is useful 
  to speed up the creation of menues by passing a list of entries (using varargs).

Entry(char* text, cbProc callback, void* data = NULL);
Entry(char* text, XmObject* receiver, cbProc callback, void* data = NULL);
Entry(char* n, char* text, cbProc callback, void* data = NULL);
Entry(char* n, char* text, XmObject* receiver, cbProc callback, void* data = NULL);
  These contructors take the information necessary to create an menu entry. text is taken for 
  both object name and item text (may contain a '&' character which denotes the item 
  mnemonic), receiver and callback are used to set the item callback, data is a pointer which can 
  be passed to the callback function. The first form (whithout giving a receiver object) takes the 
  menue's parent (application window) as default. The third form has an additional argument n, 
  the name of the object.


struct CheckEntry (: Entry)
=================

Description:
------------
This subtype of Entry must be used to create checkable Menu entries. The only difference to 
Entry constructors is a trailing parameter: 

CheckEntry(char* t, cbProc c, void* cd = NULL, bool rb = FALSE);
CheckEntry(char* t, XmObject* o, cbProc c, void* cd = NULL, bool rb = FALSE);
CheckEntry(char* n, char* t, cbProc c, void* cd = NULL, bool rb = FALSE);
CheckEntry(char* n, char* t, XmObject* o, cbProc c, void* cd = NULL, 
	bool rb = FALSE);
  If rb is specified to be TRUE the checkmark will have the shape of a radio button object. (Will 
  be visible only when using toolkits that support this feature.)

  A Note on menu callbacks and callback data:

  Menu callbacks are called with the entry name as the callback data. Passing CB_XM_DATA as 
  data causes Xm++ to use the item text instead of the name.

#define NULLENTRY Entry()
  Creates an empty entry to terminale a list of entries.


class XmMenu (: public XmObject)
============

Description:
------------
An abstract superclass for all menu classes. It implements most of the menu bahavior.

Inherited member functions:
---------------------------
XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

Member functions:
-----------------

void insertItemPos(int pos);
  Sets the (0 based) numeric index for subsequently added items, separators or submenues. If the 
  insert position is not explicitly set with this function, all added items are appended at the lower 
  end of a menu.

bool addSeparator(char* name = NULL);
bool removeSeparator(char* name);
  Separator functions. Separators need to be named only when it should be possible to remove 
  them later.

bool addItem(Entry e);
bool addItems(Entry, ...);
  Item add functions. The second form uses a NULLENTRY terminated list.

bool removeItem(char* name);
bool removeItems(char*, ...);
bool enableItem(char* name);
bool enableItems(char*, ...);
bool disableItem(char* name);
bool disableItems(char*, ...);
  Item remove/enable/disable operations. The item(s) which should be accessed are identified by 
  their name(s). Varargs lists must be NULL terminated.

XmSubMenu* addSubmenu(char* text);
XmSubMenu* addSubmenu(Entry);
bool removeSubmenu(char* name);
XmSubMenu* submenuAt(char* name);
  Submenue functions. addSubmenu() returns a pointer to a new submenu. submenuAt() returns 
  a pointer to an existing submenu. Both functions return NULL on failure. removeSubmenu() 
  works like removeItem.

bool changeItemText(char* name, char* newText);
  Changes the text of an existing menu item or submenu, the item name remains unchanged.

### bool getItemState(char* n);
### bool setItemState(char* n, bool newState);
  (existing, but currently ill named as xxxItemStatus())
  Functions for maintaining checkable menu entries which are accessed by their name. 
  getItemState() returns TRUE if the item is checked, FALSE if not. setItemState() checks or 
  unchecks the item depending on newState.


### bool setItemCallback(	char* name, 
				XmObject* receiver, 
				cbProc cb, 
				bool sr = TRUE, 
				void * cd = NULL);
  This function allows to change callback information for a menu item. Works like 
  XmObject::setCallback() except that the entry name has to be specified.


class XmPopupMenu (: public XmMenu)
=================

Description:
------------
A class implementing popup menues. This class has no public constructor - instances can be 
created with the createDropdown() function of XmDialogWindow. One popup menue per 
application window can be popped up by the user pressing the rightmost mouse button (default 
translation) inside the window for which it was created.

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmMenu
  addItem, disableItem, insertItemPos, setItemCallback, addItems, disableItems
  removeItem, setItemState, addSeparator, enableItem, removeItems, submenuAt
  addSubmenu, enableItems, removeSeparator, changeItemText, getItemState, removeSubmenu

Member functions:
-----------------

bool setLabel(char* text);
  Sets the popup menu label to the given text. 

bool popup();
  Allows to show from within the application.


class XmDropdownMenu (: public XmMenu)
====================

Description:
------------
A class implementing the well known menu bar, consisting of horizontally oriented label 
buttons and dropdown menues which are displayed, when a label button is clicked. This class 
has no public constructor - instances can be created with the createDropdown() function of 
XmDialogWindow.

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmMenu
  addItem, disableItem, insertItemPos, setItemCallback, addItems, disableItems
  removeItem, setItemState, addSeparator, enableItem, removeItems, submenuAt
  addSubmenu, enableItems, removeSeparator, changeItemText, getItemState, removeSubmenu

Member functions:
-----------------

void insertLabelPos(int pos);
  Sets the (0 based) numeric index for subsequently added labels. If the insert position is not 
  explicitly set with this function, new labels are appended after the rightmost label in a menu 
  bar.

bool addLabel(char* text);
bool addLabels(char*, ...);
bool addLabel(Entry e);
bool addLabels(Entry,...);
bool removeLabel(char* name);
bool removeLabels(char*, ...);
  These functions work quite similar to the item functions in class XmMenu except that they 
  operate on menu labels. The functions which take strings as arguments specify labels with 
  identical name and text. Functions which take Entry objects as arguments allow to have 
  different name and text passed in an Entry. (Other values of the Entry will be ignored.) 

bool setCurrentLabel(char* name);
  Sets the 'current label', the menu label to which add item operations in a menu bar will apply 
  (the inherited addItem(s) functions have no label argument). The current label defaults to the 
  label added last.

bool changeLabelText(char* name, char* new_text);
  Sets the text of the label with name to new_text.

bool changeItemText(char* label_name, char* item_name, char* new_text);
  Sets the text of the item with item_name of the label with label_name to new_text.


class XmSubMenu (: public XmMenu)
===============
Description:
A menu class which allows to build cascaded menu systems. This class has no public 
constructor, instances are created by the XmMenu's addSubmenu function.

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmMenu
  addItem, disableItem, insertItemPos, setItemCallback, addItems, disableItems
  removeItem, setItemState, addSeparator, enableItem, removeItems, submenuAt
  addSubmenu, enableItems, removeSeparator, changeItemText, getItemState, removeSubmenu


This class has no public member functions.


class XmDialog (: public XmObject)
==============

Description:
------------
An abstract base class for modal or modeless dialog windows. 

This class has no public member functions.


class XmSystemDialog (: public XmDialog)
====================

Description:
------------
An abstract base class for a couple of predefined dialogs. In the current Xm++ version all 
subclasses of this class are only interfaces to custom dialogs supported by most toolkits. Some 
functionality of these dialogs may be missing in certain environments (i.e. when using Xaw), 
future releases should fix that.

Modal system dialogs in Xm++ provide a technique which allows to retrieve a single value 
entered oder selected by the user without specifying callbacks and without leaving the current 
function context, i.e.:

char* aFilename;
if(aFilename = new XmFileSelector("/usr/*")->promptFile())
{	... do something with the selected file ...
}

The application program flow is halted here because the promptFile() function does not return 
until the user has selected a file or canceled the dialog. This makes the usage of system dialogs 
more convenient than it would be when having to specify callback functions.

This class has no public member functions.


class XmMsgBox (: public XmSystemDialog)
==============

Description:
------------
A class implementing message-, question-, warning- and error-boxes. They differ in the icon 
displayed beside the text and in number and labeling of command buttons, their appearance is 
controlled by styles.

Applicable styles:
------------------

	controlling icon:
		XmSmsgMemo, XmSmsgInfo, XmSmsgQuestion,
		XmSmsgWorking, XmSmsgWarning, XmSmsgError
	controlling buttons:
		XmSmsgOk, XmSmsgOkCancel, XmSmsgOkCancelHelp,
		XmSmsgYesNo, XmSmsgYesNoCancel
	controlling mode:
		XmSdlgModeless, XmSdlgWinModal,
		XmSdlgAppModal, XmSdlgSysModal
	predefined combined styles:
		XmSmboxInfo	(XmSdlgWinModal | XmSmsgOk | XmSmsgInfo)
		XmSmboxQuestion (XmSdlgWinModal| XmSmsgYesNo | XmSmsgQuestion)
		XmSmboxWarning	(XmSdlgAppModal | XmSmsgOk | XmSmsgWarning)
		XmSmboxError	(XmSdlgSysModal | XmSmsgOk | XmSmsgError)

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

Member functions:
-----------------

XmMsgBox(char* text,
		char* label,
		xmStyle style = 0,
		XmObject* receiver = NULL,
		cbProc callback = NULL);

  This constructor creates a message box with the given style, label and message text. An 
  optional button callback (will be called with the button name) can be specified.

bool showMsg();
  The modal execution function. It displays the dialog and returns TRUE if the user selected OK 
  or Yes, FALSE after Cancel or No.
  Note: To use a Help button, an 'asynchronous' callback must be specified too (showMsg() does 
  not return on Help).

bool setButtonText(msgButton button, char* new_text);
  Allows to change a button label to newName where button can be one of the constants OK, 
  CANCEL or HELP (OK also denotes a Yes, CANCEL a No button).

### bool setButtonCallback(msgButton button, 
		bool set_or_reset = TRUE,
		XmObject* receiver = NULL,
		cbProc callback = NULL);
  Assignes a callback to a specific button of a modal or modeless message box. The callback 
  function will be called with the button name as argument. If modal execution is used the 
  callback is called before the object is deleted.


class XmPrompter (: public XmMsgBox)
================

Description:
------------
A prompter is like a message box but has an additional editable text area. Button labels are 
always OK and Cancel (and Help if desired).

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmMsgBox
  setButtonCallback, setButtonText, showMsg

Member functions:
-----------------

XmPrompter(	char* message,
		char* label,
		char* defaultReply,
		xmStyle s = 0,
		XmObject* receiver = NULL,
		cbProc callback = NULL	);

  Like the constructor of the message box, defaultReply allows to specify the initial contents for 
  the editable field.

char* prompt();
  The modal execution function. Returns the contents of the editable field when the user clicked 
  OK, or NULL if the user clicked Cancel.

bool setText(char* new_text);
char* getText();
  These two functions are only useful when not using modal execution. setText() replaces the 
  text in the editable with new_text. getText() returns its current value. (This function must be 
  used in the button callback in order to retrieve the text before destroying the prompter.)


class XmListPrompter (: public XmPrompter)
====================

Description:
------------
A Prompter with an additional list box where the user can select the reply from predefined 
values. (Caution: Not available for some toolkits in the current implementation!)

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmMsgBox
  setButtonCallback, setButtonText, showMsg

XmPrompter
  getText, [prompt], setText

Member functions:
-----------------
XmListPrompter(	char** list,
		char* message,
		char* label,
		int default_reply,
		xmStyle s = 0,
		XmObject* receiver = NULL,
		cbProc callback = NULL	);

  Like the prompter's constructor, list is a NULL terminated array of strings which will be used 
  to fill the list box, default_reply is an index to this array.

char* promptText();
  The modal execution function. Returns the selected text.

int promptIndex();
  Another modal execution function. Returns the index of the selected item or -1 if the user 
  clicked cancel.

XmListPrompter* selectText(char* string);
XmListPrompter* selectIndex(int index);
int getIndex();
  Functions to be used when not using modal execution. selectText() and selectIndex() allow to 
  change the current selection, getIndex() returns the index of the current selection, the function 
  getText() inherited from XmPrompter returns the selected text.


class XmFileSelector (: public XmPrompter)
====================

Description:
------------
A special kind of list prompter for searching and selecting a file in a directory tree.

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmMsgBox
  setButtonCallback, setButtonText, showMsg

XmPrompter
  [getText], [prompt], [setText]

Member functions:
-----------------

XmFileSelector(	char* path
		char* label = NULL,
		char* default = NULL,
		xmStyle style = 0, 
		XmObject* receiver = NULL,
		cbProc callback = NULL	);

  The constructor of the file selecor. path specifies the initial directory to search, trailing 
  wildcards are used as filter arguments (i.e. "/home/joe/*.txt"). label allows to set an individual 
  title for the selector box, and default specifies an initial selected file name.

char* promptFile();
  The modal execution function. Returns the complete selected path or NULL if the user 
  canceled the file selection dialog.

bool setPath(char*);
char* getPath();
  Functions for non modal execution mode. setPath() resets the contents of the file list, getPath() 
  returns the currently selected path.


class XmControlPane
===================

Description:
------------
This abstract class is the base of an inheritance hierarchy for all Xm++ objects which may have 
other objects as children. The child objects are called 'controls' (borrowed from Microsoft's 
terminology) and can be primitives (like texts, buttons, etc.) or descendants of this class (like 
the group box).

This class has no public member functions.


class XmDialogPane (: public XmControlPane)
==================

Description:
------------
A class implementing children management with static layout for creating non resizeable dialog 
elements.

Member functions:
bool add(	XmControl* control,
		XmManager* receiver = NULL,
		cbProc callback = NULL,
		void* data = CB_OBJ_PTR);

  Adds the control to the dialog pane's children. receiver, callback and data allow to specify the 
  child's default callback. (This feature will not be needed when using the supplied dialog editor 
  because the add statements are generated automatically .)

bool remove(char* name);
  Removes the child with the given name after calling its destroy() function. 

XmGroupBox* groupBox(char* name);
XmStaticText* staticText(char* name);
XmStaticImage* staticImage(char* name);
XmPushButton* pushButton(char* name);
XmRadioButton* radioButton(char* name);
XmCheckBox* checkBox(char* name);
XmEdit* edit(char* name);
XmScrollBar* scrollBar(char* name);
XmListBox* listBox(char* name);
XmComboBox* comboBox(char* name);
  These functions return a (correctly casted) pointer to the child with the given name, or NULL 
  if the child with name has another type or does not exist.

  Caution: The expression 
  	aDialog->edit("myEdit")->setText("..."); 
  causes a memory fault if no edit named "myEdit" exists!


class XmUserDialog (: public XmDialog, public XmDialogPane)
==================

Description:
------------
The base class for user defined dialog boxes.

Applicable styles:
------------------

	controlling border and system menu:
		XmSmaximize, XmSminimize, XmSbordered, XmSmoveable, XmSresizeable, 
		XmScloseable, XmStitled, XmSsysMenu
	controlling mode:
		XmSdlgModeless, XmSdlgWinModal, XmSdlgAppModal, XmSdlgSysModal

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmDialogPane
  add, remove, Xm<Control-Type>* <Control-Type>

Member functions:
-----------------

XmUserDialog(char* name, XmObject* parent = NULL, xmStyle style= 0);
XmUserDialog(char* name, XmObject* parent, XmManager* mgr, xmStyle style = 0);
  These constructors initialize a dialog box according to the given arguments. If the parent 
  parameter is not used used it defaults to the display's root window (or 'desktop'). Specifying a 
  parent affects the window stacking order (child windows are always on top of their parent). 
  parent should not be NULL when style contains XmSdlgWinModal.

virtual bool initWindowSize(int& x, int& y, int& w, int& h);
  Overriding this virtual function is one way to specify initial window dimensions and 
  coordinates. This function is generated automatically when using the supplied dialog editor. 
  Subclass functions must return TRUE. Xm++ calls this function before realizing a dialog, the 
  window should appear at the location (does currently not work with all supported toolkits) and 
  with the size assigned to the respective variables.

void setInitWindowSize(int x, int y, int w, int h);
  In contrary to the passive initWindowSize() this function actively sets a window's parameters.

virtual void createContents();
  A virtual function which is first called by initialize(). Default is to do nothing. An overriding 
  subclass function is generated automatically when using the supplied dialog editor, it contains 
  add(new Control(...)) statements to create and add all the controls that make up the dialog.

virtual void initContents();
  This function is called from open() after createContents(). Default is to do nothing. It should 
  be overridden by subclasses to perform dialog initialization (i.e. enabling or disabling of 
  controls, setting callbacks, initial text and selection values).

virtual void initialize();
  This function calls createContents() and initContents() in order. When the dialog editor was 
  used and this function gets overridden in a subclass, the overriding function should invoke the 
  superclass implementation also.

bool open();
  Displays a dialog by calling initialize() and realize().

### bool run(char* ok_object_name, char* cancel_object_name = NULL);
  The modal execution function for a user dialog. It first calls open() and then runs the dialog 
  similar to a system dialog. The ok_object_name / cancel_object_name specify the objects 
  which will cause the dialog to exit with TRUE / FALSE.

bool setLabel(char* text);
  Set the dialog label (window title) to text. If this function is not used the dialog label defaults 
  to the dialog's name.

bool setFocus(char* name);
  Set the keyboard input focus to the named control (does not work properly with all toolkits in 
  this release).

bool setDefaultButton(char* name);
  Set the dialog's default button (the button which will be selected when hitting the enter key) to 
  the named button.

bool disable(char** names);
bool disable(char* name, ...);
bool enable(char** names);
bool enable(char* name, ...);
bool hideAll(char** names);
bool hideAll(char* name, ...);
bool showAll(char** names);
bool showAll(char* name, ...);
  These functions operate either with a NULL terminated array of strings (names) or a NULL 
  terminated varargs list to perform a certain operation on all given controls. The meanings of 
  the operations are explained in the reference entries for XmObject (hide/show) and XmControl 
  (disable/enable).

### virtual bool queryClose();
  This virtual function is called by Xm++ when the user has selected the window manager close 
  box or the corresponding system menu entry. Whether the dialog is deleted depends on this 
  function's return value. (Which is always TRUE in the default implementation.) Caution: An 
  application must not have any references to a dialog when enabling its closebox by specifying 
  XmScloseable!


class XmControl (: public XmObject)
===============

Description:
------------
An abstract base class for controls.

The (protected) constructor is a template for all subclasses:
	XmControl(char* name, int x, int y, int w, int h, xmStyle style);

The arguments are: object name, coordinates relative to the parent object, size, and style.

Applicable styles:
------------------

	XmStabStop

Other styles are subclass specific - they are summarized for each class in its reference entry.

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

Member functions:
-----------------

XmUserDialog* getDialog();
  Returns the dialog box or window to which this control belongs (will be different from the 
  parent when a control is the child of a group box).

xmStyle getStyle();
  Returns the controls current style.

bool changeStyle(xmStyle style);
  Changes the control's style, works only if the control has not been realized.

virtual XmControl* setText(char* new_text);
virtual XmControl* setFont(char* fontname);
virtual char* getText();
  These functions work for all subclasses, which have any text to display (static texts, edits, 
  buttons, etc.). setText() changes the object's text to new_text, setFont() changes the font used 
  to display the text, and getText() returns the current text of the object. If a control has text and 
  these functions are not used, it's text defaults to the control name. fontname must be a valid 
  X11 style font name/description (should be interpreted correctly in non X environments). 
  Warning for getText(): The returned value points to internal Xm++ data and will be 
  overwritten in subsequent calls. Therefore an application should duplicate it for further use and 
  must not delete it!
 
virtual XmControl* setImage(Pixmap image_data);
### virtual XmControl* setImage(char* image_file_name);
  Most of the controls are also able to display images instead of text. The first version of this 
  function works only in a X environment, it assignes a X11 pixmap to a control (see the macro 
  reference how to get such a pixmap from a xbm or gif file). The second form should work for 
  all supported toolkits.

virtual XmControl* setFocus();
  Forces the control to aquire the keyboard input focus.

virtual XmControl* disable();
virtual XmControl* enable();
  These functions disable/enable a control. In disabled state a control accepts no input, and its 
  visual components may be grayed (toolkit dependend).


class XmGroupBox (: public XmControl, public XmDialogPane)
================

Description:
------------
A group box is a control that allows visual grouping of logical related controls. As this class 
inherits from the dialog pane class, its behavior is widely identical to the dialog's. Group boxes 
can be added to other group boxes, and they can have a title string (which has to be specified 
with the setText() function).

Note: If a control is added to dialog containing one or more group boxes and the control's 
origin lies within the borders of a group box child, the control is added to this group box rather 
than to the dialog.

No class specific styles defined.

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmControl
  changeStyle, getDialog, setFocus, setText, disable, getStyle, setFont
  enable, getText, setImage

XmDialogPane
  add, remove, Xm<Control-Type>* <Control-Type>

Member functions:
-----------------

XmGroupBox(char* name, int x, int y, int w, int h, xmStyle style = 0);
  The group box constructor.


class XmPane (: public XmControl, public XmControlPane)
============

Description:
------------
A pane acts as link between a primitive control (like an edit or a list box) and a XmPaneArea. 
It surrounds its child and can have a label. Panes are created with the XmWindow's 
addSubpane() function.

No class specific styles defined.

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmControl
  changeStyle, getDialog, setFocus, setText, disable, getStyle, setFont
  enable, getText, setImage

Member functions:
-----------------

bool changeLabel(char* text);
  Change the pane label to text. The initial label text is given at creation as an argument to the 
  addSubpane() function.

xmControl* getControl();
  Returns the child object.


class XmPaneArea (: public XmGroupBox)
================

Description:
------------
A pane area tiles a window into multiple 'subpanes' (borrowed from Smalltalk terminology) 
which can be resized by the end user in some environments. The current implementation 
supports only vertical splitting of the XmWindow application window class.

No class specific styles defined.

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmControl
  changeStyle, getDialog, setFocus, setText, disable, getStyle, setFont
  enable, getText, setImage

XmDialogPane
  add, remove, Xm<Control-Type>* <Control-Type>

Member functions:
-----------------

XmPaneArea(char* name, int x, int y, int w, int h);
  The pane area constructor.

bool addSubpane( XmControl* control,
		char* label = NULL,
		XmObject* receiver = NULL,
		cbProc callback = NULL
		void* client_data = CB_OBJ_PTR);
  This function adds a subpane containing control, with label as the subpane label. The control's 
  default callback can be set by specifying receiver, callback and client_data.

bool removeSubpane(char* name);
  Removes the subpane which holds a control with name.

bool destroySubpane(char* name);
  This function deletes the subpane.

int numSubpanes();
  Returns the current number of subpanes in a pane area.

bool changeSubpaneLabel(char* name, char* new_label);
  Changes the label of the subpane which holds a control with name to the string new_label.


class XmToolBar (: public XmGroupBox)
===============

Description:
------------
Toolbars are areas within a window which perform automatic layout for controls added to 
them. A toolbar's size depends on its parent window and contents. They can currently be used 
only in combination with instances of the XmWindow class.

Applicable styles:
------------------

	XmShorizontal, XmSvertical

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmControl
  changeStyle, getDialog, setFocus, setText, disable, getStyle, setFont
  enable, getText, setImage

XmDialogPane
  add, remove, Xm<Control-Type>* <Control-Type>

Member functions:
-----------------

XmToolBar(char* name, xmStyle style  = XmShorizontal);
  The toolbar's constructor. The style argument specifies the orientation.

bool setRows(int max_rows);
  A toolbar can layout it's contents in one or multiple rows (if horizontally oriented) or columns 
  (if vertically oriented). The height/width of each row/column depends on the contents. This 
  function specifies the maximum number of rows/columns.


class XmStatusBar (: public XmGroupBox)
=================

Description:
------------
This is a special form of a toolbar. It is horizontally oriented and located at the bottom of a 
XmWindow. (Below a eventually existing bottom toolbar.) For default it gets a static text as 
the leftmost control, other controls are added to the right.

No class specific styles defined.

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmControl
  changeStyle, getDialog, setFocus, setText, disable, getStyle, setFont
  enable, getText, setImage

XmDialogPane
  add, remove, Xm<Control-Type>* <Control-Type>

Member functions:
-----------------

XmStatusBar(char* name);
  The status bar constructor.

bool setMessage(char* text);
  Changes the bar's status message to text.


class XmStaticText (: public XmControl)
==================

Description:
------------
Uneditable single or multi line text without a border. No callbacks.

Applicable styles:
------------------

	XmSleft, XmSright, XmScenter

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmControl
  changeStyle, getDialog, setFocus, setText, disable, getStyle, setFont
  enable, getText, setImage

Member functions:
-----------------

XmStaticText(char* name, int x = 0, int y = 0, int w = 0, int h = 0, xmStyle style = 0);
  The constructor.


class XmStaticImage (: public XmControl)
===================

Description:
------------
Static control displaying an image. No callbacks.

No class specific styles defined.

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmControl
  changeStyle, getDialog, setFocus, setText, disable, getStyle, setFont
  enable, getText, setImage

Member functions:
-----------------

XmStaticImage(char* name, int x = 0, int y = 0, int w = 0, int h = 0, xmStyle style = 0);
  The constructor.


class XmPushButton (: public XmControl)
==================

Description:
------------
A command button. The default callback is invoked when the button has been selected.

Applicable styles:
------------------

	XmSleft, XmSright, XmScenter, XmSdefault

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmControl
  changeStyle, getDialog, setFocus, setText, disable, getStyle, setFont
  enable, getText, setImage

Member functions:
-----------------

XmPushButton(char* name, int x = 0, int y = 0, int w = 0, int h = 0, xmStyle style = 0);
  The constructor.


class XmCheckBox (: public XmControl)
================

Description:
------------
A simple toggle button. The default callback is invoked when the button's state has changed.

No class specific styles defined.

Inherited member functions:
---------------------------


XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmControl
  changeStyle, getDialog, setFocus, setText, disable, getStyle, setFont
  enable, getText, setImage

Member functions:
-----------------

XmCheckBox(char* name, int x = 0, int y = 0, int w = 0, int h = 0, xmStyle style = 0);
  The constructor.

bool setState(bool new_state);
bool getState();
  Both functions return the current button state (TRUE if selected, FALSE otherwise), 
  setState() also changes the button state to new_state.


class XmRadioButton (: public XmCheckBox)
===================

Description:
------------
A special form of a toggle button, in most toolkits it looks different from a checkbox.  When 
selected, it forces all other radio buttons within it's group to be unselected. A radio button 
group consists of all radio buttons belonging to the same parent object (dialog or group box). 
The default callback is invoked when the button's state has changed.

No class specific styles defined.

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmControl
  changeStyle, getDialog, setFocus, setText, disable, getStyle, setFont
  enable, getText, setImage

XmCheckBox
  getState, setState

Member functions:
-----------------

XmRadioButton(char* name, int x = 0, int y = 0, int w = 0, int h = 0, xmStyle style = 0);
  The constructor.

XmRadioButton* getSelected();
  Returns the the currently selected radio button in its group.


class XmValuator (: public XmControl)
================

Description:
------------
A control allowing convenient selection of integer or float values. Its implementation may look 
quite different among the supported toolkits (i.e. Motif uses the Scale widget while Xaw and 
MS-Windows use Scrollbars). If not forced by style or function call its orientation depends on 
the ratio of its widht and height. The default callback is invoked when the value has been 
changed after the user has completed the change operation (i.e. after releasing the slider).

Applicable styles:

	XmShorizontal, XmSvertical

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmControl
  changeStyle, getDialog, setFocus, setText, disable, getStyle, setFont
  enable, getText, setImage

Member functions:
-----------------

XmValuator(char* name, int x = 0, int y = 0, int w = 0, int h = 0, xmStyle style= 0);
  The constructor.

bool setOrientation(bool horizontal);
  Changes the orientation regardless of the object's dimensions. (horizontal FALSE selects 
  vertical)

bool setDirection(bool left2right);
  Changes the direction in which the valuator's value will be increased. (left2right also means 
  top2bottom, FALSE selects right2left / bottom2top)
 
short setDecimalPoint(short ndigits);
  Sets the number of decimal digits when displaying a float value.

void displayValue(bool showit = TRUE);
  Makes the valuator show / hide the currently selected value.

XmControl* setRange(int min, int max);
XmControl* setRange(float min, float max);
  These functions adjust the valuator's range by specifying minimum and maximum value. The 
  actual resolution depends on the object's size and the toolkit used.

XmControl* setValue(int new_value);
XmControl* setValue(float new_value);
int getValue();
float getFloatValue();
  Set or get the valuator's value.


class XmEdit (: public XmControl)
============

Description:
------------
Editable text. Single or multi line and scrolling has to be specified using styles upon creation. 
The default callback is invoked when the edit looses the input focus and its contents was 
changed sice getting it. Note: Offset values used by some functions below are relative to the 
beginning of the text string. 

Applicable styles:

	XmSleft, XmSright, XmSautovscroll, XmSautohscroll, XmSmultiLine

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmControl
  changeStyle, getDialog, setFocus, setText, disable, getStyle, setFont
  enable, getText, setImage

Member functions:
-----------------

XmEdit(char* name, int x = 0, int y = 0, int w = 0, int h = 0, xmStyle style = 0);
  The constructor.

long getInsertPosition(int* line = NULL, int* column = NULL);
  Returns the current insert position as the number of characters from the beginning of the text. 
  If the integer pointer line or column is not null, the respective offset is calculated and assigned.

bool setInsertPosition(long offset);
bool setInsertPosition(int line, int column);
  These functions set an edit's insert position, the text position where characters subsequently 
  inserted by user interaction (typing) or application code (insertText() or paste()) will go. 

### bool insertText(char* text);
  In contrary to setText() inherited from XmControl which entirely replaces the object's text this 
  function inserts text at the current insert position.

char* getSelection();
  Returns the string which makes up the current selection.

bool setSelection(long from, long to);
  Sets the current selection to the text between the from and to offset values.

bool clearSelection();
  Deletes the current selection from the text buffer.

bool cut();
bool copy();
bool paste();
  Clipboard functions: cut or copy the current selection to the clipboard, insert the clipboard 
  contents at the current insert position.

### bool setInputCallback(	XmManager* receiver,
			cbProc cbCode,
			bool set_or_reset = TRUE,
			void* data = CB_OBJ_PTR	);
  Sets a callback which allows input verification. It is invoked on any user input to an edit 
  (typing or paste). The callback member is called with a special argument:

struct xm_edit_client_data {
	char*  input;		// the string to be inserted
	bool doit;		// the return parameter
	void* client_data; 	// the original client data supplied when setting the callback
};

Whether the edit's contents is changed depends on the doit member of this struct. It is preset to 
TRUE, if the callback code resets it to FALSE the operation will be ignored.


class XmListBox (: public XmControl)
===============

Description:
------------
A listbox. Single or multiple selection and scrolling has to be specified using styles upon 
creation. The default callback is invoked when the user selects a single item in the list. Note 
that listbox indices are 1 - based.

Applicable styles:

	XmSautovscroll, XmSautohscroll, XmSsingleSel, XmSmultipleSel

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmControl
  changeStyle, getDialog, setFocus, setText, disable, getStyle, setFont
  enable, getText, setImage

Member functions:
-----------------

XmListBox(char* name, int x = 0, int y = 0, int w = 0, int h = 0, xmStyle style = 0);
  The constructor.

XmListBox* add(char* text);
  Add the item text after the last item in the list.

XmListBox* insert(int index, char* text);
  Insert the item text before the item with index.

bool remove(char* text);
  Remove the first item matching text.

bool remove(int index);
  Remove the item with the given index.

bool change(char* old_text, char* new_text);
  Change the first item string matching old_text to new_text.

bool change(int index, char* new_text);
  Change the first item string matching old_text to new_text.

XmListBox* addAll(char** list);
XmListBox* addAll(char* text, ...);
XmListBox* insertAll(int index, char** list);
XmListBox* insertAll(int index, char* text, ...);
bool removeAll(char** list);
bool removeAll(char* text, ...);
bool removeAll(int* list);
bool removeAll(int text, ...);
  These functions work like their single forms but operate on a NULL terminated arrays or 
  NULL terminated varargs lists.

bool setContents(char** list);
char** getContents();
int getItemCount();
bool clear();
  These functions operate on the whole listbox contents. setContents() completely replaces the 
  current listbox contents with list, getContents() returns the current listbox contents, get 
  getItemCount() returns the current number of items in the listbox, and clear() resets the listbox 
  to be empty.

bool selectText(char* text, bool notify = FALSE);
bool selectIndex(int index, bool notify = FALSE);
  Select the item matching text or at the position index. If notify is set to TRUE invoke the 
  listbox's select callbacks. Whether a selected item replaces or extends the previous selection 
  depends on the listbox allowing multiple selection or not.

bool deselectText(char* text);
bool deselectIndex(int index);
  Un-select the item matching text or with the given index.

bool deselectAll();
  Un-select all items in the listbox.

bool setDoubleClickCallback(	XmObject* receiver,
				cbProc callback,
				bool set_or_reset = TRUE,
				void* data = CB_OBJ_DATA);
  Set the callback to be invoked when an item is selected with a doubleclick.

int selectedCount();
  Returns the number of currently selected items.

char* selectedItem();
  Returns the text of the selected item or NULL if none. ### When used with a multiple 
  selection listbox this function will return the item which was selected last. Warning: The 
  returned value points to internal Xm++ data and will be overwritten in subsequent calls. 
  Therefore an application should duplicate it for further use and must not delete it!

char** selectedItems();
  Returns a null terminated array of all selected items or NULL if no item is selected. Warning: 
  The returned value points to internal Xm++ data and will be overwritten in subsequent calls. 
  Therefore an application should duplicate it for further use and must not delete it!

int selectedIndex();
int* selectedIndices();
  Like above but return the index / a null terminated array of indexes. Warning for 
  selectedIndices(): The returned value points to internal Xm++ data and will be overwritten in 
  subsequent calls. Therefore an application should duplicate it for further use and must not 
  delete it!


class XmComboBox (: public XmGroupBox, public XmPushButton, 	
================    public XmListBox, public XmEdit )

Description:
------------
This class implements a control consisting of an edit field and a single selection listbox placed 
below it. (Well known to Macintosh- and MS-Windows users, Motif 2.0 also provides it.) If a 
list item is selected, the contents of the edit is set to the list item's text. Styles are used to 
define three different kinds of combo boxes:

Simple:		the listbox is always visible, the contents of the text field is 
		editable.
Dropdown:	has an arrow button to the right of the text field, the listbox is 
		not initially shown but popped up when the button is pressed. 
		Making a selection or pressing the button a second time lets 
		the listbox disappear.
Dropdownlist:	like dropdown but the text is read only and the listbox does 
		not disappear after making a selection.

The combo box default callback is invoked when either the user has selected an item in the list 
or (if style simple or dropdown) the user has edited the text field and the object looses the 
input focus.

Applicable styles:
------------------

	XmSsimple, XmSdropdown, XmSdropdownlist

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmControl
  changeStyle, getDialog, setFocus, setText, disable, getStyle, setFont
  enable, getText, setImage

XmEdit
  clearSelection, getInsertPosition, paste, setInsertPosition, copy, getSelection
  setInputCallback, setSelection, cut, insertText, setInsertPosition

XmListBox
  add, getContents, selectedCount, selectText, addAll, getItemCount, selectedIndex
  setContents, change, insert, selectedIndices, setDoubleClickCallback, clear
  insertAll, selectedItem, deselectAll, remove, selectedItems, deselectText
  removeAll, selectIndex

Member functions:
-----------------

XmComboBox(char* name, int x = 0, int y = 0, int w = 35, int h = 35, xmStyle style = 0);
  The constructor.


class XmDialogWindow (: public XmUserDialog)
====================

Description:
------------
A non-paned toplevel window class supporting popup and dropdown menues.

No class specific styles defined.

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmDialogPane
  add, remove, Xm<Control-Type>* <Control-Type>

XmUserDialog
  createContents, initContents, queryClose, setInitWindowSize, disable, initialize
  run, setLabel, enable, initWindowSize, setDefaultButton, showAll, hideAll, open
  setFocus

Member functions:
-----------------

XmDialogWindow(char* name, XmObject* parent = NULL, xmStyle s = 0);
XmDialogWindow(char* name, XmObject* parent, XmManager* mgr, xmStyle s = 0);
  The constructors. 

XmPopupMenu* createPopupMenu(char* name = "&Menu");
XmDropdownMenu* createDropdownMenu();
  Create and return the respective menu object. While there can be only one dropdown menu 
  (subsequent calls to createDropdownMenu() will have no affect), an application may create an 
  arbitrary number of popup menues for a window. The current popup (which will be used when 
  the user presses the popup key) is for defalt the last which has been created.

XmPopupMenu* getPopup();
XmDropdownMenu* getDropdown();
  These functions return the current popup or the menu bar, or NULL if there is no such object.

XmPopupMenu* setPopup(XmPopupMenu* new_popup);
  Change the current popup to be new_popup. The former used popup is returned.


class XmWindow (: public XmDialogWindow)
==============

Description:
------------
A paned toplevel window class with the additional feature of toolbars and a status bar. (See the 
descriptions of XmDialogWindow, XmPaneArea, XmPane, XmToolBar and XmStatusBar.)

No class specific styles defined.

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmDialogPane
  add, remove, Xm<Control-Type>* <Control-Type>

XmUserDialog
  createContents, initContents, queryClose, setInitWindowSize, disable, initialize
  run, setLabel, enable, initWindowSize, setDefaultButton, showAll, hideAll, open
  setFocus

XmDialogWindow
  createDropdownMenu, getDropdown, setPopup, createPopupMenu, getPopup

Member functions:
-----------------

XmWindow(char* name, XmObject* parent = NULL, xmStyle s = 0);
XmWindow(char* name, XmObject* parent, XmManager* mgr, xmStyle s = 0);
  The constructors.

bool addSubpane( XmControl* control,
			char* label = NULL,
			XmObject* receiver = NULL,
			cbProc callback = NULL );
  Adds the given control as a subpane to the window's pane area. If label is not null, the subpane 
  will be labeled with the given string. receiver and callback allow to set the control's default 
  callback. The new subpane will be created below any existing subpanes. (A method for 
  controlling the insert position should be provided in future releases.)

bool removeSubpane(char* name);
  Removes and destroys the named subpane.

bool changeSubpaneLabel(char* name, char* new_label);
  Sets the label of the named subpane to new_label.

XmToolBar* addToolbar(xmStyle style);
  Adds an empty toolbar to the window, orientation and alignment is controlled by the style 
  parameter (one of: XmStop, XmSleft, XmSright, XmSbottom). On success, a pointer to the 
  new toolbar, on failure (i.e. when a tollbar with the given style already exists) NULL is 
  returned.

bool removeToolbar(xmStyle style);
  Removes and destroys the toolbar with style.

XmToolBar* toolbar(xmStyle style);
  Returns a pointer to the toolbar object with style, or NULL if it has not been created.

XmStatusBar* createStatusBar();
  Creates and returns an empty status bar, returns NULL on failure.

XmStatusBar* getStatusBar();
  Returns a pointer to the status bar, or NULL if it has not been created.


class XmToolBox (: public XmDialogWindow, public XmToolBar)
===============

Description:
------------
This class implements a toolbox, a modeless dialog window which performs automatic layout 
for its children like a toolbar.

No class specific styles defined.

Inherited member functions:
---------------------------

XmObject
  destroy, hide, reframe, show, destroyOnDelete, isNamed, resize, topHandle
  getFrame, isRealized, setBackgroundColor, update, getName, isVisible, setCallback
  valid, getParent, move, setCursor, handle, realize, setForegroundColor

XmDialogPane
  add, remove, Xm<Control-Type>* <Control-Type>

XmUserDialog
  createContents, initContents, queryClose, setInitWindowSize, disable, initialize
  run, setLabel, enable, initWindowSize, setDefaultButton, showAll, hideAll, open
  setFocus

Member functions:
-----------------

XmToolBox(	char* name,
		XmObject* parent,
		xmStyle = XmSvertical,
		int rows = 1 );
XmToolBox(	char* name,
		XmObject* parent,
		XmManager* mgr,
		xmStyle s = XmSvertical,
		int rows = 1 );
  The constructors. See superclasses (dialog window, toolbar) for details.
