mi32/xdefns.h

Go to the documentation of this file.

#if defined (MAC_OSX) && defined(__x86_64__)
#define USE_XFT 1
#endif

#if !defined(INC_MI32_XDEFNS_H) && (!defined(WIN32_NATIVE) || defined(GENERATING_DOXYGEN_OUTPUT))

#define  INC_MI32_XDEFNS_H

#define  NoXmMessageDialogTypes  //  So don't allow XmDIALOG_ERROR, WARNING, etc 

#ifndef  INC_MI32_STDDEFNS_H
   #include <mi32/stddefns.h>
#endif

#ifndef  _XLIB_H_
   #include <X11/Xlib.h>
#endif

#ifndef  _XUTIL_H
   #include <X11/Xutil.h>
#endif

#ifdef EDITRES
   #include <X11/Xmu/Editres.h>
#endif

#ifndef  _Xm_h
   #include <Xm/Xm.h>
#endif

#ifndef  _XmToggle_h
   #include <Xm/ToggleB.h>
#endif

#ifndef  INC_MI32_DISPINFO_H
   #include <mi32/dispinfo.h>
#endif

#ifndef INC_MI32_ELEMTYPE_H
   #include <mi32/elemtype.h>
#endif

#ifndef  INC_MI32_COLOR_H
   #include <mi32/color.h>
#endif

#ifndef  INC_MI32_TEXTBASE_H
   #include <mi32/textbase.h>    
#endif

#ifndef  INC_MI32_STRTODEG_H
   #include <mi32/strtodeg.h>    // For DEGTOSTRFLAGS
#endif

#ifndef  INC_MI32_MSYS_H
   #include <mi32/msys.h>
#endif

#ifndef  INC_RVC_OBJTYPE_H
   #include <rvc/objtype.h>
#endif

#ifndef  INC_MI32_MG2ENUMS_H
   #include <mi32/mg2enums.h> 
#endif

#ifndef  INC_MI32_ICONID_H
   #include <mi32/iconid.h>
#endif

#ifndef  INC_MI32_XTABPAGE_H
   #include <mi32/xtabpage.h>
#endif

#ifndef  INC_MI32_XBASE_H
   #include <mi32/xbase.h>
#endif

#ifndef  INC_MI32_XTARGS_H
   #include <mi32/xtargs.h>
#endif

#ifndef  INC_MI32_DELEGATE_H
   #include <mi32/delegate.h>
#endif


#ifdef index
#undef index
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations
class REGION2D;
struct MICONSTRUCT;
struct RGNELEMLIST;
struct TEXTSTYLE;
struct MTIMER;
class TRANS2D_MAPGEN;
struct UNITCONV;
struct TEXTMETRICS;
class FILEPATH;
namespace MGD {
   class DEVICE;
   class DEVICE_BINARY;
   }
namespace RVC {
   class OBJITEM;
   class OBJITEMLIST;
   class RASTER;
   class STYLE;
   class STYLEPATTERN_BITMAP;
   }
namespace SPATREF {
   class COORDREFSYS;
   }
#endif


/*----------------------------------------------------------------------------*/
/*    Helper macros                                                           */
/*----------------------------------------------------------------------------*/

#define  XtSetArgI(arg,c,n,v) ((void)(arg[c].name=(char*)(n),arg[c].value=(XtArgVal)(v),c++))

   // The sizeof operators are used to ensure that the size of the variable where
   // userData will be stored is at least as large as a pointer.  Normally the
   // expression inside the [] evaluates to 1.  mju 1994-05-10
#define  MxGetUserData(w,p)   { Arg _mxgetuserdataarg[sizeof(*p)-sizeof(void*)+1]; XtSetArg(_mxgetuserdataarg[0],XmNuserData,p); XtGetValues(w,_mxgetuserdataarg,1); }

// Macros for defining class methods to add Xt callbacks / event handlers
#define  MXXTCB_ADD(_clsname)       inline void MxXtCallbackAdd (Widget w, const char *name, void (*f)(Widget,_clsname*,void*)) { XtAddCallback(w,(name),reinterpret_cast<XtCallbackProc>(f),this); }
#define  MXXTCB_REMOVE(_clsname)    inline void MxXtCallbackRemove (Widget w, const char *name, void (*f)(Widget,_clsname*,void*)) { XtRemoveCallback(w,(name),reinterpret_cast<XtCallbackProc>(f),this); }
#define  MXXTEH_ADD(_clsname)       inline void MxXtEventHandlerAdd (Widget w, EventMask emask, void (*f)(Widget,_clsname*,XEvent*,Boolean*), bool nmi=false) { XtAddEventHandler(w,(emask),(Boolean)(nmi),reinterpret_cast<XtEventHandler>(f),this); }
#define  MXXTEH_REMOVE(_clsname)    inline void MxXtEventHandlerRemove (Widget w, EventMask emask, void (*f)(Widget,_clsname*,XEvent*,Boolean*), bool nmi=false) { XtRemoveEventHandler(w,(emask),(Boolean)(nmi),reinterpret_cast<XtEventHandler>(f),this); }
#define  MXXTTO_ADD(_clsname)       inline XtIntervalId MxXtTimeOutAdd (Widget, unsigned long delay, void (*f)(_clsname*,XtIntervalId*)) { return(XtAppAddTimeOut(MsysAppGetXContext(),(delay),reinterpret_cast<XtTimerCallbackProc>(f),this)); }


/*----------------------------------------------------------------------------*/

extern "C" {

extern int _MxShadowThickness;   
extern int _MxSpaceNarrow;       
extern int _MxSpaceNormal;       
extern int _MxSpaceWide;         

}  

/*----------------------------------------------------------------------------*/
/*    Definitions for EditColor                                               */
/*----------------------------------------------------------------------------*/

#define  EDITCOLOR_AllowTransp      0x0002 
#define  EDITCOLOR_AllowTransPct    0x0004 

struct EDITCOLORINFO {
   COLOR color;
   Pixel pixel;               
   UINT8 CanChangeColor;      
   UINT8 AllowTransparent;    
   UINT8 DefaultSelected;     
   UINT8 spare;
   char *name;                
   };


/*----------------------------------------------------------------------------*/
/*    Menu Item definitions                                                   */
/*----------------------------------------------------------------------------*/

struct MENUITEM {
   mutable char *label;          
   unsigned long flags;          
   XtCallbackProc callback;      
   void *callback_data;          
   const char *help;             
   const MENUITEM *subitems;     
   void *userdata;               
   UINT32 icid;                  
   mutable Widget widget;        
   Widget *pwidget;              
   };

struct MENUBARITEM {
   mutable char *label;          
   const MENUITEM *items;        
   Widget *widget_list;          
   mutable Widget widget;        
   const char *help;             
   UINT32 icid;                  
   Widget *pwidget;              
   };

#define MxMENU_SELECTED          0x0001
#define MxMENU_ONE_OF_MANY       0x0002   
#define MxMENU_TOGGLE            0x0004   
#define MxMENU_DISABLED          0x0008   
#define MxMENU_LABEL             0x0010   
#define MxMENU_FORCENAME         0x0020   
#define MxMENU_LABELMIUNICODE    0x0040   
#define MxMENU_IGNORE            0x0080   
#define MxMENU_NOGADGET          0x0100   
#define MxMENU_NOCENTERLABEL     0x0200   
#define MxMENU_PROGRAMMER        0x0400   
#define MxMENU_NOCHGCBDATA       0x0800   
#define MxMENU_FREELABEL         0x1000   
#define MxMENU_NOCUSTOMSUBMENU   0x2000   


enum MxEDITMENUFLAGS {  
   MxEDITMENUFLAG_None =         0x0000,
   MxEDITMENUFLAG_NoSearch =     0x0001,
   MxEDITMENUFLAG_NoReplace =    0x0002,
   MxEDITMENUFLAG_NoInsertFile = 0x0004,
   MxEDITMENUFLAG_AllowFormat =  0x0008   
   };
#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(MxEDITMENUFLAGS)
#endif

/*----------------------------------------------------------------------------*/
/*    Definitions used by MxCreateButtonRow                                   */
/*----------------------------------------------------------------------------*/

struct BUTTONITEM {
   char *label;                  
   UINT32 flags;                 
   XtCallbackProc callback;      
   void *callback_data;          
   const char *help;             
   void *userdata;               
   mutable Widget pbwidget;      
   const char *IconName;         
   const char *ClassName;        
   UINT32 icid;                  
   const MIUNICODE *ToolTip;        
   Pixel BackgroundPixel;        
   Widget *pwidget;              
   };

#define  MxBUTTON_DISABLED          0x00000001  
#define  MxBUTTON_TOGGLE            0x00000002  
#define  MxBUTTON_NOINDICATOR       0x00000004  
#define  MxBUTTON_SELECTED          0x00000008  
#define  MxBUTTON_ONE_OF_MANY       0x00000010  
#define  MxBUTTON_DEFAULT           0x00000020  
#define  MxBUTTON_MULTI_CLICK       0x00000040  
#define  MxBUTTON_IGNORE            0x00000080  
#define  MxBUTTON_PROGRAMMER        0x00000100  
#define  MxBUTTON_NOMANAGE          0x00000200  
#define  MxBUTTON_ICON_MENU         0x00000400  
#define  MxBUTTON_ICON_MENU_FILE    0x00000800  
#define  MxBUTTON_BACKGROUND_PIXEL  0x00001000  
#define  MxBUTTON_NOCUSTOMSUBMENU   0x00002000  
#define  MxBUTTON_FORCENAME         0x00004000  
#define  MxBUTTON_LABELMIUNICODE    0x00008000  
#define  MxBUTTON_ALLOWRIGHTCLICK   0x00010000  

#define  MxBUTTONROW_NoIcons     0x0001   
#define  MxBUTTONROW_RowColumn   0x0002   
#define  MxBUTTONROW_XmiPane  0x0004   

/*----------------------------------------------------------------------------*/
/*    Flags for MxCreateIcon...                                               */
/*----------------------------------------------------------------------------*/

#define MXICON_Stippled             MICONFLAG_Stippled
#define MXICON_DefaultBackground    MICONFLAG_DefaultBackground
#define MXICON_StippledSelected     MICONFLAG_StippledSelected
#define MXICON_Size16               MICONFLAG_Size16
#define MXICON_Size32               MICONFLAG_Size32
#define MXICON_NoDarkenSelected     MICONFLAG_NoDarkenSelected

/* Flags for MxSelectIcon() */

#define  SELICON_Resize          0x01        


/*----------------------------------------------------------------------------*/
/*    Flags used by MxPopupGet... and MxCreateDouble() etc...                 */
/*----------------------------------------------------------------------------*/

#define GET_NoMin             (0x00000011)   
#define GET_NoMax             (0x00000022)
#define GET_NoRange           (0x00000033)
#define GET_NoDft             (0x00000004)
#define GET_InvValid          (0x00000008)   
#define GET_RastValRGB16UINT2 (0x00000008)   
#define GET_RangeMask         (0xFFFFFFFC)

#define GET_NoShowMin         (0x00000010)   
#define GET_NoShowMax         (0x00000020)
#define GET_NoShowRange       (0x00000030)   
#define GET_ShowUnitLabel     (0x00000040)   
#define GET_ShowRange         (0x00000080)   

#define GET_NoCancel          (0x00000100)
#define GET_LabelTop          (0x00000200)   
#define GET_DftRet            (0x00000400)   
#define GET_AddOne            (0x00000800)   

#define GET_DegsNS            (0x00000000)   
#define GET_DegsEW            (0x00001000)   
#define GET_ToUpper           (0x00002000)   
#define GET_DetectNULL        (0x00004000)   
#define GET_BlankZero         (0x00008000)   
#define GET_RightJustify      (0x00010000)   
#define GET_OutputOnly        (0x00020000)   
#define GET_PromptGiven       (0x00040000)   
#define GET_DegsNoDir         (0x00080000)   
#define GET_NoManage          (0x00100000)
#define GET_NoForm            (0x00200000)   
#define GET_PopupForceStr     (0x00400000)   
#define GET_HasScale          (0x00800000)   
#define GET_Degs360EW         (0x01000000)   
#define GET_Unicode           (0x02000000)   
#define GET_PromptUnicode     (0x04000000)   
#define GET_LeftJustify       (0x08000000)   
#define GET_UseLogScale       (0x20000000)   
#define GET_Password          (0x40000000)   

#define  MxPromptRastValCR_ValueChanged   0x0001

#define  MxPromptCR_ValueChanged       0x00000001  
#define  MxPromptCR_ValueChangeDrag    0x00000002  
#define  MxPromptCR_Activate           0x00000004  

struct MxPromptCallbackStruct {
   UINT32 reason;                   
   Widget prompt;                   
   void *value;                     
   };

typedef void (*MxPromptCallbackFunc)(MxPromptCallbackStruct*, void*);

#define  MXPRMTCB_ADD(_clsname)     inline void MxPromptCallbackAdd (Widget w, void (*f)(MxPromptCallbackStruct*,_clsname*), UINT32 flags = MxPromptCR_ValueChanged) const { MxPromptAddCallback(w,reinterpret_cast<MxPromptCallbackFunc>(f),(void*)this,(flags)); }
#define  MXPRMTCB_REMOVE(_clsname)  inline void MxPromptCallbackRemove (Widget w, void (*f)(MxPromptCallbackStruct*,_clsname*), UINT32 flags) const { MxPromptRemoveCallback(w,reinterpret_cast<MxPromptCallbackFunc>(f),(void*)this,(flags)); }

   /* Prompt field types */
#define MXPROMPT_ASTRING   0     
#define MXPROMPT_USTRING   1     
#define MXPROMPT_ACHAR     2     
#define MXPROMPT_UCHAR     3     
#define MXPROMPT_DOUBLE    10    
#define MXPROMPT_FLOAT     11    
#define MXPROMPT_UINT32    12    
#define MXPROMPT_INT32     13    
#define MXPROMPT_UINT16    14    
#define MXPROMPT_INT16     15    
#define MXPROMPT_UINT8     16    
#define MXPROMPT_INT8      17    
#define MXPROMPT_LATLON    18    

/*----------------------------------------------------------------------------*/
/*    Values by MxPositionWindowRel                                           */
/*----------------------------------------------------------------------------*/

enum MxRELPOSN {
   MxRELPOSN_Default =        0,
   MxRELPOSN_AutoLeftRight =  1,
   MxRELPOSN_RightTop =       2,
   MxRELPOSN_LeftTop =        3,
   MxRELPOSN_RightCenter =    4,
   MxRELPOSN_LeftCenter =     5,
   MxRELPOSN_RightBottom =    6,
   MxRELPOSN_LeftBottom =     7,
   MxRELPOSN_TopLeft =        8,
   MxRELPOSN_BottomLeft =     9,
   MxRELPOSN_TopCenter =      10,
   MxRELPOSN_BottomCenter =   11,
   MxRELPOSN_TopRight =       12,
   MxRELPOSN_BottomRight =    13,
   MxRELPOSN_MatchBottom =    14,
   MxRELPOSN_MatchTop =       15,
   MxRELPOSN_MatchLeft =      16,
   MxRELPOSN_MatchRight =     17
   };

/*----------------------------------------------------------------------------*/
/*    Values used by MxLockWindowSize()                                       */
/*----------------------------------------------------------------------------*/

#define  MxLOCKSIZE_MinHeight    0x1
#define  MxLOCKSIZE_MinWidth     0x2
#define  MxLOCKSIZE_MaxHeight    0x4
#define  MxLOCKSIZE_MaxWidth     0x8
#define  MxLOCKSIZE_Min          (MxLOCKSIZE_MinHeight | MxLOCKSIZE_MinWidth)
#define  MxLOCKSIZE_Max          (MxLOCKSIZE_MaxHeight | MxLOCKSIZE_MaxWidth)
#define  MxLOCKSIZE_MinMax       (MxLOCKSIZE_Min | MxLOCKSIZE_Max)

/*----------------------------------------------------------------------------*/
/*    Misc constants                                                          */
/*----------------------------------------------------------------------------*/

#define  MxBCOL_ALIGN_BEGINNING  1

extern "C" {

/*----------------------------------------------------------------------------*/
/*    Function prototypes (keep in alphabetical order!)                       */
/*----------------------------------------------------------------------------*/


XtAppContext MsysAppGetXContext ();

Display* MsysAppGetXDisplay ();

void MsysAppSetXDisplayContext (
   Display *xdisplay,                     
   XtAppContext xappcontext               
   );


         /* Generic callbacks */

void MxcbDisplayHelp (
   Widget,                             
   void*,
   void*
   );

void MxcbOptionUBYTE (
   Widget w,
   void *voption,
   void*
   );

void MxcbSetExit (
   Widget,
   void*,
   void*
   );

void MxcbToggleBool (
   Widget,
   void *vvalue,
   XmToggleButtonCallbackStruct *cbs
   );

void MxcbToggleUBYTE (
   Widget,
   void *vvalue,
   XmToggleButtonCallbackStruct *cbs
   );

#define  MxcbOptionUINT8      MxcbOptionUBYTE
#define  MxcbToggleUINT8      MxcbToggleUBYTE

int Main_DatabaseEditor (
   Widget parent                       
   );

void MxAddDeleteWindowCallback (
   Widget widget,
   XtCallbackProc cbproc,
   void* cbdata
   );

void MxAlignLabels (
   Widget* widgets,                       
   int num                                
   );

void MxAlignWidgets (
   Widget* widgets,                       
   int num,                               
   UINT32 flags                           
   );


#define MxANGLECONTROL_Quadrant1    0x00000001
#define MxANGLECONTROL_Quadrant2    0x00000002
#define MxANGLECONTROL_Quadrant3    0x00000004
#define MxANGLECONTROL_Quadrant4    0x00000008
#define MxANGLECONTROL_FullCircle   0x0000000F  
#define MxANGLECONTROL_ZeroAtTop    0x00000010

Widget MxAngleControlCreate (
   Widget parent,
   double *pValue,      
   int radius,          
   UINT32 flags,        
   Arg *callerargs,
   int numargs
   );


ERRVALUE MxAngleControlSetPrompt (
   Widget control,
   Widget prompt
   );

Widget MxAppShellCreate (
   const char *posnkey,                
   Arg* arg,                           
   int numargs                         
   );

void MxAssignCursor (
   Display* display,
   Window window,
   int cursor
   );

void MxClearWidget (
   Widget widget,
   bool sendexposure = true
   );

double MxConvertScreenUnits (
   double val,                            
   int InUnits,                           
   int OutUnits                           
   );

MIUNICODE* MxConvertXmStringToUC (
   XmString xmstr                         
   );

Widget MxCreateButtonColumn (
   Widget,                             
   BUTTONITEM*,                        
   void*,                              
   void*,                              
   int,                                
   Arg*,                               
   int                                 
   );

Widget MxCreateButtonFieldXe (
   Widget form,                        
   const char* name,                   
   Widget* xetext,                     
   Widget* button,                     
   XtCallbackProc cbfunc,              
   void* cbdata,                       
   Arg* arglist,                       
   int argcount                        
   );

Widget MxCreateButtonRow (
   Widget pwidget,                     
   const BUTTONITEM *buttonitem,       
   void *cbdata,                       
   void *userdata,                     
   int flags,                          
   const Arg*,                         
   int argcount                        
   );

Widget MxCreateFormDialog (
   Widget pwidget,                     
   const char* titlestr,               
   const char* helpstr,                
   XtCallbackProc cbpopdn,             
   void *cbdata,                       
   Arg *arglist,                       
   int argcount                        
   );


}  // end of Extern C

Widget MxCreateFormDialog (
   Widget pwidget,                     
   const char* titlestr,               
   Arg *arglist,                       
   int argcount                        
   );

extern "C" {

Widget MxCreateFrame (
   Widget pwidget,                     
   const XTARGS& arg,                  
   const char *label = 0               
   );

Widget MxCreateIconButtonRow (
   Widget pwidget,                     
   const MIUNICODE *iconfile,          
   const char *icongroup,              
   const BUTTONITEM *buttonitem,       
   void *cbdata,                       
   void *userdata,                     
   int flags,                          
   const Arg *arglist,                 
   int argcount                        
   );

Widget MxCreateIconLabel (
   Widget pwidget,                     
   int iconhandle,                     
   const char *IconClass,              
   const char *IconName,               
   const char *LabelName,              
   const Arg *arglist,                 
   int argcount                        
   );

}  // end of extern "C"

Widget MxCreateIconLabel (
   Widget pwidget,                     
   ICONID iconid,                      
   const MISTRING& tooltip,            
   const Arg *arglist,                 
   int argcount                        
   );

extern "C" {
Widget MxCreateIconLabelExt (
   Widget pwidget,                     
   int iconhandle,                     
   const char *IconClass,              
   const char *IconName,               
   const char *StippleName,            
   const char *LabelName,              
   const Arg *arglist,                 
   int argcount,                       
   UINT32 flags                        
   );

Widget MxCreateIconPopupMenuButton (
   Widget pwidget,                     
   int iconhandle,                     
   const char *IconClass,              
   const char *IconName,               
   const char *LabelName,              
   const MENUITEM *items,              
   Widget *widget_list,                
   void *data,                         
   void *udata,                        
   const Arg *arglist,                 
   int argcount                        
   );

#ifndef NO_DEPRECATED
DEPRECATED_MSG("There's another version that doesn't have a numeric style object id for the 2nd parameter") Widget MxCreateIconPushButton (
   Widget pwidget,                     
   int iconhandle,                     
   const char *IconClass,              
   const char *IconName,               
   const char *LabelName,              
   XtCallbackProc,                     
   void *cbdata,                       
   const Arg *arglist,                 
   int argcount                        
   );
#endif

}
Widget MxCreateIconPushButton (
   Widget pwidget,                     
   ICONID iconid,                      
   const MISTRING& tooltip,            
   XtCallbackProc cbfunc,              
   void *cbdata,                       
   const Arg *arglist,                 
   int argcount                        
   );

Widget MxCreateIconPushButton (
   Widget pwidget,                     
   const char *IconGroup,              
   const char *IconName,               
   const char *LabelName,              
   XtCallbackProc,                     
   void *cbdata,                       
   const Arg *arglist,                 
   int argcount,                       
   UINT32 flags = 0,                   
   RVC::STYLE* StyleObj = 0            
   );

extern "C" {

Widget MxCreateIconPushButtonExt (
   Widget pwidget,                     
   int iconhandle,                     
   const char *IconClass,              
   const char *IconName,               
   const char *LabelName,              
   XtCallbackProc,                     
   void *cbdata,                       
   const Arg *arglist,                 
   int argcount,                       
   UINT32 flags                        
   );

Widget MxCreateIconToggleButton (
   Widget pwidget,                     
   int iconhandle,                     
   const char *IconClass,              
   const char *IconName,               
   const char *LabelName,              
   void(*)(Widget, void*, XmToggleButtonCallbackStruct*),   
   void *cbdata,                       
   const Arg *arglist,                 
   int argcount                        
   );

Widget MxCreateIconToggleButtonExt (
   Widget pwidget,                     
   int iconhandle,                     
   const char *IconClass,              
   const char *UnselIconName,          
   const char *SelectedIconName,       
   const char *LabelName,              
   void(*)(Widget, void*, XmToggleButtonCallbackStruct*),   
   void *cbdata,                       
   const Arg *arglist,                 
   int argcount,                       
   UINT32 flags                        
   );

int MxCreateImageFromWidget (
   Widget widget,                      
   XImage** ximage,                    
   void** buffer,                      
   int width,                          
   int height                          
   );

Widget MxCreateLabelFieldXe (
   Widget form,
   const char* name,
   Widget* xetext,
   Widget* label,
   Arg* arglist,
   int argcount
   );

Widget MxCreateLatLonFormatOptionMenu (
   Widget pwidget,                     
   char *label,                        
   UINT32 dftfmt,                      
   void(*)(Widget, void *, void *),    
   void *userdata,                     
   Arg *arglist,                       
   int argcount                        
   );

Widget MxCreatePopupMenu (
   Widget parent,                      
   const char *title,                  
   const MENUITEM *items,              
   Widget *widget_list,                
   void *data,                         
   void *udata                      
   );

Widget MxCreatePulldownMenu (
   Widget parent,                      
   const MIUNICODE *label,             
   const MENUITEM *items,              
   void *cbdata,                       
   void *udata                         
   );

Widget MxCreateLabel (
   Widget parent,                      
   const char *name,                   
   Arg *arglist,                       
   int argcount                        
   );

}  

Widget MxCreateLabel (
   Widget parent,                      
   const MISTRING& label,              
   Arg *arglist,                       
   int argcount                        
   );

extern "C" {

Widget MxCreateManualPopupMenu (
   Widget parent,                      
   const char *title,                  
   const MENUITEM *items,              
   Widget *widget_list,
   void *data,
   void *udata
   );

Widget MxCreateMenuBar (
   Widget pwidget,                     
   const MENUBARITEM *menus,           
   void *clientdata,                   
   void *userdata                      
   );

Widget MxCreateOptionMenu (
   Widget pwidget,                     
   const char *title,                  
   const MENUITEM *items,              
   void *userdata                      
   );

Widget MxCreateOptionMenuExt (
   Widget pwidget,                     
   const char *title,                  
   const MENUITEM *items,              
   void *userdata,                     
   const Arg *arglist,                 
   int argcount                        
   );

Widget MxCreatePushButton (
   Widget pwidget,                     
   const char *name,                   
   XtCallbackProc,                     
   void *cbdata,                       
   Arg *arglist,                       
   int argcount                        
   );

Widget MxCreateTextEncodingLB (
   Widget pwidget,                     
   const char *label,                  
   CHAR_ENCODING& encoding,            
   ENCODELIST_FLAGS enclistflags,      
   Arg *arglist,                       
   int argcount                        
   );

Widget MxCreateToggleButton (
   Widget pwidget,                     
   const char *name,                   
   void(*)(Widget, void*, XmToggleButtonCallbackStruct*),   
   void *cbdata,                       
   Arg *arglist,                       
   int argcount                        
   );

XmString MxCreateXmStringUC (
   const MIUNICODE* const string,         
   MGD::INTERFACETEXTSTYLE style = MGD::INTERFACETEXTSTYLE_Normal
   );

void MxDestroyPopupMenu (
   Widget parent,                      
   Widget popup                        
   );

void MxDestroyTopLevel (
   );

void MxDisplayHelp (
   Widget parent,                      
   const char* helpid                        
   );

void MxDisplayHelpByID (
   Widget parent,                      
   HELPID helpid
   );

int MxEditBitmapCursor (
   Widget pwidget,
   FILEPATH *filename,
   int flags
   );

int MxEditBitmapPattern (
   Widget pwidget,                     
   const RVC::OBJITEM& StyleObjItem,
   INT32 pattnum,                      
   const COLOR& varcolor,              
   UINT32 flags                        
   );

int MxEditColor (
   Widget parent,                      
   EDITCOLORINFO *EditColorInfo,       
   int  numcolors,                     
   UINT32 flags,                       
   Widget *notused                     
   );

int MxEditHatchPattern (
   Widget pwidget,                     
   const RVC::OBJITEM& StyleObjItem,   
   INT32 pattnum,                      
   COLOR *varcolor,                    
   UINT32 flags                        
   );

const BUTTONITEM *MxEditButtonsCreate (
   void **handle, 
   MxEDITMENUFLAGS flags = MxEDITMENUFLAG_None, 
   void(*undofunc)(Widget, void*) = 0, 
   void *undodata = 0
   );


DEPRECATED const MENUITEM *MxEditMenuCreate (
   void **handle, 
   MxEDITMENUFLAGS flags = MxEDITMENUFLAG_None, 
   void(*undofunc)(Widget, void*) = 0, 
   void *undodata = 0
   );

}

const MENUITEM *MxEditMenuCreate (
   Widget shell,
   void **handle, 
   MxEDITMENUFLAGS flags = MxEDITMENUFLAG_None, 
   void(*undofunc)(Widget, void*) = 0, 
   void *undodata = 0
   );

extern "C" {
void MxEditButtonsAddCallbacks (
   void* handle, 
   Widget textwidget
   );

void MxEditMenuAddCallbacks (
   void* handle, 
   Widget textwidget
   );

int MxEditSymbol (
   Widget pwidget,                     
   const RVC::OBJITEM& StyleObjItem,
   INT32 pattnum,                      
   COLOR *varcolor,                    
   UINT32 flags                        
   );

void MxEnableMouseWheel (
   Widget owner,
   Widget scrollbar,
   int increment = 3
   );

void MxListEnableMouseWheel (
   Widget owner,
   int increment = 3
   );

Widget MxFindNamedChildWidget (
   Widget parent,                      
   char *name                          
   );

void MxForceDialog (
   Widget w                            
   );

void MxForceWindowOnScreen (
   Widget,
   int
   );

void MxFixWindowSizeForAppleX11 (
   Widget mainform
   );

Pixel MxGetColorPixel (
   COLOR const& color                  
   );

Pixel MxGetColorPixelNoICM (
   COLOR const& color                  
   );

XmFontList MxGetDefaultFontList (
   );

const char* MxGetDefaultSystemXLFD ();

const char* MxGetDefaultUIFont ();

void MxGetDisplayInfo (
   Widget widget,                      
   DISPLAYINFO *displayinfo            
   );

void MxGetDrawingAreaSize (
   Widget dawidget,                    
   INT16& width,                       
   INT16& height                       
   );

int MxGetFontStructFromWidget (
   Widget widget,                      
   XFontStruct *fontstruct             
   );

int MxGetMaxFontAscent (
   bool bForClipping = false
   );

int MxGetMaxFontDescent (
   bool bForClipping = false
   );

int MxGetMaxFontHeight (
   bool bForClipping = false
   );

int MxGetMaxFontWidth();

int MxGetTypicalFontWidth ();

int MxGetTypicalFontWidth2 (
   MGD::INTERFACETEXTSTYLE style = MGD::INTERFACETEXTSTYLE_Normal
   );

void *MxGetNamedUserData (
   Widget widget,                      
   const char *name                    
   );

void MxGetScrollAreaSize (
   Widget,                             
   int *width,                         
   int *height                         
   );

Widget MxGetShell (
   Widget widget                       
   );

Pixel MxGetStdColorPixel (
   int index                           
   );

void MxGetStdColorPixels (
   Pixel *stdpixel                     
   );

void MxGetStdColors (
   COLOR stdcolor[NUMSTDCOLORS]        
   );

int MxGetSystemPreferences (
   Widget pwidget                      
   );

Widget MxGetTopLevel (
   Widget widget                       
   );

Widget MxGetTopShell (
   Widget widget                       
   );

}  // Extern "C"

inline void *MxGetUserDataPtr (
   Widget widget                       
   ) {
   void *ptr;
   Arg arg;
   XtSetArg(arg,XmNuserData,&ptr);
   XtGetValues(widget,&arg,1);
   return (ptr);
   }


extern "C" {

MIUNICODE *MxGetWidgetLabelString (
   Widget widget                       
   );

void MxGetWidgetSize (
   Widget widget,
   Dimension& width,
   Dimension& height
   );

int MxGetWindowBorders (
   Widget widget,                      
   int *left,                          
   int *right,                         
   int *top,                           
   int *bottom                         
   );

void MxGetWindowPosition (
   Widget w,                           
   int *px,                            
   int *py                             
   );

void MxIconAddDestroyCallback (
   Widget widget,                      
   MICONSTRUCT *                       
   );

void MxIconDrawDimmed (
   Display *display,                   
   Drawable drawable,                  
   GC gc,                              
   int x,                              
   int y,                              
   MICONSTRUCT *icon                   
   );

void MxIconDrawNormal (
   Display *display,                   
   Drawable drawable,                  
   GC gc,                              
   int x,                              
   int y,                              
   MICONSTRUCT *icon                   
   );

Pixmap MxIconGetPixmapDimmed (
   const MICONSTRUCT *icon                   
   );

Pixmap MxIconGetPixmapNormal (
   const MICONSTRUCT *icon                   
   );

int MxIsExitingProcess (
   );

int MxIsTimeOutInMainLoop (
   );

DEPRECATED Widget MxListButtonCreate (
   Widget pw,                          
   const char *label,                  
   int NumItems,                       
   int maxlen,                         
   MIUNICODE*(*GetItemFunc)(int,void*),   
   void(*NotifyFunc)(int,void*),       
   void *FuncData,                     
   Arg *arglist,                       
   int argcount                        
   );

DEPRECATED void MxListButtonSetHelpID (
   Widget listbutton,                  
   const char* helpid                  
   );

DEPRECATED void MxListButtonSetItem (
   Widget listbutton,                  
   int itemnum,                        
   int notify                          
   );

DEPRECATED void MxListButtonSetNumItems (
   Widget listbutton,                  
   int NumItems                        
   );

DEPRECATED void MxListButtonSetTitle (
   Widget listbutton,                  
   const char* title                   
   );

void MxListDisableKeySelect (
   Widget list                         
   );

void MxListEnableKeySelect (
   Widget list,                        
   int start                           
   );

void MxLockWindowSize (
   Widget widget,                      
   UINT32 flags = MxLOCKSIZE_MinMax    
   );

void MxLockWindowSizeAbs (
   Widget widget,                      
   int height,                         
   int width,                          
   UINT32 flags                        
   );

void MxLockWindowSizeRel (
   Widget widget,                      
   int dheight,                        
   int dwidth,                         
   UINT32 flags                        
   );

void MxMainLoopUntilExitSet (
   );

void MxMainLoopUntilConditionMet (
   DELEGATE_BOOL_NOPARMS Delegate
   );

void MxMainLoopWhilePending (
   );

DEPRECATED void MxMakeObjectList (
   Widget list,                        
   const RVC::OBJITEMLIST& items       
   );

void MxMakeListPosCentered (
   Widget listw,                       
   int listitem                        
   );

void MxMakeListPosVisible (
   Widget listw,                       
   int listitem                        
   );

int MxMenuFileLoad (
   Widget pwidget,                     
   const FILEPATH& filepath,           
   XtCallbackProc CB_Internal,         
   XtCallbackProc CB_Executable = 0,      
   FastDelegate<void(Widget, const char*, int)> DelegateAddSpecial = 0
   );

Widget MxMenuFileCreateIconPulldown (
   Widget pwidget,                     
   const FILEPATH& filepath,
   XtCallbackProc CB_Internal,         
   int IconHandle,
   const char *IconGroup,
   const char *IconName,
   const char *LabelName,
   const Arg *arglist,                 
   int argcount                        
   );

int MxMenuGetNumItems (
   const MENUITEM *items
   );

void MxMenuInitSelectedByCallbackData (
   MENUITEM *menuitem,                 
   void *cbdata                        
   );

void MxMenuInitSelectedByUserData (
   MENUITEM *menuitem,                 
   void *userdata                      
   );

Widget MxMenuItemWidget (
   Widget menubar,                     
   const char *path                    
   );

void MxMsgLineClear (
   Widget msgline                      
   );

Widget MxMsgLineCreate (
   Widget pwidget,                     
   Arg *arglist,                       
   int argcount                        
   );

void MxMsgLineSetError (
   Widget msgline,                     
   ERRVALUE errcode                    
   );

void MxMsgLineSetText (
   Widget msgline,                     
   const MISTRING& string              
   );

void MxMsgLineSetTimer (
   Widget msgline,                        
   const MTIMER& timer,                   
   TEXTID textid = TEXTID__None           
   );

void MxOptionMenuAppendItems (
   Widget omwidget,                    
   const MENUITEM *items,              
   void *udata                         
   );

Widget MxOptionMenuGetButton (
   Widget omwidget
   );

Widget MxOptionMenuGetLabel (
   Widget omwidget
   );

void MxOptionMenuRemoveLast (
   Widget omwidget                     
   );

void MxOptionMenuReplaceItems (
   Widget omwidget,                    
   const MENUITEM *newitems,           
   void *userdata                      
   );

Boolean MxOptionMenuSetItem (
   Widget omwidget,              
   int itemnum                         
   );

Boolean MxOptionMenuSetItemByData (
   Widget widget,
   const MENUITEM *menuitem,
   void *callback_data
   );

Boolean MxOptionMenuSetItemSensitive (
   Widget omwidget,                    
   int itemnum,                        
   Boolean flag                        
   );

void MxOptionMenuSetSensitive (
   Widget omwidget,
   int sensitive
   );

int MxPixmapFromFillPattern (
   Widget pwidget,                     
   Pixel bgpixel,
   const RVC::STYLEPATTERN_BITMAP& Pattern,
   Pixmap *pixmap,                        
   bool bToGrayScale = false              
   );

Widget MxPolyfitCreateForm (
   Widget parent,                      
   void(*action)(void*),
   void *userdata,
   Arg *arglist,                       
   int argcount                        
   );

int MxPolyfitGetParm (
   Widget wPolyfit,                    
   void *vpf                           
   );

int MxPolyfitSetParm (
   Widget wPolyfit,                    
   void *vpf                           
   );

int MxPolyfitIniRead (
   void *vpf                           
   );

int MxPolyfitIniWrite(
   void *vpf                           
   );

void MxPopupMenuReplaceItems (
   Widget menupane,                    
   const MENUITEM *items,              
   void *udata
   );

int MxPopupModalDialog (
   Widget dlgparent,                   
   const char* dlgname,                
   const char* helpid,                 
   Widget (*CreateWidgetFunc)(Widget,void*,Arg*,int), 
   void* CreateWidgetData,             
   const BUTTONITEM *extrabuttons = 0, 
   bool (*CheckOkFunc)(void*) = 0      
   );

void MxPopupTransientMenu (
   Widget parent,                      
   XButtonPressedEvent *event,         
   const char *title,                  
   const MENUITEM *items,              
   void *cbdata = 0,                   
   void *udata = 0,                    
   bool waitforpopdown = false         
   );

void MxPositionWindowRel (
   Widget child,                       
   Widget base,                        
   MxRELPOSN relposn                   
   );


int MxPromptAddCallback (
   Widget prompt,                      
   void(*cbfunc)(MxPromptCallbackStruct*,void*),   
   void *cbdata,                       
   UINT32 reasonmask                   
   );

void MxPromptClearValue (
   Widget prompt                       
   );

int MxPromptColorAddCallback (
   Widget prompt,                      
   void(*cbfunc)(MxPromptCallbackStruct*,void*),   
   void *cbdata,                       
   UINT32 reasonmask                   
   );

Widget MxPromptColorCreate (
   Widget pwidget,                     
   const char *name,                   
   COLOR *color,                       
   UINT32 flags,                       
   Arg *arglist,                       
   int argcount                        
   );

Widget MxPromptColorGetLabel (
   Widget prompt                       
   );

void MxPromptColorUpdate (
   Widget prompt                       
   );

Widget MxPromptCreateChar (
   Widget parent,                      
   const char *name,                   
   char *str,                          
   const char *help,                   
   UINT32 flags,                       
   Arg *args,                          
   int numargs                         
   );

Widget MxPromptCreateDouble (
   Widget parent,                      
   const char *name,                   
   double *ret,                        
   double dft,                         
   double min,                         
   double max,                         
   int places,                         
   const char *help,                   
   UINT32 flags,                       
   Arg *args,                          
   int n                               
   );

Widget MxPromptCreateFloat (
   Widget parent,                      
   const char *name,                   
   float *ret,                         
   float dft,                          
   float min,                          
   float max,                          
   int places,                         
   const char *help,                   
   UINT32 flags,                       
   Arg *args,                          
   int n                               
   );

Widget MxPromptCreateINT8 (
   Widget parent,                      
   const char *name,                   
   INT8 *ret,                          
   INT8 dft,                           
   INT8 min,                           
   INT8 max,                           
   const char *help,                   
   UINT32 flags,                       
   Arg *args,                          
   int n                               
   );

Widget MxPromptCreateINT16 (
   Widget parent,                      
   const char *name,                   
   INT16 *ret,                         
   INT16 dft,                          
   INT16 min,                          
   INT16 max,                          
   const char *help,                   
   UINT32 flags,                       
   Arg *args,                          
   int numargs                         
   );

Widget MxPromptCreateINT32 (
   Widget parent,                      
   const char *name,                   
   INT32 *ret,                         
   INT32 dft,                          
   INT32 min,                          
   INT32 max,                          
   const char *help,                   
   UINT32 flags,                       
   Arg *args,                          
   int n                               
   );

Widget MxPromptCreateLatLon (
   Widget parent,                      
   const char *name,                   
   double *ret,                        
   double dft,                         
   double min,                         
   double max,                         
   int places,                         
   const char *help,                   
   UINT32 flags,                       
   Arg *args,                          
   int n                               
   );

Widget MxPromptCreateNum (
   Widget parent,                      
   const char *name,                   
   int type,                           
   void *ret,                          
   double dft,                         
   double min,                         
   double max,                         
   int places,                         
   const char *help,                   
   char **comboitems,                  
   UINT32 flags,                       
   Arg *args,                          
   int n                               
   );

Widget MxPromptCreateString (
   Widget parent,                      
   const char *name,                   
   char *str,                          
   int maxlen,                         
   const char *help,                   
   UINT32 flags,                       
   Arg *args,                          
   int numargs                         
   );

Widget MxPromptCreateUINT8 (
   Widget parent,                      
   const char *name,                   
   UINT8 *ret,                         
   UINT8 dft,                          
   UINT8 min,                          
   UINT8 max,                          
   const char *help,                   
   UINT32 flags,                       
   Arg *args,                          
   int n                               
   );

Widget MxPromptCreateUINT16 (
   Widget parent,                      
   const char *name,                   
   UINT16 *ret,                        
   UINT16 dft,                         
   UINT16 min,                         
   UINT16 max,                         
   const char *help,                   
   UINT32 flags,                       
   Arg *args,                          
   int n                               
   );

Widget MxPromptCreateUINT32 (
   Widget parent,                      
   const char *name,                   
   UINT32 *ret,                        
   UINT32 dft,                         
   UINT32 min,                         
   UINT32 max,                         
   const char *help,                   
   UINT32 flags,                       
   Arg *args,                          
   int n                               
   );

MDLGPARENT MxPromptCreateUnicode (
   MDLGPARENT parent,                        
   const char *name,                   
   MIUNICODE *str,                        
   int maxlen,                         
   const char *help,
   UINT32 flags, 
   Arg *args,
   int numargs
   );

void MxPromptDisableTraversal (
   Widget prompt                       
   );

int MxPromptSetValueDouble (
   Widget prompt,                      
   double val                          
   );

int MxPromptDoubleToLatLon (
   Widget prompt                       
   );

int MxPromptSetValueFloat (
   Widget prompt,                      
   float val                           
   );

Widget MxPromptGetLabel (
   Widget prompt                       
   );

void MxPromptGetMinMax (
   Widget widget,                      
   double *min,                        
   double *max                         
   );

Widget MxPromptGetScale (
   Widget prompt                       
   );

int MxPromptGetStdHeight (
   void
   );

Widget MxPromptGetUnitLabel (
   Widget widget                       
   );

void * MxPromptGetUserData (
   Widget prompt                       
   );

int MxPromptGetValueDouble (
   Widget widget,                      
   double *pval                        
   );

int MxPromptGetValueUnicode (
   Widget widget,                      
   MIUNICODE **pval                       
   );

Widget MxPromptGetXeText (
   Widget widget
   );

int MxPromptHasValue (
   Widget prompt                       
   );

MENUITEM * MxPromptLatLonGetFormatMenu (
   XtCallbackProc cbfunc,              
   int isoption                        
   );

void MxPromptLatLonSetFormat (
   Widget widget,                      
   DEGTOSTRFLAGS flags                 
   );

int MxPromptLatLonSetValue (
   Widget prompt,                      
   double val                          
   );

int MxPromptLatLonToDouble (
   Widget prompt                       
   );

int MxPromptSetValueINT32 (
   Widget prompt,                      
   INT32 val                           
   );

int MxPromptRemoveCallback (
   Widget prompt,                      
   void(*cbfunc)(MxPromptCallbackStruct*,void*),   
   void *cbdata,                       
   UINT32 reasonmask                   
   );

void MxPromptSetDecPlaces (
   Widget prompt,                      
   int places                          
   );

void MxPromptSetEditable (
   Widget prompt,                      
   int editable                        
   );

int MxPromptSetEncoding (
   Widget prompt,                      
   char *encoding,                     
   UINT32 flags                        
   );

void MxPromptSetEnterCallback (
   Widget widget,                      
   void(*func)(Widget, void*),         
   void *cbdata                        
   );

void MxPromptSetFormat (
   Widget prompt,                      
   char *format                        
   );

void MxPromptSetLogScaleRange (
   Widget prompt,                      
   double min,                         
   double max                          
   );

void MxPromptSetModifyCallback (
   Widget prompt,                      
   void(*func)(Widget, void*),         
   void *funcdata                      
   );

void MxPromptSetRange (
   Widget prompt,                      
   double min,                         
   double max,                         
   UINT32 flags                        
   );

void MxPromptSetTraversal (
   Widget prompt,                      
   Widget traverseto,                  
   XmTraversalDirection traversedir    
   );

void MxPromptSetUnitConv (
   Widget prompt,                      
   const UNITCONV *unitconv                  
   );

void MxPromptSetUnitConvCode (
   Widget prompt,                      
   int unittype,                       
   int storedcode,                     
   int showncode                       
   );

void MxPromptSetUnitConvExt (
   Widget widget,                      
   const UNITCONV *unitconv,           
   UINT32 flags                        
   );

void  MxPromptSetUserData (
   Widget prompt,                      
   void *data                          
   );

void MxPromptSetValue (
   Widget widget,                      
   double wal,                         
   int hasvalue                        
   );

void MxPromptSetValuePtr (
   Widget prompt,                      
   void *newptr,                       
   int hasvalue                        
   );

int MxPromptSetValueINT16 (
   Widget prompt,                      
   short val                           
   );

int MxPromptSetValueString (
   Widget prompt,                      
   const char *val                     
   );

int MxPromptSetValueUnicode (
   Widget prompt,                      
   const MIUNICODE *val                
   );

void MxPromptUpdateValue (
   Widget prompt                       
   );

int MxPromptUpdateData (
   Widget prompt,                      
   Boolean notify                      
   );

void MxPulldownMenuReplaceItems (
   Widget parent,                      
   const MENUITEM *items,              
   void *userdata                      
   );

void MxRedrawWidget (
   Widget widget                    
   );

int MxRgnGenSetupRasterTraceAreaV (
   Widget pwidget,
   const RVC::OBJITEM& VectObjItem,
   RGNELEMLIST *ElemList,
   int NumElemTypes,
   void(*DispRegionFunc)(const REGION2D*,void*),   
   void *DispRegionData             
   );

int MxRgnGenSetupRasterTraceBoundaryV (
   Widget pwidget,
   const RVC::OBJITEM& VectObjItem,
   RGNELEMLIST *ElemList,
   int NumElemTypes,
   void(*DispRegionFunc)(const REGION2D*,void*),   
   void *DispRegionData             
   );

Widget MxSashCreate (
   Widget pwidget,                     
   Arg *arglist,                       
   int argcount                        
   );

int MxSaveSnapshotToRaster (
   Widget pwidget,                     
   const DISPLAYINFO& dispinfo,        
   Drawable drawable                   
   );

void MxScrollBarGetValues (
   Widget w,                           
   int *value,                         
   int *sliderSize,                    
   int *increment,                     
   int *pageIncrement,                 
   int *minimum,                       
   int *maximum                        
   );

int MxSelectIcon (
   Widget pwidget,                     
   char *dialogname,                   
   char IconClass[16],                 
   char IconName[16],                  
   int minsize,                        
   int maxsize,                        
   UINT32 flags                        
   );

int MxSelectRegion (
   Widget parent,                      
   const RVC::OBJITEM& ObjItem,
   RVC::OBJTYPE ObjType,
   REGION2D& region
   );

void MxSetExitProcess ();

void MxSetNoExitProcess ();

void MxSetFocusToWidget (
   Widget widget
   );

inline void MxSetHelpCallback (
   Widget widget,
   const char *helpstr                 
   ) { XtAddCallback(widget,XmNhelpCallback,MxcbDisplayHelp,const_cast<char*>(helpstr)); }

void MxSetMenuItemCallbackData (
   MENUITEM *mi,                       
   void *cbdata                        
   );

void MxSetMenuItemUserData (
   MENUITEM *mi,                       
   void *udata                         
   );

void MxSetNamedUserData (
   Widget w,                           
   const char *name,                   
   void *data                          
   );

void MxSetSensitive (
   Widget w,                           
   int sensitive                       
   );

void MxSetTextEditable (
   Widget widget,                      
   int editable                        
   );

// Set ToolTip from RVC::OBJITEM.
void MxSetToolTipFromObjItem (
   Widget widget,
   const RVC::OBJITEM& ObjItem
   );

int MxSetupPolygonFitParms (
   Widget parent,                      
   const RVC::OBJITEM& SrcGeomObjItem,
   RGNELEMLIST *ElemList,
   int NumElemTypes,                   
   void (*dispreg)(const REGION2D*, void*),
   void *userdata
   );

int MxSetupClusterParms (
   Widget parent,                      
   const RVC::OBJITEM& SrcGeomObjItem,
   RGNELEMLIST *ElemList,
   int NumElemTypes,                   
   void (*dispreg)(const REGION2D*, void*),
   void *userdata
   );

int MxSetupBufferZoneParms (
   void *form,
   const RVC::OBJITEM& SrcObjItem,
   RGNELEMLIST *ElemList,
   int NumElemTypes,                   
   void (*dispreg)(const REGION2D*, void*),
   void *userdata
   );

int MxSetupRegionFromRangesParms (
   Widget parent,                      
   const RVC::OBJITEM& ObjItem,
   void (*dispreg)(const REGION2D*, void*),
   void *userdata
   );

int MxSetupRegionFromRastExpressParms (
   Widget parent,                      
   const RVC::OBJITEM& ObjItemRaster,
   void (*dispreg)(const REGION2D*, void*),
   void *userdata
   );

int MxSetupViewshedParms (
   MDLGPARENT parent,
   const RVC::OBJITEM& VectObjItem,
   UINT8 *setdata,
   INT32 NumEntries,
   void (*dispreg)(const REGION2D*, void*),
   void *userdata
   );

int MxSetupBasinParms (
   void *form,
   const RVC::OBJITEM& SrcVectObjItem,
   RGNELEMLIST *ElemList,
   int NumElemTypes,                   
   void (*dispreg)(const REGION2D*, void*),
   void *userdata
   );

int MxSetupTextureGrowthParms (
   MDLGPARENT parent,
   const RVC::OBJITEM& VectObjItem,
   RGNELEMLIST *ElemList,
   int NumElemTypes,                   
   void (*dispreg)(const REGION2D*, void*),
   void *userdata
   );

int MxSetupFloodParms (
   void *vparent,
   const RVC::OBJITEM& ObjItemVector,
   INT32 ActiveType,
   INT32 ActiveLine,
   void (*dispreg)(const REGION2D*, void*),
   void *userdata
   );

int MxSetupRasterCellsParms (
   MDLGPARENT parent,
   const RVC::OBJITEM& VectObjItem,
   RGNELEMLIST *ElemList,
   int NumElemTypes,
   void (*dispreg)(const REGION2D*, void*),
   void *userdata
   );

void MxSetWidgetColor (
   Widget widget,                      
   COLOR const& color                  
   );

void MxSetWindowFullScreen (
   Widget widget                       
   );

int MxSetWindowPosition (
   Widget widget,                      
   const char *group,                  
   const char *field                   
   );

int MxSetWindowPositionXY (
   Widget widget,                      
   const char *group,                  
   const char *field,                  
   int x,
   int y
   );

int MxSetWindowSize (
   Widget widget,                      
   const char *group,                  
   const char *field,                  
   int dftwidth,                       
   int dftheight                       
   );

void MxSetXmLabelString (
   Widget text,                        
   const MIUNICODE* const string       
   );

void MxShowWidget (
   Widget w,                           
   bool show = true                    
   );

void MxStringDraw (
   Display *display,                   
   Window window,                      
   GC gc,                              
   INT32 x,                            
   INT32 y,                            
   const MIUNICODE* ucstr,             
   TEXTBASEORIGIN origin,
   MGD::INTERFACETEXTSTYLE style = MGD::INTERFACETEXTSTYLE_Normal
   );

#ifdef USE_XFT
bool MxStringIsUsingAntiAlias ();

void MxStringDrawXft (
   Display *display,                                                       
   Window window,                                                          
   GC gc,                                                                          
   INT32 x,                                                                                
   INT32 y,                                                                                
   const MIUNICODE* ucstr,                                 
   TEXTBASEORIGIN origin,
   COLOR color,
   const LRECT2D& ClipRectangle,
   MGD::INTERFACETEXTSTYLE style = MGD::INTERFACETEXTSTYLE_Normal
   );
#endif

void MxStringDrawVisual (
   Display *display,                   
   Window window,                      
   GC gc,                              
   INT32 x,                            
   INT32 y,                            
   const MIUNICODE* ucstr,             
   TEXTBASEORIGIN origin,
   MGD::INTERFACETEXTSTYLE style = MGD::INTERFACETEXTSTYLE_Normal
   );

#ifdef USE_XFT
void MxStringDrawVisualXft (
   Display *display,                                                       
   Window window,                                                          
   GC gc,                                                                          
   INT32 x,                                                                                
   INT32 y,                                                                                
   const MIUNICODE* ucstr,                                 
   TEXTBASEORIGIN origin,
   COLOR color,
   const LRECT2D& ClipRectangle,
   MGD::INTERFACETEXTSTYLE style = MGD::INTERFACETEXTSTYLE_Normal
   );
#endif

void MxStringExtents (
   const MIUNICODE* const ucstr,       
   UINT32 *TextWidth,                  
   UINT32 *TextHeight,                 
   UINT32 *TextAscent,                 
   bool bHeightForClipping,            
   MGD::INTERFACETEXTSTYLE style = MGD::INTERFACETEXTSTYLE_Normal
   );

void MxStringMetrics (
   const MIUNICODE* const ucstr,       
   TEXTMETRICS& metrics,
   MGD::INTERFACETEXTSTYLE style = MGD::INTERFACETEXTSTYLE_Normal
   );

int MxStringWidth (
   const MIUNICODE* const ucstr,       
   bool bInkMetrics = false,
   MGD::INTERFACETEXTSTYLE style = MGD::INTERFACETEXTSTYLE_Normal
   );

int MxStringWidthVisual (
   const MIUNICODE* const ucstr,       
   bool bInkMetrics = false,
   MGD::INTERFACETEXTSTYLE style = MGD::INTERFACETEXTSTYLE_Normal
   );

Widget MxTabPagesCreate (
   Widget pwidget,                     
   MxTABPAGEITEM *items,               
   void *userdata,                     
   Arg *arglist,                       
   int argcount                        
   );

int MxTabPagesSetActiveItem (
   Widget tbwidget,                    
   int itemnum                         
   );

int MxTabPagesGetActiveItem (
   Widget tbwidget                     
   );

int MxTabPagesSetSensitiveItem (
   Widget tbwidget,                    
   int itemnum,                        
   int                                 
   );

int MxTabPagesGetUserData (
   Widget tbwidget,                    
   void **userdata
   );

void MxTextClearXe (
   Widget xetext                       
   );

int MxTextEditBindXeText (
   void *vtehandle,                    
   Widget xetext                       
   );

int MxTextEditCheckSave (
   void *vtehandle                     
   );

int MxTextEditCreateHandle (
   void **vtehandle,                   
   UINT32 flags                        
   );

Widget MxTextEditCreateXeText (
   Widget pwidget,                     
   void *vtehandle,                    
   Arg *arglist,
   int argcount
   );

const MENUITEM * MxTextEditGetMenuEdit (
   void *vtehandle                     
   );

const MENUITEM * MxTextEditGetMenuFile (
   void *vtehandl,                     
   UINT32 flags                        
   );

int MxTextEditLoadFile (
   void *vtehandle,                    
   MIUNICODE *filename                    
   );

void MxTextEditSetCloseFunc (
   void *vtehandle,                    
   void (*CloseFunc)(void *),          
   void *CloseData                     
   );

void MxTextEditSetDftExtn (
   void *vtehandle,                    
   char *dftextn                       
   );

void MxTextEditSetEncoding (
   void *vtehandle,                    
   char *encoding                      
   );

void MxTextSetFilePathXe (
   Widget xetext,                      
   const FILEPATH& filepath            
   );

void MxTextSetObjItemXe (
   Widget xetext,                      
   const RVC::OBJITEM& objitem
   );

int MxThemeMapEdit (
   Widget pwidget,                     
   const RVC::OBJITEM& GeoObjItem,
   ELEMTYPE elemtype,                  
   INT16& StyAsTableNum,               
   const UINT32 styletype = 0xFFFF     
   );

void MxTimeOutInMainLoopSet (
   int val
   );

MIUNICODE *MxTitleGetString (
   Widget widget                       
   );

void MxTitleSetString (
   Widget widget,                      
   const MISTRING& string              
   );

}  

void MxTitleSetString (
   Widget widget,                      
   const MISTRING& string,             
   bool ShowProcessID                  
   );
extern "C" {

int MxTTFSymbolSelect (
   Widget widget,                      
   MISTRING& fontname,                 
   UINT16 *GlyphIndex,                 
   MIUNICODE *UnicodeNum                  
   );

Widget MxTopLevel (
   void
   );

void MxUngrabKeyboard (
   Display *display                    
   );

void MxUngrabPointer (
   Display *display                    
   );

void MxWaitForUnmap (
   Widget widget
   );

void MxWaitForUnmapWithIdleDelegate (
   Widget widget,
   DELEGATE_BOOL_UINT32 DelegateOnIdle
   );

Widget MxblCreate (
   Widget pwidget,                     
   int maxsize,
   Arg *formargs,
   int formn
   );

void MxblRefresh (
   Widget dform,                       
   INT32 start
   );

void MxblResize (
   Widget dform,                       
   INT32 numitems,
   INT32 start
   );

void MxblSetEditMode (
   Widget dform,                       
   UINT32 mode                         
   );

void MxblSetEditPosn (
   Widget dform,                       
   INT32 editposn                      
   );

void MxblSetEntryCallback (
   Widget dform,                       
   void (*EntryCB)(INT32, char*, void*),  
   void *udata
   );

void MxblSetHighlightCallback (
   Widget dform,                       
   void (*HighlightCB)(INT32, void*),  
   void *udata
   );

Widget MxCreateHTMLWidget(
   Widget parent,                      
   char *name,
   Arg *arg,
   int n
   );

#define  WaitForUnmap(w) MxWaitForUnmap(w)

#ifndef GENERATING_DOXYGEN_OUTPUT

Widget _mxAppInitialize (
   int *argc,
   char *argv[],
   Arg *arglist,
   int argcount
   );

void _mxFixEncodingConverter ();

char * _mxReadDftFontList (
   void
   );

#endif 


}  

/*----------------------------------------------------------------------------*/
/*    Inline functions                                                        */
/*----------------------------------------------------------------------------*/

inline void MxToggleButtonSetState (
   Widget tb,                          
   Boolean state,                      
   Boolean notify=FALSE                
   ) { if (tb) XmToggleButtonSetState(tb,(state!=0),(notify!=0)); }

//------------------------------------------------------------------------------


#ifndef DEPRECATE_ALL

typedef void *TOOLTIPHANDLE;

#define  TOOLTIPFLAG_NoEventHandler    0x00000002  

DEPRECATED ERRVALUE MxToolTipAdd (
   Widget widget,                      
   const MIUNICODE *string,               
   TOOLTIPHANDLE *tthandle = 0,        
   UINT32 flags = 0                    
   );

DEPRECATED bool MxToolTipCheckMotion (
   TOOLTIPHANDLE handle,                  
   int x_root,                            
   int y_root,                            
   bool bAutoHide = true
   );

DEPRECATED bool MxToolTipCheckMotion (
   TOOLTIPHANDLE handle,                  
   const XEvent* ev,                      
   bool bAutoHide = true
   );

DEPRECATED ERRVALUE MxToolTipHide (
   TOOLTIPHANDLE handle,               
   UINT32 flags = 0
   );

DEPRECATED bool MxToolTipIsVisible (
   TOOLTIPHANDLE handle                
   );

DEPRECATED ERRVALUE MxToolTipShow (
   TOOLTIPHANDLE handle,               
   const MIUNICODE *text,                 
   UINT32 flags = 0
   );

#endif

//------------------------------------------------------------------------------

class XMSTR {
   public:

      XMSTR (
         ): m_xmstr(0) { }

      XMSTR (
         MISTRING const& str
         ): m_xmstr(MxCreateXmStringUC(str)) { }

      XMSTR (
         MIUNICODE const* str
         ): m_xmstr(MxCreateXmStringUC(str)) { }

      ~XMSTR (
         ) { Free(); }

      XMSTR& operator= (
         MISTRING const& str
         ) { Free(); m_xmstr = MxCreateXmStringUC(str); return (*this); }

      XMSTR& operator= (
         MIUNICODE const* str
         ) { Free(); m_xmstr = MxCreateXmStringUC(str); return (*this); }

      XmString GetXmString (
         ) const { return (m_xmstr); }

      void SetFromWidget (
         Widget widget
         ) { Free(); Arg arg; XtSetArg(arg,XmNlabelString,&m_xmstr); XtGetValues(widget,&arg,1); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      XmString m_xmstr;

      void Free (
         ) { if (m_xmstr != 0) XmStringFree(m_xmstr); }

      XMSTR (const XMSTR&);
      XMSTR& operator= (const XMSTR&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//------------------------------------------------------------------------------


#endif      // #ifndef INC_MI32_XDEFNS_H

---