// @(#)root/base:$Name: $:$Id: TVirtualX.cxx,v 1.12 2004/10/20 22:32:45 brun Exp $
// Author: Fons Rademakers 3/12/95
/*************************************************************************
* 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. *
*************************************************************************/
//////////////////////////////////////////////////////////////////////////
// //
// 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. //
// //
//////////////////////////////////////////////////////////////////////////
#include "TVirtualX.h"
#include "TString.h"
Atom_t gWM_DELETE_WINDOW;
Atom_t gMOTIF_WM_HINTS;
Atom_t gROOT_MESSAGE;
TVirtualX *gGXBatch; //Global pointer to batch graphics interface
TVirtualX* (*gPtr2VirtualX)() = 0; // returns pointer to global object
void (*gDrawDIB)(ULong_t bmi, ULong_t bmbits, Int_t xpos, Int_t ypos) = 0;
unsigned char *(*gGetBmBits)(Drawable_t wid, Int_t w, Int_t h) = 0;
Pixmap_t (*gDIB2Pixmap)(ULong_t bmbits, ULong_t bmi) = 0;
ClassImp(TVirtualX)
//______________________________________________________________________________
TVirtualX::TVirtualX(const char *name, const char *title) : TNamed(name, title),
TAttLine(1,1,1),TAttFill(1,1),TAttText(11,0,1,62,0.01), TAttMarker(1,1,1)
{
// Ctor of ABC
}
//______________________________________________________________________________
TVirtualX *&TVirtualX::Instance()
{
// Returns gVirtualX global
static TVirtualX *instance = 0;
if (gPtr2VirtualX) instance = gPtr2VirtualX();
return instance;
}
//______________________________________________________________________________
void TVirtualX::GetWindowAttributes(Window_t /*id*/, WindowAttributes_t &attr)
{
// The WindowAttributes_t structure is set to default.
attr.fX = attr.fY = 0;
attr.fWidth = attr.fHeight = 0;
attr.fVisual = 0;
attr.fMapState = kIsUnmapped;
attr.fScreen = 0;
}
//______________________________________________________________________________
Bool_t TVirtualX::ParseColor(Colormap_t /*cmap*/, const char * /*cname*/,
ColorStruct_t &color)
{
// 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.
color.fPixel = 0;
color.fRed = 0;
color.fGreen = 0;
color.fBlue = 0;
color.fMask = kDoRed | kDoGreen | kDoBlue;
return kTRUE;
}
//______________________________________________________________________________
Bool_t TVirtualX::AllocColor(Colormap_t /*cmap*/, ColorStruct_t &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
color.fPixel = 0;
return kTRUE;
}
//______________________________________________________________________________
void TVirtualX::QueryColor(Colormap_t /*cmap*/, ColorStruct_t &color)
{
// 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
color.fRed = color.fGreen = color.fBlue = 0;
}
//______________________________________________________________________________
void TVirtualX::NextEvent(Event_t &event)
{
// The "event" is set to default event.
// This method however, should never be called.
event.fType = kButtonPress;
event.fWindow = 0;
event.fTime = 0;
event.fX = 0;
event.fY = 0;
event.fXRoot = 0;
event.fYRoot = 0;
event.fState = 0;
event.fCode = 0;
event.fWidth = 0;
event.fHeight = 0;
event.fCount = 0;
}
//______________________________________________________________________________
void TVirtualX::GetPasteBuffer(Window_t /*id*/, Atom_t /*atom*/, TString &text,
Int_t &nchar, Bool_t /*del*/)
{
// Gets contents of the paste buffer "atom" into the string "text".
// (nchar = number of characters) If "del" is true deletes the paste
// buffer afterwards.
text = "";
nchar = 0;
}
//______________________________________________________________________________
Bool_t TVirtualX::Init(void * /*display*/)
{
// Initializes the X system. Returns kFALSE in case of failure.
// It is implementation dependent.
return kFALSE;
}
//______________________________________________________________________________
void TVirtualX::ClearWindow()
{
// Clears the entire area of the current window.
}
//______________________________________________________________________________
void TVirtualX::CloseWindow()
{
// Deletes current window.
}
//______________________________________________________________________________
void TVirtualX::ClosePixmap()
{
// Deletes current pixmap.
}
//______________________________________________________________________________
void TVirtualX::CopyPixmap(Int_t /*wid*/, Int_t /*xpos*/, Int_t /*ypos*/)
{
// Copies the pixmap "wid" at the position [xpos,ypos] in the current window.
}
//______________________________________________________________________________
void TVirtualX::CreateOpenGLContext(Int_t /*wid*/)
{
// Creates OpenGL context for window "wid"
}
//______________________________________________________________________________
void TVirtualX::DeleteOpenGLContext(Int_t /*wid*/)
{
// Deletes OpenGL context for window "wid"
}
//______________________________________________________________________________
void TVirtualX::DrawBox(Int_t /*x1*/, Int_t /*y1*/, Int_t /*x2*/, Int_t /*y2*/,
EBoxMode /*mode*/)
{
// Draws a box between [x1,y1] and [x2,y2] according to the "mode".
//
// mode - drawing mode:
// mode = 0 hollow (kHollow)
// mode = 1 solid (kSolid)
}
//______________________________________________________________________________
void TVirtualX::DrawCellArray(Int_t /*x1*/, Int_t /*y1*/,
Int_t /*x2*/, Int_t /*y2*/,
Int_t /*nx*/, Int_t /*ny*/, Int_t * /*ic*/)
{
// 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
}
//______________________________________________________________________________
void TVirtualX::DrawFillArea(Int_t /*n*/, TPoint * /*xy*/)
{
// Fills area described by the polygon.
//
// n - number of points
// xy(2,n) - list of points
}
//______________________________________________________________________________
void TVirtualX::DrawLine(Int_t /*x1*/, Int_t /*y1*/, Int_t /*x2*/, Int_t /*y2*/)
{
// Draws a line.
//
// x1,y1 - begin of line
// x2,y2 - end of line
}
//______________________________________________________________________________
void TVirtualX::DrawPolyLine(Int_t /*n*/, TPoint * /*xy*/)
{
// Draws a line through all points in the list.
//
// n - number of points
// xy - list of points
}
//______________________________________________________________________________
void TVirtualX::DrawPolyMarker(Int_t /*n*/, TPoint * /*xy*/)
{
// 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
}
//______________________________________________________________________________
void TVirtualX::DrawText(Int_t /*x*/, Int_t /*y*/, Float_t /*angle*/,
Float_t /*mgn*/, const char * /*text*/,
ETextMode /*mode*/)
{
// 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)
}
//______________________________________________________________________________
UInt_t TVirtualX::ExecCommand(TGWin32Command * /*code*/)
{
// Executes the command "code" coming from the other threads (Win32)
return 0;
}
//______________________________________________________________________________
Int_t TVirtualX::GetDoubleBuffer(Int_t /*wid*/)
{
// Queries the double buffer value for the window "wid".
return 0;
}
//______________________________________________________________________________
void TVirtualX::GetCharacterUp(Float_t &chupx, Float_t &chupy)
{
// Returns character up vector.
chupx = chupy = 0;
}
//______________________________________________________________________________
void TVirtualX::GetGeometry(Int_t /*wid*/, Int_t &x, Int_t &y,
UInt_t &w, UInt_t &h)
{
// 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
x = y = 0;
w = h = 0;
}
//______________________________________________________________________________
const char *TVirtualX::DisplayName(const char *)
{
// Returns hostname on which the display is opened.
return "batch";
}
//______________________________________________________________________________
Handle_t TVirtualX::GetNativeEvent() const
{
// Returns the current native event handle.
return 0;
}
//______________________________________________________________________________
ULong_t TVirtualX::GetPixel(Color_t /*cindex*/)
{
// Returns pixel value associated to specified ROOT color number "cindex".
return 0;
}
//______________________________________________________________________________
void TVirtualX::GetPlanes(Int_t &nplanes)
{
// Returns the maximum number of planes.
nplanes = 0;
}
//______________________________________________________________________________
void TVirtualX::GetRGB(Int_t /*index*/, Float_t &r, Float_t &g, Float_t &b)
{
// Returns RGB values for color "index".
r = g = b = 0;
}
//______________________________________________________________________________
void TVirtualX::GetTextExtent(UInt_t &w, UInt_t &h, char * /*mess*/)
{
// Returns the size of the specified character string "mess".
//
// w - the text width
// h - the text height
// mess - the string
w = h = 0;
}
//______________________________________________________________________________
Float_t TVirtualX::GetTextMagnitude()
{
// Returns the current font magnification factor
return 0;
}
//______________________________________________________________________________
Bool_t TVirtualX::HasTTFonts() const
{
// Returns True when TrueType fonts are used
return kFALSE;
}
//______________________________________________________________________________
Window_t TVirtualX::GetWindowID(Int_t /*wid*/)
{
// Returns the X11 window identifier.
//
// wid - workstation identifier (input)
return 0;
}
//______________________________________________________________________________
Int_t TVirtualX::InitWindow(ULong_t /*window*/)
{
// Creates a new window and return window number.
// Returns -1 if window initialization fails.
return 0;
}
//______________________________________________________________________________
Int_t TVirtualX::AddWindow(ULong_t /*qwid*/, UInt_t /*w*/, UInt_t /*h*/)
{
// Registers a window created by Qt as a ROOT window
//
// w, h - the width and height, which define the window size
return 0;
}
//______________________________________________________________________________
void TVirtualX::RemoveWindow(ULong_t /*qwid*/)
{
// Removes the created by Qt window "qwid".
}
//______________________________________________________________________________
void TVirtualX::MoveWindow(Int_t /*wid*/, Int_t /*x*/, Int_t /*y*/)
{
// 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.
}
//______________________________________________________________________________
Int_t TVirtualX::OpenPixmap(UInt_t /*w*/, UInt_t /*h*/)
{
// Creates a pixmap of the width "w" and height "h" you specified.
return 0;
}
//______________________________________________________________________________
void TVirtualX::QueryPointer(Int_t &ix, Int_t &iy)
{
// Returns the pointer position.
ix = iy = 0;
}
//______________________________________________________________________________
Pixmap_t TVirtualX::ReadGIF(Int_t /*x0*/, Int_t /*y0*/, const char * /*file*/,
Window_t /*id*/)
{
// If id is NULL - loads the specified gif file at position [x0,y0] in the
// current window. Otherwise creates pixmap from gif file
return 0;
}
//______________________________________________________________________________
Int_t TVirtualX::RequestLocator(Int_t /*mode*/, Int_t /*ctyp*/,
Int_t &x, Int_t &y)
{
// 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)
x = y = 0;
return 0;
}
//______________________________________________________________________________
Int_t TVirtualX::RequestString(Int_t /*x*/, Int_t /*y*/, char *text)
{
// 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)
if (text) *text = 0;
return 0;
}
//______________________________________________________________________________
void TVirtualX::RescaleWindow(Int_t /*wid*/, UInt_t /*w*/, UInt_t /*h*/)
{
// Rescales the window "wid".
//
// wid - window identifier
// w - the width
// h - the heigth
}
//______________________________________________________________________________
Int_t TVirtualX::ResizePixmap(Int_t /*wid*/, UInt_t /*w*/, UInt_t /*h*/)
{
// Resizes the specified pixmap "wid".
//
// w, h - the width and height which define the pixmap dimensions
return 0;
}
//______________________________________________________________________________
void TVirtualX::ResizeWindow(Int_t /*wid*/)
{
// Resizes the window "wid" if necessary.
}
//______________________________________________________________________________
void TVirtualX::SelectWindow(Int_t /*wid*/)
{
// Selects the window "wid" to which subsequent output is directed.
}
//______________________________________________________________________________
void TVirtualX::SelectPixmap(Int_t /*qpixid*/)
{
// Selects the pixmap "qpixid".
}
//______________________________________________________________________________
void TVirtualX::SetCharacterUp(Float_t /*chupx*/, Float_t /*chupy*/)
{
// Sets character up vector.
}
//______________________________________________________________________________
void TVirtualX::SetClipOFF(Int_t /*wid*/)
{
// Turns off the clipping for the window "wid".
}
//______________________________________________________________________________
void TVirtualX::SetClipRegion(Int_t /*wid*/, Int_t /*x*/, Int_t /*y*/,
UInt_t /*w*/, UInt_t /*h*/)
{
// Sets clipping region for the window "wid".
//
// wid - window indentifier
// x, y - origin of clipping rectangle
// w, h - the clipping rectangle dimensions
}
//______________________________________________________________________________
void TVirtualX::SetCursor(Int_t /*win*/, ECursor /*cursor*/)
{
// The cursor "cursor" will be used when the pointer is in the
// window "wid".
}
//______________________________________________________________________________
void TVirtualX::SetDoubleBuffer(Int_t /*wid*/, Int_t /*mode*/)
{
// 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
}
//______________________________________________________________________________
void TVirtualX::SetDoubleBufferOFF()
{
// Turns double buffer mode off.
}
//______________________________________________________________________________
void TVirtualX::SetDoubleBufferON()
{
// Turns double buffer mode on.
}
//______________________________________________________________________________
void TVirtualX::SetDrawMode(EDrawMode /*mode*/)
{
// 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
}
//______________________________________________________________________________
void TVirtualX::SetFillColor(Color_t /*cindex*/)
{
// Sets color index "cindex" for fill areas.
}
//______________________________________________________________________________
void TVirtualX::SetFillStyle(Style_t /*style*/)
{
// Sets fill area style.
//
// style - compound fill area interior style
// style = 1000 * interiorstyle + styleindex
}
//______________________________________________________________________________
void TVirtualX::SetLineColor(Color_t /*cindex*/)
{
// Sets color index "cindex" for drawing lines.
}
//______________________________________________________________________________
void TVirtualX::SetLineType(Int_t /*n*/, Int_t * /*dash*/)
{
// 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
}
//______________________________________________________________________________
void TVirtualX::SetLineStyle(Style_t /*linestyle*/)
{
// Sets the line style.
//
// linestyle <= 1 solid
// linestyle = 2 dashed
// linestyle = 3 dotted
// linestyle = 4 dashed-dotted
}
//______________________________________________________________________________
void TVirtualX::SetLineWidth(Width_t /*width*/)
{
// Sets the line width.
//
// width - the line width in pixels
}
//______________________________________________________________________________
void TVirtualX::SetMarkerColor(Color_t /*cindex*/)
{
// Sets color index "cindex" for markers.
}
//______________________________________________________________________________
void TVirtualX::SetMarkerSize(Float_t /*markersize*/)
{
// Sets marker size index.
//
// markersize - the marker scale factor
}
//______________________________________________________________________________
void TVirtualX::SetMarkerStyle(Style_t /*markerstyle*/)
{
// Sets marker style.
}
//______________________________________________________________________________
void TVirtualX::SetOpacity(Int_t /*percent*/)
{
// 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).
}
//______________________________________________________________________________
void TVirtualX::SetRGB(Int_t /*cindex*/, Float_t /*r*/, Float_t /*g*/,
Float_t /*b*/)
{
// 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
}
//______________________________________________________________________________
void TVirtualX::SetTextAlign(Short_t /*talign*/)
{
// Sets the text alignment.
//
// talign = txalh horizontal text alignment
// talign = txalv vertical text alignment
}
//______________________________________________________________________________
void TVirtualX::SetTextColor(Color_t /*cindex*/)
{
// Sets the color index "cindex" for text.
}
//______________________________________________________________________________
Int_t TVirtualX::SetTextFont(char * /*fontname*/, ETextSetMode /*mode*/)
{
// 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)
return 0;
}
//______________________________________________________________________________
void TVirtualX::SetTextFont(Font_t /*fontnumber*/)
{
// Sets the current text font number.
}
//______________________________________________________________________________
void TVirtualX::SetTextMagnitude(Float_t /*mgn*/)
{
// Sets the current text magnification factor to "mgn"
}
//______________________________________________________________________________
void TVirtualX::SetTextSize(Float_t /*textsize*/)
{
// Sets the current text size to "textsize"
}
//______________________________________________________________________________
void TVirtualX::UpdateWindow(Int_t /*mode*/)
{
// Updates or synchronises client and server once (not permanent).
// according to "mode".
// mode = 1 update
// mode = 0 sync
}
//______________________________________________________________________________
void TVirtualX::Warp(Int_t /*ix*/, Int_t /*iy*/, Window_t /*id*/)
{
// Sets the pointer position.
// ix - new X coordinate of pointer
// iy - new Y coordinate of pointer
// Coordinates are relative to the origin of the window id
// or to the origin of the current window if id == 0.
}
//______________________________________________________________________________
Int_t TVirtualX::WriteGIF(char * /*name*/)
{
// Writes the current window into GIF file.
// Returns 1 in case of success, 0 otherwise.
return 0;
}
//______________________________________________________________________________
void TVirtualX::WritePixmap(Int_t /*wid*/, UInt_t /*w*/, UInt_t /*h*/,
char * /*pxname*/)
{
// 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
}
//---- Methods used for GUI -----
//______________________________________________________________________________
void TVirtualX::MapWindow(Window_t /*id*/)
{
// 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.
}
//______________________________________________________________________________
void TVirtualX::MapSubwindows(Window_t /*id*/)
{
// Maps all subwindows for the specified window "id" in top-to-bottom
// stacking order.
}
//______________________________________________________________________________
void TVirtualX::MapRaised(Window_t /*id*/)
{
// 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.
}
//______________________________________________________________________________
void TVirtualX::UnmapWindow(Window_t /*id*/)
{
// 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.
}
//______________________________________________________________________________
void TVirtualX::DestroyWindow(Window_t /*id*/)
{
// 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.
}
//______________________________________________________________________________
void TVirtualX::DestroySubwindows(Window_t /*id*/)
{
// The DestroySubwindows function destroys all inferior windows of the
// specified window, in bottom-to-top stacking order.
}
//______________________________________________________________________________
void TVirtualX::RaiseWindow(Window_t /*id*/)
{
// Raises the specified window to the top of the stack so that no
// sibling window obscures it.
}
//______________________________________________________________________________
void TVirtualX::LowerWindow(Window_t /*id*/)
{
// Lowers the specified window "id" to the bottom of the stack so
// that it does not obscure any sibling windows.
}
//______________________________________________________________________________
void TVirtualX::MoveWindow(Window_t /*id*/, Int_t /*x*/, Int_t /*y*/)
{
// 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.
}
//______________________________________________________________________________
void TVirtualX::MoveResizeWindow(Window_t /*id*/, Int_t /*x*/, Int_t /*y*/,
UInt_t /*w*/, UInt_t /*h*/)
{
// 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
}
//______________________________________________________________________________
void TVirtualX::ResizeWindow(Window_t /*id*/, UInt_t /*w*/, UInt_t /*h*/)
{
// 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.
}
//______________________________________________________________________________
void TVirtualX::IconifyWindow(Window_t /*id*/)
{
// Iconifies the window "id".
}
//______________________________________________________________________________
void TVirtualX::ReparentWindow(Window_t /*id*/, Window_t /*pid*/,
Int_t /*x*/, Int_t /*y*/)
{
// If the specified window is mapped, ReparentWindow automatically
// performs an UnmapWindow request on it, removes it from its current
// position in the hierarchy, and inserts it as the child of the specified
// parent. The window is placed in the stacking order on top with respect
// to sibling windows.
}
//______________________________________________________________________________
void TVirtualX::SetWindowBackground(Window_t /*id*/, ULong_t /*color*/)
{
// 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.
}
//______________________________________________________________________________
void TVirtualX::SetWindowBackgroundPixmap(Window_t /*id*/, Pixmap_t /*pxm*/)
{
// Sets the background pixmap of the window "id" to the specified
// pixmap "pxm".
}
//______________________________________________________________________________
Window_t TVirtualX::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*/)
{
// 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
return 0;
}
//______________________________________________________________________________
Int_t TVirtualX::OpenDisplay(const char * /*dpyName*/)
{
// 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).
return 0;
}
//______________________________________________________________________________
void TVirtualX::CloseDisplay()
{
// Closes connection to display server and destroys all windows.
}
//______________________________________________________________________________
Display_t TVirtualX::GetDisplay() const
{
// Returns handle to display (might be usefull in some cases where
// direct X11 manipulation outside of TVirtualX is needed, e.g. GL
// interface).
return 0;
}
//______________________________________________________________________________
Visual_t TVirtualX::GetVisual() const
{
// Returns handle to visual.
//
// Might be usefull in some cases where direct X11 manipulation outside
// of TVirtualX is needed, e.g. GL interface.
return 0;
}
//______________________________________________________________________________
Int_t TVirtualX::GetScreen() const
{
// Returns screen number.
//
// Might be usefull in some cases where direct X11 manipulation outside
// of TVirtualX is needed, e.g. GL interface.
return 0;
}
//______________________________________________________________________________
Int_t TVirtualX::GetDepth() const
{
// Returns depth of screen (number of bit planes).
// Equivalent to GetPlanes().
return 0;
}
//______________________________________________________________________________
Colormap_t TVirtualX::GetColormap() const
{
// Returns handle to colormap.
//
// Might be usefull in some cases where direct X11 manipulation outside
// of TVirtualX is needed, e.g. GL interface.
return 0;
}
//______________________________________________________________________________
Window_t TVirtualX::GetDefaultRootWindow() const
{
// Returns handle to the default root window created when calling
// XOpenDisplay().
return 0;
}
//______________________________________________________________________________
Atom_t TVirtualX::InternAtom(const char * /*atom_name*/,
Bool_t /*only_if_exist*/)
{
// 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.
return 0;
}
//______________________________________________________________________________
Window_t TVirtualX::GetParent(Window_t /*id*/) const
{
// Returns the parent of the window "id".
return 0;
}
//______________________________________________________________________________
FontStruct_t TVirtualX::LoadQueryFont(const char * /*font_name*/)
{
// 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.
return 0;
}
//______________________________________________________________________________
FontH_t TVirtualX::GetFontHandle(FontStruct_t /*fs*/)
{
// Returns the font handle of the specified font structure "fs".
return 0;
}
//______________________________________________________________________________
void TVirtualX::DeleteFont(FontStruct_t /*fs*/)
{
// Explicitely deletes the font structure "fs" obtained via LoadQueryFont().
}
//______________________________________________________________________________
GContext_t TVirtualX::CreateGC(Drawable_t /*id*/, GCValues_t * /*gval*/)
{
// 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.
return 0;
}
//______________________________________________________________________________
void TVirtualX::ChangeGC(GContext_t /*gc*/, GCValues_t * /*gval*/)
{
// 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)
}
//______________________________________________________________________________
void TVirtualX::CopyGC(GContext_t /*org*/, GContext_t /*dest*/, Mask_t /*mask*/)
{
// 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.
}
//______________________________________________________________________________
void TVirtualX::DeleteGC(GContext_t /*gc*/)
{
// Deletes the specified GC "gc".
}
//______________________________________________________________________________
Cursor_t TVirtualX::CreateCursor(ECursor /*cursor*/)
{
// 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
return 0;
}
//______________________________________________________________________________
void TVirtualX::SetCursor(Window_t /*id*/, Cursor_t /*curid*/)
{
// Sets the cursor "curid" to be used when the pointer is in the
// window "id".
}
//______________________________________________________________________________
Pixmap_t TVirtualX::CreatePixmap(Drawable_t /*id*/, UInt_t /*w*/, UInt_t /*h*/)
{
// Creates a pixmap of the specified width and height and returns
// a pixmap ID that identifies it.
return kNone;
}
//______________________________________________________________________________
Pixmap_t TVirtualX::CreatePixmap(Drawable_t /*id*/, const char * /*bitmap*/,
UInt_t /*width*/, UInt_t /*height*/,
ULong_t /*forecolor*/, ULong_t /*backcolor*/,
Int_t /*depth*/)
{
// 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
return 0;
}
//______________________________________________________________________________
Pixmap_t TVirtualX::CreateBitmap(Drawable_t /*id*/, const char * /*bitmap*/,
UInt_t /*width*/, UInt_t /*height*/)
{
// 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
return 0;
}
//______________________________________________________________________________
void TVirtualX::DeletePixmap(Pixmap_t /*pmap*/)
{
// Explicitely deletes the pixmap resource "pmap".
}
//______________________________________________________________________________
Bool_t TVirtualX::CreatePictureFromFile(Drawable_t /*id*/,
const char * /*filename*/,
Pixmap_t &/*pict*/,
Pixmap_t &/*pict_mask*/,
PictureAttributes_t &/*attr*/)
{
// 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.
return kFALSE;
}
//______________________________________________________________________________
Bool_t TVirtualX::CreatePictureFromData(Drawable_t /*id*/, char ** /*data*/,
Pixmap_t &/*pict*/,
Pixmap_t &/*pict_mask*/,
PictureAttributes_t & /*attr*/)
{
// 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.
return kFALSE;
}
//______________________________________________________________________________
Bool_t TVirtualX::ReadPictureDataFromFile(const char * /*filename*/,
char *** /*ret_data*/)
{
// Reads picture data from file "filename" and store it in "ret_data".
// Returns kTRUE in case of success, kFALSE otherwise.
return kFALSE;
}
//______________________________________________________________________________
void TVirtualX::DeletePictureData(void * /*data*/)
{
// Delete picture data created by the function ReadPictureDataFromFile.
}
//______________________________________________________________________________
void TVirtualX::SetDashes(GContext_t /*gc*/, Int_t /*offset*/,
const char * /*dash_list*/, Int_t /*n*/)
{
// 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)
}
//______________________________________________________________________________
void TVirtualX::FreeColor(Colormap_t /*cmap*/, ULong_t /*pixel*/)
{
// Frees color cell with specified pixel value.
}
//______________________________________________________________________________
Int_t TVirtualX::EventsPending()
{
// Returns the number of events that have been received from the X server
// but have not been removed from the event queue.
return 0;
}
//______________________________________________________________________________
void TVirtualX::Bell(Int_t /*percent*/)
{
// Sets the sound bell. Percent is loudness from -100% .. 100%.
}
//______________________________________________________________________________
void TVirtualX::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*/)
{
// 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)
}
//______________________________________________________________________________
void TVirtualX::ChangeWindowAttributes(Window_t /*id*/,
SetWindowAttributes_t * /*attr*/)
{
// 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.
}
//______________________________________________________________________________
void TVirtualX::ChangeProperty(Window_t /*id*/, Atom_t /*property*/,
Atom_t /*type*/, UChar_t * /*data*/,
Int_t /*len*/)
{
// 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
}
//______________________________________________________________________________
void TVirtualX::DrawLine(Drawable_t /*id*/, GContext_t /*gc*/,
Int_t /*x1*/, Int_t /*y1*/, Int_t /*x2*/, Int_t /*y2*/)
{
// 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)
}
//______________________________________________________________________________
void TVirtualX::ClearArea(Window_t /*id*/, Int_t /*x*/, Int_t /*y*/,
UInt_t /*w*/, UInt_t /*h*/)
{
// 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
}
//______________________________________________________________________________
Bool_t TVirtualX::CheckEvent(Window_t /*id*/, EGEventType /*type*/,
Event_t &/*ev*/)
{
// 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.
return kFALSE;
}
//______________________________________________________________________________
void TVirtualX::SendEvent(Window_t /*id*/, Event_t * /*ev*/)
{
// Specifies the event "ev" is to be sent to the window "id".
// This function requires you to pass an event mask.
}
//______________________________________________________________________________
void TVirtualX::WMDeleteNotify(Window_t /*id*/)
{
// Tells WM to send message when window is closed via WM.
}
//______________________________________________________________________________
void TVirtualX::SetKeyAutoRepeat(Bool_t /*on = kTRUE*/)
{
// Turns key auto repeat on (kTRUE) or off (kFALSE).
}
//______________________________________________________________________________
void TVirtualX::GrabKey(Window_t /*id*/, Int_t /*keycode*/, UInt_t /*modifier*/,
Bool_t /*grab = kTRUE*/)
{
// 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
}
//______________________________________________________________________________
void TVirtualX::GrabButton(Window_t /*id*/, EMouseButton /*button*/,
UInt_t /*modifier*/, UInt_t /*evmask*/,
Window_t /*confine*/, Cursor_t /*cursor*/,
Bool_t /*grab = kTRUE*/)
{
// 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.
}
//______________________________________________________________________________
void TVirtualX::GrabPointer(Window_t /*id*/, UInt_t /*evmask*/,
Window_t /*confine*/, Cursor_t /*cursor*/,
Bool_t /*grab = kTRUE*/,
Bool_t /*owner_events = kTRUE*/)
{
// Establishes an active pointer grab. While an active pointer grab is in
// effect, further pointer events are only reported to the grabbing
// client window.
}
//______________________________________________________________________________
void TVirtualX::SetWindowName(Window_t /*id*/, char * /*name*/)
{
// Sets the window name.
}
//______________________________________________________________________________
void TVirtualX::SetIconName(Window_t /*id*/, char * /*name*/)
{
// Sets the window icon name.
}
//______________________________________________________________________________
void TVirtualX::SetIconPixmap(Window_t /*id*/, Pixmap_t /*pix*/)
{
// Sets the icon name pixmap.
}
//______________________________________________________________________________
void TVirtualX::SetClassHints(Window_t /*id*/, char * /*className*/,
char * /*resourceName*/)
{
// Sets the windows class and resource name.
}
//______________________________________________________________________________
void TVirtualX::SetMWMHints(Window_t /*id*/, UInt_t /*value*/, UInt_t /*funcs*/,
UInt_t /*input*/)
{
// Sets decoration style.
}
//______________________________________________________________________________
void TVirtualX::SetWMPosition(Window_t /*id*/, Int_t /*x*/, Int_t /*y*/)
{
// Tells the window manager the desired position [x,y] of window "id".
}
//______________________________________________________________________________
void TVirtualX::SetWMSize(Window_t /*id*/, UInt_t /*w*/, UInt_t /*h*/)
{
// Tells window manager the desired size of window "id".
//
// w - the width
// h - the height
}
//______________________________________________________________________________
void TVirtualX::SetWMSizeHints(Window_t /*id*/, UInt_t /*wmin*/, UInt_t /*hmin*/,
UInt_t /*wmax*/, UInt_t /*hmax*/,
UInt_t /*winc*/, UInt_t /*hinc*/)
{
// 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)
}
//______________________________________________________________________________
void TVirtualX::SetWMState(Window_t /*id*/, EInitialState /*state*/)
{
// Sets the initial state of the window "id": either kNormalState
// or kIconicState.
}
//______________________________________________________________________________
void TVirtualX::SetWMTransientHint(Window_t /*id*/, Window_t /*main_id*/)
{
// 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.
}
//______________________________________________________________________________
void TVirtualX::DrawString(Drawable_t /*id*/, GContext_t /*gc*/, Int_t /*x*/,
Int_t /*y*/, const char * /*s*/, Int_t /*len*/)
{
// 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)
}
//______________________________________________________________________________
Int_t TVirtualX::TextWidth(FontStruct_t /*font*/, const char * /*s*/,
Int_t /*len*/)
{
// Return lenght of the string "s" in pixels. Size depends on font.
return 5;
}
//______________________________________________________________________________
void TVirtualX::GetFontProperties(FontStruct_t /*font*/, Int_t &max_ascent,
Int_t &max_descent)
{
// Returns the font properties.
max_ascent = 5;
max_descent = 5;
}
//______________________________________________________________________________
void TVirtualX::GetGCValues(GContext_t /*gc*/, GCValues_t &gval)
{
// Returns the components specified by the mask in "gval" for the
// specified GC "gc" (see also the GCValues_t structure)
gval.fMask = 0;
}
//______________________________________________________________________________
FontStruct_t TVirtualX::GetFontStruct(FontH_t /*fh*/)
{
// Retrieves the associated font structure of the font specified font
// handle "fh".
//
// Free returned FontStruct_t using FreeFontStruct().
return 0;
}
//______________________________________________________________________________
void TVirtualX::FreeFontStruct(FontStruct_t /*fs*/)
{
// Frees the font structure "fs". The font itself will be freed when
// no other resource references it.
}
//______________________________________________________________________________
void TVirtualX::ClearWindow(Window_t /*id*/)
{
// Clears the entire area in the specified window and it is equivalent to
// ClearArea(id, 0, 0, 0, 0)
}
//______________________________________________________________________________
Int_t TVirtualX::KeysymToKeycode(UInt_t /*keysym*/)
{
// 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.
return 0;
}
//______________________________________________________________________________
void TVirtualX::FillRectangle(Drawable_t /*id*/, GContext_t /*gc*/,
Int_t /*x*/, Int_t /*y*/,
UInt_t /*w*/, UInt_t /*h*/)
{
// 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)
}
//______________________________________________________________________________
void TVirtualX::DrawRectangle(Drawable_t /*id*/, GContext_t /*gc*/,
Int_t /*x*/, Int_t /*y*/,
UInt_t /*w*/, UInt_t /*h*/)
{
// 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)
}
//______________________________________________________________________________
void TVirtualX::DrawSegments(Drawable_t /*id*/, GContext_t /*gc*/,
Segment_t * /*seg*/, Int_t /*nseg*/)
{
// 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)
}
//______________________________________________________________________________
void TVirtualX::SelectInput(Window_t /*id*/, UInt_t /*evmask*/)
{
// 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.
}
//______________________________________________________________________________
Window_t TVirtualX::GetInputFocus()
{
// Returns the window id of the window having the input focus.
return kNone;
}
//______________________________________________________________________________
void TVirtualX::SetInputFocus(Window_t /*id*/)
{
// Changes the input focus to specified window "id".
}
//______________________________________________________________________________
Window_t TVirtualX::GetPrimarySelectionOwner()
{
// Returns the window id of the current owner of the primary selection.
// That is the window in which, for example some text is selected.
return kNone;
}
//______________________________________________________________________________
void TVirtualX::SetPrimarySelectionOwner(Window_t /*id*/)
{
// Makes the window "id" the current owner of the primary selection.
// That is the window in which, for example some text is selected.
}
//______________________________________________________________________________
void TVirtualX::ConvertPrimarySelection(Window_t /*id*/, Atom_t /*clipboard*/,
Time_t /*when*/)
{
// 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.
}
//______________________________________________________________________________
void TVirtualX::LookupString(Event_t * /*event*/, char * /*buf*/,
Int_t /*buflen*/, UInt_t &keysym)
{
// 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
keysym = 0;
}
//______________________________________________________________________________
void TVirtualX::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)
{
// 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
dest_x = dest_y = 0;
child = 0;
}
//______________________________________________________________________________
void TVirtualX::GetWindowSize(Drawable_t /*id*/, Int_t &x, Int_t &y,
UInt_t &w, UInt_t &h)
{
// 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
x = y = 0;
w = h = 1;
}
//______________________________________________________________________________
void TVirtualX::FillPolygon(Window_t /*id*/, GContext_t /*gc*/, Point_t *
/*points*/, Int_t /*npnt*/) {
// 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)
}
//______________________________________________________________________________
void TVirtualX::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)
{
// 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
rootw = childw = kNone;
root_x = root_y = win_x = win_y = 0;
mask = 0;
}
//______________________________________________________________________________
void TVirtualX::SetForeground(GContext_t /*gc*/, ULong_t /*foreground*/)
{
// 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)
}
//______________________________________________________________________________
void TVirtualX::SetClipRectangles(GContext_t /*gc*/, Int_t /*x*/, Int_t /*y*/,
Rectangle_t * /*recs*/, Int_t /*n*/)
{
// 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)
}
//______________________________________________________________________________
void TVirtualX::Update(Int_t /*mode = 0*/)
{
// 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.
}
//______________________________________________________________________________
Region_t TVirtualX::CreateRegion()
{
// Creates a new empty region.
return 0;
}
//______________________________________________________________________________
void TVirtualX::DestroyRegion(Region_t /*reg*/)
{
// Destroys the region "reg".
}
//______________________________________________________________________________
void TVirtualX::UnionRectWithRegion(Rectangle_t * /*rect*/, Region_t /*src*/,
Region_t /*dest*/)
{
// 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
}
//______________________________________________________________________________
Region_t TVirtualX::PolygonRegion(Point_t * /*points*/, Int_t /*np*/,
Bool_t /*winding*/)
{
// 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)
return 0;
}
//______________________________________________________________________________
void TVirtualX::UnionRegion(Region_t /*rega*/, Region_t /*regb*/,
Region_t /*result*/)
{
// 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
}
//______________________________________________________________________________
void TVirtualX::IntersectRegion(Region_t /*rega*/, Region_t /*regb*/,
Region_t /*result*/)
{
// 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
}
//______________________________________________________________________________
void TVirtualX::SubtractRegion(Region_t /*rega*/, Region_t /*regb*/,
Region_t /*result*/)
{
// Subtracts regb from rega and stores the results in result.
}
//______________________________________________________________________________
void TVirtualX::XorRegion(Region_t /*rega*/, Region_t /*regb*/,
Region_t /*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
}
//______________________________________________________________________________
Bool_t TVirtualX::EmptyRegion(Region_t /*reg*/)
{
// Returns kTRUE if the region reg is empty.
return kFALSE;
}
//______________________________________________________________________________
Bool_t TVirtualX::PointInRegion(Int_t /*x*/, Int_t /*y*/, Region_t /*reg*/)
{
// Returns kTRUE if the point [x, y] is contained in the region reg.
return kFALSE;
}
//______________________________________________________________________________
Bool_t TVirtualX::EqualRegion(Region_t /*rega*/, Region_t /*regb*/)
{
// Returns kTRUE if the two regions have the same offset, size, and shape.
return kFALSE;
}
//______________________________________________________________________________
void TVirtualX::GetRegionBox(Region_t /*reg*/, Rectangle_t * /*rect*/)
{
// Returns smallest enclosing rectangle.
}
//______________________________________________________________________________
char **TVirtualX::ListFonts(const char * /*fontname*/, Int_t /*max*/, Int_t &/*count*/)
{
// 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
return 0;
}
//______________________________________________________________________________
void TVirtualX::FreeFontNames(char ** /*fontlist*/)
{
// Frees the specified the array of strings "fontlist".
}
//______________________________________________________________________________
Drawable_t TVirtualX::CreateImage(UInt_t /*width*/, UInt_t /*height*/)
{
// Allocates the memory needed for an drawable.
//
// width - the width of the image, in pixels
// height - the height of the image, in pixels
return 0;
}
//______________________________________________________________________________
void TVirtualX::GetImageSize(Drawable_t /*id*/, UInt_t &/*width*/,
UInt_t &/*height*/)
{
// Returns the width and height of the image id
}
//______________________________________________________________________________
void TVirtualX::PutPixel(Drawable_t /*id*/, Int_t /*x*/, Int_t /*y*/,
ULong_t /*pixel*/)
{
// 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
}
//______________________________________________________________________________
void TVirtualX::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*/)
{
// 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)
}
//______________________________________________________________________________
void TVirtualX::DeleteImage(Drawable_t /*img*/)
{
// Deallocates the memory associated with the image img
}
ROOT page - Class index - Class Hierarchy - Top of the page
This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.