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