Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TGGC.cxx
Go to the documentation of this file.
1// @(#)root/gui:$Id$
2// Author: Fons Rademakers 20/9/2000
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/** \class TGGC
14 \ingroup guiwidgets
15
16Encapsulate a graphics context used in the low level graphics.
17TGGCPool provides a pool of graphics contexts.
18
19*/
20
21
22#include "TGClient.h"
23#include "TGGC.h"
24#include "TVirtualX.h"
25#include "THashTable.h"
26#include "TColor.h"
27#include "TROOT.h"
28
29#include <iostream>
30#include <cstring>
31
32
33
34////////////////////////////////////////////////////////////////////////////////
35/// Create a graphics context (only called via TGGCPool::GetGC()).
36
38{
39 fContext = 0;
40 if (values) {
41 fValues = *values;
42 fContext = gVirtualX->CreateGC(gVirtualX->GetDefaultRootWindow(), values);
43 if (values->fMask & kGCDashList) {
44 if (values->fDashLen > (Int_t)sizeof(fValues.fDashes))
45 Warning("TGGC", "dash list can have only up to %ld elements",
46 (Long_t)sizeof(fValues.fDashes));
47 fValues.fDashLen = std::min(values->fDashLen, (Int_t)sizeof(fValues.fDashes));
50 }
51 } else {
52 fValues = {};
53 fContext = 0;
54 }
55 SetRefCount(1);
56}
57
58////////////////////////////////////////////////////////////////////////////////
59/// Create a graphics context, registers GC in GCPool.
60
62{
63 fContext = 0;
64 // case of default ctor at program startup before gClient exists
65 if (!values) {
66 fValues = {};
67 fContext = 0;
68 SetRefCount(1);
69 return;
70 }
71
72 if (gClient)
73 gClient->GetGC(values, kTRUE);
74 else {
75 fContext = 0;
76 Error("TGGC", "TGClient not yet initialized, should never happen");
77 }
78}
79
80////////////////////////////////////////////////////////////////////////////////
81/// Copy a graphics context.
82
84{
85 fValues = g.fValues;
86 if (g.fContext) {
87 fContext = gVirtualX->CreateGC(gVirtualX->GetDefaultRootWindow(), &fValues);
91 } else
92 fContext = 0;
93 SetRefCount(1);
94
95 if (gClient)
96 gClient->GetGCPool()->fList->Add(this);
97}
98
99////////////////////////////////////////////////////////////////////////////////
100/// Delete graphics context.
101
103{
104 if (gClient)
105 gClient->GetGCPool()->ForceFreeGC(this);
106
107 if (fContext)
108 gVirtualX->DeleteGC(fContext);
109}
110
111////////////////////////////////////////////////////////////////////////////////
112/// Graphics context assignment operator.
113
115{
116 if (this != &rhs) {
117 if (!fContext && gClient) {
118 TGGC *gc = gClient->GetGCPool()->FindGC(this);
119 if (!gc)
120 gClient->GetGCPool()->fList->Add(this);
121 }
122 if (fContext)
123 gVirtualX->DeleteGC(fContext);
125 fValues = rhs.fValues;
126 fContext = gVirtualX->CreateGC(gVirtualX->GetDefaultRootWindow(), &fValues);
130 }
131 return *this;
132}
133
134////////////////////////////////////////////////////////////////////////////////
135/// Not inline due to a bug in g++ 2.96 20000731 (Red Hat Linux 7.0).
136
138{
139 return fContext;
140}
141
142////////////////////////////////////////////////////////////////////////////////
143/// Update values + mask.
144
146{
147 fValues.fMask |= values->fMask;
148
149 for (Mask_t bit = 1; bit <= fValues.fMask; bit <<= 1) {
150 switch (bit & values->fMask) {
151 default:
152 case 0:
153 continue;
154 case kGCFunction:
155 fValues.fFunction = values->fFunction;
156 break;
157 case kGCPlaneMask:
158 fValues.fPlaneMask = values->fPlaneMask;
159 break;
160 case kGCForeground:
162 break;
163 case kGCBackground:
165 break;
166 case kGCLineWidth:
167 fValues.fLineWidth = values->fLineWidth;
168 break;
169 case kGCLineStyle:
170 fValues.fLineStyle = values->fLineStyle;
171 break;
172 case kGCCapStyle:
173 fValues.fCapStyle = values->fCapStyle;
174 break;
175 case kGCJoinStyle:
176 fValues.fJoinStyle = values->fJoinStyle;
177 break;
178 case kGCFillStyle:
179 fValues.fFillStyle = values->fFillStyle;
180 break;
181 case kGCFillRule:
182 fValues.fFillRule = values->fFillRule;
183 break;
184 case kGCTile:
185 fValues.fTile = values->fTile;
186 break;
187 case kGCStipple:
188 fValues.fStipple = values->fStipple;
189 break;
191 fValues.fTsXOrigin = values->fTsXOrigin;
192 break;
194 fValues.fTsYOrigin = values->fTsYOrigin;
195 break;
196 case kGCFont:
197 fValues.fFont = values->fFont;
198 break;
199 case kGCSubwindowMode:
201 break;
204 break;
205 case kGCClipXOrigin:
207 break;
208 case kGCClipYOrigin:
210 break;
211 case kGCClipMask:
212 fValues.fClipMask = values->fClipMask;
213 break;
214 case kGCDashOffset:
216 break;
217 case kGCDashList:
218 if (values->fDashLen > (Int_t)sizeof(fValues.fDashes))
219 Warning("UpdateValues", "dash list can have only up to %ld elements",
220 (Long_t)sizeof(fValues.fDashes));
221 fValues.fDashLen = std::min(values->fDashLen, (Int_t)sizeof(fValues.fDashes));
223 break;
224 case kGCArcMode:
225 fValues.fArcMode = values->fArcMode;
226 break;
227 }
228 }
229}
230
231////////////////////////////////////////////////////////////////////////////////
232/// Set attributes as specified in the values structure.
233
235{
236 if (!fContext && gClient) {
237 TGGC *gc = gClient->GetGCPool()->FindGC(this);
238 if (!gc)
239 gClient->GetGCPool()->fList->Add(this);
240 }
241
242 if (fContext)
243 gVirtualX->ChangeGC(fContext, values);
244 else
245 fContext = gVirtualX->CreateGC(gVirtualX->GetDefaultRootWindow(), values);
246 UpdateValues(values);
247 if (values->fMask & kGCDashList)
250}
251
252////////////////////////////////////////////////////////////////////////////////
253/// Set graphics context drawing function.
254
256{
257 GCValues_t values;
258 values.fFunction = v;
259 values.fMask = kGCFunction;
260 SetAttributes(&values);
261}
262
263////////////////////////////////////////////////////////////////////////////////
264/// Set plane mask.
265
267{
268 GCValues_t values;
269 values.fPlaneMask = v;
270 values.fMask = kGCPlaneMask;
271 SetAttributes(&values);
272}
273
274////////////////////////////////////////////////////////////////////////////////
275/// Set foreground color.
276
278{
279 GCValues_t values;
280 values.fForeground = v;
281 values.fMask = kGCForeground;
282 SetAttributes(&values);
283}
284
285////////////////////////////////////////////////////////////////////////////////
286/// Set background color.
287
289{
290 GCValues_t values;
291 values.fBackground = v;
292 values.fMask = kGCBackground;
293 SetAttributes(&values);
294}
295
296////////////////////////////////////////////////////////////////////////////////
297/// Set line width.
298
300{
301 GCValues_t values;
302 values.fLineWidth = v;
303 values.fMask = kGCLineWidth;
304 SetAttributes(&values);
305}
306
307////////////////////////////////////////////////////////////////////////////////
308/// Set line style (kLineSolid, kLineOnOffDash, kLineDoubleDash).
309
311{
312 GCValues_t values;
313 values.fLineStyle = v;
314 values.fMask = kGCLineStyle;
315 SetAttributes(&values);
316}
317
318////////////////////////////////////////////////////////////////////////////////
319/// Set cap style (kCapNotLast, kCapButt, kCapRound, kCapProjecting).
320
322{
323 GCValues_t values;
324 values.fCapStyle = v;
325 values.fMask = kGCCapStyle;
326 SetAttributes(&values);
327}
328
329////////////////////////////////////////////////////////////////////////////////
330/// Set line join style (kJoinMiter, kJoinRound, kJoinBevel).
331
333{
334 GCValues_t values;
335 values.fJoinStyle = v;
336 values.fMask = kGCJoinStyle;
337 SetAttributes(&values);
338}
339
340////////////////////////////////////////////////////////////////////////////////
341/// Set fill style (kFillSolid, kFillTiled, kFillStippled,
342/// kFillOpaeueStippled).
343
345{
346 GCValues_t values;
347 values.fFillStyle = v;
348 values.fMask = kGCFillStyle;
349 SetAttributes(&values);
350}
351
352////////////////////////////////////////////////////////////////////////////////
353/// Set fill rule (kEvenOddRule, kWindingRule).
354
356{
357 GCValues_t values;
358 values.fFillRule = v;
359 values.fMask = kGCFillRule;
360 SetAttributes(&values);
361}
362
363////////////////////////////////////////////////////////////////////////////////
364/// Set tile pixmap for tiling operations.
365
367{
368 GCValues_t values;
369 values.fTile = v;
370 values.fMask = kGCTile;
371 SetAttributes(&values);
372}
373
374////////////////////////////////////////////////////////////////////////////////
375/// Set 1 plane pixmap for stippling.
376
378{
379 GCValues_t values;
380 values.fStipple = v;
381 values.fMask = kGCStipple;
382 SetAttributes(&values);
383}
384
385////////////////////////////////////////////////////////////////////////////////
386/// X offset for tile or stipple operations.
387
389{
390 GCValues_t values;
391 values.fTsXOrigin = v;
392 values.fMask = kGCTileStipXOrigin;
393 SetAttributes(&values);
394}
395
396////////////////////////////////////////////////////////////////////////////////
397/// Y offset for tile or stipple operations.
398
400{
401 GCValues_t values;
402 values.fTsYOrigin = v;
403 values.fMask = kGCTileStipYOrigin;
404 SetAttributes(&values);
405}
406
407////////////////////////////////////////////////////////////////////////////////
408/// Set font.
409
411{
412 GCValues_t values;
413 values.fFont = v;
414 values.fMask = kGCFont;
415 SetAttributes(&values);
416}
417
418////////////////////////////////////////////////////////////////////////////////
419/// Set sub window mode (kClipByChildren, kIncludeInferiors).
420
422{
423 GCValues_t values;
424 values.fSubwindowMode = v;
425 values.fMask = kGCSubwindowMode;
426 SetAttributes(&values);
427}
428
429////////////////////////////////////////////////////////////////////////////////
430/// True if graphics exposure should be generated.
431
433{
434 GCValues_t values;
435 values.fGraphicsExposures = v;
437 SetAttributes(&values);
438}
439
440////////////////////////////////////////////////////////////////////////////////
441/// X origin for clipping.
442
444{
445 GCValues_t values;
446 values.fClipXOrigin = v;
447 values.fMask = kGCClipXOrigin;
448 SetAttributes(&values);
449}
450
451////////////////////////////////////////////////////////////////////////////////
452/// Y origin for clipping.
453
455{
456 GCValues_t values;
457 values.fClipYOrigin = v;
458 values.fMask = kGCClipYOrigin;
459 SetAttributes(&values);
460}
461
462////////////////////////////////////////////////////////////////////////////////
463/// Bitmap for clipping.
464
466{
467 GCValues_t values;
468 values.fClipMask = v;
469 values.fMask = kGCClipMask;
470 SetAttributes(&values);
471}
472
473////////////////////////////////////////////////////////////////////////////////
474/// Patterned/dashed line offset.
475
477{
478 GCValues_t values;
479 values.fDashOffset = v;
480 values.fMask = kGCDashOffset;
481 SetAttributes(&values);
482}
483
484////////////////////////////////////////////////////////////////////////////////
485/// Set dash pattern. First use SetDashOffset() if not 0.
486
487void TGGC::SetDashList(const char v[], Int_t len)
488{
489 GCValues_t values;
490 if (len > (Int_t)sizeof(values.fDashes))
491 Warning("SetDashList", "dash list can have only up to %ld elements",
492 (Long_t)sizeof(values.fDashes));
493 values.fDashLen = std::min(len, (Int_t)sizeof(values.fDashes));
494 memcpy(values.fDashes, v, values.fDashLen);
495 values.fMask = kGCDashList;
496 SetAttributes(&values);
497}
498
499////////////////////////////////////////////////////////////////////////////////
500/// Set arc mode (kArcChord, kArcPieSlice).
501
503{
504 GCValues_t values;
505 values.fArcMode = v;
506 values.fMask = kGCArcMode;
507 SetAttributes(&values);
508}
509
510////////////////////////////////////////////////////////////////////////////////
511/// Print graphics contexts info.
512
514{
515 Printf("TGGC: mask = %x, handle = %lx, ref cnt = %u", fValues.fMask,
517}
518
519////////////////////////////////////////////////////////////////////////////////
520/// Returns GC mask as a string - used in SavePrimitive().
521
523{
525
526 Mask_t fmask = GetMask();
527
528 if (fmask & kGCFunction) {
529 if (mask.Length() == 0) mask = "kGCFunction";
530 else mask += " | kGCFunction";
531 }
532 if (fmask & kGCPlaneMask) {
533 if (mask.Length() == 0) mask = "kGCPlaneMask";
534 else mask += " | kGCPlaneMask";
535 }
536 if (fmask & kGCForeground) {
537 if (mask.Length() == 0) mask = "kGCForeground";
538 else mask += " | kGCForeground";
539 }
540 if (fmask & kGCBackground) {
541 if (mask.Length() == 0) mask = "kGCBackground";
542 else mask += " | kGCBackground";
543 }
544 if (fmask & kGCLineWidth) {
545 if (mask.Length() == 0) mask = "kGCLineWidth";
546 else mask += " | kGCLineWidth";
547 }
548 if (fmask & kGCLineStyle) {
549 if (mask.Length() == 0) mask = "kGCLineStyle";
550 else mask += " | kGCLineStyle";
551 }
552 if (fmask & kGCCapStyle) {
553 if (mask.Length() == 0) mask = "kGCCapStyle";
554 else mask += " | kGCCapStyle";
555 }
556 if (fmask & kGCJoinStyle) {
557 if (mask.Length() == 0) mask = "kGCJoinStyle";
558 else mask += " | kGCJoinStyle";
559 }
560 if (fmask & kGCFillStyle) {
561 if (mask.Length() == 0) mask = "kGCFillStyle";
562 else mask += " | kGCFillStyle";
563 }
564 if (fmask & kGCFillRule) {
565 if (mask.Length() == 0) mask = "kGCFillRule";
566 else mask += " | kGCFillRule";
567 }
568 if (fmask & kGCTile) {
569 if (mask.Length() == 0) mask = "kGCTile";
570 else mask += " | kGCTile";
571 }
572 if (fmask & kGCStipple) {
573 if (mask.Length() == 0) mask = "kGCStipple";
574 else mask += " | kGCStipple";
575 }
577 if (mask.Length() == 0) mask = "kGCTileStipXOrigin";
578 else mask += " | kGCTileStipXOrigin";
579 }
581 if (mask.Length() == 0) mask = "kGCTileStipYOrigin";
582 else mask += " | kGCTileStipYOrigin";
583 }
584 if (fmask & kGCFont) {
585 if (mask.Length() == 0) mask = "kGCFont";
586 else mask += " | kGCFont";
587 }
588 if (fmask & kGCSubwindowMode) {
589 if (mask.Length() == 0) mask = "kGCSubwindowMode";
590 else mask += " | kGCSubwindowMode";
591 }
593 if (mask.Length() == 0) mask = "kGCGraphicsExposures";
594 else mask += " | kGCGraphicsExposures";
595 }
596 if (fmask & kGCClipXOrigin) {
597 if (mask.Length() == 0) mask = "kGCClipXOrigin";
598 else mask += " | kGCClipXOrigin";
599 }
600 if (fmask & kGCClipYOrigin) {
601 if (mask.Length() == 0) mask = "kGCClipYOrigin";
602 else mask += " | kGCClipYOrigin";
603 }
604 if (fmask & kGCClipMask) {
605 if (mask.Length() == 0) mask = "kGCClipMask";
606 else mask += " | kGCClipMask";
607 }
608 if (fmask & kGCDashOffset) {
609 if (mask.Length() == 0) mask = "kGCDashOffset";
610 else mask += " | kGCDashOffset";
611 }
612 if (fmask & kGCDashList) {
613 if (mask.Length() == 0) mask = "kGCDashList";
614 else mask += " | kGCDashList";
615 }
616 if (fmask & kGCArcMode) {
617 if (mask.Length() == 0) mask = "kGCArcMode";
618 else mask += " | kGCArcMode";
619 }
620 return mask;
621}
622
623////////////////////////////////////////////////////////////////////////////////
624/// Save graphics context info as a C++ statement(s) on output stream out
625
626void TGGC::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
627{
628 out << " \n";
629 // declare graphics context object to reflect required user changes
630 if (!gROOT->ClassSaved(TGGC::Class()))
631 out << " TGGC *uGC; // will reflect user GC changes\n";
632
633 Mask_t fmask = GetMask();
634
636 const char *colorname;
637 ULong_t color;
638
639 out << " // graphics context changes\n";
640 out << " GCValues_t " << valname << ";\n";
641 out << " " << valname << ".fMask = " << GetMaskString() << ";\n";
642
643 for (Mask_t bit = 1; bit <= fmask; bit <<= 1) {
644 switch (bit & fmask) {
645 default:
646 case 0:
647 continue;
648 case kGCFunction:
649 out << " " << valname << ".fFunction = ";
650 switch (GetFunction()) {
651 case kGXclear:
652 out << "kGXclear";
653 break;
654 case kGXand:
655 out << "kGXand";
656 break;
657 case kGXandReverse:
658 out << "kGXandReverse";
659 break;
660 case kGXcopy:
661 out << "kGXcopy";
662 break;
663 case kGXandInverted:
664 out << "kGXandInverted";
665 break;
666 case kGXnoop:
667 out << "kGXnoop";
668 break;
669 case kGXxor:
670 out << "kGXxor";
671 break;
672 case kGXor:
673 out << "kGXor";
674 break;
675 case kGXnor:
676 out << "kGXnor";
677 break;
678 case kGXequiv:
679 out << "kGXequiv";
680 break;
681 case kGXinvert:
682 out << "kGXinvert";
683 break;
684 case kGXorReverse:
685 out << "kGXorReverse";
686 break;
687 case kGXcopyInverted:
688 out << "kGXcopyInverted";
689 break;
690 case kGXorInverted:
691 out << "kGXorInverted";
692 break;
693 case kGXnand:
694 out << "kGXnand";
695 break;
696 case kGXset:
697 out << "kGXset";
698 break;
699 }
700 out << ";\n";
701 break;
702 case kGCPlaneMask:
703 out << " " << valname << ".fPlaneMask = " << GetPlaneMask() << ";\n";
704 break;
705 case kGCForeground:
706 color = GetForeground();
708 out << " gClient->GetColorByName(\"" << colorname << "\", " << valname << ".fForeground);\n";
709 break;
710 case kGCBackground:
711 color = GetBackground();
713 out << " gClient->GetColorByName(\"" << colorname << "\", " << valname << ".fBackground);\n";
714 break;
715 case kGCLineWidth:
716 out << " " << valname << ".fLineWidth = " << GetLineWidth() << ";\n";
717 break;
718 case kGCLineStyle:
719 out << " " << valname << ".fLineStyle = ";
720 switch (GetLineStyle()) {
721 case kLineSolid:
722 out << "kLineSolid";
723 break;
724 case kLineOnOffDash:
725 out << "kLineOnOffDash";
726 break;
727 case kLineDoubleDash:
728 out << "kLineDoubleDash";
729 break;
730 }
731 out << ";\n";
732 break;
733 case kGCCapStyle:
734 out << " " << valname << ".fCapStyle = ";
735 switch (GetCapStyle()) {
736 case kCapNotLast:
737 out << "kCapNotLast";
738 break;
739 case kCapButt:
740 out << "kCapButt";
741 break;
742 case kCapRound:
743 out << "kCapRound";
744 break;
745 case kCapProjecting:
746 out << "kCapProjecting";
747 break;
748 }
749 out << ";\n";
750 break;
751 case kGCJoinStyle:
752 out << " " << valname << ".fJoinStyle = ";
753 switch (GetJoinStyle()) {
754 case kJoinMiter:
755 out << "kJoinMiter";
756 break;
757 case kJoinRound:
758 out << "kJoinRound";
759 break;
760 case kJoinBevel:
761 out << "kJoinBevel";
762 break;
763 }
764 out << ";\n";
765 break;
766 case kGCFillStyle:
767 out << " " << valname << ".fFillStyle = ";
768 switch (GetFillStyle()) {
769 case kFillSolid:
770 out << "kFillSolid";
771 break;
772 case kFillTiled:
773 out << "kFillTiled";
774 break;
775 case kFillStippled:
776 out << "kFillStippled";
777 break;
779 out << "kFillOpaqueStippled";
780 break;
781 }
782 out << ";\n";
783 break;
784 case kGCFillRule:
785 out << " " << valname << ".fFillRule = ";
786 switch (GetFillRule()) {
787 case kEvenOddRule:
788 out << "kEvenOddRule";
789 break;
790 case kWindingRule:
791 out << "kWindingRule";
792 break;
793 }
794 out << ";\n";
795 break;
796 case kGCTile:
797 out << " " << valname << ".fTile = " << GetTile() << ";\n";
798 break;
799 case kGCStipple:
800 out << " " << valname << ".fStipple = " << GetStipple() << ";\n";
801 break;
803 out << " " << valname << ".fTsXOrigin = " << GetTileStipXOrigin() << ";\n";
804 break;
806 out << " " << valname << ".fTsYOrigin = " << GetTileStipYOrigin() << ";\n";
807 break;
808 case kGCFont:
809 out << " " << valname << ".fFont = ufont->GetFontHandle();\n";
810 break;
811 case kGCSubwindowMode:
812 out << " " << valname << ".fSubwindowMode = ";
813 switch (GetSubwindowMode()) {
814 case kClipByChildren:
815 out << "kClipByChildren";
816 break;
818 out << "kIncludeInferiors";
819 break;
820 }
821 out << ";\n";
822 break;
824 out << " " << valname << ".fGraphicsExposures = ";
826 out << "kTRUE";
827 else
828 out << "kFALSE";
829 out << ";\n";
830 break;
831 case kGCClipXOrigin:
832 out << " " << valname << ".fClipXOrigin = " << GetClipXOrigin() << ";\n";
833 break;
834 case kGCClipYOrigin:
835 out << " " << valname << ".fClipYOrigin = " << GetClipYOrigin() << ";\n";
836 break;
837 case kGCClipMask:
838 out << " " << valname << ".fClipMask = " << GetClipMask() << ";\n";
839 break;
840 case kGCDashOffset:
841 out << " " << valname << ".fDashOffset = " << GetDashOffset() << ";\n";
842 break;
843 case kGCDashList:
844 if (GetDashLen() > (Int_t)sizeof(GetDashes()))
845 Warning("SavePrimitive", "dash list can have only up to %ld elements",
846 (Long_t)sizeof(GetDashes()));
847 out << " " << valname << ".fDashLen = "
848 << std::min(GetDashLen(),(Int_t)sizeof(GetDashes())) << ";\n";
849 out << " memcpy(GetDashes()," << valname << ".fDashes,"
850 << valname << ".fDashLen);\n";
851 break;
852 case kGCArcMode:
853 out << " " << valname << ".fArcMode = ";
854 switch (GetArcMode()) {
855 case kArcChord:
856 out << "kArcChord";
857 break;
858 case kArcPieSlice:
859 out << "kArcPieSlice";
860 break;
861 }
862 out << ";\n";
863 break;
864 }
865 }
866 out << " uGC = gClient->GetGC(&" << valname << ", kTRUE);\n";
867}
868
869
870
871////////////////////////////////////////////////////////////////////////////////
872/// Create graphics context pool.
873
875{
876 fClient = client;
877 fList = new THashTable;
878 fList->SetOwner();
879}
880
881////////////////////////////////////////////////////////////////////////////////
882/// Delete graphics context pool.
883
885{
886 delete fList;
887}
888
889////////////////////////////////////////////////////////////////////////////////
890/// Force remove graphics context from list. Is only called via ~TGGC().
891
893{
894 TGGC *gc = (TGGC *) fList->FindObject(gct);
895
896 if (gc) {
897 if (gc->References() > 1)
898 Error("ForceFreeGC", "removed a shared graphics context\n"
899 "best to use graphics contexts via the TGGCPool()");
900 fList->Remove(gc);
901 }
902}
903
904////////////////////////////////////////////////////////////////////////////////
905/// Delete graphics context if it is not used anymore.
906
908{
909 TGGC *gc = (TGGC *) fList->FindObject(gct);
910
911 if (gc) {
912 if (gc->RemoveReference() == 0) {
913 fList->Remove(gc);
914 delete gc;
915 }
916 }
917}
918
919////////////////////////////////////////////////////////////////////////////////
920/// Delete graphics context if it is not used anymore.
921
923{
924 TIter next(fList);
925
926 while (TGGC *gc = (TGGC *) next()) {
927 if (gc->fContext == gct) {
928 if (gc->RemoveReference() == 0) {
929 fList->Remove(gc);
930 delete gc;
931 return;
932 }
933 }
934 }
935}
936
937////////////////////////////////////////////////////////////////////////////////
938/// Find graphics context. Returns 0 in case gc is not found.
939
941{
942 return (TGGC*) fList->FindObject(gct);
943}
944
945////////////////////////////////////////////////////////////////////////////////
946/// Find graphics context based on its GContext_t handle. Returns 0
947/// in case gc is not found.
948
950{
951 TIter next(fList);
952
953 while (TGGC *gc = (TGGC *) next()) {
954 if (gc->fContext == gct)
955 return gc;
956 }
957 return 0;
958}
959
960////////////////////////////////////////////////////////////////////////////////
961/// returns graphics context based on its GContext_t handle.
962
964{
966 gVirtualX->GetGCValues(gct, gval);
967 return GetGC(&gval, kTRUE);
968}
969
970////////////////////////////////////////////////////////////////////////////////
971/// Get the best matching graphics context depending on values.
972/// If rw is false only a readonly, not modifiable graphics context
973/// is returned. If rw is true a new modifiable graphics context is
974/// returned.
975
977{
978 TGGC *gc, *best_match = 0;
981
982 if (!values)
983 rw = kTRUE;
984
985 if (!rw) {
986
987 // First, try to find an exact matching GC.
988 // If no one found, then use the closest one.
989
990 TIter next(fList);
991
992 while ((gc = (TGGC *) next())) {
993 matching_bits = MatchGC(gc, values);
996 best_match = gc;
997 if ((gc->fValues.fMask & values->fMask) == values->fMask) {
998 exact = kTRUE;
999 break;
1000 }
1001 }
1002 }
1003
1004 if (best_match) {
1005 if (gDebug > 0)
1006 Printf("<TGGCPool::GetGC>: %smatching GC found\n", exact ? "exact " : "");
1007 best_match->AddReference();
1008 if (!exact) {
1009 // add missing values to the best_match'ing GC...
1010 UpdateGC(best_match, values);
1011 }
1012 return best_match;
1013 }
1014 }
1015
1016 gc = new TGGC(values, kTRUE);
1017
1018 fList->Add(gc);
1019
1020 return gc;
1021}
1022
1023////////////////////////////////////////////////////////////////////////////////
1024/// Try to find matching graphics context. On success returns the amount
1025/// of matching bits (which may be zero if masks have no common bits),
1026/// -1 on failure (when there are common bits but not a single match).
1027
1029{
1031 Int_t matching_bits = -1;
1032 Bool_t match = kFALSE;
1033 const GCValues_t *gcv = &gc->fValues;
1034
1035 common_bits = values->fMask & gcv->fMask;
1036
1037 if (common_bits == 0) return 0; // no common bits, a possible
1038 // candidate anyway.
1039
1040 // Careful, check first the tile and stipple mask bits, as these
1041 // influence nearly all other GC functions... (do the same for
1042 // some other such bits as GCFunction, etc...). Perhaps we should
1043 // allow only exact GC matches.
1044
1045 if (gcv->fMask & kGCTile)
1046 if ((gcv->fTile != kNone) && !(values->fMask & kGCTile)) return -1;
1047 if (values->fMask & kGCTile)
1048 if ((values->fTile != kNone) && !(gcv->fMask & kGCTile)) return -1;
1049 if (gcv->fMask & kGCStipple)
1050 if ((gcv->fStipple != kNone) && !(values->fMask & kGCStipple)) return -1;
1051 if (values->fMask & kGCStipple)
1052 if ((values->fStipple != kNone) && !(gcv->fMask & kGCStipple)) return -1;
1053
1054 for (bit = 1; bit <= common_bits; bit <<= 1) {
1055 switch (bit & common_bits) {
1056 default:
1057 case 0:
1058 continue;
1059 case kGCFunction:
1060 match = (values->fFunction == gcv->fFunction);
1061 break;
1062 case kGCPlaneMask:
1063 match = (values->fPlaneMask == gcv->fPlaneMask);
1064 break;
1065 case kGCForeground:
1066 match = (values->fForeground == gcv->fForeground);
1067 break;
1068 case kGCBackground:
1069 match = (values->fBackground == gcv->fBackground);
1070 break;
1071 case kGCLineWidth:
1072 match = (values->fLineWidth == gcv->fLineWidth);
1073 break;
1074 case kGCLineStyle:
1075 match = (values->fLineStyle == gcv->fLineStyle);
1076 break;
1077 case kGCCapStyle:
1078 match = (values->fCapStyle == gcv->fCapStyle);
1079 break;
1080 case kGCJoinStyle:
1081 match = (values->fJoinStyle == gcv->fJoinStyle);
1082 break;
1083 case kGCFillStyle:
1084 match = (values->fFillStyle == gcv->fFillStyle);
1085 break;
1086 case kGCFillRule:
1087 match = (values->fFillRule == gcv->fFillRule);
1088 break;
1089 case kGCTile:
1090 match = (values->fTile == gcv->fTile);
1091 break;
1092 case kGCStipple:
1093 match = (values->fStipple == gcv->fStipple);
1094 break;
1095 case kGCTileStipXOrigin:
1096 match = (values->fTsXOrigin == gcv->fTsXOrigin);
1097 break;
1098 case kGCTileStipYOrigin:
1099 match = (values->fTsYOrigin == gcv->fTsYOrigin);
1100 break;
1101 case kGCFont:
1102 match = (values->fFont == gcv->fFont);
1103 break;
1104 case kGCSubwindowMode:
1105 match = (values->fSubwindowMode == gcv->fSubwindowMode);
1106 break;
1108 match = (values->fGraphicsExposures == gcv->fGraphicsExposures);
1109 break;
1110 case kGCClipXOrigin:
1111 match = (values->fClipXOrigin == gcv->fClipXOrigin);
1112 break;
1113 case kGCClipYOrigin:
1114 match = (values->fClipYOrigin == gcv->fClipYOrigin);
1115 break;
1116 case kGCClipMask:
1117 match = (values->fClipMask == gcv->fClipMask);
1118 break;
1119 case kGCDashOffset:
1120 match = (values->fDashOffset == gcv->fDashOffset);
1121 break;
1122 case kGCDashList:
1123 if (values->fDashLen == gcv->fDashLen)
1124 match = (strncmp(values->fDashes, gcv->fDashes, gcv->fDashLen) == 0);
1125 break;
1126 case kGCArcMode:
1127 match = (values->fArcMode == gcv->fArcMode);
1128 break;
1129 }
1130 if (!match)
1131 return -1;
1132 matching_bits++;
1133 match = kFALSE;
1134 }
1135
1136 return matching_bits;
1137}
1138
1139////////////////////////////////////////////////////////////////////////////////
1140/// Update graphics context with the values spcified in values->fMask.
1141
1143{
1144 gc->SetAttributes(values);
1145}
1146
1147////////////////////////////////////////////////////////////////////////////////
1148/// List all graphics contexts in the pool.
1149
1151{
1152 fList->Print();
1153}
const Mask_t kGCCapStyle
Definition GuiTypes.h:292
const Mask_t kGCArcMode
Definition GuiTypes.h:308
const Mask_t kGCDashOffset
Definition GuiTypes.h:306
const Mask_t kGCBackground
Definition GuiTypes.h:289
const Mask_t kGCForeground
Definition GuiTypes.h:288
const Mask_t kGCLineStyle
Definition GuiTypes.h:291
const Mask_t kGCSubwindowMode
Definition GuiTypes.h:301
const Mask_t kGCLineWidth
Definition GuiTypes.h:290
Handle_t Pixmap_t
Pixmap handle.
Definition GuiTypes.h:30
const Mask_t kGCTile
Definition GuiTypes.h:296
const Mask_t kGCClipXOrigin
Definition GuiTypes.h:303
Handle_t FontH_t
Font handle (as opposed to Font_t which is an index)
Definition GuiTypes.h:35
const Mask_t kGCDashList
Definition GuiTypes.h:307
const Mask_t kGCFillStyle
Definition GuiTypes.h:294
const Mask_t kGCJoinStyle
Definition GuiTypes.h:293
const Mask_t kGCFunction
Definition GuiTypes.h:286
EGraphicsFunction
Definition GuiTypes.h:67
@ kGXorReverse
src OR NOT dst
Definition GuiTypes.h:79
@ kGXnand
NOT src OR NOT dst.
Definition GuiTypes.h:82
@ kGXandReverse
src AND NOT dst
Definition GuiTypes.h:70
@ kGXor
src OR dst
Definition GuiTypes.h:75
@ kGXcopy
src
Definition GuiTypes.h:71
@ kGXorInverted
NOT src OR dst.
Definition GuiTypes.h:81
@ kGXandInverted
NOT src AND dst.
Definition GuiTypes.h:72
@ kGXequiv
NOT src XOR dst.
Definition GuiTypes.h:77
@ kGXset
1
Definition GuiTypes.h:83
@ kGXnor
NOT src AND NOT dst.
Definition GuiTypes.h:76
@ kGXnoop
dst
Definition GuiTypes.h:73
@ kGXinvert
NOT dst.
Definition GuiTypes.h:78
@ kGXxor
src XOR dst
Definition GuiTypes.h:74
@ kGXand
src AND dst
Definition GuiTypes.h:69
@ kGXclear
0
Definition GuiTypes.h:68
@ kGXcopyInverted
NOT src.
Definition GuiTypes.h:80
Handle_t GContext_t
Graphics context handle.
Definition GuiTypes.h:38
const Mask_t kGCTileStipXOrigin
Definition GuiTypes.h:298
const Mask_t kGCFont
Definition GuiTypes.h:300
const Handle_t kNone
Definition GuiTypes.h:88
@ kEvenOddRule
Definition GuiTypes.h:52
@ kArcPieSlice
Definition GuiTypes.h:54
@ kCapNotLast
Definition GuiTypes.h:49
@ kCapProjecting
Definition GuiTypes.h:49
@ kWindingRule
Definition GuiTypes.h:52
@ kFillOpaqueStippled
Definition GuiTypes.h:51
@ kClipByChildren
Definition GuiTypes.h:53
@ kLineDoubleDash
Definition GuiTypes.h:48
@ kCapButt
Definition GuiTypes.h:49
@ kCapRound
Definition GuiTypes.h:49
@ kJoinBevel
Definition GuiTypes.h:50
@ kIncludeInferiors
Definition GuiTypes.h:53
@ kFillStippled
Definition GuiTypes.h:51
@ kFillSolid
Definition GuiTypes.h:51
@ kLineSolid
Definition GuiTypes.h:48
@ kJoinRound
Definition GuiTypes.h:50
@ kJoinMiter
Definition GuiTypes.h:50
@ kLineOnOffDash
Definition GuiTypes.h:48
@ kArcChord
Definition GuiTypes.h:54
@ kFillTiled
Definition GuiTypes.h:51
const Mask_t kGCFillRule
Definition GuiTypes.h:295
const Mask_t kGCPlaneMask
Definition GuiTypes.h:287
const Mask_t kGCStipple
Definition GuiTypes.h:297
const Mask_t kGCGraphicsExposures
Definition GuiTypes.h:302
const Mask_t kGCClipYOrigin
Definition GuiTypes.h:304
const Mask_t kGCClipMask
Definition GuiTypes.h:305
const Mask_t kGCTileStipYOrigin
Definition GuiTypes.h:299
#define g(i)
Definition RSha256.hxx:105
unsigned long ULong_t
Unsigned long integer 4 bytes (unsigned long). Size depends on architecture.
Definition RtypesCore.h:69
long Long_t
Signed long integer 4 bytes (long). Size depends on architecture.
Definition RtypesCore.h:68
constexpr Bool_t kFALSE
Definition RtypesCore.h:108
constexpr Bool_t kTRUE
Definition RtypesCore.h:107
const char Option_t
Option string (const char)
Definition RtypesCore.h:80
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
#define gClient
Definition TGClient.h:157
Option_t Option_t option
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t mask
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t UChar_t len
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t gval
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void gc
Int_t gDebug
Global variable setting the debug level. Set to 0 to disable, increase it in steps of 1 to increase t...
Definition TROOT.cxx:627
#define gROOT
Definition TROOT.h:411
void Printf(const char *fmt,...)
Formats a string in a circular formatting buffer and prints the string.
Definition TString.cxx:2509
#define gVirtualX
Definition TVirtualX.h:337
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
static const char * PixelAsHexString(ULong_t pixel)
Convert machine dependent pixel value (obtained via RGB2Pixel or via Number2Pixel() or via TColor::Ge...
Definition TColor.cxx:2542
Window client.
Definition TGClient.h:37
THashTable * fList
Definition TGGC.h:108
void Print(Option_t *option="") const override
List all graphics contexts in the pool.
Definition TGGC.cxx:1150
Int_t MatchGC(const TGGC *gc, GCValues_t *values)
Try to find matching graphics context.
Definition TGGC.cxx:1028
~TGGCPool() override
Delete graphics context pool.
Definition TGGC.cxx:884
TGGC * GetGC(GCValues_t *values, Bool_t rw=kFALSE)
Get the best matching graphics context depending on values.
Definition TGGC.cxx:976
void FreeGC(const TGGC *gc)
Delete graphics context if it is not used anymore.
Definition TGGC.cxx:907
friend class TGGC
Definition TGGC.h:105
TGGC * FindGC(const TGGC *gc)
Find graphics context. Returns 0 in case gc is not found.
Definition TGGC.cxx:940
void ForceFreeGC(const TGGC *gc)
Force remove graphics context from list. Is only called via ~TGGC().
Definition TGGC.cxx:892
TGGCPool(const TGGCPool &gp)
Definition TGGC.h:115
void UpdateGC(TGGC *gc, GCValues_t *values)
Update graphics context with the values spcified in values->fMask.
Definition TGGC.cxx:1142
Encapsulate a graphics context used in the low level graphics.
Definition TGGC.h:22
Pixmap_t GetTile() const
Definition TGGC.h:77
void SetArcMode(Int_t v)
Set arc mode (kArcChord, kArcPieSlice).
Definition TGGC.cxx:502
Int_t GetTileStipYOrigin() const
Definition TGGC.h:80
TGGC(GCValues_t *values, Bool_t calledByGCPool)
Create a graphics context (only called via TGGCPool::GetGC()).
Definition TGGC.cxx:37
Int_t GetJoinStyle() const
Definition TGGC.h:88
Bool_t GetGraphicsExposures() const
Definition TGGC.h:83
Int_t GetSubwindowMode() const
Definition TGGC.h:81
Int_t GetFillStyle() const
Definition TGGC.h:89
void SetLineWidth(Int_t v)
Set line width.
Definition TGGC.cxx:299
ULong_t GetPlaneMask() const
Definition TGGC.h:72
Int_t GetDashLen() const
Definition TGGC.h:92
void SetFont(FontH_t v)
Set font.
Definition TGGC.cxx:410
void SetPlaneMask(ULong_t v)
Set plane mask.
Definition TGGC.cxx:266
TGGC & operator=(const TGGC &rhs)
Graphics context assignment operator.
Definition TGGC.cxx:114
GContext_t fContext
graphics context handle
Definition TGGC.h:28
void SetTileStipYOrigin(Int_t v)
Y offset for tile or stipple operations.
Definition TGGC.cxx:399
Pixmap_t GetClipMask() const
Definition TGGC.h:86
Int_t GetClipXOrigin() const
Definition TGGC.h:84
void SavePrimitive(std::ostream &out, Option_t *option="") override
Save graphics context info as a C++ statement(s) on output stream out.
Definition TGGC.cxx:626
void SetFillStyle(Int_t v)
Set fill style (kFillSolid, kFillTiled, kFillStippled, kFillOpaeueStippled).
Definition TGGC.cxx:344
Pixel_t GetForeground() const
Definition TGGC.h:73
Int_t GetFillRule() const
Definition TGGC.h:90
GCValues_t fValues
graphics context values + mask
Definition TGGC.h:27
void SetCapStyle(Int_t v)
Set cap style (kCapNotLast, kCapButt, kCapRound, kCapProjecting).
Definition TGGC.cxx:321
~TGGC() override
Delete graphics context.
Definition TGGC.cxx:102
const char * GetDashes() const
Definition TGGC.h:93
Int_t GetTileStipXOrigin() const
Definition TGGC.h:79
void SetForeground(Pixel_t v)
Set foreground color.
Definition TGGC.cxx:277
Int_t GetLineStyle() const
Definition TGGC.h:76
void SetClipMask(Pixmap_t v)
Bitmap for clipping.
Definition TGGC.cxx:465
void SetFillRule(Int_t v)
Set fill rule (kEvenOddRule, kWindingRule).
Definition TGGC.cxx:355
GContext_t operator()() const
Not inline due to a bug in g++ 2.96 20000731 (Red Hat Linux 7.0).
Definition TGGC.cxx:137
void SetDashOffset(Int_t v)
Patterned/dashed line offset.
Definition TGGC.cxx:476
void SetTileStipXOrigin(Int_t v)
X offset for tile or stipple operations.
Definition TGGC.cxx:388
void SetAttributes(GCValues_t *values)
Set attributes as specified in the values structure.
Definition TGGC.cxx:234
void SetDashList(const char v[], Int_t len)
Set dash pattern. First use SetDashOffset() if not 0.
Definition TGGC.cxx:487
EGraphicsFunction GetFunction() const
Definition TGGC.h:71
static TClass * Class()
void SetJoinStyle(Int_t v)
Set line join style (kJoinMiter, kJoinRound, kJoinBevel).
Definition TGGC.cxx:332
void SetClipXOrigin(Int_t v)
X origin for clipping.
Definition TGGC.cxx:443
Int_t GetClipYOrigin() const
Definition TGGC.h:85
Pixel_t GetBackground() const
Definition TGGC.h:74
void SetTile(Pixmap_t v)
Set tile pixmap for tiling operations.
Definition TGGC.cxx:366
void SetClipYOrigin(Int_t v)
Y origin for clipping.
Definition TGGC.cxx:454
void Print(Option_t *option="") const override
Print graphics contexts info.
Definition TGGC.cxx:513
void UpdateValues(GCValues_t *v)
Update values + mask.
Definition TGGC.cxx:145
void SetBackground(Pixel_t v)
Set background color.
Definition TGGC.cxx:288
void SetFunction(EGraphicsFunction v)
Set graphics context drawing function.
Definition TGGC.cxx:255
void SetStipple(Pixmap_t v)
Set 1 plane pixmap for stippling.
Definition TGGC.cxx:377
Mask_t GetMask() const
Definition TGGC.h:70
Pixmap_t GetStipple() const
Definition TGGC.h:78
Int_t GetLineWidth() const
Definition TGGC.h:75
void SetGraphicsExposures(Bool_t v)
True if graphics exposure should be generated.
Definition TGGC.cxx:432
void SetLineStyle(Int_t v)
Set line style (kLineSolid, kLineOnOffDash, kLineDoubleDash).
Definition TGGC.cxx:310
Int_t GetDashOffset() const
Definition TGGC.h:91
Int_t GetCapStyle() const
Definition TGGC.h:87
Int_t GetArcMode() const
Definition TGGC.h:94
TString GetMaskString() const
Returns GC mask as a string - used in SavePrimitive().
Definition TGGC.cxx:522
void SetSubwindowMode(Int_t v)
Set sub window mode (kClipByChildren, kIncludeInferiors).
Definition TGGC.cxx:421
TGClient * fClient
Connection to display server.
Definition TGObject.h:25
THashTable implements a hash table to store TObject's.
Definition THashTable.h:35
void Add(TObject *obj) override
Add object to the hash table.
TObject * Remove(TObject *obj) override
Remove object from the hashtable.
TObject * FindObject(const char *name) const override
Find object using its name.
void Print(Option_t *option, Int_t recurse) const override
Print the collection header and its elements.
Mother of all ROOT objects.
Definition TObject.h:41
TObject & operator=(const TObject &rhs) noexcept
TObject assignment operator.
Definition TObject.h:299
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition TObject.cxx:1057
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:1071
Definitions for TRefCnt, base class for reference counted objects.
Definition TRefCnt.h:27
void SetRefCount(UInt_t r)
Definition TRefCnt.h:39
UInt_t References() const
Definition TRefCnt.h:38
Basic string class.
Definition TString.h:138
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Definition TString.cxx:2384
Graphics context structure.
Definition GuiTypes.h:224
ULong_t fBackground
background pixel
Definition GuiTypes.h:228
Int_t fFillRule
kEvenOddRule, kWindingRule
Definition GuiTypes.h:236
Pixmap_t fClipMask
bitmap clipping; other calls for rects
Definition GuiTypes.h:247
Int_t fDashOffset
patterned/dashed line information
Definition GuiTypes.h:248
Int_t fClipYOrigin
Definition GuiTypes.h:246
Int_t fClipXOrigin
origin for clipping
Definition GuiTypes.h:245
Int_t fLineWidth
line width
Definition GuiTypes.h:229
Pixmap_t fStipple
stipple 1 plane pixmap for stippling
Definition GuiTypes.h:239
Mask_t fMask
bit mask specifying which fields are valid
Definition GuiTypes.h:251
Int_t fLineStyle
kLineSolid, kLineOnOffDash, kLineDoubleDash
Definition GuiTypes.h:230
Pixmap_t fTile
tile pixmap for tiling operations
Definition GuiTypes.h:238
Bool_t fGraphicsExposures
boolean, should exposures be generated
Definition GuiTypes.h:244
Int_t fJoinStyle
kJoinMiter, kJoinRound, kJoinBevel
Definition GuiTypes.h:233
Char_t fDashes[8]
dash pattern list (dash length per byte)
Definition GuiTypes.h:249
ULong_t fForeground
foreground pixel
Definition GuiTypes.h:227
ULong_t fPlaneMask
plane mask
Definition GuiTypes.h:226
Int_t fFillStyle
kFillSolid, kFillTiled, kFillStippled, kFillOpaeueStippled
Definition GuiTypes.h:234
FontH_t fFont
default text font for text operations
Definition GuiTypes.h:242
Int_t fTsXOrigin
offset for tile or stipple operations
Definition GuiTypes.h:240
EGraphicsFunction fFunction
logical operation
Definition GuiTypes.h:225
Int_t fDashLen
number of dashes in fDashes
Definition GuiTypes.h:250
Int_t fCapStyle
kCapNotLast, kCapButt, kCapRound, kCapProjecting
Definition GuiTypes.h:231
Int_t fArcMode
kArcChord, kArcPieSlice
Definition GuiTypes.h:237
Int_t fTsYOrigin
Definition GuiTypes.h:241
Int_t fSubwindowMode
kClipByChildren, kIncludeInferiors
Definition GuiTypes.h:243