TVirtualX

class TVirtualX : public TNamed, public TAttLine, public TAttFill, public TAttText, public TAttMarker

    public:

                           TVirtualX()
                           TVirtualX(const char* name, const char* title)
                           TVirtualX(const TVirtualX&)
                   virtual ~TVirtualX()
             virtual Int_t AddWindow(ULong_t qwid, UInt_t w, UInt_t h)
            virtual Bool_t AllocColor(Colormap_t cmap, ColorStruct_t& color)
              virtual void Bell(Int_t percent)
              virtual void ChangeGC(GContext_t gc, GCValues_t* gval)
              virtual void ChangeProperty(Window_t id, Atom_t property, Atom_t type, UChar_t* data, Int_t len)
              virtual void ChangeWindowAttributes(Window_t id, SetWindowAttributes_t* attr)
            virtual Bool_t CheckEvent(Window_t id, EGEventType type, Event_t& ev)
            static TClass* Class()
              virtual void ClearArea(Window_t id, Int_t x, Int_t y, UInt_t w, UInt_t h)
              virtual void ClearWindow()
              virtual void ClearWindow(Window_t id)
              virtual void CloseDisplay()
              virtual void ClosePixmap()
              virtual void CloseWindow()
              virtual void ConvertPrimarySelection(Window_t id, Atom_t clipboard, Time_t when)
              virtual void CopyArea(Drawable_t src, Drawable_t dest, GContext_t gc, Int_t src_x, Int_t src_y, UInt_t width, UInt_t height, Int_t dest_x, Int_t dest_y)
              virtual void CopyGC(GContext_t org, GContext_t dest, Mask_t mask)
              virtual void CopyPixmap(Int_t wid, Int_t xpos, Int_t ypos)
          virtual Pixmap_t CreateBitmap(Drawable_t id, const char* bitmap, UInt_t width, UInt_t height)
          virtual Cursor_t CreateCursor(ECursor cursor)
        virtual GContext_t CreateGC(Drawable_t id, GCValues_t* gval)
          virtual Window_t CreateGLWindow(Window_t wind, Visual_t visual = 0, Int_t depth = 0)
        virtual Drawable_t CreateImage(UInt_t width, UInt_t height)
              virtual void CreateOpenGLContext(Int_t wid = 0)
            virtual Bool_t CreatePictureFromData(Drawable_t id, char** data, Pixmap_t& pict, Pixmap_t& pict_mask, PictureAttributes_t& attr)
            virtual Bool_t CreatePictureFromFile(Drawable_t id, const char* filename, Pixmap_t& pict, Pixmap_t& pict_mask, PictureAttributes_t& attr)
          virtual Pixmap_t CreatePixmap(Drawable_t id, UInt_t w, UInt_t h)
          virtual Pixmap_t CreatePixmap(Drawable_t id, const char* bitmap, UInt_t width, UInt_t height, ULong_t forecolor, ULong_t backcolor, Int_t depth)
          virtual Region_t CreateRegion()
          virtual Window_t CreateWindow(Window_t parent, Int_t x, Int_t y, UInt_t w, UInt_t h, UInt_t border, Int_t depth, UInt_t clss, void* visual, SetWindowAttributes_t* attr, UInt_t wtype)
              virtual void DeleteFont(FontStruct_t fs)
              virtual void DeleteGC(GContext_t gc)
              virtual void DeleteImage(Drawable_t img)
              virtual void DeleteOpenGLContext(Int_t wid = 0)
              virtual void DeletePictureData(void* data)
              virtual void DeletePixmap(Pixmap_t pmap)
              virtual void DestroyRegion(Region_t reg)
              virtual void DestroyWindow(Window_t id)
       virtual const char* DisplayName(const char* = "0") const
              virtual void DrawBox(Int_t x1, Int_t y1, Int_t x2, Int_t y2, TVirtualX::EBoxMode mode)
              virtual void DrawCellArray(Int_t x1, Int_t y1, Int_t x2, Int_t y2, Int_t nx, Int_t ny, Int_t* ic)
              virtual void DrawFillArea(Int_t n, TPoint* xy)
              virtual void DrawLine(Int_t x1, Int_t y1, Int_t x2, Int_t y2)
              virtual void DrawLine(Drawable_t id, GContext_t gc, Int_t x1, Int_t y1, Int_t x2, Int_t y2)
              virtual void DrawPolyLine(Int_t n, TPoint* xy)
              virtual void DrawPolyMarker(Int_t n, TPoint* xy)
              virtual void DrawRectangle(Drawable_t id, GContext_t gc, Int_t x, Int_t y, UInt_t w, UInt_t h)
              virtual void DrawSegments(Drawable_t id, GContext_t gc, Segment_t* seg, Int_t nseg)
              virtual void DrawString(Drawable_t id, GContext_t gc, Int_t x, Int_t y, const char* s, Int_t len)
              virtual void DrawText(Int_t x, Int_t y, Float_t angle, Float_t mgn, const char* text, TVirtualX::ETextMode mode)
            virtual Bool_t EmptyRegion(Region_t reg)
            virtual Bool_t EqualRegion(Region_t rega, Region_t regb)
             virtual Int_t EventsPending()
            virtual UInt_t ExecCommand(TGWin32Command* code)
              virtual void FillPolygon(Window_t id, GContext_t gc, Point_t* points, Int_t npnt)
              virtual void FillRectangle(Drawable_t id, GContext_t gc, Int_t x, Int_t y, UInt_t w, UInt_t h)
              virtual void FreeColor(Colormap_t cmap, ULong_t pixel)
              virtual void FreeFontNames(char** fontlist)
              virtual void FreeFontStruct(FontStruct_t fs)
              virtual void GetCharacterUp(Float_t& chupx, Float_t& chupy)
        virtual Colormap_t GetColormap() const
          virtual Window_t GetDefaultRootWindow() const
             virtual Int_t GetDepth() const
         virtual Display_t GetDisplay() const
             virtual Int_t GetDoubleBuffer(Int_t wid)
      TVirtualX::EDrawMode GetDrawMode()
           virtual FontH_t GetFontHandle(FontStruct_t fs)
              virtual void GetFontProperties(FontStruct_t font, Int_t& max_ascent, Int_t& max_descent)
      virtual FontStruct_t GetFontStruct(FontH_t fh)
              virtual void GetGCValues(GContext_t gc, GCValues_t& gval)
              virtual void GetGeometry(Int_t wid, Int_t& x, Int_t& y, UInt_t& w, UInt_t& h)
              virtual void GetImageSize(Drawable_t id, UInt_t& width, UInt_t& height)
          virtual Window_t GetInputFocus()
          virtual Handle_t GetNativeEvent() const
          virtual Window_t GetParent(Window_t id) const
              virtual void GetPasteBuffer(Window_t id, Atom_t atom, TString& text, Int_t& nchar, Bool_t del)
           virtual ULong_t GetPixel(Color_t cindex)
              virtual void GetPlanes(Int_t& nplanes)
          virtual Window_t GetPrimarySelectionOwner()
              virtual void GetRegionBox(Region_t reg, Rectangle_t* rect)
              virtual void GetRGB(Int_t index, Float_t& r, Float_t& g, Float_t& b)
             virtual Int_t GetScreen() const
              virtual void GetTextExtent(UInt_t& w, UInt_t& h, char* mess)
           virtual Float_t GetTextMagnitude()
          virtual Visual_t GetVisual() const
           virtual ULong_t GetWinDC(Window_t wind)
              virtual void GetWindowAttributes(Window_t id, WindowAttributes_t& attr)
          virtual Window_t GetWindowID(Int_t wid)
              virtual void GetWindowSize(Drawable_t id, Int_t& x, Int_t& y, UInt_t& w, UInt_t& h)
              virtual void glBegin(UInt_t mode)
              virtual void glCallList(UInt_t list)
              virtual void glClear(UInt_t mode)
              virtual void glClearColor(Float_t red, Float_t green, Float_t blue, Float_t alpha)
              virtual void glClearIndex(Float_t fParam)
              virtual void glColor3fv(const Float_t* color)
              virtual void glCullFace(UInt_t mode)
              virtual void glDeleteLists(UInt_t list, Int_t sizei)
              virtual void glDisable(UInt_t mode)
              virtual void glDrawBuffer(UInt_t mode)
              virtual void glEnable(UInt_t mode)
              virtual void glEnd()
              virtual void glEndList()
              virtual void glFlush()
              virtual void glFrontFace(UInt_t mode)
              virtual void glFrustum(Double_t min_0, Double_t max_0, Double_t min_1, Double_t max_1, Double_t dnear, Double_t dfar)
            virtual UInt_t glGenLists(UInt_t list)
              virtual void glGetBooleanv(UInt_t mode, UChar_t* bRet)
              virtual void glGetDoublev(UInt_t mode, Double_t* dRet)
             virtual Int_t glGetError()
              virtual void glGetFloatv(UInt_t mode, Float_t* fRet)
              virtual void glGetIntegerv(UInt_t mode, Int_t* iRet)
              virtual void glIndexi(Int_t index)
              virtual void glLineWidth(Float_t width)
              virtual void glLoadIdentity()
              virtual void glLoadMatrixd(const Double_t* matrix)
              virtual void glMatrixMode(UInt_t mode)
              virtual void glMultMatrixd(const Double_t* matrix)
              virtual void glNewList(UInt_t list, UInt_t mode)
              virtual void glNormal3fv(const Float_t* norm)
              virtual void glOrtho(Double_t min_0, Double_t max_0, Double_t min_1, Double_t max_1, Double_t dnear, Double_t dfar)
              virtual void glPointSize(Float_t size)
              virtual void glPolygonMode(UInt_t face, UInt_t mode)
              virtual void glPopMatrix()
              virtual void glPushMatrix()
              virtual void glRotated(Double_t angle, Double_t x, Double_t y, Double_t z)
              virtual void glShadeModel(UInt_t mode)
              virtual void glTranslated(Double_t x, Double_t y, Double_t z)
              virtual void glVertex3f(Float_t x, Float_t y, Float_t z)
              virtual void glVertex3fv(const Float_t* vert)
              virtual void glViewport(Int_t x0, Int_t y0, Int_t x1, Int_t y1)
              virtual void GrabButton(Window_t id, EMouseButton button, UInt_t modifier, UInt_t evmask, Window_t confine, Cursor_t cursor, Bool_t grab = kTRUE)
              virtual void GrabKey(Window_t id, Int_t keycode, UInt_t modifier, Bool_t grab = kTRUE)
              virtual void GrabPointer(Window_t id, UInt_t evmask, Window_t confine, Cursor_t cursor, Bool_t grab = kTRUE, Bool_t owner_events = kTRUE)
            virtual Bool_t HasTTFonts() const
              virtual void IconifyWindow(Window_t id)
            virtual Bool_t Init(void* display = 0)
             virtual Int_t InitWindow(ULong_t window)
        static TVirtualX*& Instance()
            virtual Atom_t InternAtom(const char* atom_name, Bool_t only_if_exist)
              virtual void IntersectRegion(Region_t rega, Region_t regb, Region_t result)
           virtual TClass* IsA() const
             virtual Int_t KeysymToKeycode(UInt_t keysym)
            virtual char** ListFonts(char* fontname, Int_t max, Int_t& count)
      virtual FontStruct_t LoadQueryFont(const char* font_name)
              virtual void LookupString(Event_t* event, char* buf, Int_t buflen, UInt_t& keysym)
              virtual void LowerWindow(Window_t id)
              virtual void MapRaised(Window_t id)
              virtual void MapSubwindows(Window_t id)
              virtual void MapWindow(Window_t id)
              virtual void MoveResizeWindow(Window_t id, Int_t x, Int_t y, UInt_t w, UInt_t h)
              virtual void MoveWindow(Int_t wid, Int_t x, Int_t y)
              virtual void MoveWindow(Window_t id, Int_t x, Int_t y)
              virtual void NextEvent(Event_t& event)
             virtual Int_t OpenDisplay(const char* dpyName)
             virtual Int_t OpenPixmap(UInt_t w, UInt_t h)
            virtual Bool_t ParseColor(Colormap_t cmap, const char* cname, ColorStruct_t& color)
            virtual Bool_t PointInRegion(Int_t x, Int_t y, Region_t reg)
          virtual Region_t PolygonRegion(Point_t* points, Int_t np, Bool_t winding)
              virtual void PutImage(Drawable_t id, GContext_t gc, Drawable_t img, Int_t dx, Int_t dy, Int_t x, Int_t y, UInt_t w, UInt_t h)
              virtual void PutPixel(Drawable_t id, Int_t x, Int_t y, ULong_t pixel)
              virtual void QueryColor(Colormap_t cmap, ColorStruct_t& color)
              virtual void QueryPointer(Int_t& ix, Int_t& iy)
              virtual void QueryPointer(Window_t id, Window_t& rootw, Window_t& childw, Int_t& root_x, Int_t& root_y, Int_t& win_x, Int_t& win_y, UInt_t& mask)
              virtual void RaiseWindow(Window_t id)
              virtual void ReadGIF(Int_t x0, Int_t y0, const char* file)
            virtual Bool_t ReadPictureDataFromFile(const char* filename, char*** ret_data)
              virtual void RemoveWindow(ULong_t qwid)
             virtual Int_t RequestLocator(Int_t mode, Int_t ctyp, Int_t& x, Int_t& y)
             virtual Int_t RequestString(Int_t x, Int_t y, char* text)
              virtual void RescaleWindow(Int_t wid, UInt_t w, UInt_t h)
             virtual Int_t ResizePixmap(Int_t wid, UInt_t w, UInt_t h)
              virtual void ResizeWindow(Int_t wid)
              virtual void ResizeWindow(Window_t id, UInt_t w, UInt_t h)
              virtual void SelectInput(Window_t id, UInt_t evmask)
              virtual void SelectPixmap(Int_t qpixid)
              virtual void SelectWindow(Int_t wid)
              virtual void SendEvent(Window_t id, Event_t* ev)
              virtual void SetCharacterUp(Float_t chupx, Float_t chupy)
              virtual void SetClassHints(Window_t id, char* className, char* resourceName)
              virtual void SetClipOFF(Int_t wid)
              virtual void SetClipRectangles(GContext_t gc, Int_t x, Int_t y, Rectangle_t* recs, Int_t n)
              virtual void SetClipRegion(Int_t wid, Int_t x, Int_t y, UInt_t w, UInt_t h)
              virtual void SetCursor(Int_t win, ECursor cursor)
              virtual void SetCursor(Window_t id, Cursor_t curid)
              virtual void SetDashes(GContext_t gc, Int_t offset, const char* dash_list, Int_t n)
              virtual void SetDoubleBuffer(Int_t wid, Int_t mode)
              virtual void SetDoubleBufferOFF()
              virtual void SetDoubleBufferON()
              virtual void SetDrawMode(TVirtualX::EDrawMode mode)
              virtual void SetFillColor(Color_t cindex)
              virtual void SetFillStyle(Style_t style)
              virtual void SetForeground(GContext_t gc, ULong_t foreground)
              virtual void SetIconName(Window_t id, char* name)
              virtual void SetIconPixmap(Window_t id, Pixmap_t pix)
              virtual void SetInputFocus(Window_t id)
              virtual void SetKeyAutoRepeat(Bool_t on = kTRUE)
              virtual void SetLineColor(Color_t cindex)
              virtual void SetLineStyle(Style_t linestyle)
              virtual void SetLineType(Int_t n, Int_t* dash)
              virtual void SetLineWidth(Width_t width)
              virtual void SetMarkerColor(Color_t cindex)
              virtual void SetMarkerSize(Float_t markersize)
              virtual void SetMarkerStyle(Style_t markerstyle)
              virtual void SetMWMHints(Window_t id, UInt_t value, UInt_t funcs, UInt_t input)
              virtual void SetOpacity(Int_t percent)
              virtual void SetPrimarySelectionOwner(Window_t id)
              virtual void SetRGB(Int_t cindex, Float_t r, Float_t g, Float_t b)
              virtual void SetTextAlign(Short_t talign = 11)
              virtual void SetTextColor(Color_t cindex)
             virtual Int_t SetTextFont(char* fontname, TVirtualX::ETextSetMode mode)
              virtual void SetTextFont(Font_t fontnumber)
              virtual void SetTextMagnitude(Float_t mgn)
              virtual void SetTextSize(Float_t textsize)
              virtual void SetWindowBackground(Window_t id, ULong_t color)
              virtual void SetWindowBackgroundPixmap(Window_t id, Pixmap_t pxm)
              virtual void SetWindowName(Window_t id, char* name)
              virtual void SetWMPosition(Window_t id, Int_t x, Int_t y)
              virtual void SetWMSize(Window_t id, UInt_t w, UInt_t h)
              virtual void SetWMSizeHints(Window_t id, UInt_t wmin, UInt_t hmin, UInt_t wmax, UInt_t hmax, UInt_t winc, UInt_t hinc)
              virtual void SetWMState(Window_t id, EInitialState state)
              virtual void SetWMTransientHint(Window_t id, Window_t main_id)
              virtual void ShowMembers(TMemberInspector& insp, char* parent)
              virtual void Streamer(TBuffer& b)
                      void StreamerNVirtual(TBuffer& b)
              virtual void SubtractRegion(Region_t rega, Region_t regb, Region_t result)
             virtual Int_t TextWidth(FontStruct_t font, const char* s, Int_t len)
              virtual void TranslateCoordinates(Window_t src, Window_t dest, Int_t src_x, Int_t src_y, Int_t& dest_x, Int_t& dest_y, Window_t& child)
              virtual void UnionRectWithRegion(Rectangle_t* rect, Region_t src, Region_t dest)
              virtual void UnionRegion(Region_t rega, Region_t regb, Region_t result)
              virtual void UnmapWindow(Window_t id)
              virtual void Update(Int_t mode = 0)
              virtual void UpdateWindow(Int_t mode)
              virtual void Warp(Int_t ix, Int_t iy)
           virtual ULong_t wglCreateContext(Window_t wind)
              virtual void wglDeleteContext(ULong_t ctx)
              virtual void wglMakeCurrent(Window_t wind, ULong_t ctx)
              virtual void wglSwapLayerBuffers(Window_t wind, UInt_t mode)
              virtual void WMDeleteNotify(Window_t id)
             virtual Int_t WriteGIF(char* name)
              virtual void WritePixmap(Int_t wid, UInt_t w, UInt_t h, char* pxname)
              virtual void XorRegion(Region_t rega, Region_t regb, Region_t result)

Data Members

    protected:

      TVirtualX::EDrawMode fDrawMode  Drawing mode

    public:

         static const TVirtualX::EDrawMode kCopy    
         static const TVirtualX::EDrawMode kXor     
         static const TVirtualX::EDrawMode kInvert  
          static const TVirtualX::EBoxMode kHollow  
          static const TVirtualX::EBoxMode kFilled  
         static const TVirtualX::ETextMode kClear   
         static const TVirtualX::ETextMode kOpaque  
      static const TVirtualX::ETextSetMode kCheck   
      static const TVirtualX::ETextSetMode kLoad    

See also

TGX11

Class Description

                                                                      
 TVirtualX                                                            
                                                                      
 Semi-Abstract base class defining a generic interface to the         
 underlying, low level, graphics system (X11, Win32, MacOS).          
 An instance of TVirtualX itself defines a batch interface to the     
 graphics system.                                                     
                                                                      

 Ctor of ABC

 Returns gVirtualX global

 The WindowAttributes_t structure is set to default.

 Looks up the string name of a color "cname" with respect to the screen
 associated with the specified colormap. It returns the exact color value.
 If the color name is not in the Host Portable Character Encoding,
 the result is implementation dependent.

 cmap  - the colormap
 cname - the color name string; use of uppercase or lowercase
         does not matter
 color - returns the exact color value for later use

 The ColorStruct_t structure is set to default. Let system think we
 could parse color.

 Allocates a read-only colormap entry corresponding to the closest RGB
 value supported by the hardware. If no cell could be allocated it
 returns kFALSE, otherwise kTRUE.

 The pixel value is set to default. Let system think we could allocate
 color.

 cmap  - the colormap
 color - specifies and returns the values actually used in the cmap

 Returns the current RGB value for the pixel in the "color" structure

 The color components are set to default.

 cmap  - the colormap
 color - specifies and returns the RGB values for the pixel specified
         in the structure

 The "event" is set to default event.
 This method however, should never be called.

 Gets contents of the paste buffer "atom" into the string "text".
 (nchar = number of characters) If "del" is true deletes the paste
 buffer afterwards.

 Initializes the X system. Returns kFALSE in case of failure.
 It is implementation dependent.

 Clears the entire area of the current window.

 Deletes current window.

 Deletes current pixmap.

 Copies the pixmap "wid" at the position [xpos,ypos] in the current window.

 Creates OpenGL context for window "wid"

 Deletes OpenGL context for window "wid"

 Draws a box between [x1,y1] and [x2,y2] according to the "mode".

 mode  - drawing mode:
         mode = 0 hollow  (kHollow)
         mode = 1 solid   (kSolid)

 Draws a cell array. The drawing is done with the pixel presicion
 if (x2-x1)/nx (or y) is not a exact pixel number the position of
 the top rigth corner may be wrong.

 x1,y1 - left down corner
 x2,y2 - right up corner
 nx,ny - array size
 ic    - array

 Fills area described by the polygon.

 n       - number of points
 xy(2,n) - list of points

 Draws a line.

 x1,y1 - begin of line
 x2,y2 - end of line

 Draws a line through all points in the list.

 n  - number of points
 xy - list of points

 Draws "n" markers with the current attributes at position [x,y].

 n  - number of markers to draw
 xy - an array of x,y marker coordinates

 Draws a text string using current font.

 x,y   - text position
 angle - text angle
 mgn   - magnification factor
 text  - text string
 mode  - drawing mode:
         mode = 0 the background is not drawn (kClear)
         mode = 1 the background is drawn (kOpaque)

 Executes the command "code" coming from the other threads (Win32)

 Queries the double buffer value for the window "wid".

 Returns character up vector.

 Returns position and size of window "wid".

 wid  - window identifier
        if wid < 0 the size of the display is returned
 x, y - returned window position
 w, h - returned window size

 Returns hostname on which the display is opened.

 Returns the current native event handle.

 Returns pixel value associated to specified ROOT color number "cindex".

 Returns the maximum number of planes.

 Returns RGB values for color "index".

 Returns the size of the specified character string "mess".

 w    - the text width
 h    - the text height
 mess - the string

 Returns the current font magnification factor

 Returns True when TrueType fonts are used

 Returns the X11 window identifier.

 wid - workstation identifier (input)

 Creates a new window and return window number.
 Returns -1 if window initialization fails.

 Registers a window created by Qt as a ROOT window

 w, h - the width and height, which define the window size

 Removes the created by Qt window "qwid".

 Moves the window "wid" to the specified x and y coordinates.
 It does not change the window's size, raise the window, or change
 the mapping state of the window.

 x, y - coordinates, which define the new position of the window
        relative to its parent.

 Creates a pixmap of the width "w" and height "h" you specified.

 Returns the pointer position.

 If id is NULL - loads the specified gif file at position [x0,y0] in the
 current window. Otherwise creates pixmap from gif file

 Requests Locator position.
 x,y  - cursor position at moment of button press (output)
 ctyp - cursor type (input)
        ctyp = 1 tracking cross
        ctyp = 2 cross-hair
        ctyp = 3 rubber circle
        ctyp = 4 rubber band
        ctyp = 5 rubber rectangle

 mode - input mode
        mode = 0 request
        mode = 1 sample

 The returned value is:
        in request mode:
                       1 = left is pressed
                       2 = middle is pressed
                       3 = right is pressed
        in sample mode:
                       11 = left is released
                       12 = middle is released
                       13 = right is released
                       -1 = nothing is pressed or released
                       -2 = leave the window
                     else = keycode (keyboard is pressed)

 Requests string: text is displayed and can be edited with Emacs-like
 keybinding. Returns termination code (0 for ESC, 1 for RETURN)

 x,y  - position where text is displayed
 text - displayed text (as input), edited text (as output)

 Rescales the window "wid".

 wid - window identifier
 w   - the width
 h   - the heigth

 Resizes the specified pixmap "wid".

 w, h - the width and height which define the pixmap dimensions

 Resizes the window "wid" if necessary.

 Selects the window "wid" to which subsequent output is directed.

 Selects the pixmap "qpixid".

 Sets character up vector.

 Turns off the clipping for the window "wid".

 Sets clipping region for the window "wid".

 wid  - window indentifier
 x, y - origin of clipping rectangle
 w, h - the clipping rectangle dimensions

 The cursor "cursor" will be used when the pointer is in the
 window "wid".

 Sets the double buffer on/off on the window "wid".
 wid  - window identifier.
        999 means all opened windows.
 mode - the on/off switch
        mode = 1 double buffer is on
        mode = 0 double buffer is off

 Turns double buffer mode off.

 Turns double buffer mode on.

 Sets the drawing mode.

 mode = 1 copy
 mode = 2 xor
 mode = 3 invert
 mode = 4 set the suitable mode for cursor echo according to the vendor

 Sets color index "cindex" for fill areas.

 Sets fill area style.

 style - compound fill area interior style
         style = 1000 * interiorstyle + styleindex

 Sets color index "cindex" for drawing lines.

 Sets the line type.

 n       - length of the dash list
           n <= 0 use solid lines
           n >  0 use dashed lines described by dash(n)
                 e.g. n = 4,dash = (6,3,1,3) gives a dashed-dotted line
                 with dash length 6 and a gap of 7 between dashes
 dash(n) - dash segment lengths

 Sets the line style.

 linestyle <= 1 solid
 linestyle  = 2 dashed
 linestyle  = 3 dotted
 linestyle  = 4 dashed-dotted

 Sets the line width.

 width - the line width in pixels

 Sets color index "cindex" for markers.

 Sets marker size index.

 markersize - the marker scale factor

 Sets marker style.

 Sets opacity of the current window. This image manipulation routine
 works by adding to a percent amount of neutral to each pixels RGB.
 Since it requires quite some additional color map entries is it
 only supported on displays with more than > 8 color planes (> 256
 colors).

 Sets color intensities the specified color index "cindex".

 cindex  - color index
 r, g, b - the red, green, blue intensities between 0.0 and 1.0

 Sets the text alignment.

 talign = txalh horizontal text alignment
 talign = txalv vertical text alignment

 Sets the color index "cindex" for text.

 Sets text font to specified name "fontname".This function returns 0 if
 the specified font is found, 1 if it is not.

 mode - loading flag
        mode = 0 search if the font exist (kCheck)
        mode = 1 search the font and load it if it exists (kLoad)

 Sets the current text font number.

 Sets the current text magnification factor to "mgn"

 Sets the current text size to "textsize"

 Updates or synchronises client and server once (not permanent).
 according to "mode".
    mode = 1 update
    mode = 0 sync

 Sets the pointer position.
 ix - new X coordinate of pointer
 iy - new Y coordinate of pointer
 (both coordinates are relative to the origin of the current window)

 Writes the current window into GIF file.
 Returns 1 in case of success, 0 otherwise.

 Writes the pixmap "wid" in the bitmap file "pxname".

 wid    - the pixmap address
 w, h   - the width and height of the pixmap.
 pxname - the file name

 Maps the window "id" and all of its subwindows that have had map
 requests. This function has no effect if the window is already mapped.

 Maps all subwindows for the specified window "id" in top-to-bottom
 stacking order.

 Maps the window "id" and all of its subwindows that have had map
 requests on the screen and put this window on the top of of the
 stack of all windows.

 Unmaps the specified window "id". If the specified window is already
 unmapped, this function has no effect. Any child window will no longer
 be visible (but they are still mapped) until another map call is made
 on the parent.

 Destroys the window "id" as well as all of its subwindows.
 The window should never be referenced again. If the window specified
 by the "id" argument is mapped, it is unmapped automatically.

 Raises the specified window to the top of the stack so that no
 sibling window obscures it.

 Lowers the specified window "id" to the bottom of the stack so
 that it does not obscure any sibling windows.

 Moves the specified window to the specified x and y coordinates.
 It does not change the window's size, raise the window, or change
 the mapping state of the window.

 x, y - coordinates, which define the new position of the window
        relative to its parent.

 Changes the size and location of the specified window "id" without
 raising it.

 x, y - coordinates, which define the new position of the window
        relative to its parent.
 w, h - the width and height, which define the interior size of
        the window

 Changes the width and height of the specified window "id", not
 including its borders. This function does not change the window's
 upper-left coordinate.

 w, h - the width and height, which are the interior dimensions of
        the window after the call completes.

 Iconifies the window "id".

 Sets the background of the window "id" to the specified color value
 "color". Changing the background does not cause the window contents
 to be changed.

 Sets the background pixmap of the window "id" to the specified
 pixmap "pxm".

 Creates an unmapped subwindow for a specified parent window and returns
 the created window. The created window is placed on top in the stacking
 order with respect to siblings. The coordinate system has the X axis
 horizontal and the Y axis vertical with the origin [0,0] at the
 upper-left corner. Each window and pixmap has its own coordinate system.

 parent - the parent window
 x, y   - coordinates, the top-left outside corner of the window's
          borders; relative to the inside of the parent window's borders
 w, h   - width and height of the created window; do not include the
          created window's borders
 border - the border pixel value of the window
 depth  - the window's depth
 clss   - the created window's class; can be InputOutput, InputOnly, or
          CopyFromParent
 visual - the visual type
 attr   - the structure from which the values are to be taken.
 wtype  - the window type

 Opens connection to display server (if such a thing exist on the
 current platform). The encoding and interpretation of the display
 name
 On X11 this method returns on success the X display socket descriptor
 >0, 0 in case of batch mode, and <0 in case of failure (cannot connect
 to display dpyName).

 Closes connection to display server and destroys all windows.

 Returns handle to display (might be usefull in some cases where
 direct X11 manipulation outside of TVirtualX is needed, e.g. GL
 interface).

 Returns handle to visual.

 Might be usefull in some cases where direct X11 manipulation outside
 of TVirtualX is needed, e.g. GL interface.

 Returns screen number.

 Might be usefull in some cases where direct X11 manipulation outside
 of TVirtualX is needed, e.g. GL interface.

 Returns depth of screen (number of bit planes).
 Equivalent to GetPlanes().

 Returns handle to colormap.

 Might be usefull in some cases where direct X11 manipulation outside
 of TVirtualX is needed, e.g. GL interface.

 Returns handle to the default root window created when calling
 XOpenDisplay().

 Returns the atom identifier associated with the specified "atom_name"
 string. If "only_if_exists" is False, the atom is created if it does
 not exist. If the atom name is not in the Host Portable Character
 Encoding, the result is implementation dependent. Uppercase and
 lowercase matter; the strings "thing", "Thing", and "thinG" all
 designate different atoms.

 Returns the parent of the window "id".

 Provides the most common way for accessing a font: opens (loads) the
 specified font and returns a pointer to the appropriate FontStruct_t
 structure. If the font does not exist, it returns NULL.

 Returns the font handle of the specified font structure "fs".

 Explicitely deletes the font structure "fs" obtained via LoadQueryFont().

 Creates a graphics context using the provided GCValues_t *gval structure.
 The mask data member of gval specifies which components in the GC are
 to be set using the information in the specified values structure.
 It returns a graphics context handle GContext_t that can be used with any
 destination drawable or O if the creation falls.

 Changes the components specified by the mask in gval for the specified GC.

 GContext_t gc   - specifies the GC to be changed
 GCValues_t gval - specifies the mask and the values to be set
 (see also the GCValues_t structure)

 Copies the specified components from the source GC "org" to the
 destination GC "dest". The "mask" defines which component to copy
 and it is a data member of GCValues_t.

 Deletes the specified GC "gc".

 Creates the specified cursor. (just return cursor from cursor pool).
 The cursor can be:

 kBottomLeft, kBottomRight, kTopLeft,  kTopRight,
 kBottomSide, kLeftSide,    kTopSide,  kRightSide,
 kMove,       kCross,       kArrowHor, kArrowVer,
 kHand,       kRotate,      kPointer,  kArrowRight,
 kCaret,      kWatch

 Sets the cursor "curid" to be used when the pointer is in the
 window "id".

 Creates a pixmap of the specified width and height and returns
 a pixmap ID that identifies it.

 Creates a pixmap from bitmap data of the width, height, and depth you
 specified and returns a pixmap that identifies it. The width and height
 arguments must be nonzero. The depth argument must be one of the depths
 supported by the screen of the specified drawable.

 id            - specifies which screen the pixmap is created on
 bitmap        - the data in bitmap format
 width, height - define the dimensions of the pixmap
 forecolor     - the foreground pixel values to use
 backcolor     - the background pixel values to use
 depth         - the depth of the pixmap

 Creates a bitmap (i.e. pixmap with depth 1) from the bitmap data.

 id            - specifies which screen the pixmap is created on
 bitmap        - the data in bitmap format
 width, height - define the dimensions of the pixmap

 Explicitely deletes the pixmap resource "pmap".

 Creates a picture pict from data in file "filename". The picture
 attributes "attr" are used for input and output. Returns kTRUE in
 case of success, kFALSE otherwise. If the mask "pict_mask" does not
 exist it is set to kNone.

 Creates a picture pict from data in bitmap format. The picture
 attributes "attr" are used for input and output. Returns kTRUE in
 case of success, kFALSE otherwise. If the mask "pict_mask" does not
 exist it is set to kNone.

 Reads picture data from file "filename" and store it in "ret_data".
 Returns kTRUE in case of success, kFALSE otherwise.

 Delete picture data created by the function ReadPictureDataFromFile.

 Sets the dash-offset and dash-list attributes for dashed line styles
 in the specified GC. There must be at least one element in the
 specified dash_list. The initial and alternating elements (second,
 fourth, and so on) of the dash_list are the even dashes, and the
 others are the odd dashes. Each element in the "dash_list" array
 specifies the length (in pixels) of a segment of the pattern.

 gc        - specifies the GC (see GCValues_t structure)
 offset    - the phase of the pattern for the dashed line-style you
             want to set for the specified GC.
 dash_list - the dash-list for the dashed line-style you want to set
             for the specified GC
 n         - the number of elements in dash_list
 (see also the GCValues_t structure)

 Frees color cell with specified pixel value.

 Returns the number of events that have been received from the X server
 but have not been removed from the event queue.

 Sets the sound bell. Percent is loudness from -100% .. 100%.

 Combines the specified rectangle of "src" with the specified rectangle
 of "dest" according to the "gc".

 src_x, src_y   - specify the x and y coordinates, which are relative
                  to the origin of the source rectangle and specify
                  upper-left corner.
 width, height  - the width and height, which are the dimensions of both
                  the source and destination rectangles                                                                   
 dest_x, dest_y - specify the upper-left corner of the destination
                  rectangle

 GC components in use: function, plane-mask, subwindow-mode,
 graphics-exposure, clip-x-origin, clip-y-origin, and clip-mask.
 (see also the GCValues_t structure)

 Changes the attributes of the specified window "id" according the
 values provided in "attr". The mask data member of "attr" specifies
 which window attributes are defined in the attributes argument.
 This mask is the bitwise inclusive OR of the valid attribute mask
 bits; if it is zero, the attributes are ignored.

 Alters the property for the specified window and causes the X server
 to generate a PropertyNotify event on that window.

 id       - the window whose property you want to change
 property - specifies the property name
 type     - the type of the property; the X server does not
            interpret the type but simply passes it back to
            an application that might ask about the window
            properties
 data     - the property data
 len      - the length of the specified data format

 Uses the components of the specified GC to draw a line between the
 specified set of points (x1, y1) and (x2, y2).

 GC components in use: function, plane-mask, line-width, line-style,
 cap-style, fill-style, subwindow-mode, clip-x-origin, clip-y-origin,
 and clip-mask.
 GC mode-dependent components: foreground, background, tile, stipple,
 tile-stipple-x-origin, tile-stipple-y-origin, dash-offset, dash-list.
 (see also the GCValues_t structure)

 Paints a rectangular area in the specified window "id" according to
 the specified dimensions with the window's background pixel or pixmap.

 id - specifies the window
 x, y - coordinates, which are relative to the origin
 w, h - the width and height which define the rectangle dimensions

 Check if there is for window "id" an event of type "type". If there
 is it fills in the event structure and return true. If no such event
 return false.

 Specifies the event "ev" is to be sent to the window "id".
 This function requires you to pass an event mask.

 Tells WM to send message when window is closed via WM.

 Turns key auto repeat on (kTRUE) or off (kFALSE).

 Establishes a passive grab on the keyboard. In the future, the
 keyboard is actively grabbed, the last-keyboard-grab time is set
 to the time at which the key was pressed (as transmitted in the
 KeyPress event), and the KeyPress event is reported if all of the
 following conditions are true:
    - the keyboard is not grabbed and the specified key (which can
      itself be a modifier key) is logically pressed when the
      specified modifier keys are logically down, and no other
      modifier keys are logically down;
    - either the grab window "id" is an ancestor of (or is) the focus
      window, or "id" is a descendant of the focus window and contains
      the pointer;
    - a passive grab on the same key combination does not exist on any
      ancestor of grab_window

 id       - window id
 keycode  - specifies the KeyCode or AnyKey
 modifier - specifies the set of keymasks or AnyModifier; the mask is
            the bitwise inclusive OR of the valid keymask bits
 grab     - a switch between grab/ungrab key
            grab = kTRUE  grab the key and modifier
            grab = kFALSE ungrab the key and modifier

 Establishes a passive grab on a certain mouse button. That is, when a
 certain mouse button is hit while certain modifier's (Shift, Control,
 Meta, Alt) are active then the mouse will be grabed for window id.
 When grab is false, ungrab the mouse button for this button and modifier.

 Establishes an active pointer grab. While an active pointer grab is in
 effect, further pointer events are only reported to the grabbing
 client window.

 Sets the window name.

 Sets the window icon name.

 Sets the icon name pixmap.

 Sets the windows class and resource name.

 Sets decoration style.

 Tells the window manager the desired position [x,y] of window "id".

 Tells window manager the desired size of window "id".

 w - the width
 h - the height

 Gives the window manager minimum and maximum size hints of the window
 "id". Also specify via "winc" and "hinc" the resize increments.

 wmin, hmin - specify the minimum window size
 wmax, hmax - specify the maximum window size
 winc, hinc - define an arithmetic progression of sizes into which
              the window to be resized (minimum to maximum)

 Sets the initial state of the window "id": either kNormalState
 or kIconicState.

 Tells window manager that the window "id" is a transient window
 of the window "main_id". A window manager may decide not to decorate
 a transient window or may treat it differently in other ways.

 Each character image, as defined by the font in the GC, is treated as an
 additional mask for a fill operation on the drawable.

 id   - the drawable
 gc   - the GC
 x, y - coordinates, which are relative to the origin of the specified
        drawable and define the origin of the first character
 s    - the character string
 len  - the number of characters in the string argument

 GC components in use: function, plane-mask, fill-style, font,
 subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.
 GC mode-dependent components: foreground, background, tile, stipple,
 tile-stipple-x-origin, and tile-stipple-y-origin.
 (see also the GCValues_t structure)

 Return lenght of the string "s" in pixels. Size depends on font.

 Returns the font properties.

 Returns the components specified by the mask in "gval" for the
 specified GC "gc" (see also the GCValues_t structure)

 Retrieves the associated font structure of the font specified font
 handle "fh".

 Free returned FontStruct_t using FreeFontStruct().

 Frees the font structure "fs". The font itself will be freed when
 no other resource references it.

 Clears the entire area in the specified window and it is equivalent to
 ClearArea(id, 0, 0, 0, 0)

 Converts the "keysym" to the appropriate keycode. For example,
 keysym is a letter and keycode is the matching keyboard key (which
 is dependend on the current keyboard mapping). If the specified
 "keysym" is not defined for any keycode, returns zero.

 Fills the specified rectangle defined by [x,y] [x+w,y] [x+w,y+h] [x,y+h].
 using the GC you specify.

 GC components in use are: function, plane-mask, fill-style,
 subwindow-mode, clip-x-origin, clip-y-origin, clip-mask.
 GC mode-dependent components: foreground, background, tile, stipple,
 tile-stipple-x-origin, and tile-stipple-y-origin.
 (see also the GCValues_t structure)

 Draws rectangle outlines of [x,y] [x+w,y] [x+w,y+h] [x,y+h]

 GC components in use: function, plane-mask, line-width, line-style,
 cap-style, join-style, fill-style, subwindow-mode, clip-x-origin,
 clip-y-origin, clip-mask.
 GC mode-dependent components: foreground, background, tile, stipple,
 tile-stipple-x-origin, tile-stipple-y-origin, dash-offset, dash-list.
 (see also the GCValues_t structure)

 Draws multiple line segments. Each line is specified by a pair of points.
 Segment_t *seg - specifies an array of segments
 Int_t nseg     - specifies the number of segments in the array

 GC components in use: function, plane-mask, line-width, line-style,
 cap-style, join-style, fill-style, subwindow-mode, clip-x-origin,
 clip-y-origin, clip-mask.
 GC mode-dependent components: foreground, background, tile, stipple,
 tile-stipple-x-origin, tile-stipple-y-origin, dash-offset, and dash-list.
 (see also the GCValues_t structure)

 Defines which input events the window is interested in. By default
 events are propageted up the window stack. This mask can also be
 set at window creation time via the SetWindowAttributes_t::fEventMask
 attribute.

 Returns the window id of the window having the input focus.

 Changes the input focus to specified window "id".

 Returns the window id of the current owner of the primary selection.
 That is the window in which, for example some text is selected.

 Makes the window "id" the current owner of the primary selection.
 That is the window in which, for example some text is selected.

 Causes a SelectionRequest event to be sent to the current primary
 selection owner. This event specifies the selection property
 (primary selection), the format into which to convert that data before
 storing it (target = XA_STRING), the property in which the owner will
 place the information (sel_property), the window that wants the
 information (id), and the time of the conversion request (when).
 The selection owner responds by sending a SelectionNotify event, which
 confirms the selected atom and type.

 Converts the keycode from the event structure to a key symbol (according
 to the modifiers specified in the event structure and the current
 keyboard mapping). In "buf" a null terminated ASCII string is returned
 representing the string that is currently mapped to the key code.

 event  - specifies the event structure to be used
 buf    - returns the translated characters
 buflen - the length of the buffer
 keysym - returns the "keysym" computed from the event
          if this argument is not NULL

 Translates coordinates in one window to the coordinate space of another
 window. It takes the "src_x" and "src_y" coordinates relative to the
 source window's origin and returns these coordinates to "dest_x" and
 "dest_y" relative to the destination window's origin.

 src            - the source window
 dest           - the destination window
 src_x, src_y   - coordinates within the source window
 dest_x, dest_y - coordinates within the destination window
 child          - returns the child of "dest" if the coordinates
                  are contained in a mapped child of the destination
                  window; otherwise, child is set to 0

 Returns the location and the size of window "id"

 x, y - coordinates of the upper-left outer corner relative to the
        parent window's origin
 w, h - the inside size of the window, not including the border

 Fills the region closed by the specified path. The path is closed
 automatically if the last point in the list does not coincide with
 the first point.

 Point_t *points - specifies an array of points
 Int_t npnt      - specifies the number of points in the array

 GC components in use: function, plane-mask, fill-style, fill-rule,
 subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.
 GC mode-dependent components: foreground, background, tile, stipple,
 tile-stipple-x-origin, and tile-stipple-y-origin.
 (see also the GCValues_t structure)

 Returns the root window the pointer is logically on and the pointer
 coordinates relative to the root window's origin.

 id             - specifies the window
 rotw           - the root window that the pointer is in
 childw         - the child window that the pointer is located in, if any
 root_x, root_y - the pointer coordinates relative to the root window's
                  origin
 win_x, win_y   - the pointer coordinates relative to the specified
                  window "id"
 mask           - the current state of the modifier keys and pointer
                  buttons

 Sets the foreground color for the specified GC (shortcut for ChangeGC
 with only foreground mask set).

 gc         - specifies the GC
 foreground - the foreground you want to set
 (see also the GCValues_t structure)

 Sets clipping rectangles in graphics context. [x,y] specify the origin
 of the rectangles. "recs" specifies an array of rectangles that define
 the clipping mask and "n" is the number of rectangles.
 (see also the GCValues_t structure)

 Flushes (mode = 0, default) or synchronizes (mode = 1) X output buffer.
 Flush flushes output buffer. Sync flushes buffer and waits till all
 requests have been processed by X server.

 Creates a new empty region.

 Destroys the region "reg".

 Updates the destination region from a union of the specified rectangle
 and the specified source region.

 rect - specifies the rectangle
 src  - specifies the source region to be used
 dest - returns the destination region

 Returns a region for the polygon defined by the points array.

 points  - specifies an array of points
 np      - specifies the number of points in the polygon
 winding - specifies the winding-rule is set (kTRUE) or not(kFALSE)

 Computes the union of two regions.

 rega, regb - specify the two regions with which you want to perform
              the computation
 result     - returns the result of the computation

 Computes the intersection of two regions.

 rega, regb - specify the two regions with which you want to perform
              the computation
 result     - returns the result of the computation

 Subtracts regb from rega and stores the results in result.

 Calculates the difference between the union and intersection of
 two regions.

 rega, regb - specify the two regions with which you want to perform
              the computation
 result     - returns the result of the computation

 Returns kTRUE if the region reg is empty.

 Returns kTRUE if the point [x, y] is contained in the region reg.

 Returns kTRUE if the two regions have the same offset, size, and shape.

 Returns smallest enclosing rectangle.

 Returns list of font names matching fontname regexp, like "-*-times-*".
 The pattern string can contain any characters, but each asterisk (*)
 is a wildcard for any number of characters, and each question mark (?)
 is a wildcard for a single character. If the pattern string is not in
 the Host Portable Character Encoding, the result is implementation
 dependent. Use of uppercase or lowercase does not matter. Each returned
 string is null-terminated.

 fontname - specifies the null-terminated pattern string that can
            contain wildcard characters
 max      - specifies the maximum number of names to be returned
 count    - returns the actual number of font names

 Frees the specified the array of strings "fontlist".

 Allocates the memory needed for an drawable.

 width  - the width of the image, in pixels
 height - the height of the image, in pixels

 Returns the width and height of the image id

 Overwrites the pixel in the image with the specified pixel value.
 The image must contain the x and y coordinates.

 id    - specifies the image
 x, y  - coordinates
 pixel - the new pixel value

 Combines an image with a rectangle of the specified drawable. The
 section of the image defined by the x, y, width, and height arguments
 is drawn on the specified part of the drawable.

 id   - the drawable
 gc   - the GC
 img  - the image you want combined with the rectangle
 dx   - the offset in X from the left edge of the image
 dy   - the offset in Y from the top edge of the image
 x, y - coordinates, which are relative to the origin of the
        drawable and are the coordinates of the subimage
 w, h - the width and height of the subimage, which define the
        rectangle dimensions

 GC components in use: function, plane-mask, subwindow-mode,
 clip-x-origin, clip-y-origin, and clip-mask.
 GC mode-dependent components: foreground and background.
 (see also the GCValues_t structure)

 Deallocates the memory associated with the image img

 Creates a GL window.

 Returns HDC.

 Creates a new OpenGL rendering context; if the function succeeds,
 the return value is a valid handle to an OpenGL rendering context.

 Deletes a specified OpenGL rendering context "ctx".

 Makes a specified OpenGL rendering context "ctx" the calling thread's
 current rendering context "wind".

 Swaps the front and back buffers in the overlay, underlay, and
 main planes of the window "wind".

 mode - specifies the overlay, underlay and main planes
        to be swapped

 Sets the viewport.

 x0, y0 - the lower-left corner of the viewport rectangle, in pixels
 x1, y1 - the width and height, respectively, of the viewport

 Specifies the clear value for the color-index buffers.

 fParam - the index used when the color-index buffers are cleared;
          the default value is zero.

 Specifies clear values for the color buffers. The default
 values are all zero.

 Specifies which color buffers are to be drawn into.

 mode - specifies up to four color buffers to be drawn into with
        the following acceptable symbolic constants:
        GL_NONE           - no color buffers are written
        GL_FRONT_LEFT     - only the front-left color buffer is written
        GL_FRONT_RIGHT    - only the front-right color buffer is written
        GL_BACK_LEFT      - only the back-left color buffer is written
        GL_BACK_RIGHT     - only the back-right color buffer is written
        GL_FRONT          - only the front-left and front-right color
                            buffers are written; if there is no
                            front-right color buffer, only the front
                            buffer left-color is written
        GL_BACK           - only the back-left and back-right color
                            buffers are written; if there is no back-right
                            color buffer, only the back-left color buffer
                            is written
        GL_LEFT           - only the front-left and back-left color
                            buffers are written; if there is no back-left
                            color buffer, only the front-left color buffer
                            is written
        GL_RIGHT          - only the front-right and back-right color
                            buffers are written; if there is no back-right
                            color buffer, only the front-right color
                            buffer is written
        GL_FRONT_AND_BACK - all the front and back color buffers
                            (front-left, front-right, back-left,
                            back-right) are written; if there are no back
                            color buffers, only the front-left and
                            front-right color buffers are written;
                            if there are no right color buffers, only
                            the front-left and back-left color buffers
                            are written; if there are no right or back
                            color buffers, only the front-left color
                            buffer is written

 Clears buffers to preset values.

 mode - indicates the buffers to be cleared
        GL_COLOR_BUFFER_BIT   - buffers currently enabled for color writing
        GL_DEPTH_BUFFER_BIT   - the depth buffer
        GL_ACCUM_BUFFER_BIT   - the accumulation buffer
        GL_STENCIL_BUFFER_BIT - the stencil buffer

 Disables various OpenGL graphics capabilities.

 mode - see TVirtualX::glEnable

 Enables various OpenGL graphics capabilities.

 mode - can assume one of the following values:
            GL_ALPHA_TEST - if enabled, do alpha testing
           GL_AUTO_NORMAL - if enabled, compute surface normal vectors
                            analytically when either GL_MAP2_VERTEX_3 or
                            GL_MAP2_VERTEX_4 has generated vertices
                 GL_BLEND - if enabled, blend the incoming RGBA color
                            values with the values in the color buffers
           GL_CLIP_PLANEi - if enabled, clip geometry against
                            user-defined clipping plane i
        GL_COLOR_LOGIC_OP - if enabled, apply the current logical
                            operation to the incoming RGBA color and
                            color buffer values
        GL_COLOR_MATERIAL - if enabled, have one or more material
                            parameters track the current color
             GL_CULL_FACE - if enabled, cull polygons based on their
                            winding in window coordinates
            GL_DEPTH_TEST - if enabled, do depth comparisons and
                            update the depth buffer
                GL_DITHER - if enabled, dither color components or
                            indexes before they are written to the
                            color buffer
                   GL_FOG - if enabled, blend a fog color into the
                            post-texturing color
        GL_INDEX_LOGIC_OP - if enabled, apply the current logical
                            operation to the incoming index and color
                            buffer indices
                GL_LIGHTi - if enabled, include light i in the
                            evaluation of the lighting equation
              GL_LIGHTING - if enabled, use the current lighting
                            parameters to compute the vertex color or
                            index. If disabled, associate the current
                            color or index with each vertex.
           GL_LINE_SMOOTH - if enabled, draw lines with correct
                            filtering; if disabled, draw aliased lines
          GL_LINE_STIPPLE - if enabled, use the current line stipple
                            pattern when drawing lines
              GL_LOGIC_OP - if enabled, apply the currently selected
                            logical operation to the incoming and
                            color-buffer indexes
          GL_MAP1_COLOR_4 - if enabled, calls to glEvalCoord1,
                            glEvalMesh1, and glEvalPoint1 generate
                            RGBA values
            GL_MAP1_INDEX - if enabled, calls to glEvalCoord1,
                            glEvalMesh1, and glEvalPoint1 generate
                            color indexes
           GL_MAP1_NORMAL - if enabled, calls to glEvalCoord1,
                            glEvalMesh1, and glEvalPoint1 generate
                            normals
  GL_MAP1_TEXTURE_COORD_1 - if enabled, calls to glEvalCoord1,
                            glEvalMesh1, and glEvalPoint1 generate
                            s texture coordinates
  GL_MAP1_TEXTURE_COORD_2 - if enabled, calls to glEvalCoord1,
                            glEvalMesh1, and glEvalPoint1 generate
                            s and t texture coordinates
  GL_MAP1_TEXTURE_COORD_3 - if enabled, calls to glEvalCoord1,
                            glEvalMesh1, and glEvalPoint1 generate
                            s, t, and r texture coordinates
  GL_MAP1_TEXTURE_COORD_4 - if enabled, calls to glEvalCoord1,
                            glEvalMesh1, and glEvalPoint1 generate
                            s, t, r, and q texture coordinates
         GL_MAP1_VERTEX_3 - if enabled, calls to glEvalCoord1,
                            glEvalMesh1, and glEvalPoint1 generate
                            x, y, and z vertex coordinates
         GL_MAP1_VERTEX_4 - if enabled, calls to glEvalCoord1,
                            glEvalMesh1, and glEvalPoint1 generate
                            homogeneous x, y, z, and w vertex
                            coordinates
          GL_MAP2_COLOR_4 - if enabled, calls to glEvalCoord2,
                            glEvalMesh2, and glEvalPoint2 generate
                            RGBA values
            GL_MAP2_INDEX - if enabled, calls to glEvalCoord2,
                            glEvalMesh2, and glEvalPoint2 generate
                            color indexes
           GL_MAP2_NORMAL - if enabled, calls to glEvalCoord2,
                            glEvalMesh2, and glEvalPoint2 generate
                            normals
  GL_MAP2_TEXTURE_COORD_1 - if enabled, calls to glEvalCoord2,
                            glEvalMesh2, and glEvalPoint2 generate
                            s texture coordinates
  GL_MAP2_TEXTURE_COORD_2 - if enabled, calls to glEvalCoord2,
                            glEvalMesh2, and glEvalPoint2 generate
                            s and t texture coordinates
  GL_MAP2_TEXTURE_COORD_3 - if enabled, calls to glEvalCoord2,
                            glEvalMesh2, and glEvalPoint2 generate
                            s, t, and r texture coordinates
  GL_MAP2_TEXTURE_COORD_4 - if enabled, calls to glEvalCoord2,
                            glEvalMesh2, and glEvalPoint2 generate
                            s, t, r, and q texture coordinates
         GL_MAP2_VERTEX_3 - if enabled, calls to glEvalCoord2,
                            glEvalMesh2, and glEvalPoint2 generate
                            x, y, and z vertex coordinates
         GL_MAP2_VERTEX_4 - if enabled, calls to glEvalCoord2,
                            glEvalMesh2, and glEvalPoint2 generate
                            homogeneous x, y, z, and w vertex
                            coordinates
             GL_NORMALIZE - if enabled, normal vectors specified with
                            glNormal are scaled to unit length after
                            transformation
          GL_POINT_SMOOTH - if enabled, draw points with proper
                            filtering; if disabled, draw aliased points
   GL_POLYGON_OFFSET_FILL - if enabled, and if the polygon is rendered
                            in GL_FILL mode, an offset is added to depth
                            values of a polygon's fragments before the
                            depth comparison is performed
   GL_POLYGON_OFFSET_LINE - if enabled, and if the polygon is rendered in
                            GL_LINE mode, an offset is added to depth
                            values of a polygon's fragments before the
                            depth comparison is performed
  GL_POLYGON_OFFSET_POINT - if enabled, an offset is added to depth values
                            of a polygon's fragments before the depth
                            comparison is performed, if the polygon is
                            rendered in GL_POINT mode
        GL_POLYGON_SMOOTH - if enabled, draw polygons with proper
                            filtering. If disabled, draw aliased polygons.
       GL_POLYGON_STIPPLE - if enabled, use the current polygon stipple
                            pattern when rendering polygons
          GL_SCISSOR_TEST - if enabled, discard fragments that are
                            outside the scissor rectangle
          GL_STENCIL_TEST - if enabled, do stencil testing and update the
                            stencil buffer
            GL_TEXTURE_1D - if enabled, one-dimensional texturing is
                            performed (unless two-dimensional
                            texturing is also enabled)
            GL_TEXTURE_2D - if enabled, two-dimensional texturing is
                            performed
         GL_TEXTURE_GEN_Q - if enabled, the q texture coordinate is
                            computed using the texture-generation
                            function defined with glTexGen; otherwise,
                            the current q texture coordinate is used
         GL_TEXTURE_GEN_R - if enabled, the r texture coordinate is
                            computed using the texture generation
                            function defined with glTexGen; if disabled,
                            the current r texture coordinate is used.
         GL_TEXTURE_GEN_S - if enabled, the s texture coordinate is
                            computed using the texture generation
                            function defined with glTexGen; if disabled,
                            the current s texture coordinate is used
         GL_TEXTURE_GEN_T - if enabled, the t texture coordinate is
                            computed using the texture generation
                            function defined with glTexGen; if disabled,
                            the current t texture coordinate is used

 Forces execution of OpenGL functions in finite time.

 Defines front- and back-facing polygons. In a scene composed entirely
 of opaque closed surfaces, back-facing polygons are never visible.
 Eliminating these invisible polygons has the obvious benefit of speeding
 up the rendering of the image. You enable and disable elimination of
 back-facing polygons with glEnable and glDisable using argument
 GL_CULL_FACE.

 mode - the orientation of front-facing polygons
        GL_CW  - selects clockwise polygons as front-facing
        GL_CCW - counterclockwise polygons as front-facing
                 the default value is GL_CCW

 Creates a display list.

 list - the display list name
 mode - the compilation mode
        GL_COMPILE             - commands are merely compiled
        GL_COMPILE_AND_EXECUTE - commands are executed as they
                                 are compiled into the display list

 Returns the Boolean value or values of the specified parameter "mode".

 Returns the double value or values of the specified parameter "mode".

 Returns the float value or values of the specified parameter "mode".

 Returns the integer value or values of the specified parameter "mode".

 Returns error information.

 Replaces a display list.

 Delimits the vertices of a primitive or a group of primitives.

 mode - the primitive or primitives that will be created from vertices
        The following are accepted symbolic constants and their meanings:
        GL_POINTS        - treats each vertex as a single point; vertex n
                           defines point n. N points are drawn.
        GL_LINES         - treats each pair of vertices as an independent
                           line segment. Vertices 2n-1 and 2n define
                           line n. N/2 lines are drawn.

       GL_LINE_STRIP     - draws a connected group of line segments from
                           the first vertex to the last. Vertices n and
                           n+1 define line n. N-1 lines are drawn.
       GL_LINE_LOOP      - draws a connected group of line segments
                           from the first vertex to the last, then back
                           to the first; vertices n and n+1 define line n;
                           the last line, however, is defined by vertices
                           N and 1. N lines are drawn.
       GL_TRIANGLES      - treats each triplet of vertices as an
                           independenttriangle; vertices 3n-2, 3n-1,
                           and 3n define triangle n.
                           N/3 triangles are drawn.
       GL_TRIANGLE_STRIP - draws a connected group of triangles;
                           one triangle is defined for each vertex
                           presented after the first two vertices.
                           For odd n, vertices n, n+1, and n+2
                           define triangle n. For even n, vertices n+1,
                           n, and n+2 define triangle n.
                           N 2 triangles are drawn.
       GL_TRIANGLE_FAN   - draws a connected group of triangles.
                           One triangle is defined for each vertex
                           presented after the first two vertices.
                           Vertices 1, n+1, and n+2 define triangle n.
                           N 2 triangles are drawn.
       GL_QUADS          - treats each group of four vertices as an
                           independent quadrilateral. Vertices 4n-3,
                           4n-2, 4n-1, and 4n define quadrilateral n.
                           N/4 quadrilaterals are drawn.
       GL_QUAD_STRIP     - draws a connected group of quadrilaterals.
                           One quadrilateral is defined for each pair of
                           vertices presented after the first pair.
                           Vertices 2n-1, 2n, 2n+2, and 2n+1 define
                           quadrilateral n. N quadrilaterals are drawn.
                           Note that the order in which vertices are used
                           to construct a quadrilateral from strip data
                           is different from that used with independent
                           data.
       GL_POLYGON        - draws a single, convex polygon. Vertices 1
                           through N define this polygon.

 Ends the vertices of a primitive or a group of primitives.
 See TVirtualX::glBegin

 Pushes the current matrix stack.

 Pops the current matrix stack.

 Computes a matrix that performs a counterclockwise rotation of "angle"
 degrees about the vector from the origin through the point (x,y,z).

 angle   - the angle of rotation, in degrees
 x, y, z - vector coordinates

 Produces the translation specified by (x,y,z).
 The translation vector is used to compute a 4x4 translation matrix:
     | 1  0  0  x |
     | 0  1  0  y |
     | 0  0  1  z |
     | 0  0  0  1 |
 The current matrix is multiplied by this translation matrix, with the
 product replacing the current matrix.

 Multiplies the current matrix by the one specified in "matrix".
 The product replaces the current matrix.

 Sets the current color to "color"

 color - an array that contains red, green, blue values

 Specifies a vertex with coordinates (x, y, z).

 Specifies a vertex with coordinates (x, y, z).

 vert - a pointer to an array of three elements (x,y,z)

 Sets the current color index to "index".

 Sets the diameter of rasterized points to "size". The default is 1.0.

 Sets the width of rasterized lines to "width". The default is 1.0.

 Deletes a contiguous group of display lists.

 list  - the name of the first display list to delete
 sizei - the number of display lists to delete

 Generates a contiguous set of empty display lists. Returns a number
 of generated empty display lists; or 0 if no display lists are generated

 list - the number of contiguous empty display lists to be generated.

 Executes a display list "list".

 Sets the current matrix.

 mode - specifies the  matrix stack that is the target for subsequent
        matrix operations:
        GL_MODELVIEW  - applies subsequent matrix operations to
                        the modelview matrix stack
        GL_PROJECTION - applies subsequent matrix operations to
                        the projection matrix stack
        GL_TEXTURE    - applies subsequent matrix operations to
                        the texture matrix stack

 Replaces the current matrix with the identity matrix.

 Multiplies the current matrix by a perspective matrix that produces
 a perspective projection.

 min_0, max_0 - the left- and right-vertical clipping plane coordinates
 min_1, max_1 - the bottom- and top-horizontal clipping plane coordinates
 dnear, dfar  - the near- and far-depth clipping plane distances (must be
                positive)

 The corresponding matrix is:
        | E  0  A  0 |
        | 0  F  B  0 |
        | 0  0  C  D |
        | 0  0 -1  0 |
 where
        E = (2*near)/(max_0 - min_0)
        F = (2*near)/(max_1 - min_1)
        A = (min_0 + max_0)/(max_0 - min_0)
        B = (min_1 + max_1)/(max_1 - min_1)
        C = (dfar + dnear)/(dfar - dnear)
        D = (2*dfar*dnear)/(dfar - dnear)

 The current matrix is multiplied by this matrix with the result
 replacing the current matrix.

 Multiplies the current matrix by an orthographic matrix.

 min_0, max_0 - the left- and right-vertical clipping plane coordinates
 min_1, max_1 - the bottom- and top-horizontal clipping plane coordinates
 dnear, dfar  - the near- and far-depth clipping plane distances (these
                distances are negative if the plane is to be behind the
                viewer)

 The corresponding matrix is:
        | E  0  0  A |
        | 0  F  0  B |
        | 0  0  G  C |
        | 0  0  0 -1 |
 where
        E = 2/(max_0 - min_0)
        F = 2/(max_1 - min_1)
        G = -2/(dfar - dnear)
        A = (min_0 + max_0)/(max_0 - min_0)
        B = (min_1 + max_1)/(max_1 - min_1)
        C = (dfar + dnear)/(dfar - dnear)

 The current matrix is multiplied by this matrix with the result
 replacing the current matrix.

 Specifies whether front- or back-facing facets can be culled.

 mode - specifies the whether front- or back-facing facets are candidates
        for culling. The symbolic constants GL_FRONT, GL_BACK,
        and GL_FRONT_AND_BACK are accepted.
        The default value is GL_BACK.

 Controls the interpretation of polygons for rasterization.
 The "face" parameter describes which polygons mode applies to:
 front-facing polygons (GL_FRONT), back-facing polygons (GL_BACK),
 or both (GL_FRONT_AND_BACK). The polygon mode affects only the final
 rasterization of polygons. In particular, a polygon's vertices are
 lit and the polygon is clipped and possibly culled before these modes
 are applied. To draw a surface with filled back-facing polygons and
 outlined front-facing polygons, call
        glPolygonMode(GL_FRONT, GL_LINE);

 face - the polygons that mode applies to
        GL_FRONT          for front-facing polygons
        GL_BACK           for back-facing polygons
        GL_FRONT_AND_BACK for front- and back-facing polygons
 mode - sets the way polygons will be rasterized
        GL_POINT - polygon vertices that are marked as the start of
                   a boundary edge are drawn as points. Point
                   attributes such as GL_POINT_SIZE and
                   GL_POINT_SMOOTH control the rasterization of the
                   points. Polygon rasterization attributes other
                   than GL_POLYGON_MODE have no effect
        GL_LINE  - boundary edges of the polygon are drawn as line
                   segments. They are treated as connected line
                   segments for line stippling; the line stipple
                   counter and pattern are not reset between segments
                   Line attributes such as GL_LINE_WIDTH and
                   GL_LINE_SMOOTH control the rasterization of the
                   lines. Polygon rasterization attributes other
                   than GL_POLYGON_MODE have no effect.
        GL_FILL  - the interior of the polygon is filled.
                   Polygon attributes such as GL_POLYGON_STIPPLE and
                   GL_POLYGON_SMOOTH control the rasterization

 Replaces the current matrix with the specified "matrix".

 Selects flat or smooth shading.

 mode - sets a shading technique:
        GL_FLAT   - flat
        GL_SMOOTH - smooth (default)

 Sets the current normal vector.

 norm - a pointer to an array of three elements: the x, y, z coordinates
        of the new current normal

Inline Functions

                   TVirtualX TVirtualX(const char* name, const char* title)
        TVirtualX::EDrawMode GetDrawMode()
                     TClass* Class()
                     TClass* IsA() const
                        void ShowMembers(TMemberInspector& insp, char* parent)
                        void Streamer(TBuffer& b)
                        void StreamerNVirtual(TBuffer& b)
                   TVirtualX TVirtualX(const TVirtualX&)
                        void ~TVirtualX()