    /* @(#)root/base:$Name:  $:$Id: GuiTypes.h,v 1.8 2005/06/08 07:07:43 rdm Exp $ */

    /*************************************************************************
     * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
     * All rights reserved.                                                  *
     *                                                                       *
     * For the licensing terms see $ROOTSYS/LICENSE.                         *
     * For the list of contributors see $ROOTSYS/README/CREDITS.             *
     *************************************************************************/

    #ifndef ROOT_GuiTypes
    #define ROOT_GuiTypes

    //////////////////////////////////////////////////////////////////////////
    //                                                                      //
    // GuiTypes                                                             //
    //                                                                      //
    // Types used by the GUI classes.                                       //
    //                                                                      //
    //////////////////////////////////////////////////////////////////////////

    #ifndef ROOT_Rtypes
    #include "Rtypes.h"
    #endif

    // Basic GUI types
    typedef ULong_t            Handle_t;     //Generic resource handle
    typedef Handle_t           Display_t;    //Display handle
    typedef Handle_t           Visual_t;     //Visual handle
    typedef Handle_t           Window_t;     //Window handle
    typedef Handle_t           Pixmap_t;     //Pixmap handle
    typedef Handle_t           Drawable_t;   //Drawable handle
    typedef Handle_t           Region_t;     //Region handle
    typedef Handle_t           Colormap_t;   //Colormap handle
    typedef Handle_t           Cursor_t;     //Cursor handle
    typedef Handle_t           FontH_t;      //Font handle (as opposed to Font_t which is an index)
    typedef Handle_t           KeySym_t;     //Key symbol handle
    typedef Handle_t           Atom_t;       //WM token
    typedef Handle_t           GContext_t;   //Graphics context handle
    typedef Handle_t           FontStruct_t; //Pointer to font structure
    typedef ULong_t            Pixel_t;      //Pixel value
    typedef UInt_t             Mask_t;       //Structure mask type
    typedef ULong_t            Time_t;       //Event time

    enum EGuiConstants {
       kNotUseful = 0, kWhenMapped = 1, kAlways = 2,
       kIsUnmapped = 0, kIsUnviewable = 1, kIsViewable = 2,
       kInputOutput = 1, kInputOnly = 2,
       kLineSolid = 0, kLineOnOffDash = 1, kLineDoubleDash = 2,
       kCapNotLast = 0, kCapButt = 1, kCapRound = 2, kCapProjecting = 3,
       kJoinMiter = 0, kJoinRound = 1, kJoinBevel = 2,
       kFillSolid = 0, kFillTiled = 1, kFillStippled = 2, kFillOpaqueStippled = 3,
       kEvenOddRule = 0, kWindingRule = 1,
       kClipByChildren = 0, kIncludeInferiors = 1,
       kArcChord = 0, kArcPieSlice = 1
    };

    // GUI event types. Later merge with EEventType in Button.h and rename to
    // EEventTypes. Also rename in that case kGKeyPress to kKeyPress.
    enum EGEventType {
       kGKeyPress, kKeyRelease, kButtonPress, kButtonRelease,
       kMotionNotify, kEnterNotify, kLeaveNotify, kFocusIn, kFocusOut,
       kExpose, kConfigureNotify, kMapNotify, kUnmapNotify, kDestroyNotify,
       kClientMessage, kSelectionClear, kSelectionRequest, kSelectionNotify,
       kColormapNotify, kButtonDoubleClick, kOtherEvent
    };

    enum EGraphicsFunction {
       kGXclear = 0,               // 0
       kGXand,                     // src AND dst
       kGXandReverse,              // src AND NOT dst
       kGXcopy,                    // src
       kGXandInverted,             // NOT src AND dst
       kGXnoop,                    // dst
       kGXxor,                     // src XOR dst
       kGXor,                      // src OR dst
       kGXnor,                     // NOT src AND NOT dst
       kGXequiv,                   // NOT src XOR dst
       kGXinvert,                  // NOT dst
       kGXorReverse,               // src OR NOT dst
       kGXcopyInverted,            // NOT src
       kGXorInverted,              // NOT src OR dst
       kGXnand,                    // NOT src OR NOT dst
       kGXset                      // 1
    };

    enum { kDefaultScrollBarWidth = 16 };

    const Handle_t kNone = 0;
    const Handle_t kCopyFromParent = 0;
    const Handle_t kParentRelative = 1;

    // Attributes that can be used when creating or changing a window
    struct SetWindowAttributes_t {
       Pixmap_t   fBackgroundPixmap;     // background or kNone or kParentRelative
       ULong_t    fBackgroundPixel;      // background pixel
       Pixmap_t   fBorderPixmap;         // border of the window
       ULong_t    fBorderPixel;          // border pixel value
       UInt_t     fBorderWidth;          // border width in pixels
       Int_t      fBitGravity;           // one of bit gravity values
       Int_t      fWinGravity;           // one of the window gravity values
       Int_t      fBackingStore;         // kNotUseful, kWhenMapped, kAlways
       ULong_t    fBackingPlanes;        // planes to be preseved if possible
       ULong_t    fBackingPixel;         // value to use in restoring planes
       Bool_t     fSaveUnder;            // should bits under be saved (popups)?
       Long_t     fEventMask;            // set of events that should be saved
       Long_t     fDoNotPropagateMask;   // set of events that should not propagate
       Bool_t     fOverrideRedirect;     // boolean value for override-redirect
       Colormap_t fColormap;             // color map to be associated with window
       Cursor_t   fCursor;               // cursor to be displayed (or kNone)
       Mask_t     fMask;                 // bit mask specifying which fields are valid
    };

    // Window attributes that can be inquired
    struct WindowAttributes_t {
       Int_t      fX, fY;                 // location of window
       Int_t      fWidth, fHeight;        // width and height of window
       Int_t      fBorderWidth;           // border width of window
       Int_t      fDepth;                 // depth of window
       void      *fVisual;                // the associated visual structure
       Window_t   fRoot;                  // root of screen containing window
       Int_t      fClass;                 // kInputOutput, kInputOnly
       Int_t      fBitGravity;            // one of bit gravity values
       Int_t      fWinGravity;            // one of the window gravity values
       Int_t      fBackingStore;          // kNotUseful, kWhenMapped, kAlways
       ULong_t    fBackingPlanes;         // planes to be preserved if possible
       ULong_t    fBackingPixel;          // value to be used when restoring planes
       Bool_t     fSaveUnder;             // boolean, should bits under be saved?
       Colormap_t fColormap;              // color map to be associated with window
       Bool_t     fMapInstalled;          // boolean, is color map currently installed
       Int_t      fMapState;              // kIsUnmapped, kIsUnviewable, kIsViewable
       Long_t     fAllEventMasks;         // set of events all people have interest in
       Long_t     fYourEventMask;         // my event mask
       Long_t     fDoNotPropagateMask;    // set of events that should not propagate
       Bool_t     fOverrideRedirect;      // boolean value for override-redirect
       void      *fScreen;                // back pointer to correct screen
    };

    // Bits telling which SetWindowAttributes_t fields are valid
    const Mask_t kWABackPixmap       = BIT(0);
    const Mask_t kWABackPixel        = BIT(1);
    const Mask_t kWABorderPixmap     = BIT(2);
    const Mask_t kWABorderPixel      = BIT(3);
    const Mask_t kWABorderWidth      = BIT(4);
    const Mask_t kWABitGravity       = BIT(5);
    const Mask_t kWAWinGravity       = BIT(6);
    const Mask_t kWABackingStore     = BIT(7);
    const Mask_t kWABackingPlanes    = BIT(8);
    const Mask_t kWABackingPixel     = BIT(9);
    const Mask_t kWAOverrideRedirect = BIT(10);
    const Mask_t kWASaveUnder        = BIT(11);
    const Mask_t kWAEventMask        = BIT(12);
    const Mask_t kWADontPropagate    = BIT(13);
    const Mask_t kWAColormap         = BIT(14);
    const Mask_t kWACursor           = BIT(15);

    // Input event masks, used to set SetWindowAttributes_t::fEventMask
    // and to be passed to TVirtualX::SelectInput()
    const Mask_t kNoEventMask         = 0;
    const Mask_t kKeyPressMask        = BIT(0);
    const Mask_t kKeyReleaseMask      = BIT(1);
    const Mask_t kButtonPressMask     = BIT(2);
    const Mask_t kButtonReleaseMask   = BIT(3);
    const Mask_t kPointerMotionMask   = BIT(4);
    const Mask_t kButtonMotionMask    = BIT(5);
    const Mask_t kExposureMask        = BIT(6);
    const Mask_t kStructureNotifyMask = BIT(7);
    const Mask_t kEnterWindowMask     = BIT(8);
    const Mask_t kLeaveWindowMask     = BIT(9);
    const Mask_t kFocusChangeMask     = BIT(10);
    const Mask_t kOwnerGrabButtonMask = BIT(11);
    const Mask_t kColormapChangeMask  = BIT(12);

    // Event structure
    struct Event_t {
       EGEventType fType;              // of event (see EGEventTypes)
       Window_t    fWindow;            // window reported event is relative to
       Time_t      fTime;              // time event event occured in ms
       Int_t       fX, fY;             // pointer x, y coordinates in event window
       Int_t       fXRoot, fYRoot;     // coordinates relative to root
       UInt_t      fCode;              // key or button code
       UInt_t      fState;             // key or button mask
       UInt_t      fWidth, fHeight;    // width and height of exposed area
       Int_t       fCount;             // if non-zero, at least this many more exposes
       Bool_t      fSendEvent;         // true if event came from SendEvent
       Handle_t    fHandle;            // general resource handle (used for atoms or windows)
       Int_t       fFormat;            // Next fields only used by kClientMessageEvent
       Long_t      fUser[5];           // 5 longs can be used by client message events
                                       // NOTE: only [0], [1] and [2] may be used.
                                       // [1] and [2] may contain >32 bit quantities
                                       // (i.e. pointers on 64 bit machines)
    };

    // Key masks, used as modifiers to GrabButton and GrabKey and
    // in Event_t::fState in various key-, mouse-, and button-related events
    const Mask_t kKeyShiftMask   = BIT(0);
    const Mask_t kKeyLockMask    = BIT(1);
    const Mask_t kKeyControlMask = BIT(2);
    const Mask_t kKeyMod1Mask    = BIT(3);   // typically the Alt key
    const Mask_t kKeyMod2Mask    = BIT(4);   // typically mod on numeric keys
    const Mask_t kButton1Mask    = BIT(8);
    const Mask_t kButton2Mask    = BIT(9);
    const Mask_t kButton3Mask    = BIT(10);
    const Mask_t kButton4Mask    = BIT(11);
    const Mask_t kButton5Mask    = BIT(12);
    const Mask_t kAnyModifier    = BIT(15);

    // Button names. Used as arguments to GrabButton and as Event_t::fCode
    // for button events. Maps to the X11 values.
    enum EMouseButton { kAnyButton, kButton1, kButton2, kButton3,
                        kButton4, kButton5 };

    // Some magic X notify modes used in TGTextEntry widget.
    // Values must match the ones in /usr/include/X11/X.h. Check when porting.
    enum EXMagic { kNotifyNormal = 0, kNotifyGrab = 1, kNotifyUngrab = 2,
                   kNotifyPointer = 5, kColormapUninstalled = 0,
                   kColormapInstalled = 1 };

    // Graphics context structure
    struct GCValues_t {
       EGraphicsFunction fFunction;  // logical operation
       ULong_t  fPlaneMask;          // plane mask
       ULong_t  fForeground;         // foreground pixel
       ULong_t  fBackground;         // background pixel
       Int_t    fLineWidth;          // line width
       Int_t    fLineStyle;          // kLineSolid, kLineOnOffDash, kLineDoubleDash
       Int_t    fCapStyle;           // kCapNotLast, kCapButt,
                                     // kCapRound, kCapProjecting
       Int_t    fJoinStyle;          // kJoinMiter, kJoinRound, kJoinBevel
       Int_t    fFillStyle;          // kFillSolid, kFillTiled,
                                     // kFillStippled, kFillOpaeueStippled
       Int_t    fFillRule;           // kEvenOddRule, kWindingRule
       Int_t    fArcMode;            // kArcChord, kArcPieSlice
       Pixmap_t fTile;               // tile pixmap for tiling operations
       Pixmap_t fStipple;            // stipple 1 plane pixmap for stipping
       Int_t    fTsXOrigin;          // offset for tile or stipple operations
       Int_t    fTsYOrigin;
       FontH_t  fFont;               // default text font for text operations
       Int_t    fSubwindowMode;      // kClipByChildren, kIncludeInferiors
       Bool_t   fGraphicsExposures;  // boolean, should exposures be generated
       Int_t    fClipXOrigin;        // origin for clipping
       Int_t    fClipYOrigin;
       Pixmap_t fClipMask;           // bitmap clipping; other calls for rects
       Int_t    fDashOffset;         // patterned/dashed line information
       Char_t   fDashes[8];          // dash pattern list (dash length per byte)
       Int_t    fDashLen;            // number of dashes in fDashes
       Mask_t   fMask;               // bit mask specifying which fields are valid

       GCValues_t() { // default constructor
          fFunction = kGXcopy;
          fPlaneMask = 0;
          fForeground = 0;
          fBackground = 1;
          fLineWidth = 0;
          fLineStyle = kLineSolid;
          fCapStyle = kCapButt;
          fJoinStyle = kJoinMiter;
          fFillStyle = kFillSolid;
          fFillRule = kEvenOddRule;
          fArcMode = kArcPieSlice;
          fTile = 0;
          fStipple = 0;
          fTsXOrigin = 0;
          fTsYOrigin = 0;
          fFont = 0;
          fSubwindowMode = kClipByChildren;
          fGraphicsExposures = kTRUE;
          fClipXOrigin = 0;
          fClipYOrigin = 0;
          fClipMask = 0;
          fDashOffset = 0;
          fDashes[0] = 5; // dashed
          fDashes[1] = 5;
          for (int i=2; i<8; i++) fDashes[i] = 0;
          fDashLen = 2;
          fMask = 0;
       }
    };

    // Bits telling which GCValues_t fields are valid
    const Mask_t kGCFunction          = BIT(0);
    const Mask_t kGCPlaneMask         = BIT(1);
    const Mask_t kGCForeground        = BIT(2);
    const Mask_t kGCBackground        = BIT(3);
    const Mask_t kGCLineWidth         = BIT(4);
    const Mask_t kGCLineStyle         = BIT(5);
    const Mask_t kGCCapStyle          = BIT(6);
    const Mask_t kGCJoinStyle         = BIT(7);
    const Mask_t kGCFillStyle         = BIT(8);
    const Mask_t kGCFillRule          = BIT(9);
    const Mask_t kGCTile              = BIT(10);
    const Mask_t kGCStipple           = BIT(11);
    const Mask_t kGCTileStipXOrigin   = BIT(12);
    const Mask_t kGCTileStipYOrigin   = BIT(13);
    const Mask_t kGCFont              = BIT(14);
    const Mask_t kGCSubwindowMode     = BIT(15);
    const Mask_t kGCGraphicsExposures = BIT(16);
    const Mask_t kGCClipXOrigin       = BIT(17);
    const Mask_t kGCClipYOrigin       = BIT(18);
    const Mask_t kGCClipMask          = BIT(19);
    const Mask_t kGCDashOffset        = BIT(20);
    const Mask_t kGCDashList          = BIT(21);
    const Mask_t kGCArcMode           = BIT(22);

    struct ColorStruct_t {
       ULong_t   fPixel;    // color pixel value (index in color table)
       UShort_t  fRed;      // red component (0..65535)
       UShort_t  fGreen;    // green component (0..65535)
       UShort_t  fBlue;     // blue component (0..65535)
       UShort_t  fMask;     // mask telling which color components are valid
    };

    // Bits telling which ColorStruct_t fields are valid
    const Mask_t kDoRed   = BIT(0);
    const Mask_t kDoGreen = BIT(1);
    const Mask_t kDoBlue  = BIT(2);

    struct PictureAttributes_t {
       Colormap_t   fColormap;   // colormap to use
       Int_t        fDepth;      // depth of window
       UInt_t       fWidth;      // width of picture
       UInt_t       fHeight;     // height of picture
       UInt_t       fXHotspot;   // picture x hotspot coordinate
       UInt_t       fYHotspot;   // picture y hotspot coordinate
       ULong_t     *fPixels;     // list of used color pixels (if set use delete[])
       UInt_t       fNpixels;    // number of used color pixels
       UInt_t       fCloseness;  // allowable RGB deviation
       Mask_t       fMask;       // mask specifying which attributes are defined
    };

    // PictureAttributes_t masks bits
    const Mask_t kPAColormap     = BIT(0);
    const Mask_t kPADepth        = BIT(1);
    const Mask_t kPASize         = BIT(2);   // width and height
    const Mask_t kPAHotspot      = BIT(3);   // x and y hotspot
    const Mask_t kPAReturnPixels = BIT(4);
    const Mask_t kPACloseness    = BIT(5);

    // Initial window mapping state
    enum EInitialState {
       kNormalState = BIT(0),
       kIconicState = BIT(1)
    };

    // Used for drawing line segments (maps to the X11 XSegments structure)
    struct Segment_t {
       Short_t fX1, fY1, fX2, fY2;
    };

    // Point structure (maps to the X11 XPoint structure)
    struct Point_t {
       Short_t fX, fY;
    };

    // Rectangle structure (maps to the X11 XRectangle structure)
    struct Rectangle_t {
       Short_t  fX, fY;
       UShort_t fWidth, fHeight;
    };

    // Atoms used for text cut and paste between windows
    const Atom_t kPrimarySelection = 1;  // magic values, must match the ones
    const Atom_t kCutBuffer        = 9;  // in /usr/include/X11/Xatom.h
    const Int_t  kMaxPixel         = 32000;

    #endif