mi32/mxtools.h

Go to the documentation of this file.

#ifndef  INC_MI32_MXTOOLS_H
#define  INC_MI32_MXTOOLS_H

#ifndef  INC_MI32_XDEFNS_H
   #include <mi32/xdefns.h>
#endif

#ifndef  INC_MI32_UNITCONV_H
   #include <mi32/unitconv.h>
#endif

#ifndef  INC_MI32_TRANS2DC_H
   #include <mi32/trans2dc.h>
#endif

#ifndef  INC_MI32_REGION2D_H
   #include <mi32/region2d.h>
#endif

#ifndef  INC_MI32_ELEMSTYL_H
   #include <mi32/elemstyl.h>
#endif

#ifndef  INC_MI32_MCB_H
   #include <mi32/mcb.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
namespace SPATREF {
   class COORDREFSYS;
   }
class TRANS2D_AFFINE;
#endif // GENERATING_DOXYGEN_OUTPUT

typedef void *MXTHANDLE;

/*
* Alter tool position flags
* for MxtMove(), MxtResize(), MxtShear(), MxtRotate().
*/

#define  MxtADJUST_Relative      0x0000
#define  MxtADJUST_Absolute      0x0001
#define  MxtADJUST_ToolCoords    0x0000
#define  MxtADJUST_ScreenCoords  0x0002
#define  MxtADJUST_Notify        0x8000


/********   Change reason flags  **********/

#define MxtCR_ReasonMask   0xFF000000
#define MxtCR_IsBegin      0x10000000
#define MxtCR_IsContinue   0x20000000
#define MxtCR_IsEnd        0x40000000
#define MxtCR_IsOther      0x80000000
#define MxtCR_IsActivate   0x01000000
#define MxtCR_IsDestroy    0x02000000

#define MxtCR_NoReason           (0|MxtCR_IsOther)    /* "No reason, I just like doing things like that." */
#define MxtCR_Activate           (1|MxtCR_IsOther|MxtCR_IsActivate)
#define MxtCR_SetValues          (2|MxtCR_IsOther)
#define MxtCR_NewLimits          (3|MxtCR_IsOther)
#define MxtCR_SelectPosition     (4|MxtCR_IsOther)
#define MxtCR_Manage             (5|MxtCR_IsOther)
#define MxtCR_Unmanage           (6|MxtCR_IsOther)
#define MxtCR_ClearPosition      (7|MxtCR_IsOther)
#define MxtCR_Cancel             (8|MxtCR_IsOther)    /* User pressed 'Cancel' button */
#define MxtCR_Destroy            (10|MxtCR_IsDestroy)
#define MxtCR_ChangeCurrentElem  (11|MxtCR_IsOther)

#define MxtCR_MoveBegin          (30|MxtCR_IsBegin)
#define MxtCR_MoveContinue       (30|MxtCR_IsContinue)
#define MxtCR_MoveEnd            (30|MxtCR_IsEnd)
#define MxtCR_ResizeBegin        (31|MxtCR_IsBegin)
#define MxtCR_ResizeContinue     (31|MxtCR_IsContinue)
#define MxtCR_ResizeEnd          (31|MxtCR_IsEnd)
#define MxtCR_RotateBegin        (32|MxtCR_IsBegin)
#define MxtCR_RotateContinue     (32|MxtCR_IsContinue)
#define MxtCR_RotateEnd          (32|MxtCR_IsEnd)
#define MxtCR_ShearBegin         (33|MxtCR_IsBegin)
#define MxtCR_ShearContinue      (33|MxtCR_IsContinue)
#define MxtCR_ShearEnd           (33|MxtCR_IsEnd)
#define MxtCR_EditBegin          (34|MxtCR_IsBegin)
#define MxtCR_EditContinue       (34|MxtCR_IsContinue)
#define MxtCR_EditEnd            (34|MxtCR_IsEnd)
#define MxtCR_CreateBegin        (35|MxtCR_IsBegin)
#define MxtCR_CreateContinue     (35|MxtCR_IsContinue)
#define MxtCR_CreateEnd          (35|MxtCR_IsEnd)
#define MxtCR_Trace              (36|MxtCR_IsOther)
#define MxtCR_WheelForward       (37|MxtCR_IsOther)
#define MxtCR_WheelBackward      (38|MxtCR_IsOther)

#define MxtCR_CreateTool         MxtCR_CreateBegin    

struct SNAPGRIDPARMS {
   DPOINT3D BasePt;                    
   double xsize;                       
   double ysize;                       
   double zsize;                       
   double rotate;                      
   MAT3X3 OtoS, StoO;                  
   };

struct MANUALTOOLPARMS {
   TRANS2D_MAPGEN *m_pTransViewToTool; 
   UNITCONV units;                     
   double xscaletou;                   
   double yscaletou;
   double zscaletou;
   unsigned scalevaluesset:1,          
            unitconvset:1,             
            mapparmset:1,              
            unused:29;
   MANUALTOOLPARMS ()
      : m_pTransViewToTool(0) {}
   };


struct MxtAnyCallbackStruct {
   UINT32 reason;                      
   MXTHANDLE mxt;                      
   XAnyEvent *event;                   
   void *toolinfo;                     
   unsigned IsGPS:1,
            IsXYDig:1,
            unused:30;
   };


/* Flags common to ALL tools, allocated MSB first */

#define  MxtFLAG_DialogManipMask 0xF8000200     
#define  MxtFLAG_EnableXYDig     0x10000000     
#define  MxtFLAG_EnableManual    0x20000000     
#define  MxtFLAG_EnableDialog    0x40000000     
#define  MxtFLAG_EnableSnapGrid  0x80000000     

#define  MxtFLAG_EnableGPS       0x08000000     
#define  MxtFLAG_NoManualProj    0x04000000     

#define  MxtFLAG_NoResize        0x00100000
#define  MxtFLAG_NoCreate        0x00200000
#define  MxtFLAG_CanMoveOff      0x00400000     
#define  MxtFLAG_NoRotate        0x00800000

#define  MxtFLAG_NotifyMotion    0x00010000     
#define  MxtFLAG_NoResetDialog   0x00020000     
#define  MxtFLAG_NoExposeResize  0x00040000     
#define  MxtFLAG_NoSaveB         0x00080000     

#define  MxtFLAG_HalfStepDeltas  0x00001000     
#define  MxtFLAG_ForceActivate   0x00002000     
#define  MxtFLAG_AllowCancelBtn  0x00004000     
#define  MxtFLAG_NoDialog        0x00008000     

#define  MxtFLAG_ForceManual     0x00000800     
#define  MxtFLAG_NoMove          0x00000400     
#define  MxtFLAG_NoElemHeight    0x00000200     

/* Flags for MxtSetBounds() */
#define  MxtBOUND_Xmin           0x01000000
#define  MxtBOUND_Ymin           0x02000000
#define  MxtBOUND_Xmax           0x04000000
#define  MxtBOUND_Ymax           0x08000000
#define  MxtBOUND_FullRect       0x0F000000


/*
* Marker types, used in various tools.  Defaults should be set in mxtE...() functions
*/

#define  MxtMARKER_X          0        
#define  MxtMARKER_Plus       1
#define  MxtMARKER_ArrowIn    2
#define  MxtMARKER_ArrowOut   3
#define  MxtMARKER_None       4
#define  MxtMARKER_Circle     5
#define  MxtMARKER_Flat       6
#define  MxtMARKER_Square     7


/*----------------------------------------------------------------------------*/
/*    Definitions for elastic line tool                                       */
/*----------------------------------------------------------------------------*/

struct ELINEINFO {
   DPOINT2D start, end;
   UINT16 smarker, emarker;            
   UINT16 smarksize, emarksize;        
   };


/*----------------------------------------------------------------------------*/
/*    Definitions for elastic box tool                                        */
/*----------------------------------------------------------------------------*/

struct EBOXINFO {
   double xinit, yinit, xlast, ylast;  
   DPOINT2D corner[4];                 
   double wmin, hmin, wmax, hmax;      
   double xsize, ysize;                
   double rotangle;                    
   double xproport, yproport;          
   };

#define  MxEBOX_Range         0x00000001     
#define  MxEBOX_AllCorners    0x00000002     
#define  MxEBOX_Proport       0x00000004

#define  MxEBOX_Corner0       0x00000010     
#define  MxEBOX_Corner1       0x00000020     
#define  MxEBOX_Corner2       0x00000040     
#define  MxEBOX_Corner3       0x00000080     

#define  MxEBOX_CanFlipHorz   0x00000100     
#define  MxEBOX_CanFlipVert   0x00000200     
#define  MxEBOX_CanFlipBoth   (MxEBOX_CanFlipHorz|MxEBOX_CanFlipVert)

/* Maximum allowed flag is 0x00000200 !!! */

/*----------------------------------------------------------------------------*/
/*    Definitions for elastic polyline tool                                   */
/*----------------------------------------------------------------------------*/

struct EPOLYLINEINFO {
   DPOLYGON poly;
   double zvalue;                      
   unsigned Is3D:1,                    
            IsPoly:1,                  
            LockStartPt:1,             
            LockEndPt:1,               
            KeepModIndex:1,            
            EnableTraceBtn:1,          
            InTraceMode:1,             
            unused:25;                 
   UINT32 CurveType;                   
   UINT16 smarker, emarker;            
   UINT16 smarksize, emarksize;        
   UINT16 smarkcolor, emarkcolor;      
   INT32 *ModIndex;                    
   };

#define  MxEPOLYLINE_EditPoly             0x00000001  
#define  MxEPOLYLINE_EnableProfile        0x00000004  
#define  MxEPOLYLINE_EnableTrace          0x00000008  

#define  MxEPOLYLINE_EnableResetB         0x00000010  
#define  MxEPOLYLINE_NoClearB             0x00000020  
#define  MxEPOLYLINE_NoClosePolyB         0x00000040  
#define  MxEPOLYLINE_UseCurveFit          0x00000080  

#define  MxEPOLYLINE_CanChgLinePolyMode   0x00000100  
#define  MxEPOLYLINE_NoEditZValue         0x00000200  

/*----------------------------------------------------------------------------*/
/*    Definitions for elastic multi-polyline tool                             */
/*----------------------------------------------------------------------------*/

struct EMULTILINEINFO {
   DPOLYGON *Lines;                    
   UINT32 NumLines;                    
   INT32 ActiveLine;                   
   double zvalue;                      
   unsigned Is3D:1,                    
            IsPoly:1,                  
            LockStartPt:1,             
            LockEndPt:1,               
            SingleLine:1,              
            unused:27;                 
   UINT32 CurveType;                   
   UINT16 smarker, emarker;            
   UINT16 smarksize, emarksize;        
   UINT16 smarkcolor, emarkcolor;      
   };

#define  MxEMULTILINE_EditPoly            0x00000001  
#define  MxEMULTILINE_LineIs3D            0x00000002  
#define  MxEMULTILINE_EnableResetB        0x00000004  
#define  MxEMULTILINE_NoClearB            0x00000008  

#define  MxEMULTILINE_NoClosePolyB        0x00000010  
#define  MxEMULTILINE_UseCurveFit         0x00000020  
#define  MxEMULTILINE_CanChgLinePolyMode  0x00000040  
#define  MxEMULTILINE_NoEditZValue        0x00000080  

#define  MxEMULTILINE_SingleLineOnly      0x00000100  

/*----------------------------------------------------------------------------*/
/*    Definitions for elastic point tool                                      */
/*----------------------------------------------------------------------------*/

struct EPOINTINFO {
   DPOINT3D pt;
   UINT16 marker;                      
   UINT16 markersize;                  
   };

#define  MxEPOINT_NoEditZValue         0x00000001  


/*----------------------------------------------------------------------------*/
/*    Definitions for elastic point tool                                      */
/*----------------------------------------------------------------------------*/

struct EMULTIPOINTINFO {
   DPOINT3D *pt;
   INT32 NumPoints;
   INT32 ActivePoint;                  
   UINT16 marker;                      
   UINT16 markersize;                  
   };

#define  MxEMULTIPOINT_NoEditZValue       0x00000001  
#define  MxEMULTIPOINT_SinglePointOnly    0x00000002  

/*----------------------------------------------------------------------------*/
/*    Definitions for elastic circle tool                                     */
/*----------------------------------------------------------------------------*/

struct ECIRCLEINFO {
   DPOINT2D center;                    
   double radius;                      
   double rmin, rmax;                  
   UINT16 cmarker;                     
   UINT16 cmarkersize;                 
   double rotangle;                    
   };

#define  MxECIRCLE_Rmin          0x00000001  
#define  MxECIRCLE_Rmax          0x00000002
#define  MxECIRCLE_RotationBar   0x00000004  


/*----------------------------------------------------------------------------*/
/*    Definitions for elastic regular polygon tool                            */
/*----------------------------------------------------------------------------*/

struct EREGPOLYINFO {
   DPOINT2D center;                    
   double radius;                      
   double rmin, rmax;                  
   double rotangle;                    
   UINT32 NumSegments;                 
   UINT16 cmarker;                     
   UINT16 cmarkersize;                 
   };

#define  MxEREGPOLY_Rmin            0x00000001  
#define  MxEREGPOLY_Rmax            0x00000002


/*----------------------------------------------------------------------------*/
/*    Definitions for elastic arc tools                                       */
/*----------------------------------------------------------------------------*/

struct EARCINFO {
   DPOINT2D center;                    
   double radius;                      
   int startang;                       
   int sweepang;                       
   double rmin, rmax;                  
   UINT16 cmarker;                     
   UINT16 cmarkersize;                 
   unsigned IsChord:1,                 
            IsWedge:1,                 
            unused:30;                 
   };

#define  MxEARC_Rmin          0x00000001     
#define  MxEARC_Rmax          0x00000002
#define  MxEARC_EditWedge     0x00000004
#define  MxEARC_EditChord     0x00000008


/*----------------------------------------------------------------------------*/
/*    Definitions for crosshair tool                                          */
/*----------------------------------------------------------------------------*/

struct CROSSHAIRINFO {
   DPOINT2D center;                    
   double angle;                       
   double hlen, vlen;                  
   DPOINT2D endpt0, endpt180;          
   DPOINT2D endpt90, endpt270;         
   };

#define  MxCROSSHAIR_NoBar0      0x00000001  
#define  MxCROSSHAIR_NoBar90     0x00000002  
#define  MxCROSSHAIR_NoBar180    0x00000004  
#define  MxCROSSHAIR_NoBar270    0x00000008  
#define  MxCROSSHAIR_SnapInside  0x00000010  


/*----------------------------------------------------------------------------*/
/*    Definitions for elastic ellipse tool                                    */
/*----------------------------------------------------------------------------*/

struct EELLIPSEINFO {
   DPOINT2D center;                    
   double angle;
   double xradius;                     
   double yradius;                     
   double xrmin, xrmax;                
   double yrmin, yrmax;                
   UINT16 cmarker;                     
   UINT16 cmarkersize;                 
   };

#define  MxEELLIPSE_Rmin      0x00000001     
#define  MxEELLIPSE_Rmax      0x00000002


/*----------------------------------------------------------------------------*/
/*    Definitions for elastic text label tool                              */
/*----------------------------------------------------------------------------*/

class ETEXTLABELINFO {
   public:
   
      enum BASECURVE {
         BASECURVE_Straight,
         BASECURVE_Exact,
         BASECURVE_Spline
         };
         
      struct LEADERINFO {
         POLYLINE m_Line;
         DPOINT3D m_TiePoint;
         INT32 m_ElemNum;
         ELEMTYPE m_ElemType;
         
         LEADERINFO () : m_ElemNum(0), m_ElemType(ELEMTYPE_Empty) {}
         };
         
      POLYLINE m_Baseline;                
      BASECURVE m_BaseCurve;              
      MISTRING m_String;                  
      double m_Height;                    
      TEXTSTYLE m_Style;                  
      double m_MapScale;                  
      MILIST<LEADERINFO> m_LeaderLines;   
      POLYLINE m_SourceLine;              
      
      ETEXTLABELINFO (
         ) :
         m_BaseCurve(BASECURVE_Straight),
         m_Height(1.0),
         m_MapScale(1.0)
         {}
         
      ETEXTLABELINFO (
         const ETEXTLABELINFO& rhs
         ) :
         m_Baseline(rhs.m_Baseline),
         m_BaseCurve(rhs.m_BaseCurve),
         m_String(rhs.m_String),
         m_Height(rhs.m_Height),
         m_Style(rhs.m_Style),
         m_MapScale(rhs.m_MapScale),
         m_LeaderLines(rhs.m_LeaderLines),
         m_SourceLine(rhs.m_SourceLine)
         {}

      ETEXTLABELINFO& operator= (
         const ETEXTLABELINFO& rhs
         ) {
         if (this != &rhs) {
            m_Baseline = rhs.m_Baseline;
            m_BaseCurve = rhs.m_BaseCurve;
            m_String = rhs.m_String;
            m_Height = rhs.m_Height;
            m_Style = rhs.m_Style;
            m_MapScale = rhs.m_MapScale;
            m_LeaderLines = rhs.m_LeaderLines;
            m_SourceLine = rhs.m_SourceLine;
            }
         return (*this);
         }
         
      void Clear (
         ) {
         m_String.Clear();
         m_LeaderLines.Clear();
         m_Baseline.Clear();
         return;
         }
         
   };

#define  MxETEXTLABEL_NoLeaderLines       0x00000001     
#define  MxETEXTLABEL_NoAdvanced          0x00000002     
#define  MxETEXTLABEL_NoBaselineEdit      0x00000004     
#define  MxETEXTLABEL_NoStylePanel        0x00000008     

PREVENT_MEMFUNC(ETEXTLABELINFO);

/*----------------------------------------------------------------------------*/
/*    Definitions for elastic region tool                                     */
/*----------------------------------------------------------------------------*/

struct EREGIONINFO {
   REGION2D region;                    
   };
PREVENT_MEMFUNC(EREGIONINFO);

#define  MxEREGION_NoMove        0x00000001



#define  MXT_ADD(_clsname)    inline void MxtCallbackAdd (MXTHANDLE vmxt, void (*f)(MxtAnyCallbackStruct*,_clsname*), UINT32 flags) const { MxtAddCallback(vmxt,reinterpret_cast<McbCallbackFunc>(f),const_cast<_clsname*>(this),(flags)); }
#define  MXT_REMOVE(_clsname) inline void MxtCallbackRemove (MXTHANDLE vmxt, void (*f)(MxtAnyCallbackStruct*,_clsname*), UINT32 flags) const { MxtRemoveCallback(vmxt,reinterpret_cast<McbCallbackFunc>(f),const_cast<_clsname*>(this),(flags)); }






extern "C" {

MXTHANDLE mxtCrossHair (
   UINT32 flags, 
   void *pwidget
   );

MXTHANDLE mxtEArc (
   UINT32 flags, 
   void *pwidget
   );
   
MXTHANDLE mxtEBox (
   UINT32 flags, 
   void *pwidget
   );

MXTHANDLE mxtECircle (
   UINT32 flags, 
   void *pwidget
   );

MXTHANDLE mxtEEllipse (
   UINT32 flags, 
   void *pwidget
   );
   
MXTHANDLE mxtELine (
   UINT32 flags, 
   void *pwidget
   );

MXTHANDLE mxtEMultiPoint (
   UINT32 flags, 
   void *pwidget
   );

MXTHANDLE mxtEMultiPolyLine (
   UINT32 flags, 
   void *pwidget
   );

MXTHANDLE mxtEPoint (
   UINT32 flags, 
   void *pwidget
   );

MXTHANDLE mxtEPolyLine (
   UINT32 flags, 
   void *pwidget
   );

MXTHANDLE mxtERegion (
   UINT32 flags, 
   void *pwidget
   );

MXTHANDLE mxtERegPoly (
   UINT32 flags, 
   void *pwidget
   );

MXTHANDLE mxtETextLabel (
   UINT32 flags, 
   void *pwidget
   );

MXTHANDLE mxtSelectPoint (
   UINT32 flags, 
   void *pwidget
   );

int MxtAddCallback (
   MXTHANDLE vmxt,                     
   McbCallbackFunc func,               
   void *udata,                        
   UINT32 reason                       
   );

int MxtCallbackAddExt (
   MXTHANDLE vmxt,                     
   McbCallbackFunc func,               
   void *udata,                        
   UINT32 reason,                      
   INT8 priority
   );

void MxtCallActivateCallback (
   MXTHANDLE mxt                       
   );

void MxtCallChangeCallback (
   MXTHANDLE mxt,                      
   UINT32 reason                       
   );

void MxtClearPosition (
   MXTHANDLE mxt                       
   );

MXTHANDLE MxtCreate (
   Widget pwidget,                           
   MXTHANDLE (*CreateFunc)(UINT32, void*),   
   UINT32 flags                              
   );

void MxtDestroy (
   MXTHANDLE mxt                       
   );

void MxtDrawGraphic (
   MXTHANDLE vmxt,                     
   const LRECT2D *rect                 
   );

int MxtEditGlobalOptions (
   Widget pwidget                      
   );

void MxtEnableGps (
   Widget pwidget,                     
   int enabled                         
   );

void MxtFreeValues (
   MXTHANDLE mxt,                      
   void *toolvalues                    
   );

Widget MxtGenerateManualForm (
   MXTHANDLE vmxt,                     
   Widget parent                       
   );

int MxtGenerateRegion (
   MXTHANDLE vmxt,                     
   REGION2D& region,                   
   UINT32 flags                        
   );

Widget MxtGenerateSpatialForm (
   MXTHANDLE vmxt,                     
   Widget parent                       
   );

Widget MxtGenerateToolForm (
   MXTHANDLE vmxt,                     
   Widget parent                       
   );

void MxtGetArrowKeyDeltas (
   MXTHANDLE mxt,                      
   double *delta_x,                    
   double *delta_y                     
   );

int MxtGetBounds (
   MXTHANDLE mxt,                      
   DRECT2D *rect                       
   );

MXTHANDLE MxtGetCurrentTool (
   MXTHANDLE mxt                       
   );

UINT32 MxtGetFlags (
   MXTHANDLE mxt
   );

void MxtGetGlobalColor (
   int *UseTool,                       
   COLOR *color,                       
   COLOR *seccolor,                    
   int *LineWidth                      
   );

int MxtGetManualMode (
   MXTHANDLE mxt                       
   );

void MxtGetManualParms (
   MXTHANDLE mxt,                      
   MANUALTOOLPARMS *mtparms            
   );

void MxtGetSnapGrid (
   MXTHANDLE mxt,                      
   SNAPGRIDPARMS *snapgrid             
   );

int MxtGetSnapGridMode (
   MXTHANDLE mxt                       
   );

GC MxtGetToolGC (
   MXTHANDLE mxt
   );

int MxtGetToolSize (
   MXTHANDLE mxt                       
   );

void MxtGetTrans2D (
   MXTHANDLE mxt,                      
   TRANS2D_AFFINE& TtoW                
   );

void *MxtGetUserData (
   MXTHANDLE mxt                       
   );

int MxtGetValues (
   MXTHANDLE mxt,                      
   void *toolvalues                    
   );

int MxtGetXYDigitizerMode (
   MXTHANDLE mxt                       
   );

int MxtHasPosition (
   MXTHANDLE mxt                       
   );

int MxtInBgUpdateCall (
   MXTHANDLE mxt
   );

int MxtIsManaged (
   MXTHANDLE mxt                       
   );

int MxtIsSuspended (
   MXTHANDLE mxt                       
   );

int MxtIsTrackingGps (
   MXTHANDLE mxt
   );

void MxtManage (
   MXTHANDLE mxt                       
   );

int MxtManualViewCoordRefSysSet (
   MXTHANDLE vmxt,                                    
   const SPATREF::COORDREFSYS& ViewCoordRefSys,       
   bool ForceProj                                     
   );

void MxtMove (
   MXTHANDLE mxt,                      
   double dx,                          
   double dy,                          
   XAnyEvent *event,                   
   UINT32 flags                        
   );

void MxtRaiseWindow (
   MXTHANDLE vmxt                      
   );

void MxtRemoveCallback (
   MXTHANDLE vmxt, 
   McbCallbackFunc func, 
   void *udata, 
   UINT32 reason
   );

void MxtResize (
   MXTHANDLE mxt,                      
   double dx,                          
   double dy,                          
   XAnyEvent *event,                   
   UINT32 flags                        
   );

void MxtResume (
   MXTHANDLE mxt                       
   );

void MxtRotate (
   MXTHANDLE mxt, 
   double drot, 
   XAnyEvent *event, 
   UINT32 flags
   );

void MxtSaveGlobalColor (
   char *group
   );

void MxtSetActivateCallback (
   MXTHANDLE mxt, 
   void (*CBFunc)(MxtAnyCallbackStruct*, void*), 
   void *udata
   );

void MxtSetArrowKeyDeltas (
   MXTHANDLE mxt,                      
   double delta_x,                     
   double delta_y                      
   );

void MxtSetBgUpdateFunc (
   Widget pwidget, 
   void (*UpdBg)(Widget, DRECT2D*, void*), 
   void *udata
   );

void MxtSetBounds (
   MXTHANDLE mxt,                      
   DRECT2D *rect,                      
   UINT32 flags                        
   );

void MxtSetChangeCallback (
   MXTHANDLE mxt,                                  
   void (*CBFunc)(MxtAnyCallbackStruct*, void*),   
   void *udata                                     
   );

int MxtSetDialogPosition (
   MXTHANDLE vmxt, 
   int NewPosn
   );

void MxtSetFlags (
   MXTHANDLE mxt,                      
   UINT32 flags                        
   );

void MxtSetGlobalColor (
   Widget parent,                      
   int UseTool,                        
   const COLOR& color,                       
   const COLOR& seccolor,                    
   int LineWidth                       
   );

void MxtSetGpsSource (
   MXTHANDLE vmxt,                     
   void *vNewSource                    
   );

void MxtSetHelpString (
   MXTHANDLE mxt,                      
   char *helpstr                       
   );

void MxtSetManualMode (
   MXTHANDLE mxt,                      
   int setflag                         
   );

int MxtSetManualParms (
   MXTHANDLE mxt,                      
   MANUALTOOLPARMS *mtparms            
   );

int MxtSetOutputTrans (
   MXTHANDLE vmxt,                     
   const TRANS2D_MAPGEN& trans
   );

int MxtSetSnapGrid (
   MXTHANDLE mxt,                      
   SNAPGRIDPARMS *snapgrid             
   );

void MxtSetSnapGridMode (
   MXTHANDLE mxt,                      
   int setflag                         
   );

void MxtSetToolColor (
   MXTHANDLE vmxt,                     
   COLOR *color,                       
   COLOR *seccolor,                    
   int LineWidth                       
   );

}  // extern "C"
void MxtSetTrans2D (
   MXTHANDLE mxt,                      
   const TRANS2D_AFFINE& TtoW          
   );

extern "C" {

void MxtSetTrans2D (
   MXTHANDLE mxt,                      
   const MAT3X3 OtoD,                  
   const MAT3X3 DtoO                   
   );

void MxtSetUserData (
   MXTHANDLE mxt,                      
   void *udata                         
   );

int MxtSetValues (
   MXTHANDLE mxt,                      
   void *toolvalues,                   
   int notify                          
   );

void MxtSetWindowButtonRow (
   MXTHANDLE mxt,                      
   BUTTONITEM *buttonrow,              
   void *udata                         
   );

void MxtSetWindowFormCallback (
   MXTHANDLE mxt,                      
   int (*AddToForm)(Widget, void*),    
   void *udata                         
   );

void MxtSetWindowSaveButton (
   MXTHANDLE mxt,                      
   const char *savebutton                    
   );


}     // Extern "C"

void MxtSetWindowTitle (
   MXTHANDLE mxt,                      
   TEXTID textid
   );

extern "C" {

void MxtSetXORPixel (
   MXTHANDLE mxt,                      
   Pixel pixel                         
   );

void MxtSetXYDigitizerMode (
   MXTHANDLE mxt,                      
   int setflag                         
   );

void MxtSetXYDtoObjectTrans (
   MXTHANDLE mxt,                      
   TRANSFUNC tfunc,                    
   void *udata                         
   );

void MxtShear (
   MXTHANDLE mxt,                      
   double dshear,                      
   XAnyEvent *event,                   
   UINT32 flags                        
   );

void MxtSuspend (
   MXTHANDLE mxt                       
   );

void MxtTrackGps (
   MXTHANDLE vmxt, 
   int track
   );

void MxtUnmanage (
   MXTHANDLE mxt                       
   );

}     // Extern "C"

inline MXTHANDLE MxtCreateCrossHair (
   Widget dawidget,                    
   UINT32 flags = 0                    
   ) {
   return (MxtCreate(dawidget,mxtCrossHair,flags));
   }

inline MXTHANDLE MxtCreateEArc (
   Widget dawidget,                    
   UINT32 flags = 0                    
   ) {
   return (MxtCreate(dawidget,mxtEArc,flags));
   }

inline MXTHANDLE MxtCreateEBox (
   Widget dawidget,                    
   UINT32 flags = 0                    
   ) {
   return (MxtCreate(dawidget,mxtEBox,flags));
   }

inline MXTHANDLE MxtCreateECircle (
   Widget dawidget,                    
   UINT32 flags = 0                    
   ) {
   return (MxtCreate(dawidget,mxtECircle,flags));
   }

inline MXTHANDLE MxtCreateEEllipse (
   Widget dawidget,                    
   UINT32 flags = 0                    
   ) {
   return (MxtCreate(dawidget,mxtEEllipse,flags));
   }

inline MXTHANDLE MxtCreateELine (
   Widget dawidget,                    
   UINT32 flags = 0                    
   ) {
   return (MxtCreate(dawidget,mxtELine,flags));
   }

inline MXTHANDLE MxtCreateEMultiPoint (
   Widget dawidget,                    
   UINT32 flags = 0                    
   ) {
   return (MxtCreate(dawidget,mxtEMultiPoint,flags));
   }

inline MXTHANDLE MxtCreateEMultiPolyLine (
   Widget dawidget,                    
   UINT32 flags = 0                    
   ) {
   return (MxtCreate(dawidget,mxtEMultiPolyLine,flags));
   }

inline MXTHANDLE MxtCreateEPoint (
   Widget dawidget,                    
   UINT32 flags = 0                    
   ) {
   return (MxtCreate(dawidget,mxtEPoint,flags));
   }

inline MXTHANDLE MxtCreateEPolyLine (
   Widget dawidget,                    
   UINT32 flags = 0                    
   ) {
   return (MxtCreate(dawidget,mxtEPolyLine,flags));
   }

inline MXTHANDLE MxtCreateERegion (
   Widget dawidget,                    
   UINT32 flags = 0                    
   ) {
   return (MxtCreate(dawidget,mxtERegion,flags));
   }

inline MXTHANDLE MxtCreateERegPoly (
   Widget dawidget,                    
   UINT32 flags = 0                    
   ) {
   return (MxtCreate(dawidget,mxtERegPoly,flags));
   }

inline MXTHANDLE MxtCreateETextLabel (
   Widget dawidget,                    
   UINT32 flags = 0                    
   ) {
   return (MxtCreate(dawidget,mxtETextLabel,flags));
   }

inline MXTHANDLE MxtCreateSelectPoint (
   Widget dawidget,                    
   UINT32 flags = 0                    
   ) {
   return (MxtCreate(dawidget,mxtSelectPoint,flags));
   }

inline UINT32 MxtGetReasonClass (
   UINT32 reason                       
   ) {
   return (reason & MxtCR_ReasonMask);
   }


#endif      

---