Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TVirtualX.cxx
Go to the documentation of this file.
1// @(#)root/base:$Id$
2// Author: Fons Rademakers 3/12/95
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12/**
13\defgroup GraphicsBackends Graphics' Backends
14\ingroup Graphics
15Graphics' Backends interface classes.
16Graphics classes interfacing ROOT graphics with the low level
17native graphics backends(s) like X11, Cocoa, Win32 etc...
18These classes are not meant to be used directly by ROOT users.
19*/
20
21/** \class TVirtualX
22\ingroup GraphicsBackends
23\ingroup Base
24Semi-Abstract base class defining a generic interface to the underlying, low
25level, native graphics backend (X11, Win32, MacOS, OpenGL...).
26An instance of TVirtualX itself defines a batch interface to the graphics system.
27*/
28
29#include "TVirtualX.h"
30#include "TString.h"
31
32
36
37
38TVirtualX *gGXBatch; //Global pointer to batch graphics interface
39TVirtualX* (*gPtr2VirtualX)() = nullptr; // returns pointer to global object
40
41
42
43
44////////////////////////////////////////////////////////////////////////////////
45/// Ctor of ABC
46
47TVirtualX::TVirtualX(const char *name, const char *title) : TNamed(name, title),
48 TAttLine(1,1,1),TAttFill(1,1),TAttText(11,0,1,62,0.01), TAttMarker(1,1,1),
49 fDrawMode()
50{
51}
52
53////////////////////////////////////////////////////////////////////////////////
54/// Returns gVirtualX global
55
57{
58 static TVirtualX *instance = nullptr;
60 return instance;
61}
62
63////////////////////////////////////////////////////////////////////////////////
64/// The WindowAttributes_t structure is set to default.
65
67{
68 attr.fX = attr.fY = 0;
69 attr.fWidth = attr.fHeight = 0;
70 attr.fVisual = nullptr;
71 attr.fMapState = kIsUnmapped;
72 attr.fScreen = nullptr;
73}
74
75////////////////////////////////////////////////////////////////////////////////
76/// Looks up the string name of a color "cname" with respect to the screen
77/// associated with the specified colormap. It returns the exact color value.
78/// If the color name is not in the Host Portable Character Encoding,
79/// the result is implementation dependent.
80///
81/// \param [in] cmap the colormap
82/// \param [in] cname the color name string; use of uppercase or lowercase
83/// does not matter
84/// \param [in] color returns the exact color value for later use
85///
86/// The ColorStruct_t structure is set to default. Let system think we
87/// could parse color.
88
89Bool_t TVirtualX::ParseColor(Colormap_t /*cmap*/, const char * /*cname*/,
90 ColorStruct_t &color)
91{
92 color.fPixel = 0;
93 color.fRed = 0;
94 color.fGreen = 0;
95 color.fBlue = 0;
96 color.fMask = kDoRed | kDoGreen | kDoBlue;
97
98 return kTRUE;
99}
100
101////////////////////////////////////////////////////////////////////////////////
102/// Allocates a read-only colormap entry corresponding to the closest RGB
103/// value supported by the hardware. If no cell could be allocated it
104/// returns kFALSE, otherwise kTRUE.
105///
106/// The pixel value is set to default. Let system think we could allocate
107/// color.
108///
109/// \param [in] cmap the colormap
110/// \param [in] color specifies and returns the values actually used in the cmap
111
113{
114 color.fPixel = 0;
115 return kTRUE;
116}
117
118////////////////////////////////////////////////////////////////////////////////
119/// Returns the current RGB value for the pixel in the "color" structure
120///
121/// The color components are set to default.
122///
123/// \param [in] cmap the colormap
124/// \param [in] color specifies and returns the RGB values for the pixel specified
125/// in the structure
126
128{
129 color.fRed = color.fGreen = color.fBlue = 0;
130}
131
132////////////////////////////////////////////////////////////////////////////////
133/// The "event" is set to default event.
134/// This method however, should never be called.
135
137{
138 event.fType = kButtonPress;
139 event.fWindow = 0;
140 event.fTime = 0;
141 event.fX = 0;
142 event.fY = 0;
143 event.fXRoot = 0;
144 event.fYRoot = 0;
145 event.fState = 0;
146 event.fCode = 0;
147 event.fWidth = 0;
148 event.fHeight = 0;
149 event.fCount = 0;
150}
151
152////////////////////////////////////////////////////////////////////////////////
153/// Gets contents of the paste buffer "atom" into the string "text".
154/// (nchar = number of characters) If "del" is true deletes the paste
155/// buffer afterwards.
156
158 Int_t &nchar, Bool_t /*del*/)
159{
160 text = "";
161 nchar = 0;
162}
163
164////////////////////////////////////////////////////////////////////////////////
165/// Initializes the X system. Returns kFALSE in case of failure.
166/// It is implementation dependent.
167
168Bool_t TVirtualX::Init(void * /*display*/)
169{
170 return kFALSE;
171}
172
173////////////////////////////////////////////////////////////////////////////////
174/// Clears the entire area of the current window.
175
177{
178}
179
180////////////////////////////////////////////////////////////////////////////////
181/// Deletes current window.
182
184{
185}
186
187////////////////////////////////////////////////////////////////////////////////
188/// Deletes current pixmap.
189
191{
192}
193
194////////////////////////////////////////////////////////////////////////////////
195/// Copies the pixmap "wid" at the position [xpos,ypos] in the current window.
196
197void TVirtualX::CopyPixmap(Int_t /*wid*/, Int_t /*xpos*/, Int_t /*ypos*/)
198{
199}
200
201////////////////////////////////////////////////////////////////////////////////
202///On a HiDPI resolution it can be > 1., this means glViewport should use
203///scaled width and height.
204
209
210////////////////////////////////////////////////////////////////////////////////
211/// Creates OpenGL context for window "wid"
212
214{
215}
216
217////////////////////////////////////////////////////////////////////////////////
218/// Deletes OpenGL context for window "wid"
219
221{
222}
223
224////////////////////////////////////////////////////////////////////////////////
225///Create window with special pixel format. Noop everywhere except Cocoa.
226
227Window_t TVirtualX::CreateOpenGLWindow(Window_t /*parentID*/, UInt_t /*width*/, UInt_t /*height*/, const std::vector<std::pair<UInt_t, Int_t> > &/*format*/)
228{
229 return Window_t();
230}
231
232////////////////////////////////////////////////////////////////////////////////
233/// Creates OpenGL context for window "windowID".
234
236{
237 return Handle_t();
238}
239
240////////////////////////////////////////////////////////////////////////////////
241/// Makes context ctx current OpenGL context.
242
244{
245 return kFALSE;
246}
247
248////////////////////////////////////////////////////////////////////////////////
249/// Asks OpenGL subsystem about the current OpenGL context.
250
255
256////////////////////////////////////////////////////////////////////////////////
257/// Flushes OpenGL buffer.
258
262
263////////////////////////////////////////////////////////////////////////////////
264/// Draws a box between [x1,y1] and [x2,y2] according to the "mode".
265///
266/// \param [in] x1,y1 left down corner
267/// \param [in] x2,y2 right up corner
268/// \param [in] mode drawing mode:
269/// - mode = 0 hollow (kHollow)
270/// - mode = 1 solid (kSolid)
271
272void TVirtualX::DrawBox(Int_t /*x1*/, Int_t /*y1*/, Int_t /*x2*/, Int_t /*y2*/,
273 EBoxMode /*mode*/)
274{
275}
276
277////////////////////////////////////////////////////////////////////////////////
278/// Draws a cell array. The drawing is done with the pixel precision
279/// if (x2-x1)/nx (or y) is not a exact pixel number the position of
280/// the top right corner may be wrong.
281///
282/// \param [in] x1,y1 left down corner
283/// \param [in] x2,y2 right up corner
284/// \param [in] nx,ny array size
285/// \param [in] ic array
286
288 Int_t /*x2*/, Int_t /*y2*/,
289 Int_t /*nx*/, Int_t /*ny*/, Int_t * /*ic*/)
290{
291}
292
293////////////////////////////////////////////////////////////////////////////////
294/// Fills area described by the polygon.
295///
296/// \param [in] n number of points
297/// \param [in] xy list of points. xy(2,n)
298
300{
301}
302
303////////////////////////////////////////////////////////////////////////////////
304/// Draws a line.
305///
306/// \param [in] x1,y1 begin of line
307/// \param [in] x2,y2 end of line
308
309void TVirtualX::DrawLine(Int_t /*x1*/, Int_t /*y1*/, Int_t /*x2*/, Int_t /*y2*/)
310{
311}
312
313////////////////////////////////////////////////////////////////////////////////
314/// Draws a line through all points in the list.
315///
316/// \param [in] n number of points
317/// \param [in] xy list of points
318
320{
321}
322
323////////////////////////////////////////////////////////////////////////////////
324/// Draws "n" markers with the current attributes at position [x,y].
325///
326/// \param [in] n number of markers to draw
327/// \param [in] xy an array of x,y marker coordinates
328
330{
331}
332
333////////////////////////////////////////////////////////////////////////////////
334/// Draws a text string using current font.
335///
336/// \param [in] x,y text position
337/// \param [in] angle text angle
338/// \param [in] mgn magnification factor
339/// \param [in] text text string
340/// \param [in] mode drawing mode:
341/// - mode = 0 the background is not drawn (kClear)
342/// - mode = 1 the background is drawn (kOpaque)
343
344void TVirtualX::DrawText(Int_t /*x*/, Int_t /*y*/, Float_t /*angle*/,
345 Float_t /*mgn*/, const char * /*text*/,
346 ETextMode /*mode*/)
347{
348}
349
350////////////////////////////////////////////////////////////////////////////////
351/// Draws a text string using current font.
352///
353/// \param [in] x,y text position
354/// \param [in] angle text angle
355/// \param [in] mgn magnification factor
356/// \param [in] text text string
357/// \param [in] mode drawing mode:
358/// - mode = 0 the background is not drawn (kClear)
359/// - mode = 1 the background is drawn (kOpaque)
360
361void TVirtualX::DrawText(Int_t /*x*/, Int_t /*y*/, Float_t /*angle*/,
362 Float_t /*mgn*/, const wchar_t * /*text*/,
363 ETextMode /*mode*/)
364{
365}
366
367////////////////////////////////////////////////////////////////////////////////
368/// Executes the command "code" coming from the other threads (Win32)
369
371{
372 return 0;
373}
374
375////////////////////////////////////////////////////////////////////////////////
376/// Queries the double buffer value for the window "wid".
377
379{
380 return 0;
381}
382
383////////////////////////////////////////////////////////////////////////////////
384/// Returns character up vector.
385
390
391////////////////////////////////////////////////////////////////////////////////
392/// Returns position and size of window "wid".
393///
394/// \param [in] wid window identifier
395/// if wid < 0 the size of the display is returned
396/// \param [in] x, y returned window position
397/// \param [in] w, h returned window size
398
400 UInt_t &w, UInt_t &h)
401{
402 x = y = 0;
403 w = h = 0;
404}
405
406////////////////////////////////////////////////////////////////////////////////
407/// Returns hostname on which the display is opened.
408
409const char *TVirtualX::DisplayName(const char *)
410{
411 return "batch";
412}
413
414////////////////////////////////////////////////////////////////////////////////
415/// Returns the current native event handle.
416
418{
419 return 0;
420}
421
422////////////////////////////////////////////////////////////////////////////////
423/// Returns pixel value associated to specified ROOT color number "cindex".
424
426{
427 return 0;
428}
429
430////////////////////////////////////////////////////////////////////////////////
431/// Returns the maximum number of planes.
432
434{
435 nplanes = 0;
436}
437
438////////////////////////////////////////////////////////////////////////////////
439/// Returns RGB values for color "index".
440
442{
443 r = g = b = 0;
444}
445
446////////////////////////////////////////////////////////////////////////////////
447/// Returns the size of the specified character string "mess".
448///
449/// \param [in] w the text width
450/// \param [in] h the text height
451/// \param [in] mess the string
452
453void TVirtualX::GetTextExtent(UInt_t &w, UInt_t &h, char * /*mess*/)
454{
455 w = h = 0;
456}
457
458////////////////////////////////////////////////////////////////////////////////
459/// Returns the size of the specified character string "mess".
460///
461/// \param [in] w the text width
462/// \param [in] h the text height
463/// \param [in] mess the string
464
465void TVirtualX::GetTextExtent(UInt_t &w, UInt_t &h, wchar_t * /*mess*/)
466{
467 w = h = 0;
468}
469
470////////////////////////////////////////////////////////////////////////////////
471/// Returns the ascent of the current font (in pixels).
472/// The ascent of a font is the distance from the baseline
473/// to the highest position characters extend to
474
476{
477 return 0;
478}
479
480////////////////////////////////////////////////////////////////////////////////
481/// Default version is noop, but in principle what
482/// ROOT understands as ascent is text related.
483
484Int_t TVirtualX::GetFontAscent(const char * /*mess*/) const
485{
486 return GetFontAscent();
487}
488
489////////////////////////////////////////////////////////////////////////////////
490/// Returns the descent of the current font (in pixels.
491/// The descent is the distance from the base line
492/// to the lowest point characters extend to.
493
495{
496 return 0;
497}
498
499////////////////////////////////////////////////////////////////////////////////
500/// Default version is noop, but in principle what
501/// ROOT understands as descent requires a certain text.
502
503Int_t TVirtualX::GetFontDescent(const char * /*mess*/) const
504{
505 return GetFontDescent();
506}
507
508////////////////////////////////////////////////////////////////////////////////
509/// Returns the current font magnification factor
510
512{
513 return 0;
514}
515
516////////////////////////////////////////////////////////////////////////////////
517/// Returns True when TrueType fonts are used
518
520{
521 return kFALSE;
522}
523
524////////////////////////////////////////////////////////////////////////////////
525/// Returns the X11 window identifier.
526///
527/// \param [in] wid workstation identifier (input)
528
530{
531 return 0;
532}
533
534////////////////////////////////////////////////////////////////////////////////
535/// Creates a new window and return window number.
536/// Returns -1 if window initialization fails.
537
539{
540 return 0;
541}
542
543////////////////////////////////////////////////////////////////////////////////
544/// Registers a window created by Qt as a ROOT window
545///
546/// \param [in] qwid window identifier
547/// \param [in] w, h the width and height, which define the window size
548
550{
551 return 0;
552}
553
554////////////////////////////////////////////////////////////////////////////////
555/// Registers a pixmap created by TGLManager as a ROOT pixmap
556///
557/// \param [in] pixid pixmap identifier
558/// \param [in] w, h the width and height, which define the pixmap size
559
561{
562 return 0;
563}
564
565
566////////////////////////////////////////////////////////////////////////////////
567/// Removes the created by Qt window "qwid".
568
570{
571}
572
573////////////////////////////////////////////////////////////////////////////////
574/// Moves the window "wid" to the specified x and y coordinates.
575/// It does not change the window's size, raise the window, or change
576/// the mapping state of the window.
577///
578/// \param [in] wid window identifier
579/// \param [in] x, y coordinates, which define the new position of the window
580/// relative to its parent.
581
582void TVirtualX::MoveWindow(Int_t /*wid*/, Int_t /*x*/, Int_t /*y*/)
583{
584}
585
586////////////////////////////////////////////////////////////////////////////////
587/// Creates a pixmap of the width "w" and height "h" you specified.
588
590{
591 return 0;
592}
593
594////////////////////////////////////////////////////////////////////////////////
595/// Returns the pointer position.
596
598{
599 ix = iy = 0;
600}
601
602////////////////////////////////////////////////////////////////////////////////
603/// If id is NULL - loads the specified gif file at position [x0,y0] in the
604/// current window. Otherwise creates pixmap from gif file
605
606Pixmap_t TVirtualX::ReadGIF(Int_t /*x0*/, Int_t /*y0*/, const char * /*file*/,
607 Window_t /*id*/)
608{
609 return 0;
610}
611
612////////////////////////////////////////////////////////////////////////////////
613/// Requests Locator position.
614///
615/// \param [in] x,y cursor position at moment of button press (output)
616/// \param [in] ctyp cursor type (input)
617/// - ctyp = 1 tracking cross
618/// - ctyp = 2 cross-hair
619/// - ctyp = 3 rubber circle
620/// - ctyp = 4 rubber band
621/// - ctyp = 5 rubber rectangle
622///
623/// \param [in] mode input mode
624/// - mode = 0 request
625/// - mode = 1 sample
626///
627/// \return
628/// - in request mode:
629/// - 1 = left is pressed
630/// - 2 = middle is pressed
631/// - 3 = right is pressed
632/// - in sample mode:
633/// - 11 = left is released
634/// - 12 = middle is released
635/// - 13 = right is released
636/// - -1 = nothing is pressed or released
637/// - -2 = leave the window
638/// - else = keycode (keyboard is pressed)
639
641 Int_t &x, Int_t &y)
642{
643 x = y = 0;
644 return 0;
645}
646
647////////////////////////////////////////////////////////////////////////////////
648/// Requests string: text is displayed and can be edited with Emacs-like
649/// keybinding. Returns termination code (0 for ESC, 1 for RETURN)
650///
651/// \param [in] x,y position where text is displayed
652/// \param [in] text displayed text (as input), edited text (as output)
653
655{
656 if (text) *text = 0;
657 return 0;
658}
659
660////////////////////////////////////////////////////////////////////////////////
661/// Rescales the window "wid".
662///
663/// \param [in] wid window identifier
664/// \param [in] w the width
665/// \param [in] h the height
666
667void TVirtualX::RescaleWindow(Int_t /*wid*/, UInt_t /*w*/, UInt_t /*h*/)
668{
669}
670
671////////////////////////////////////////////////////////////////////////////////
672/// Resizes the specified pixmap "wid".
673///
674/// \param [in] wid window identifier
675/// \param [in] w, h the width and height which define the pixmap dimensions
676
678{
679 return 0;
680}
681
682////////////////////////////////////////////////////////////////////////////////
683/// Resizes the window "wid" if necessary.
684
686{
687}
688
689////////////////////////////////////////////////////////////////////////////////
690/// Selects the window "wid" to which subsequent output is directed.
691
693{
694}
695
696////////////////////////////////////////////////////////////////////////////////
697/// Selects the pixmap "qpixid".
698
700{
701}
702
703////////////////////////////////////////////////////////////////////////////////
704/// Sets character up vector.
705
706void TVirtualX::SetCharacterUp(Float_t /*chupx*/, Float_t /*chupy*/)
707{
708}
709
710////////////////////////////////////////////////////////////////////////////////
711/// Turns off the clipping for the window "wid".
712
714{
715}
716
717////////////////////////////////////////////////////////////////////////////////
718/// Sets clipping region for the window "wid".
719///
720/// \param [in] wid window identifier
721/// \param [in] x, y origin of clipping rectangle
722/// \param [in] w, h the clipping rectangle dimensions
723
724void TVirtualX::SetClipRegion(Int_t /*wid*/, Int_t /*x*/, Int_t /*y*/,
725 UInt_t /*w*/, UInt_t /*h*/)
726{
727}
728
729////////////////////////////////////////////////////////////////////////////////
730/// The cursor "cursor" will be used when the pointer is in the
731/// window "wid".
732
733void TVirtualX::SetCursor(Int_t /*win*/, ECursor /*cursor*/)
734{
735}
736
737////////////////////////////////////////////////////////////////////////////////
738/// Sets the double buffer on/off on the window "wid".
739///
740/// \param [in] wid window identifier.
741/// - 999 means all opened windows.
742/// \param [in] mode the on/off switch
743/// - mode = 1 double buffer is on
744/// - mode = 0 double buffer is off
745
747{
748}
749
750////////////////////////////////////////////////////////////////////////////////
751/// Turns double buffer mode off.
752
756
757////////////////////////////////////////////////////////////////////////////////
758/// Turns double buffer mode on.
759
763
764////////////////////////////////////////////////////////////////////////////////
765/// Sets the drawing mode.
766///
767/// \param [in] mode drawing mode.
768/// - mode = 1 copy
769/// - mode = 2 xor
770/// - mode = 3 invert
771/// - mode = 4 set the suitable mode for cursor echo according to the vendor
772
774{
775}
776
777////////////////////////////////////////////////////////////////////////////////
778/// Sets color index "cindex" for fill areas.
779
781{
782}
783
784////////////////////////////////////////////////////////////////////////////////
785/// Sets fill area style.
786///
787/// \param [in] style compound fill area interior style
788/// - style = 1000 * interiorstyle + styleindex
789
791{
792}
793
794////////////////////////////////////////////////////////////////////////////////
795/// Sets color index "cindex" for drawing lines.
796
798{
799}
800
801////////////////////////////////////////////////////////////////////////////////
802/// Sets the line type.
803///
804/// \param [in] n length of the dash list
805/// - n <= 0 use solid lines
806/// - n > 0 use dashed lines described by dash(n)
807/// e.g. n = 4,dash = (6,3,1,3) gives a dashed-dotted line
808/// with dash length 6 and a gap of 7 between dashes
809/// \param [in] dash dash segment lengths
810
811void TVirtualX::SetLineType(Int_t /*n*/, Int_t * /*dash*/)
812{
813}
814
815////////////////////////////////////////////////////////////////////////////////
816/// Sets the line style.
817///
818/// \param [in] linestyle line style.
819/// - linestyle <= 1 solid
820/// - linestyle = 2 dashed
821/// - linestyle = 3 dotted
822/// - linestyle = 4 dashed-dotted
823
825{
826}
827
828////////////////////////////////////////////////////////////////////////////////
829/// Sets the line width.
830///
831/// \param [in] width the line width in pixels
832
834{
835}
836
837////////////////////////////////////////////////////////////////////////////////
838/// Sets color index "cindex" for markers.
839
841{
842}
843
844////////////////////////////////////////////////////////////////////////////////
845/// Sets marker size index.
846///
847/// \param [in] markersize the marker scale factor
848
850{
851}
852
853////////////////////////////////////////////////////////////////////////////////
854/// Sets marker style.
855
857{
858}
859
860////////////////////////////////////////////////////////////////////////////////
861/// Sets opacity of the current window. This image manipulation routine
862/// works by adding to a percent amount of neutral to each pixels RGB.
863/// Since it requires quite some additional color map entries is it
864/// only supported on displays with more than > 8 color planes (> 256
865/// colors).
866
868{
869}
870
871////////////////////////////////////////////////////////////////////////////////
872/// Sets color intensities the specified color index "cindex".
873///
874/// \param [in] cindex color index
875/// \param [in] r, g, b the red, green, blue intensities between 0.0 and 1.0
876
877void TVirtualX::SetRGB(Int_t /*cindex*/, Float_t /*r*/, Float_t /*g*/,
878 Float_t /*b*/)
879{
880}
881
882////////////////////////////////////////////////////////////////////////////////
883/// Sets the text alignment.
884///
885/// \param [in] talign text alignment.
886/// - talign = txalh horizontal text alignment
887/// - talign = txalv vertical text alignment
888
890{
891}
892
893////////////////////////////////////////////////////////////////////////////////
894/// Sets the color index "cindex" for text.
895
897{
898}
899
900////////////////////////////////////////////////////////////////////////////////
901/// Sets text font to specified name "fontname".This function returns 0 if
902/// the specified font is found, 1 if it is not.
903///
904/// \param [in] fontname font name
905/// \param [in] mode loading flag
906/// - mode = 0 search if the font exist (kCheck)
907/// - mode = 1 search the font and load it if it exists (kLoad)
908
909Int_t TVirtualX::SetTextFont(char * /*fontname*/, ETextSetMode /*mode*/)
910{
911 return 0;
912}
913
914////////////////////////////////////////////////////////////////////////////////
915/// Sets the current text font number.
916
917void TVirtualX::SetTextFont(Font_t /*fontnumber*/)
918{
919}
920
921////////////////////////////////////////////////////////////////////////////////
922/// Sets the current text magnification factor to "mgn"
923
925{
926}
927
928////////////////////////////////////////////////////////////////////////////////
929/// Sets the current text size to "textsize"
930
932{
933}
934
935////////////////////////////////////////////////////////////////////////////////
936/// Set synchronisation on or off.
937///
938/// \param [in] mode synchronisation on/off
939/// - mode=1 on
940/// - mode<>0 off
941
942void TVirtualX::Sync(Int_t /*mode*/)
943{
944}
945
946////////////////////////////////////////////////////////////////////////////////
947/// Updates or synchronises client and server once (not permanent).
948/// according to "mode".
949///
950/// \param [in] mode update mode.
951/// - mode = 1 update
952/// - mode = 0 sync
953
955{
956}
957
958////////////////////////////////////////////////////////////////////////////////
959/// Sets the pointer position.
960///
961/// \param [in] ix new X coordinate of pointer
962/// \param [in] iy new Y coordinate of pointer
963/// \param [in] id window identifier
964///
965/// Coordinates are relative to the origin of the window id
966/// or to the origin of the current window if id == 0.
967
968void TVirtualX::Warp(Int_t /*ix*/, Int_t /*iy*/, Window_t /*id*/)
969{
970}
971
972////////////////////////////////////////////////////////////////////////////////
973/// Writes the current window into GIF file.
974/// Returns 1 in case of success, 0 otherwise.
975
977{
978 return 0;
979}
980
981////////////////////////////////////////////////////////////////////////////////
982/// Writes the pixmap "wid" in the bitmap file "pxname".
983///
984/// \param [in] wid the pixmap address
985/// \param [in] w, h the width and height of the pixmap.
986/// \param [in] pxname the file name
987
988void TVirtualX::WritePixmap(Int_t /*wid*/, UInt_t /*w*/, UInt_t /*h*/,
989 char * /*pxname*/)
990{
991}
992
993
994//---- Methods used for GUI -----
995////////////////////////////////////////////////////////////////////////////////
996/// Maps the window "id" and all of its subwindows that have had map
997/// requests. This function has no effect if the window is already mapped.
998
1000{
1001}
1002
1003////////////////////////////////////////////////////////////////////////////////
1004/// Maps all subwindows for the specified window "id" in top-to-bottom
1005/// stacking order.
1006
1008{
1009}
1010
1011////////////////////////////////////////////////////////////////////////////////
1012/// Maps the window "id" and all of its subwindows that have had map
1013/// requests on the screen and put this window on the top of of the
1014/// stack of all windows.
1015
1017{
1018}
1019
1020////////////////////////////////////////////////////////////////////////////////
1021/// Unmaps the specified window "id". If the specified window is already
1022/// unmapped, this function has no effect. Any child window will no longer
1023/// be visible (but they are still mapped) until another map call is made
1024/// on the parent.
1025
1027{
1028}
1029
1030////////////////////////////////////////////////////////////////////////////////
1031/// Destroys the window "id" as well as all of its subwindows.
1032/// The window should never be referenced again. If the window specified
1033/// by the "id" argument is mapped, it is unmapped automatically.
1034
1036{
1037}
1038
1039////////////////////////////////////////////////////////////////////////////////
1040/// The DestroySubwindows function destroys all inferior windows of the
1041/// specified window, in bottom-to-top stacking order.
1042
1046
1047////////////////////////////////////////////////////////////////////////////////
1048/// Raises the specified window to the top of the stack so that no
1049/// sibling window obscures it.
1050
1052{
1053}
1054
1055////////////////////////////////////////////////////////////////////////////////
1056/// Lowers the specified window "id" to the bottom of the stack so
1057/// that it does not obscure any sibling windows.
1058
1060{
1061}
1062
1063////////////////////////////////////////////////////////////////////////////////
1064/// Moves the specified window to the specified x and y coordinates.
1065/// It does not change the window's size, raise the window, or change
1066/// the mapping state of the window.
1067///
1068/// \param [in] id window identifier
1069/// \param [in] x, y coordinates, which define the new position of the window
1070/// relative to its parent.
1071
1072void TVirtualX::MoveWindow(Window_t /*id*/, Int_t /*x*/, Int_t /*y*/)
1073{
1074}
1075
1076////////////////////////////////////////////////////////////////////////////////
1077/// Changes the size and location of the specified window "id" without
1078/// raising it.
1079///
1080/// \param [in] id window identifier
1081/// \param [in] x, y coordinates, which define the new position of the window
1082/// relative to its parent.
1083/// \param [in] w, h the width and height, which define the interior size of
1084/// the window
1085
1087 UInt_t /*w*/, UInt_t /*h*/)
1088{
1089}
1090
1091////////////////////////////////////////////////////////////////////////////////
1092/// Changes the width and height of the specified window "id", not
1093/// including its borders. This function does not change the window's
1094/// upper-left coordinate.
1095///
1096/// \param [in] id window identifier
1097/// \param [in] w, h the width and height, which are the interior dimensions of
1098/// the window after the call completes.
1099
1101{
1102}
1103
1104////////////////////////////////////////////////////////////////////////////////
1105/// Iconifies the window "id".
1106
1108{
1109}
1110////////////////////////////////////////////////////////////////////////////////
1111/// Notify the low level GUI layer ROOT requires "tgwindow" to be
1112/// updated
1113///
1114/// Returns kTRUE if the notification was desirable and it was sent
1115///
1116/// At the moment only Qt4 layer needs that
1117///
1118/// One needs explicitly cast the first parameter to TGWindow to make
1119/// it working in the implementation.
1120///
1121/// One needs to process the notification to confine
1122/// all paint operations within "expose" / "paint" like low level event
1123/// or equivalent
1124
1126{
1127 return kFALSE;
1128}
1129
1130////////////////////////////////////////////////////////////////////////////////
1131/// If the specified window is mapped, ReparentWindow automatically
1132/// performs an UnmapWindow request on it, removes it from its current
1133/// position in the hierarchy, and inserts it as the child of the specified
1134/// parent. The window is placed in the stacking order on top with respect
1135/// to sibling windows.
1136
1138 Int_t /*x*/, Int_t /*y*/)
1139{
1140}
1141
1142////////////////////////////////////////////////////////////////////////////////
1143/// Sets the background of the window "id" to the specified color value
1144/// "color". Changing the background does not cause the window contents
1145/// to be changed.
1146
1148{
1149}
1150
1151////////////////////////////////////////////////////////////////////////////////
1152/// Sets the background pixmap of the window "id" to the specified
1153/// pixmap "pxm".
1154
1158
1159////////////////////////////////////////////////////////////////////////////////
1160/// Creates an unmapped subwindow for a specified parent window and returns
1161/// the created window. The created window is placed on top in the stacking
1162/// order with respect to siblings. The coordinate system has the X axis
1163/// horizontal and the Y axis vertical with the origin [0,0] at the
1164/// upper-left corner. Each window and pixmap has its own coordinate system.
1165///
1166/// \param [in] parent the parent window
1167/// \param [in] x, y coordinates, the top-left outside corner of the window's
1168/// borders; relative to the inside of the parent window's borders
1169/// \param [in] w, h width and height of the created window; do not include the
1170/// created window's borders
1171/// \param [in] border the border pixel value of the window
1172/// \param [in] depth the window's depth
1173/// \param [in] clss the created window's class; can be InputOutput, InputOnly, or
1174/// CopyFromParent
1175/// \param [in] visual the visual type
1176/// \param [in] attr the structure from which the values are to be taken.
1177/// \param [in] wtype the window type
1178
1180 UInt_t /*w*/, UInt_t /*h*/,
1181 UInt_t /*border*/, Int_t /*depth*/,
1182 UInt_t /*clss*/, void * /*visual*/,
1183 SetWindowAttributes_t * /*attr*/,
1184 UInt_t /*wtype*/)
1185{
1186 return 0;
1187}
1188
1189////////////////////////////////////////////////////////////////////////////////
1190/// Opens connection to display server (if such a thing exist on the
1191/// current platform). The encoding and interpretation of the display
1192/// name.
1193///
1194/// On X11 this method returns on success the X display socket descriptor
1195/// >0, 0 in case of batch mode, and <0 in case of failure (cannot connect
1196/// to display dpyName).
1197
1198Int_t TVirtualX::OpenDisplay(const char * /*dpyName*/)
1199{
1200 return 0;
1201}
1202
1203////////////////////////////////////////////////////////////////////////////////
1204/// Closes connection to display server and destroys all windows.
1205
1207{
1208}
1209
1210////////////////////////////////////////////////////////////////////////////////
1211/// Returns handle to display (might be useful in some cases where
1212/// direct X11 manipulation outside of TVirtualX is needed, e.g. GL
1213/// interface).
1214
1216{
1217 return 0;
1218}
1219
1220////////////////////////////////////////////////////////////////////////////////
1221/// Returns handle to visual.
1222///
1223/// Might be useful in some cases where direct X11 manipulation outside
1224/// of TVirtualX is needed, e.g. GL interface.
1225
1227{
1228 return 0;
1229}
1230
1231////////////////////////////////////////////////////////////////////////////////
1232/// Returns screen number.
1233///
1234/// Might be useful in some cases where direct X11 manipulation outside
1235/// of TVirtualX is needed, e.g. GL interface.
1236
1238{
1239 return 0;
1240}
1241
1242////////////////////////////////////////////////////////////////////////////////
1243/// Returns depth of screen (number of bit planes).
1244/// Equivalent to GetPlanes().
1245
1247{
1248 return 0;
1249}
1250
1251////////////////////////////////////////////////////////////////////////////////
1252/// Returns handle to colormap.
1253///
1254/// Might be useful in some cases where direct X11 manipulation outside
1255/// of TVirtualX is needed, e.g. GL interface.
1256
1258{
1259 return 0;
1260}
1261
1262////////////////////////////////////////////////////////////////////////////////
1263/// Returns handle to the default root window created when calling
1264/// XOpenDisplay().
1265
1267{
1268 return 0;
1269}
1270
1271////////////////////////////////////////////////////////////////////////////////
1272/// Returns the atom identifier associated with the specified "atom_name"
1273/// string. If "only_if_exists" is False, the atom is created if it does
1274/// not exist. If the atom name is not in the Host Portable Character
1275/// Encoding, the result is implementation dependent. Uppercase and
1276/// lowercase matter; the strings "thing", "Thing", and "thinG" all
1277/// designate different atoms.
1278
1279Atom_t TVirtualX::InternAtom(const char * /*atom_name*/,
1280 Bool_t /*only_if_exist*/)
1281{
1282 return 0;
1283}
1284
1285////////////////////////////////////////////////////////////////////////////////
1286/// Returns the parent of the window "id".
1287
1289{
1290 return 0;
1291}
1292
1293////////////////////////////////////////////////////////////////////////////////
1294/// Provides the most common way for accessing a font: opens (loads) the
1295/// specified font and returns a pointer to the appropriate FontStruct_t
1296/// structure. If the font does not exist, it returns NULL.
1297
1298FontStruct_t TVirtualX::LoadQueryFont(const char * /*font_name*/)
1299{
1300 return 0;
1301}
1302
1303////////////////////////////////////////////////////////////////////////////////
1304/// Returns the font handle of the specified font structure "fs".
1305
1307{
1308 return 0;
1309}
1310
1311////////////////////////////////////////////////////////////////////////////////
1312/// Explicitly deletes the font structure "fs" obtained via LoadQueryFont().
1313
1315{
1316}
1317
1318////////////////////////////////////////////////////////////////////////////////
1319/// Creates a graphics context using the provided GCValues_t *gval structure.
1320/// The mask data member of gval specifies which components in the GC are
1321/// to be set using the information in the specified values structure.
1322/// It returns a graphics context handle GContext_t that can be used with any
1323/// destination drawable or O if the creation falls.
1324
1326{
1327 return 0;
1328}
1329
1330////////////////////////////////////////////////////////////////////////////////
1331/// Changes the components specified by the mask in gval for the specified GC.
1332///
1333/// \param [in] gc specifies the GC to be changed
1334/// \param [in] gval specifies the mask and the values to be set
1335///
1336/// (see also the GCValues_t structure)
1337
1339{
1340}
1341
1342////////////////////////////////////////////////////////////////////////////////
1343/// Copies the specified components from the source GC "org" to the
1344/// destination GC "dest". The "mask" defines which component to copy
1345/// and it is a data member of GCValues_t.
1346
1347void TVirtualX::CopyGC(GContext_t /*org*/, GContext_t /*dest*/, Mask_t /*mask*/)
1348{
1349}
1350
1351////////////////////////////////////////////////////////////////////////////////
1352/// Deletes the specified GC "gc".
1353
1355{
1356}
1357
1358////////////////////////////////////////////////////////////////////////////////
1359/// Creates the specified cursor. (just return cursor from cursor pool).
1360/// The cursor can be:
1361/// ~~~ {.cpp}
1362/// kBottomLeft, kBottomRight, kTopLeft, kTopRight,
1363/// kBottomSide, kLeftSide, kTopSide, kRightSide,
1364/// kMove, kCross, kArrowHor, kArrowVer,
1365/// kHand, kRotate, kPointer, kArrowRight,
1366/// kCaret, kWatch
1367/// ~~~
1368
1370{
1371 return 0;
1372}
1373
1374////////////////////////////////////////////////////////////////////////////////
1375/// Sets the cursor "curid" to be used when the pointer is in the
1376/// window "id".
1377
1379{
1380}
1381
1382////////////////////////////////////////////////////////////////////////////////
1383/// Creates a pixmap of the specified width and height and returns
1384/// a pixmap ID that identifies it.
1385
1387{
1388 return kNone;
1389}
1390////////////////////////////////////////////////////////////////////////////////
1391/// Creates a pixmap from bitmap data of the width, height, and depth you
1392/// specified and returns a pixmap that identifies it. The width and height
1393/// arguments must be nonzero. The depth argument must be one of the depths
1394/// supported by the screen of the specified drawable.
1395///
1396/// \param [in] id specifies which screen the pixmap is created on
1397/// \param [in] bitmap the data in bitmap format
1398/// \param [in] width, height define the dimensions of the pixmap
1399/// \param [in] forecolor the foreground pixel values to use
1400/// \param [in] backcolor the background pixel values to use
1401/// \param [in] depth the depth of the pixmap
1402
1403Pixmap_t TVirtualX::CreatePixmap(Drawable_t /*id*/, const char * /*bitmap*/,
1404 UInt_t /*width*/, UInt_t /*height*/,
1405 ULong_t /*forecolor*/, ULong_t /*backcolor*/,
1406 Int_t /*depth*/)
1407{
1408 return 0;
1409}
1410
1411////////////////////////////////////////////////////////////////////////////////
1412/// Creates a bitmap (i.e. pixmap with depth 1) from the bitmap data.
1413///
1414/// \param [in] id specifies which screen the pixmap is created on
1415/// \param [in] bitmap the data in bitmap format
1416/// \param [in] width, height define the dimensions of the pixmap
1417
1418Pixmap_t TVirtualX::CreateBitmap(Drawable_t /*id*/, const char * /*bitmap*/,
1419 UInt_t /*width*/, UInt_t /*height*/)
1420{
1421 return 0;
1422}
1423
1424////////////////////////////////////////////////////////////////////////////////
1425/// Explicitly deletes the pixmap resource "pmap".
1426
1428{
1429}
1430
1431////////////////////////////////////////////////////////////////////////////////
1432/// Creates a picture pict from data in file "filename". The picture
1433/// attributes "attr" are used for input and output. Returns kTRUE in
1434/// case of success, kFALSE otherwise. If the mask "pict_mask" does not
1435/// exist it is set to kNone.
1436
1438 const char * /*filename*/,
1439 Pixmap_t &/*pict*/,
1440 Pixmap_t &/*pict_mask*/,
1441 PictureAttributes_t &/*attr*/)
1442{
1443 return kFALSE;
1444}
1445
1446////////////////////////////////////////////////////////////////////////////////
1447/// Creates a picture pict from data in bitmap format. The picture
1448/// attributes "attr" are used for input and output. Returns kTRUE in
1449/// case of success, kFALSE otherwise. If the mask "pict_mask" does not
1450/// exist it is set to kNone.
1451
1453 Pixmap_t &/*pict*/,
1454 Pixmap_t &/*pict_mask*/,
1455 PictureAttributes_t & /*attr*/)
1456{
1457 return kFALSE;
1458}
1459////////////////////////////////////////////////////////////////////////////////
1460/// Reads picture data from file "filename" and store it in "ret_data".
1461/// Returns kTRUE in case of success, kFALSE otherwise.
1462
1464 char *** /*ret_data*/)
1465{
1466 return kFALSE;
1467}
1468
1469////////////////////////////////////////////////////////////////////////////////
1470/// Delete picture data created by the function ReadPictureDataFromFile.
1471
1472void TVirtualX::DeletePictureData(void * /*data*/)
1473{
1474}
1475
1476////////////////////////////////////////////////////////////////////////////////
1477/// Sets the dash-offset and dash-list attributes for dashed line styles
1478/// in the specified GC. There must be at least one element in the
1479/// specified dash_list. The initial and alternating elements (second,
1480/// fourth, and so on) of the dash_list are the even dashes, and the
1481/// others are the odd dashes. Each element in the "dash_list" array
1482/// specifies the length (in pixels) of a segment of the pattern.
1483///
1484/// \param [in] gc specifies the GC (see GCValues_t structure)
1485/// \param [in] offset the phase of the pattern for the dashed line-style you
1486/// want to set for the specified GC.
1487/// \param [in] dash_list the dash-list for the dashed line-style you want to set
1488/// for the specified GC
1489/// \param [in] n the number of elements in dash_list
1490/// (see also the GCValues_t structure)
1491
1492void TVirtualX::SetDashes(GContext_t /*gc*/, Int_t /*offset*/,
1493 const char * /*dash_list*/, Int_t /*n*/)
1494{
1495}
1496
1497////////////////////////////////////////////////////////////////////////////////
1498/// Frees color cell with specified pixel value.
1499
1500void TVirtualX::FreeColor(Colormap_t /*cmap*/, ULong_t /*pixel*/)
1501{
1502}
1503
1504////////////////////////////////////////////////////////////////////////////////
1505/// Returns the number of events that have been received from the X server
1506/// but have not been removed from the event queue.
1507
1509{
1510 return 0;
1511}
1512
1513////////////////////////////////////////////////////////////////////////////////
1514/// Sets the sound bell. Percent is loudness from -100% to 100%.
1515
1516void TVirtualX::Bell(Int_t /*percent*/)
1517{
1518}
1519
1520////////////////////////////////////////////////////////////////////////////////
1521/// Combines the specified rectangle of "src" with the specified rectangle
1522/// of "dest" according to the "gc".
1523///
1524/// \param [in] src source rectangle
1525/// \param [in] dest destination rectangle
1526/// \param [in] gc graphics context
1527/// \param [in] src_x, src_y specify the x and y coordinates, which are relative
1528/// to the origin of the source rectangle and specify
1529/// upper-left corner.
1530/// \param [in] width, height the width and height, which are the dimensions of both
1531/// the source and destination rectangles
1532/// \param [in] dest_x, dest_y specify the upper-left corner of the destination
1533/// rectangle
1534///
1535/// GC components in use: function, plane-mask, subwindow-mode,
1536/// graphics-exposure, clip-x-origin, clip-y-origin, and clip-mask.
1537/// (see also the GCValues_t structure)
1538
1540 GContext_t /*gc*/, Int_t /*src_x*/, Int_t /*src_y*/,
1541 UInt_t /*width*/, UInt_t /*height*/,
1542 Int_t /*dest_x*/, Int_t /*dest_y*/)
1543{
1544}
1545
1546////////////////////////////////////////////////////////////////////////////////
1547/// Changes the attributes of the specified window "id" according the
1548/// values provided in "attr". The mask data member of "attr" specifies
1549/// which window attributes are defined in the attributes argument.
1550/// This mask is the bitwise inclusive OR of the valid attribute mask
1551/// bits; if it is zero, the attributes are ignored.
1552
1554 SetWindowAttributes_t * /*attr*/)
1555{
1556}
1557
1558////////////////////////////////////////////////////////////////////////////////
1559/// Alters the property for the specified window and causes the X server
1560/// to generate a PropertyNotify event on that window.
1561///
1562/// \param [in] id the window whose property you want to change
1563/// \param [in] property specifies the property name
1564/// \param [in] type the type of the property; the X server does not
1565/// interpret the type but simply passes it back to
1566/// an application that might ask about the window
1567/// properties
1568/// \param [in] data the property data
1569/// \param [in] len the length of the specified data format
1570
1572 Atom_t /*type*/, UChar_t * /*data*/,
1573 Int_t /*len*/)
1574{
1575}
1576
1577////////////////////////////////////////////////////////////////////////////////
1578/// Uses the components of the specified GC to draw a line between the
1579/// specified set of points (x1, y1) and (x2, y2).
1580///
1581/// GC components in use: function, plane-mask, line-width, line-style,
1582/// cap-style, fill-style, subwindow-mode, clip-x-origin, clip-y-origin,
1583/// and clip-mask.
1584///
1585/// GC mode-dependent components: foreground, background, tile, stipple,
1586/// tile-stipple-x-origin, tile-stipple-y-origin, dash-offset, dash-list.
1587/// (see also the GCValues_t structure)
1588
1590 Int_t /*x1*/, Int_t /*y1*/, Int_t /*x2*/, Int_t /*y2*/)
1591{
1592}
1593
1594////////////////////////////////////////////////////////////////////////////////
1595/// Paints a rectangular area in the specified window "id" according to
1596/// the specified dimensions with the window's background pixel or pixmap.
1597///
1598/// \param [in] id specifies the window
1599/// \param [in] x, y coordinates, which are relative to the origin
1600/// \param [in] w, h the width and height which define the rectangle dimensions
1601
1602void TVirtualX::ClearArea(Window_t /*id*/, Int_t /*x*/, Int_t /*y*/,
1603 UInt_t /*w*/, UInt_t /*h*/)
1604{
1605}
1606
1607////////////////////////////////////////////////////////////////////////////////
1608/// Check if there is for window "id" an event of type "type". If there
1609/// is it fills in the event structure and return true. If no such event
1610/// return false.
1611
1613 Event_t &/*ev*/)
1614{
1615 return kFALSE;
1616}
1617
1618////////////////////////////////////////////////////////////////////////////////
1619/// Specifies the event "ev" is to be sent to the window "id".
1620/// This function requires you to pass an event mask.
1621
1623{
1624}
1625
1626////////////////////////////////////////////////////////////////////////////////
1627/// Force processing of event, sent by SendEvent before.
1628
1630{
1631}
1632
1633////////////////////////////////////////////////////////////////////////////////
1634/// Tells WM to send message when window is closed via WM.
1635
1637{
1638}
1639
1640////////////////////////////////////////////////////////////////////////////////
1641/// Turns key auto repeat on (kTRUE) or off (kFALSE).
1642
1644{
1645}
1646
1647////////////////////////////////////////////////////////////////////////////////
1648/// Establishes a passive grab on the keyboard. In the future, the
1649/// keyboard is actively grabbed, the last-keyboard-grab time is set
1650/// to the time at which the key was pressed (as transmitted in the
1651/// KeyPress event), and the KeyPress event is reported if all of the
1652/// following conditions are true:
1653///
1654/// - the keyboard is not grabbed and the specified key (which can
1655/// itself be a modifier key) is logically pressed when the
1656/// specified modifier keys are logically down, and no other
1657/// modifier keys are logically down;
1658/// - either the grab window "id" is an ancestor of (or is) the focus
1659/// window, or "id" is a descendant of the focus window and contains
1660/// the pointer;
1661/// - a passive grab on the same key combination does not exist on any
1662/// ancestor of grab_window
1663///
1664/// \param [in] id window id
1665/// \param [in] keycode specifies the KeyCode or AnyKey
1666/// \param [in] modifier specifies the set of keymasks or AnyModifier; the mask is
1667/// the bitwise inclusive OR of the valid keymask bits
1668/// \param [in] grab a switch between grab/ungrab key
1669/// grab = kTRUE grab the key and modifier
1670/// grab = kFALSE ungrab the key and modifier
1671
1672void TVirtualX::GrabKey(Window_t /*id*/, Int_t /*keycode*/, UInt_t /*modifier*/,
1673 Bool_t /*grab = kTRUE*/)
1674{
1675}
1676
1677////////////////////////////////////////////////////////////////////////////////
1678/// Establishes a passive grab on a certain mouse button. That is, when a
1679/// certain mouse button is hit while certain modifier's (Shift, Control,
1680/// Meta, Alt) are active then the mouse will be grabbed for window id.
1681/// When grab is false, ungrab the mouse button for this button and modifier.
1682
1684 UInt_t /*modifier*/, UInt_t /*evmask*/,
1685 Window_t /*confine*/, Cursor_t /*cursor*/,
1686 Bool_t /*grab = kTRUE*/)
1687{
1688}
1689
1690////////////////////////////////////////////////////////////////////////////////
1691/// Establishes an active pointer grab. While an active pointer grab is in
1692/// effect, further pointer events are only reported to the grabbing
1693/// client window.
1694
1696 Window_t /*confine*/, Cursor_t /*cursor*/,
1697 Bool_t /*grab = kTRUE*/,
1698 Bool_t /*owner_events = kTRUE*/)
1699{
1700}
1701
1702////////////////////////////////////////////////////////////////////////////////
1703/// Sets the window name.
1704
1705void TVirtualX::SetWindowName(Window_t /*id*/, char * /*name*/)
1706{
1707}
1708
1709////////////////////////////////////////////////////////////////////////////////
1710/// Sets the window icon name.
1711
1712void TVirtualX::SetIconName(Window_t /*id*/, char * /*name*/)
1713{
1714}
1715
1716////////////////////////////////////////////////////////////////////////////////
1717/// Sets the icon name pixmap.
1718
1720{
1721}
1722
1723////////////////////////////////////////////////////////////////////////////////
1724/// Sets the windows class and resource name.
1725
1726void TVirtualX::SetClassHints(Window_t /*id*/, char * /*className*/,
1727 char * /*resourceName*/)
1728{
1729}
1730
1731////////////////////////////////////////////////////////////////////////////////
1732/// Sets decoration style.
1733
1734void TVirtualX::SetMWMHints(Window_t /*id*/, UInt_t /*value*/, UInt_t /*funcs*/,
1735 UInt_t /*input*/)
1736{
1737}
1738
1739////////////////////////////////////////////////////////////////////////////////
1740/// Tells the window manager the desired position [x,y] of window "id".
1741
1743{
1744}
1745
1746////////////////////////////////////////////////////////////////////////////////
1747/// Tells window manager the desired size of window "id".
1748///
1749/// \param [in] id window identifier
1750/// \param [in] w the width
1751/// \param [in] h the height
1752
1753void TVirtualX::SetWMSize(Window_t /*id*/, UInt_t /*w*/, UInt_t /*h*/)
1754{
1755}
1756
1757////////////////////////////////////////////////////////////////////////////////
1758/// Gives the window manager minimum and maximum size hints of the window
1759/// "id". Also specify via "winc" and "hinc" the resize increments.
1760///
1761/// \param [in] id window identifier
1762/// \param [in] wmin, hmin specify the minimum window size
1763/// \param [in] wmax, hmax specify the maximum window size
1764/// \param [in] winc, hinc define an arithmetic progression of sizes into which
1765/// the window to be resized (minimum to maximum)
1766
1767void TVirtualX::SetWMSizeHints(Window_t /*id*/, UInt_t /*wmin*/, UInt_t /*hmin*/,
1768 UInt_t /*wmax*/, UInt_t /*hmax*/,
1769 UInt_t /*winc*/, UInt_t /*hinc*/)
1770{
1771}
1772
1773////////////////////////////////////////////////////////////////////////////////
1774/// Sets the initial state of the window "id": either kNormalState
1775/// or kIconicState.
1776
1778{
1779}
1780
1781////////////////////////////////////////////////////////////////////////////////
1782/// Tells window manager that the window "id" is a transient window
1783/// of the window "main_id". A window manager may decide not to decorate
1784/// a transient window or may treat it differently in other ways.
1785
1787{
1788}
1789
1790////////////////////////////////////////////////////////////////////////////////
1791/// Each character image, as defined by the font in the GC, is treated as an
1792/// additional mask for a fill operation on the drawable.
1793///
1794/// \param [in] id the drawable
1795/// \param [in] gc the GC
1796/// \param [in] x, y coordinates, which are relative to the origin of the specified
1797/// drawable and define the origin of the first character
1798/// \param [in] s the character string
1799/// \param [in] len the number of characters in the string argument
1800///
1801/// GC components in use: function, plane-mask, fill-style, font,
1802/// subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask.
1803/// GC mode-dependent components: foreground, background, tile, stipple,
1804/// tile-stipple-x-origin, and tile-stipple-y-origin.
1805/// (see also the GCValues_t structure)
1806
1808 Int_t /*y*/, const char * /*s*/, Int_t /*len*/)
1809{
1810}
1811
1812////////////////////////////////////////////////////////////////////////////////
1813/// Return length of the string "s" in pixels. Size depends on font.
1814
1815Int_t TVirtualX::TextWidth(FontStruct_t /*font*/, const char * /*s*/,
1816 Int_t /*len*/)
1817{
1818 return 5;
1819}
1820
1821////////////////////////////////////////////////////////////////////////////////
1822/// Returns the font properties.
1823
1830
1831////////////////////////////////////////////////////////////////////////////////
1832/// Returns the components specified by the mask in "gval" for the
1833/// specified GC "gc" (see also the GCValues_t structure)
1834
1836{
1837 gval.fMask = 0;
1838}
1839
1840////////////////////////////////////////////////////////////////////////////////
1841/// Return the font associated with the graphics context gc
1842
1844{
1845 return 0;
1846}
1847
1848////////////////////////////////////////////////////////////////////////////////
1849/// Retrieves the associated font structure of the font specified font
1850/// handle "fh".
1851///
1852/// Free returned FontStruct_t using FreeFontStruct().
1853
1855{
1856 return 0;
1857}
1858
1859////////////////////////////////////////////////////////////////////////////////
1860/// Frees the font structure "fs". The font itself will be freed when
1861/// no other resource references it.
1862
1866
1867////////////////////////////////////////////////////////////////////////////////
1868/// Clears the entire area in the specified window and it is equivalent to
1869/// ClearArea(id, 0, 0, 0, 0)
1870
1872{
1873}
1874
1875////////////////////////////////////////////////////////////////////////////////
1876/// Converts the "keysym" to the appropriate keycode. For example,
1877/// keysym is a letter and keycode is the matching keyboard key (which
1878/// is dependent on the current keyboard mapping). If the specified
1879/// "keysym" is not defined for any keycode, returns zero.
1880
1882{
1883 return 0;
1884}
1885
1886////////////////////////////////////////////////////////////////////////////////
1887/// Fills the specified rectangle defined by [x,y] [x+w,y] [x+w,y+h] [x,y+h].
1888/// using the GC you specify.
1889///
1890/// GC components in use are: function, plane-mask, fill-style,
1891/// subwindow-mode, clip-x-origin, clip-y-origin, clip-mask.
1892/// GC mode-dependent components: foreground, background, tile, stipple,
1893/// tile-stipple-x-origin, and tile-stipple-y-origin.
1894/// (see also the GCValues_t structure)
1895
1897 Int_t /*x*/, Int_t /*y*/,
1898 UInt_t /*w*/, UInt_t /*h*/)
1899{
1900}
1901
1902////////////////////////////////////////////////////////////////////////////////
1903/// Draws rectangle outlines of [x,y] [x+w,y] [x+w,y+h] [x,y+h]
1904///
1905/// GC components in use: function, plane-mask, line-width, line-style,
1906/// cap-style, join-style, fill-style, subwindow-mode, clip-x-origin,
1907/// clip-y-origin, clip-mask.
1908/// GC mode-dependent components: foreground, background, tile, stipple,
1909/// tile-stipple-x-origin, tile-stipple-y-origin, dash-offset, dash-list.
1910/// (see also the GCValues_t structure)
1911
1913 Int_t /*x*/, Int_t /*y*/,
1914 UInt_t /*w*/, UInt_t /*h*/)
1915{
1916}
1917
1918////////////////////////////////////////////////////////////////////////////////
1919/// Draws multiple line segments. Each line is specified by a pair of points.
1920///
1921/// \param [in] id Drawable identifier
1922/// \param [in] gc graphics context
1923/// \param [in] *seg specifies an array of segments
1924/// \param [in] nseg specifies the number of segments in the array
1925///
1926/// GC components in use: function, plane-mask, line-width, line-style,
1927/// cap-style, join-style, fill-style, subwindow-mode, clip-x-origin,
1928/// clip-y-origin, clip-mask.
1929///
1930/// GC mode-dependent components: foreground, background, tile, stipple,
1931/// tile-stipple-x-origin, tile-stipple-y-origin, dash-offset, and dash-list.
1932/// (see also the GCValues_t structure)
1933
1935 Segment_t * /*seg*/, Int_t /*nseg*/)
1936{
1937}
1938
1939////////////////////////////////////////////////////////////////////////////////
1940/// Defines which input events the window is interested in. By default
1941/// events are propagated up the window stack. This mask can also be
1942/// set at window creation time via the SetWindowAttributes_t::fEventMask
1943/// attribute.
1944
1946{
1947}
1948
1949////////////////////////////////////////////////////////////////////////////////
1950/// Returns the window id of the window having the input focus.
1951
1953{
1954 return kNone;
1955}
1956
1957////////////////////////////////////////////////////////////////////////////////
1958/// Changes the input focus to specified window "id".
1959
1961{
1962}
1963
1964////////////////////////////////////////////////////////////////////////////////
1965/// Returns the window id of the current owner of the primary selection.
1966/// That is the window in which, for example some text is selected.
1967
1972
1973////////////////////////////////////////////////////////////////////////////////
1974/// Makes the window "id" the current owner of the primary selection.
1975/// That is the window in which, for example some text is selected.
1976
1980
1981////////////////////////////////////////////////////////////////////////////////
1982/// Causes a SelectionRequest event to be sent to the current primary
1983/// selection owner. This event specifies the selection property
1984/// (primary selection), the format into which to convert that data before
1985/// storing it (target = XA_STRING), the property in which the owner will
1986/// place the information (sel_property), the window that wants the
1987/// information (id), and the time of the conversion request (when).
1988/// The selection owner responds by sending a SelectionNotify event, which
1989/// confirms the selected atom and type.
1990
1992 Time_t /*when*/)
1993{
1994}
1995
1996////////////////////////////////////////////////////////////////////////////////
1997/// Converts the keycode from the event structure to a key symbol (according
1998/// to the modifiers specified in the event structure and the current
1999/// keyboard mapping). In "buf" a null terminated ASCII string is returned
2000/// representing the string that is currently mapped to the key code.
2001///
2002/// \param [in] event specifies the event structure to be used
2003/// \param [in] buf returns the translated characters
2004/// \param [in] buflen the length of the buffer
2005/// \param [in] keysym returns the "keysym" computed from the event
2006/// if this argument is not NULL
2007
2008void TVirtualX::LookupString(Event_t * /*event*/, char * /*buf*/,
2009 Int_t /*buflen*/, UInt_t &keysym)
2010{
2011 keysym = 0;
2012}
2013
2014////////////////////////////////////////////////////////////////////////////////
2015/// Translates coordinates in one window to the coordinate space of another
2016/// window. It takes the "src_x" and "src_y" coordinates relative to the
2017/// source window's origin and returns these coordinates to "dest_x" and
2018/// "dest_y" relative to the destination window's origin.
2019///
2020/// \param [in] src the source window
2021/// \param [in] dest the destination window
2022/// \param [in] src_x, src_y coordinates within the source window
2023/// \param [in] dest_x, dest_y coordinates within the destination window
2024/// \param [in] child returns the child of "dest" if the coordinates
2025/// are contained in a mapped child of the destination
2026/// window; otherwise, child is set to 0
2027
2029 Int_t /*src_x*/, Int_t /*src_y*/,
2031 Window_t &child)
2032{
2033 dest_x = dest_y = 0;
2034 child = 0;
2035}
2036
2037////////////////////////////////////////////////////////////////////////////////
2038/// Returns the location and the size of window "id"
2039///
2040/// \param [in] id drawable identifier
2041/// \param [in] x, y coordinates of the upper-left outer corner relative to the
2042/// parent window's origin
2043/// \param [in] w, h the inside size of the window, not including the border
2044
2046 UInt_t &w, UInt_t &h)
2047{
2048 x = y = 0;
2049 w = h = 1;
2050}
2051
2052////////////////////////////////////////////////////////////////////////////////
2053/// Fills the region closed by the specified path. The path is closed
2054/// automatically if the last point in the list does not coincide with the
2055/// first point.
2056///
2057/// \param [in] id window identifier
2058/// \param [in] gc graphics context
2059/// \param [in] *points specifies an array of points
2060/// \param [in] npnt specifies the number of points in the array
2061///
2062/// GC components in use: function, plane-mask, fill-style, fill-rule,
2063/// subwindow-mode, clip-x-origin, clip-y-origin, and clip-mask. GC
2064/// mode-dependent components: foreground, background, tile, stipple,
2065/// tile-stipple-x-origin, and tile-stipple-y-origin.
2066/// (see also the GCValues_t structure)
2067
2069 /*points*/, Int_t /*npnt*/) {
2070}
2071
2072////////////////////////////////////////////////////////////////////////////////
2073/// Returns the root window the pointer is logically on and the pointer
2074/// coordinates relative to the root window's origin.
2075///
2076/// \param [in] id specifies the window
2077/// \param [in] rootw the root window that the pointer is in
2078/// \param [in] childw the child window that the pointer is located in, if any
2079/// \param [in] root_x, root_y the pointer coordinates relative to the root window's
2080/// origin
2081/// \param [in] win_x, win_y the pointer coordinates relative to the specified
2082/// window "id"
2083/// \param [in] mask the current state of the modifier keys and pointer
2084/// buttons
2085
2089{
2090 rootw = childw = kNone;
2091 root_x = root_y = win_x = win_y = 0;
2092 mask = 0;
2093}
2094
2095////////////////////////////////////////////////////////////////////////////////
2096/// Sets the foreground color for the specified GC (shortcut for ChangeGC
2097/// with only foreground mask set).
2098///
2099/// \param [in] gc specifies the GC
2100/// \param [in] foreground the foreground you want to set
2101///
2102/// (see also the GCValues_t structure)
2103
2104void TVirtualX::SetForeground(GContext_t /*gc*/, ULong_t /*foreground*/)
2105{
2106}
2107
2108////////////////////////////////////////////////////////////////////////////////
2109/// Sets clipping rectangles in graphics context. [x,y] specify the origin
2110/// of the rectangles. "recs" specifies an array of rectangles that define
2111/// the clipping mask and "n" is the number of rectangles.
2112/// (see also the GCValues_t structure)
2113
2115 Rectangle_t * /*recs*/, Int_t /*n*/)
2116{
2117}
2118
2119////////////////////////////////////////////////////////////////////////////////
2120/// Flushes (mode = 0, default) or synchronizes (mode = 1) X output buffer.
2121/// Flush flushes output buffer. Sync flushes buffer and waits till all
2122/// requests have been processed by X server.
2123
2124void TVirtualX::Update(Int_t /*mode = 0*/)
2125{
2126}
2127
2128////////////////////////////////////////////////////////////////////////////////
2129/// Creates a new empty region.
2130
2132{
2133 return 0;
2134}
2135
2136////////////////////////////////////////////////////////////////////////////////
2137/// Destroys the region "reg".
2138
2140{
2141}
2142
2143////////////////////////////////////////////////////////////////////////////////
2144/// Updates the destination region from a union of the specified rectangle
2145/// and the specified source region.
2146///
2147/// \param [in] rect specifies the rectangle
2148/// \param [in] src specifies the source region to be used
2149/// \param [in] dest returns the destination region
2150
2152 Region_t /*dest*/)
2153{
2154}
2155
2156////////////////////////////////////////////////////////////////////////////////
2157/// Returns a region for the polygon defined by the points array.
2158///
2159/// \param [in] points specifies an array of points
2160/// \param [in] np specifies the number of points in the polygon
2161/// \param [in] winding specifies the winding-rule is set (kTRUE) or not(kFALSE)
2162
2164 Bool_t /*winding*/)
2165{
2166 return 0;
2167}
2168
2169////////////////////////////////////////////////////////////////////////////////
2170/// Computes the union of two regions.
2171///
2172/// \param [in] rega, regb specify the two regions with which you want to perform
2173/// the computation
2174/// \param [in] result returns the result of the computation
2175
2177 Region_t /*result*/)
2178{
2179}
2180
2181////////////////////////////////////////////////////////////////////////////////
2182/// Computes the intersection of two regions.
2183///
2184/// \param [in] rega, regb specify the two regions with which you want to perform
2185/// the computation
2186/// \param [in] result returns the result of the computation
2187
2189 Region_t /*result*/)
2190{
2191}
2192
2193////////////////////////////////////////////////////////////////////////////////
2194/// Subtracts regb from rega and stores the results in result.
2195
2197 Region_t /*result*/)
2198{
2199}
2200
2201////////////////////////////////////////////////////////////////////////////////
2202/// Calculates the difference between the union and intersection of
2203/// two regions.
2204///
2205/// \param [in] rega, regb specify the two regions with which you want to perform
2206/// the computation
2207/// \param [in] result returns the result of the computation
2208
2210 Region_t /*result*/)
2211{
2212}
2213
2214////////////////////////////////////////////////////////////////////////////////
2215/// Returns kTRUE if the region reg is empty.
2216
2218{
2219 return kFALSE;
2220}
2221
2222////////////////////////////////////////////////////////////////////////////////
2223/// Returns kTRUE if the point [x, y] is contained in the region reg.
2224
2226{
2227 return kFALSE;
2228}
2229
2230////////////////////////////////////////////////////////////////////////////////
2231/// Returns kTRUE if the two regions have the same offset, size, and shape.
2232
2234{
2235 return kFALSE;
2236}
2237
2238////////////////////////////////////////////////////////////////////////////////
2239/// Returns smallest enclosing rectangle.
2240
2242{
2243}
2244
2245////////////////////////////////////////////////////////////////////////////////
2246/// Returns list of font names matching fontname regexp, like "-*-times-*".
2247/// The pattern string can contain any characters, but each asterisk (*)
2248/// is a wildcard for any number of characters, and each question mark (?)
2249/// is a wildcard for a single character. If the pattern string is not in
2250/// the Host Portable Character Encoding, the result is implementation
2251/// dependent. Use of uppercase or lowercase does not matter. Each returned
2252/// string is null-terminated.
2253///
2254/// \param [in] fontname specifies the null-terminated pattern string that can
2255/// contain wildcard characters
2256/// \param [in] max specifies the maximum number of names to be returned
2257/// \param [in] count returns the actual number of font names
2258
2259char **TVirtualX::ListFonts(const char * /*fontname*/, Int_t /*max*/, Int_t & count)
2260{
2261 count=0;
2262 return nullptr;
2263}
2264
2265////////////////////////////////////////////////////////////////////////////////
2266/// Frees the specified the array of strings "fontlist".
2267
2268void TVirtualX::FreeFontNames(char ** /*fontlist*/)
2269{
2270}
2271
2272////////////////////////////////////////////////////////////////////////////////
2273/// Allocates the memory needed for an drawable.
2274///
2275/// \param [in] width the width of the image, in pixels
2276/// \param [in] height the height of the image, in pixels
2277
2279{
2280 return 0;
2281}
2282
2283////////////////////////////////////////////////////////////////////////////////
2284/// Returns the width and height of the image id
2285
2287 UInt_t &/*height*/)
2288{
2289}
2290
2291////////////////////////////////////////////////////////////////////////////////
2292/// Overwrites the pixel in the image with the specified pixel value.
2293/// The image must contain the x and y coordinates.
2294///
2295/// \param [in] id specifies the image
2296/// \param [in] x, y coordinates
2297/// \param [in] pixel the new pixel value
2298
2299void TVirtualX::PutPixel(Drawable_t /*id*/, Int_t /*x*/, Int_t /*y*/,
2300 ULong_t /*pixel*/)
2301{
2302}
2303
2304////////////////////////////////////////////////////////////////////////////////
2305/// Combines an image with a rectangle of the specified drawable. The
2306/// section of the image defined by the x, y, width, and height arguments
2307/// is drawn on the specified part of the drawable.
2308///
2309/// \param [in] id the drawable
2310/// \param [in] gc the GC
2311/// \param [in] img the image you want combined with the rectangle
2312/// \param [in] dx the offset in X from the left edge of the image
2313/// \param [in] dy the offset in Y from the top edge of the image
2314/// \param [in] x, y coordinates, which are relative to the origin of the
2315/// drawable and are the coordinates of the subimage
2316/// \param [in] w, h the width and height of the subimage, which define the
2317/// rectangle dimensions
2318///
2319/// GC components in use: function, plane-mask, subwindow-mode,
2320/// clip-x-origin, clip-y-origin, and clip-mask.
2321/// GC mode-dependent components: foreground and background.
2322/// (see also the GCValues_t structure)
2323
2325 Drawable_t /*img*/, Int_t /*dx*/, Int_t /*dy*/,
2326 Int_t /*x*/, Int_t /*y*/, UInt_t /*w*/, UInt_t /*h*/)
2327{
2328}
2329
2330////////////////////////////////////////////////////////////////////////////////
2331/// Deallocates the memory associated with the image img
2332
2334{
2335}
2336
2337////////////////////////////////////////////////////////////////////////////////
2338/// pointer to the current internal window used in canvas graphics
2339
2341{
2342 return (Window_t)0;
2343}
2344
2345////////////////////////////////////////////////////////////////////////////////
2346/// Returns an array of pixels created from a part of drawable (defined by x, y, w, h)
2347/// in format:
2348///
2349/// ~~~ {.cpp}
2350/// b1, g1, r1, 0, b2, g2, r2, 0 ... bn, gn, rn, 0 ..
2351/// ~~~
2352///
2353/// Pixels are numbered from left to right and from top to bottom.
2354/// By default all pixels from the whole drawable are returned.
2355///
2356/// Note that return array is 32-bit aligned
2357
2358unsigned char *TVirtualX::GetColorBits(Drawable_t /*wid*/, Int_t /*x*/, Int_t /*y*/,
2359 UInt_t /*w*/, UInt_t /*h*/)
2360{
2361 return nullptr;
2362}
2363
2364////////////////////////////////////////////////////////////////////////////////
2365/// create pixmap from RGB data. RGB data is in format:
2366///
2367/// ~~~ {.cpp}
2368/// b1, g1, r1, 0, b2, g2, r2, 0 ... bn, gn, rn, 0 ..
2369/// ~~~
2370///
2371/// Pixels are numbered from left to right and from top to bottom.
2372/// Note that data must be 32-bit aligned
2373
2374Pixmap_t TVirtualX::CreatePixmapFromData(unsigned char * /*bits*/, UInt_t /*width*/,
2375 UInt_t /*height*/)
2376{
2377 return (Pixmap_t)0;
2378}
2379
2380////////////////////////////////////////////////////////////////////////////////
2381/// The Non-rectangular Window Shape Extension adds non-rectangular
2382/// windows to the System.
2383/// This allows for making shaped (partially transparent) windows
2384
2388
2389////////////////////////////////////////////////////////////////////////////////
2390/// Returns the width of the screen in millimeters.
2391
2393{
2394 return 400;
2395}
2396
2397////////////////////////////////////////////////////////////////////////////////
2398/// Deletes the specified property only if the property was defined on the
2399/// specified window and causes the X server to generate a PropertyNotify
2400/// event on the window unless the property does not exist.
2401
2405
2406////////////////////////////////////////////////////////////////////////////////
2407/// Returns the actual type of the property; the actual format of the property;
2408/// the number of 8-bit, 16-bit, or 32-bit items transferred; the number of
2409/// bytes remaining to be read in the property; and a pointer to the data
2410/// actually returned.
2411
2413 Atom_t*, Int_t*, ULong_t*, ULong_t*, unsigned char**)
2414{
2415 return 0;
2416}
2417
2418////////////////////////////////////////////////////////////////////////////////
2419/// Changes the specified dynamic parameters if the pointer is actively
2420/// grabbed by the client and if the specified time is no earlier than the
2421/// last-pointer-grab time and no later than the current X server time.
2422
2426
2427////////////////////////////////////////////////////////////////////////////////
2428/// Requests that the specified selection be converted to the specified
2429/// target type.
2430
2434
2435////////////////////////////////////////////////////////////////////////////////
2436/// Changes the owner and last-change time for the specified selection.
2437
2442
2443////////////////////////////////////////////////////////////////////////////////
2444/// Alters the property for the specified window and causes the X server
2445/// to generate a PropertyNotify event on that window.
2446
2450
2451////////////////////////////////////////////////////////////////////////////////
2452/// Add XdndAware property and the list of drag and drop types to the
2453/// Window win.
2454
2458
2459////////////////////////////////////////////////////////////////////////////////
2460/// Add the list of drag and drop types to the Window win.
2461
2465
2466////////////////////////////////////////////////////////////////////////////////
2467/// Recursively search in the children of Window for a Window which is at
2468/// location x, y and is DND aware, with a maximum depth of maxd.
2469
2471{
2472 return kNone;
2473}
2474
2475////////////////////////////////////////////////////////////////////////////////
2476/// Checks if the Window is DND aware, and knows any of the DND formats
2477/// passed in argument.
2478
2483
2484////////////////////////////////////////////////////////////////////////////////
2485/// Start a modal session for a dialog window.
2486
2490
2491////////////////////////////////////////////////////////////////////////////////
2492/// Returns 1 if window system server supports extension given by the
2493/// argument, returns 0 in case extension is not supported and returns -1
2494/// in case of error (like server not initialized).
2495
2497{
2498 return -1;
2499}
2500
2501////////////////////////////////////////////////////////////////////////////////
2502/// Map the XftFont with the Graphics Context using it.
2503
2507
2508
Handle_t Atom_t
WM token.
Definition GuiTypes.h:37
Handle_t Region_t
Region handle.
Definition GuiTypes.h:32
EGEventType
Definition GuiTypes.h:59
@ kButtonPress
Definition GuiTypes.h:60
ECursor
Definition GuiTypes.h:372
Handle_t Pixmap_t
Pixmap handle.
Definition GuiTypes.h:30
Handle_t FontH_t
Font handle (as opposed to Font_t which is an index)
Definition GuiTypes.h:35
Handle_t Visual_t
Visual handle.
Definition GuiTypes.h:28
Handle_t Window_t
Window handle.
Definition GuiTypes.h:29
const Mask_t kDoRed
Definition GuiTypes.h:319
Handle_t Display_t
Display handle.
Definition GuiTypes.h:27
ULong_t Time_t
Event time.
Definition GuiTypes.h:42
Handle_t GContext_t
Graphics context handle.
Definition GuiTypes.h:38
EInitialState
Initial window mapping state.
Definition GuiTypes.h:345
Handle_t Drawable_t
Drawable handle.
Definition GuiTypes.h:31
Handle_t Cursor_t
Cursor handle.
Definition GuiTypes.h:34
const Handle_t kNone
Definition GuiTypes.h:88
@ kIsUnmapped
Definition GuiTypes.h:46
const Mask_t kDoGreen
Definition GuiTypes.h:320
const Mask_t kDoBlue
Definition GuiTypes.h:321
EMouseButton
Button names.
Definition GuiTypes.h:214
Handle_t Colormap_t
Colormap handle.
Definition GuiTypes.h:33
ULongptr_t Handle_t
Generic resource handle.
Definition GuiTypes.h:26
Handle_t FontStruct_t
Pointer to font structure.
Definition GuiTypes.h:39
#define b(i)
Definition RSha256.hxx:100
#define g(i)
Definition RSha256.hxx:105
#define h(i)
Definition RSha256.hxx:106
static Roo_reg_AGKInteg1D instance
short Style_t
Style number (short)
Definition RtypesCore.h:96
short Color_t
Color number (short)
Definition RtypesCore.h:99
unsigned char UChar_t
Unsigned Character 1 byte (unsigned char)
Definition RtypesCore.h:52
unsigned long ULong_t
Unsigned long integer 4 bytes (unsigned long). Size depends on architecture.
Definition RtypesCore.h:69
long Long_t
Signed long integer 4 bytes (long). Size depends on architecture.
Definition RtypesCore.h:68
unsigned long ULongptr_t
Unsigned integer large enough to hold a pointer (platform-dependent)
Definition RtypesCore.h:90
short Width_t
Line width (short)
Definition RtypesCore.h:98
float Float_t
Float 4 bytes (float)
Definition RtypesCore.h:71
short Font_t
Font number (short)
Definition RtypesCore.h:95
short Short_t
Signed Short integer 2 bytes (short)
Definition RtypesCore.h:53
constexpr Bool_t kFALSE
Definition RtypesCore.h:108
constexpr Bool_t kTRUE
Definition RtypesCore.h:107
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void chupy
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t mask
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t dest_x
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t r
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t child
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void chupx
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t dest_y
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t attr
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t nchar
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t gval
Option_t Option_t TPoint TPoint const char text
char name[80]
Definition TGX11.cxx:110
Atom_t gMOTIF_WM_HINTS
Definition TVirtualX.cxx:34
TVirtualX * gGXBatch
Definition TVirtualX.cxx:38
Atom_t gROOT_MESSAGE
Definition TVirtualX.cxx:35
Atom_t gWM_DELETE_WINDOW
Definition TVirtualX.cxx:33
R__EXTERN TVirtualX *(* gPtr2VirtualX)()
Definition TVirtualX.h:338
Fill Area Attributes class.
Definition TAttFill.h:20
Line Attributes class.
Definition TAttLine.h:20
Marker Attributes class.
Definition TAttMarker.h:20
Text Attributes class.
Definition TAttText.h:20
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
SCoord_t fY
Definition TPoint.h:36
SCoord_t fX
Definition TPoint.h:35
Basic string class.
Definition TString.h:138
Semi-Abstract base class defining a generic interface to the underlying, low level,...
Definition TVirtualX.h:46
virtual void 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].
virtual Bool_t AllocColor(Colormap_t cmap, ColorStruct_t &color)
Allocates a read-only colormap entry corresponding to the closest RGB value supported by the hardware...
virtual Int_t WriteGIF(char *name)
Writes the current window into GIF file.
virtual void DestroyWindow(Window_t id)
Destroys the window "id" as well as all of its subwindows.
virtual Window_t CreateOpenGLWindow(Window_t parentID, UInt_t width, UInt_t height, const std::vector< std::pair< UInt_t, Int_t > > &format)
Create window with special pixel format. Noop everywhere except Cocoa.
virtual void DispatchClientMessage(UInt_t messageID)
Force processing of event, sent by SendEvent before.
virtual void GetGCValues(GContext_t gc, GCValues_t &gval)
Returns the components specified by the mask in "gval" for the specified GC "gc" (see also the GCValu...
virtual Handle_t GetCurrentOpenGLContext()
Asks OpenGL subsystem about the current OpenGL context.
virtual void DrawPolyLine(Int_t n, TPoint *xy)
Draws a line through all points in the list.
virtual void SetWindowBackground(Window_t id, ULong_t color)
Sets the background of the window "id" to the specified color value "color".
virtual Int_t KeysymToKeycode(UInt_t keysym)
Converts the "keysym" to the appropriate keycode.
virtual void SetPrimarySelectionOwner(Window_t id)
Makes the window "id" the current owner of the primary selection.
virtual void DeleteImage(Drawable_t img)
Deallocates the memory associated with the image img.
void SetFillColor(Color_t cindex) override
Sets color index "cindex" for fill areas.
void SetMarkerStyle(Style_t markerstyle) override
Sets marker style.
virtual void SetWMTransientHint(Window_t id, Window_t main_id)
Tells window manager that the window "id" is a transient window of the window "main_id".
virtual void SetTextMagnitude(Float_t mgn)
Sets the current text magnification factor to "mgn".
virtual void GetWindowSize(Drawable_t id, Int_t &x, Int_t &overridey, UInt_t &w, UInt_t &h)
Returns the location and the size of window "id".
virtual void MapRaised(Window_t id)
Maps the window "id" and all of its subwindows that have had map requests on the screen and put this ...
virtual void SetOpacity(Int_t percent)
Sets opacity of the current window.
virtual void DeleteFont(FontStruct_t fs)
Explicitly deletes the font structure "fs" obtained via LoadQueryFont().
virtual Pixmap_t CreateBitmap(Drawable_t id, const char *bitmap, UInt_t width, UInt_t height)
Creates a bitmap (i.e.
virtual void ConvertSelection(Window_t, Atom_t &, Atom_t &, Atom_t &, Time_t &)
Requests that the specified selection be converted to the specified target type.
virtual void 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.
virtual void ChangeActivePointerGrab(Window_t, UInt_t, Cursor_t)
Changes the specified dynamic parameters if the pointer is actively grabbed by the client and if the ...
virtual Int_t OpenPixmap(UInt_t w, UInt_t h)
Creates a pixmap of the width "w" and height "h" you specified.
virtual void UnmapWindow(Window_t id)
Unmaps the specified window "id".
virtual void SetRGB(Int_t cindex, Float_t r, Float_t g, Float_t b)
Sets color intensities the specified color index "cindex".
virtual void FreeFontStruct(FontStruct_t fs)
Frees the font structure "fs".
virtual Int_t AddPixmap(ULongptr_t pixid, UInt_t w, UInt_t h)
Registers a pixmap created by TGLManager as a ROOT pixmap.
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)
Combines an image with a rectangle of the specified drawable.
virtual void FillPolygon(Window_t id, GContext_t gc, Point_t *points, Int_t npnt)
Fills the region closed by the specified path.
virtual FontStruct_t GetGCFont(GContext_t gc)
Return the font associated with the graphics context gc.
virtual void XorRegion(Region_t rega, Region_t regb, Region_t result)
Calculates the difference between the union and intersection of two regions.
virtual void SetClipOFF(Int_t wid)
Turns off the clipping for the window "wid".
virtual void FlushOpenGLBuffer(Handle_t ctx)
Flushes OpenGL buffer.
virtual void DeleteOpenGLContext(Int_t wid=0)
Deletes OpenGL context for window "wid".
virtual Colormap_t GetColormap() const
Returns handle to colormap.
virtual FontStruct_t LoadQueryFont(const char *font_name)
Provides the most common way for accessing a font: opens (loads) the specified font and returns a poi...
virtual void SetTypeList(Window_t win, Atom_t prop, Atom_t *typelist)
Add the list of drag and drop types to the Window win.
virtual void DeleteProperty(Window_t, Atom_t &)
Deletes the specified property only if the property was defined on the specified window and causes th...
virtual Bool_t HasTTFonts() const
Returns True when TrueType fonts are used.
virtual Cursor_t CreateCursor(ECursor cursor)
Creates the specified cursor.
virtual void 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 i...
virtual void 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.
virtual void RaiseWindow(Window_t id)
Raises the specified window to the top of the stack so that no sibling window obscures it.
virtual Float_t GetTextMagnitude()
Returns the current font magnification factor.
virtual void SetWindowBackgroundPixmap(Window_t id, Pixmap_t pxm)
Sets the background pixmap of the window "id" to the specified pixmap "pxm".
virtual void GetCharacterUp(Float_t &chupx, Float_t &chupy)
Returns character up vector.
virtual void SelectInput(Window_t id, UInt_t evmask)
Defines which input events the window is interested in.
virtual Display_t GetDisplay() const
Returns handle to display (might be useful in some cases where direct X11 manipulation outside of TVi...
virtual Bool_t EqualRegion(Region_t rega, Region_t regb)
Returns kTRUE if the two regions have the same offset, size, and shape.
virtual Bool_t 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.
virtual void SetIconPixmap(Window_t id, Pixmap_t pix)
Sets the icon name pixmap.
virtual Bool_t SetSelectionOwner(Window_t, Atom_t &)
Changes the owner and last-change time for the specified selection.
virtual void SetClipRegion(Int_t wid, Int_t x, Int_t y, UInt_t w, UInt_t h)
Sets clipping region for the window "wid".
virtual void GetImageSize(Drawable_t id, UInt_t &width, UInt_t &height)
Returns the width and height of the image id.
virtual Window_t GetDefaultRootWindow() const
Returns handle to the default root window created when calling XOpenDisplay().
virtual Bool_t EmptyRegion(Region_t reg)
Returns kTRUE if the region reg is empty.
virtual Int_t SupportsExtension(const char *ext) const
Returns 1 if window system server supports extension given by the argument, returns 0 in case extensi...
virtual void BeginModalSessionFor(Window_t window)
Start a modal session for a dialog window.
virtual void DeletePixmap(Pixmap_t pmap)
Explicitly deletes the pixmap resource "pmap".
virtual void SetClassHints(Window_t id, char *className, char *resourceName)
Sets the windows class and resource name.
virtual FontH_t GetFontHandle(FontStruct_t fs)
Returns the font handle of the specified font structure "fs".
virtual void 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.
virtual Bool_t Init(void *display=nullptr)
Initializes the X system.
virtual void ResizeWindow(Int_t wid)
Resizes the window "wid" if necessary.
virtual void 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.
virtual void Warp(Int_t ix, Int_t iy, Window_t id=0)
Sets the pointer position.
virtual Int_t GetProperty(Window_t, Atom_t, Long_t, Long_t, Bool_t, Atom_t, Atom_t *, Int_t *, ULong_t *, ULong_t *, unsigned char **)
Returns the actual type of the property; the actual format of the property; the number of 8-bit,...
virtual void 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].
virtual Drawable_t CreateImage(UInt_t width, UInt_t height)
Allocates the memory needed for an drawable.
virtual Int_t GetDoubleBuffer(Int_t wid)
Queries the double buffer value for the window "wid".
virtual void SetDoubleBuffer(Int_t wid, Int_t mode)
Sets the double buffer on/off on the window "wid".
virtual Int_t GetScreen() const
Returns screen number.
virtual void LowerWindow(Window_t id)
Lowers the specified window "id" to the bottom of the stack so that it does not obscure any sibling w...
virtual void CreateOpenGLContext(Int_t wid=0)
Creates OpenGL context for window "wid".
virtual void 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...
virtual void MapSubwindows(Window_t id)
Maps all subwindows for the specified window "id" in top-to-bottom stacking order.
virtual void FreeFontNames(char **fontlist)
Frees the specified the array of strings "fontlist".
virtual Window_t GetInputFocus()
Returns the window id of the window having the input focus.
virtual void ClosePixmap()
Deletes current pixmap.
virtual void SetInputFocus(Window_t id)
Changes the input focus to specified window "id".
virtual void SetWMState(Window_t id, EInitialState state)
Sets the initial state of the window "id": either kNormalState or kIconicState.
virtual void Update(Int_t mode=0)
Flushes (mode = 0, default) or synchronizes (mode = 1) X output buffer.
virtual Int_t RequestLocator(Int_t mode, Int_t ctyp, Int_t &x, Int_t &y)
Requests Locator position.
virtual UInt_t ExecCommand(TGWin32Command *code)
Executes the command "code" coming from the other threads (Win32)
virtual void SendEvent(Window_t id, Event_t *ev)
Specifies the event "ev" is to be sent to the window "id".
virtual Int_t AddWindow(ULongptr_t qwid, UInt_t w, UInt_t h)
Registers a window created by Qt as a ROOT window.
virtual Int_t GetFontAscent() const
Returns the ascent of the current font (in pixels).
virtual void SetForeground(GContext_t gc, ULong_t foreground)
Sets the foreground color for the specified GC (shortcut for ChangeGC with only foreground mask set).
virtual void 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".
virtual FontStruct_t GetFontStruct(FontH_t fh)
Retrieves the associated font structure of the font specified font handle "fh".
virtual Bool_t ReadPictureDataFromFile(const char *filename, char ***ret_data)
Reads picture data from file "filename" and store it in "ret_data".
virtual void UpdateWindow(Int_t mode)
Updates or synchronises client and server once (not permanent).
virtual void SetCursor(Int_t win, ECursor cursor)
The cursor "cursor" will be used when the pointer is in the window "wid".
virtual void CopyGC(GContext_t org, GContext_t dest, Mask_t mask)
Copies the specified components from the source GC "org" to the destination GC "dest".
void SetFillStyle(Style_t style) override
Sets fill area style.
virtual void CloseWindow()
Deletes current window.
virtual void RescaleWindow(Int_t wid, UInt_t w, UInt_t h)
Rescales the window "wid".
virtual Int_t OpenDisplay(const char *dpyName)
Opens connection to display server (if such a thing exist on the current platform).
virtual Int_t SetTextFont(char *fontname, ETextSetMode mode)
Sets text font to specified name "fontname".This function returns 0 if the specified font is found,...
virtual Int_t RequestString(Int_t x, Int_t y, char *text)
Requests string: text is displayed and can be edited with Emacs-like keybinding.
virtual void GetTextExtent(UInt_t &w, UInt_t &h, char *mess)
Returns the size of the specified character string "mess".
virtual ULong_t GetPixel(Color_t cindex)
Returns pixel value associated to specified ROOT color number "cindex".
virtual void ChangeProperties(Window_t id, Atom_t property, Atom_t type, Int_t format, UChar_t *data, Int_t len)
Alters the property for the specified window and causes the X server to generate a PropertyNotify eve...
virtual void SetDNDAware(Window_t, Atom_t *)
Add XdndAware property and the list of drag and drop types to the Window win.
virtual void 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".
virtual void GetWindowAttributes(Window_t id, WindowAttributes_t &attr)
The WindowAttributes_t structure is set to default.
Definition TVirtualX.cxx:66
void SetTextSize(Float_t textsize) override
Sets the current text size to "textsize".
virtual Bool_t 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".
virtual Bool_t 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 ...
Definition TVirtualX.cxx:89
virtual Int_t ResizePixmap(Int_t wid, UInt_t w, UInt_t h)
Resizes the specified pixmap "wid".
virtual Window_t FindRWindow(Window_t win, Window_t dragwin, Window_t input, int x, int y, int maxd)
Recursively search in the children of Window for a Window which is at location x, y and is DND aware,...
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)
Translates coordinates in one window to the coordinate space of another window.
virtual Double_t GetOpenGLScalingFactor()
On a HiDPI resolution it can be > 1., this means glViewport should use scaled width and height.
virtual void 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...
virtual void DrawSegments(Drawable_t id, GContext_t gc, Segment_t *seg, Int_t nseg)
Draws multiple line segments.
virtual void CloseDisplay()
Closes connection to display server and destroys all windows.
virtual void DeletePictureData(void *data)
Delete picture data created by the function ReadPictureDataFromFile.
static TVirtualX *& Instance()
Returns gVirtualX global.
Definition TVirtualX.cxx:56
virtual void UnionRegion(Region_t rega, Region_t regb, Region_t result)
Computes the union of two regions.
virtual void SetWindowName(Window_t id, char *name)
Sets the window name.
virtual void Bell(Int_t percent)
Sets the sound bell. Percent is loudness from -100% to 100%.
virtual void GetFontProperties(FontStruct_t font, Int_t &max_ascent, Int_t &max_descent)
Returns the font properties.
virtual Bool_t PointInRegion(Int_t x, Int_t y, Region_t reg)
Returns kTRUE if the point [x, y] is contained in the region reg.
virtual void CopyPixmap(Int_t wid, Int_t xpos, Int_t ypos)
Copies the pixmap "wid" at the position [xpos,ypos] in the current window.
virtual Pixmap_t 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.
virtual Int_t GetFontDescent() const
Returns the descent of the current font (in pixels.
virtual void SetDoubleBufferOFF()
Turns double buffer mode off.
void SetLineColor(Color_t cindex) override
Sets color index "cindex" for drawing lines.
virtual void GetPlanes(Int_t &nplanes)
Returns the maximum number of planes.
virtual void SetKeyAutoRepeat(Bool_t on=kTRUE)
Turns key auto repeat on (kTRUE) or off (kFALSE).
void SetLineStyle(Style_t linestyle) override
Sets the line style.
virtual void DrawPolyMarker(Int_t n, TPoint *xy)
Draws "n" markers with the current attributes at position [x,y].
virtual void SetWMSize(Window_t id, UInt_t w, UInt_t h)
Tells window manager the desired size of window "id".
virtual void ChangeWindowAttributes(Window_t id, SetWindowAttributes_t *attr)
Changes the attributes of the specified window "id" according the values provided in "attr".
virtual void GetRGB(Int_t index, Float_t &r, Float_t &g, Float_t &b)
Returns RGB values for color "index".
virtual void 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".
virtual Handle_t GetNativeEvent() const
Returns the current native event handle.
virtual void SetIconName(Window_t id, char *name)
Sets the window icon name.
virtual void Sync(Int_t mode)
Set synchronisation on or off.
virtual void SetClipRectangles(GContext_t gc, Int_t x, Int_t y, Rectangle_t *recs, Int_t n)
Sets clipping rectangles in graphics context.
void SetMarkerColor(Color_t cindex) override
Sets color index "cindex" for markers.
virtual void SetLineType(Int_t n, Int_t *dash)
Sets the line type.
virtual Region_t PolygonRegion(Point_t *points, Int_t np, Bool_t winding)
Returns a region for the polygon defined by the points array.
virtual void DestroySubwindows(Window_t id)
The DestroySubwindows function destroys all inferior windows of the specified window,...
virtual void SelectPixmap(Int_t qpixid)
Selects the pixmap "qpixid".
void SetTextAlign(Short_t talign=11) override
Sets the text alignment.
virtual Atom_t InternAtom(const char *atom_name, Bool_t only_if_exist)
Returns the atom identifier associated with the specified "atom_name" string.
virtual void WritePixmap(Int_t wid, UInt_t w, UInt_t h, char *pxname)
Writes the pixmap "wid" in the bitmap file "pxname".
virtual void 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 regio...
virtual void SetDoubleBufferON()
Turns double buffer mode on.
virtual void SetDrawMode(EDrawMode mode)
Sets the drawing mode.
virtual unsigned char * GetColorBits(Drawable_t wid, Int_t x=0, Int_t y=0, UInt_t w=0, UInt_t h=0)
Returns an array of pixels created from a part of drawable (defined by x, y, w, h) in format:
virtual void ChangeGC(GContext_t gc, GCValues_t *gval)
Changes the components specified by the mask in gval for the specified GC.
virtual const char * DisplayName(const char *=nullptr)
Returns hostname on which the display is opened.
virtual void ShapeCombineMask(Window_t id, Int_t x, Int_t y, Pixmap_t mask)
The Non-rectangular Window Shape Extension adds non-rectangular windows to the System.
virtual void 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.
virtual Window_t GetPrimarySelectionOwner()
Returns the window id of the current owner of the primary selection.
virtual void IconifyWindow(Window_t id)
Iconifies the window "id".
virtual Window_t GetCurrentWindow() const
pointer to the current internal window used in canvas graphics
void SetLineWidth(Width_t width) override
Sets the line width.
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)
Combines the specified rectangle of "src" with the specified rectangle of "dest" according to the "gc...
virtual void 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.
virtual char ** ListFonts(const char *fontname, Int_t max, Int_t &count)
Returns list of font names matching fontname regexp, like "-*-times-*".
virtual void DeleteGC(GContext_t gc)
Deletes the specified GC "gc".
virtual void 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 eve...
virtual void NextEvent(Event_t &event)
The "event" is set to default event.
virtual void FreeColor(Colormap_t cmap, ULong_t pixel)
Frees color cell with specified pixel value.
virtual void QueryPointer(Int_t &ix, Int_t &iy)
Returns the pointer position.
virtual void SetCharacterUp(Float_t chupx, Float_t chupy)
Sets character up vector.
virtual void QueryColor(Colormap_t cmap, ColorStruct_t &color)
Returns the current RGB value for the pixel in the "color" structure.
void SetTextColor(Color_t cindex) override
Sets the color index "cindex" for text.
virtual void GetGeometry(Int_t wid, Int_t &x, Int_t &y, UInt_t &w, UInt_t &h)
Returns position and size of window "wid".
virtual Pixmap_t CreatePixmapFromData(unsigned char *bits, UInt_t width, UInt_t height)
create pixmap from RGB data.
virtual void GetRegionBox(Region_t reg, Rectangle_t *rect)
Returns smallest enclosing rectangle.
virtual void RemoveWindow(ULongptr_t qwid)
Removes the created by Qt window "qwid".
virtual Window_t GetParent(Window_t id) const
Returns the parent of the window "id".
virtual void DrawFillArea(Int_t n, TPoint *xy)
Fills area described by the polygon.
virtual void SetWMPosition(Window_t id, Int_t x, Int_t y)
Tells the window manager the desired position [x,y] of window "id".
virtual void 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 o...
virtual void MapGCFont(GContext_t, FontStruct_t)
Map the XftFont with the Graphics Context using it.
virtual void DestroyRegion(Region_t reg)
Destroys the region "reg".
virtual void SubtractRegion(Region_t rega, Region_t regb, Region_t result)
Subtracts regb from rega and stores the results in result.
virtual void GrabKey(Window_t id, Int_t keycode, UInt_t modifier, Bool_t grab=kTRUE)
Establishes a passive grab on the keyboard.
virtual Int_t EventsPending()
Returns the number of events that have been received from the X server but have not been removed from...
virtual GContext_t CreateGC(Drawable_t id, GCValues_t *gval)
Creates a graphics context using the provided GCValues_t *gval structure.
virtual Int_t InitWindow(ULongptr_t window)
Creates a new window and return window number.
virtual Bool_t MakeOpenGLContextCurrent(Handle_t ctx, Window_t windowID)
Makes context ctx current OpenGL context.
void SetMarkerSize(Float_t markersize) override
Sets marker size index.
virtual UInt_t ScreenWidthMM() const
Returns the width of the screen in millimeters.
virtual void DrawLine(Int_t x1, Int_t y1, Int_t x2, Int_t y2)
Draws a line.
virtual Bool_t NeedRedraw(ULongptr_t tgwindow, Bool_t force)
Notify the low level GUI layer ROOT requires "tgwindow" to be updated.
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)
Creates an unmapped subwindow for a specified parent window and returns the created window.
virtual Visual_t GetVisual() const
Returns handle to visual.
virtual Pixmap_t ReadGIF(Int_t x0, Int_t y0, const char *file, Window_t id=0)
If id is NULL - loads the specified gif file at position [x0,y0] in the current window.
virtual Bool_t IsDNDAware(Window_t win, Atom_t *typelist)
Checks if the Window is DND aware, and knows any of the DND formats passed in argument.
virtual Int_t TextWidth(FontStruct_t font, const char *s, Int_t len)
Return length of the string "s" in pixels. Size depends on font.
virtual void ClearWindow()
Clears the entire area of the current window.
virtual void SelectWindow(Int_t wid)
Selects the window "wid" to which subsequent output is directed.
virtual void PutPixel(Drawable_t id, Int_t x, Int_t y, ULong_t pixel)
Overwrites the pixel in the image with the specified pixel value.
virtual Int_t GetDepth() const
Returns depth of screen (number of bit planes).
virtual Window_t GetWindowID(Int_t wid)
Returns the X11 window identifier.
virtual Bool_t CheckEvent(Window_t id, EGEventType type, Event_t &ev)
Check if there is for window "id" an event of type "type".
virtual void ConvertPrimarySelection(Window_t id, Atom_t clipboard, Time_t when)
Causes a SelectionRequest event to be sent to the current primary selection owner.
virtual void MoveWindow(Int_t wid, Int_t x, Int_t y)
Moves the window "wid" to the specified x and y coordinates.
virtual void WMDeleteNotify(Window_t id)
Tells WM to send message when window is closed via WM.
virtual void IntersectRegion(Region_t rega, Region_t regb, Region_t result)
Computes the intersection of two regions.
virtual Region_t CreateRegion()
Creates a new empty region.
virtual void MapWindow(Window_t id)
Maps the window "id" and all of its subwindows that have had map requests.
virtual void SetMWMHints(Window_t id, UInt_t value, UInt_t funcs, UInt_t input)
Sets decoration style.
Double_t y[n]
Definition legend1.C:17
Double_t x[n]
Definition legend1.C:17
ULong_t fPixel
color pixel value (index in color table)
Definition GuiTypes.h:311
UShort_t fRed
red component (0..65535)
Definition GuiTypes.h:312
UShort_t fGreen
green component (0..65535)
Definition GuiTypes.h:313
UShort_t fBlue
blue component (0..65535)
Definition GuiTypes.h:314
UShort_t fMask
mask telling which color components are valid
Definition GuiTypes.h:315
Event structure.
Definition GuiTypes.h:174
Graphics context structure.
Definition GuiTypes.h:224
Point structure (maps to the X11 XPoint structure)
Definition GuiTypes.h:356
Rectangle structure (maps to the X11 XRectangle structure)
Definition GuiTypes.h:361
Used for drawing line segments (maps to the X11 XSegments structure)
Definition GuiTypes.h:351
Attributes that can be used when creating or changing a window.
Definition GuiTypes.h:93
Window attributes that can be inquired.
Definition GuiTypes.h:114