Logo ROOT  
Reference Guide
TGFrame.cxx
Go to the documentation of this file.
1// @(#)root/gui:$Id$
2// Author: Fons Rademakers 03/01/98
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 This source is based on Xclass95, a Win95-looking GUI toolkit.
14 Copyright (C) 1996, 1997 David Barth, Ricky Ralston, Hector Peraza.
15
16 Xclass95 is free software; you can redistribute it and/or
17 modify it under the terms of the GNU Library General Public
18 License as published by the Free Software Foundation; either
19 version 2 of the License, or (at your option) any later version.
20
21**************************************************************************/
22
23
24/** \class TGFrame
25 \ingroup guiwidgets
26
27A subclasses of TGWindow, and is used as base
28class for some simple widgets (buttons, labels, etc.).
29It provides:
30 - position & dimension fields
31 - an 'options' attribute (see constant above)
32 - a generic event handler
33 - a generic layout mechanism
34 - a generic border
35
36
37\class TGCompositeFrame
38\ingroup guiwidgets
39
40The base class for composite widgets
41(menu bars, list boxes, etc.).
42It provides:
43 - a layout manager
44 - a frame container (TList *)
45
46
47\class TGVerticalFrame
48\ingroup guiwidgets
49A composite frame that layout their children in vertical way.
50
51
52\class TGHorizontalFrame
53\ingroup guiwidgets
54A composite frame that layout their children in horizontal way.
55
56
57\class TGMainFrame
58\ingroup guiwidgets
59Defines top level windows that interact with the system Window Manager.
60
61
62\class TGTransientFrame
63\ingroup guiwidgets
64Defines transient windows that typically are used for dialogs windows.
65
66
67\class TGGroupFrame
68\ingroup guiwidgets
69A composite frame with a border and a title.
70It is typically used to group a number of logically related widgets visually together.
71
72\class TGHeaderFrame
73\ingroup guiwidgets
74Horizontal Frame used to contain header buttons and splitters
75in a list view. Used to have resizable column headers.
76
77*/
78
79
80#include "TError.h"
81#include "TGFrame.h"
82#include "TGResourcePool.h"
83#include "TGPicture.h"
84#include "TList.h"
85#include "TApplication.h"
86#include "TTimer.h"
87#include "TClass.h"
88
89#include "TObjString.h"
90#include "TBits.h"
91#include "TColor.h"
92#include "TROOT.h"
93#include "TDatime.h"
94#include "KeySymbols.h"
95#include "TGFileDialog.h"
96#include "TGMsgBox.h"
97#include "TSystem.h"
98#include "TVirtualDragManager.h"
99#include "TGuiBuilder.h"
100#include "TQConnection.h"
101#include "TGButton.h"
102#include "TGSplitter.h"
103#include "TGDNDManager.h"
104#include "TImage.h"
105#include "TObjectSpy.h"
106#include "TVirtualX.h"
107
108#include <iostream>
109#include <fstream>
110
111
117const TGGC *TGFrame::fgBlackGC = nullptr;
118const TGGC *TGFrame::fgWhiteGC = nullptr;
119const TGGC *TGFrame::fgHilightGC = nullptr;
120const TGGC *TGFrame::fgShadowGC = nullptr;
121const TGGC *TGFrame::fgBckgndGC = nullptr;
128
129const TGFont *TGGroupFrame::fgDefaultFont = nullptr;
130const TGGC *TGGroupFrame::fgDefaultGC = nullptr;
131
133
134static const char *gSaveMacroTypes[] = {
135 "ROOT macros", "*.C",
136 "GIF", "*.gif",
137 "PNG", "*.png",
138 "JPEG", "*.jpg",
139 "TIFF", "*.tiff",
140 "XPM", "*.xpm",
141 "All files", "*",
142 0, 0
143};
144
146
155
156
157////////////////////////////////////////////////////////////////////////////////
158/// Create a TGFrame object. Options is an OR of the EFrameTypes.
159
161 UInt_t options, Pixel_t back)
162 : TGWindow(p, 0, 0, w, h, 0, 0, 0, 0, 0, options)
163{
164 if (!fgInit && gClient) {
174 fgInit = kTRUE;
175 }
176
178
179 fDNDState = 0;
180 fBackground = back;
181 fOptions = options;
182 fWidth = w; fHeight = h; fX = fY = fBorderWidth = 0;
183 fMinWidth = 0;
184 fMinHeight = 0;
187 fFE = 0;
188
190 fBorderWidth = (gClient->GetStyle() > 1) ? 1 : (fOptions & kDoubleBorder) ? 2 : 1;
191
193 wattr.fBackgroundPixel = back;
195 if (fOptions & kMainFrame) {
197 gVirtualX->ChangeWindowAttributes(fId, &wattr);
198 //if (fgDefaultBackgroundPicture)
199 // SetBackgroundPixmap(fgDefaultBackgroundPicture->GetPicture());
200 } else {
201 gVirtualX->ChangeWindowAttributes(fId, &wattr);
202 //if (!(fOptions & kOwnBackground))
203 // SetBackgroundPixmap(kParentRelative);
204 }
205 fEventMask = (UInt_t) wattr.fEventMask;
206
207 if ((fOptions & kDoubleBorder) && (gClient->GetStyle() > 1))
209
211}
212
213////////////////////////////////////////////////////////////////////////////////
214/// Create a frame using an externally created window. For example
215/// to register the root window (called by TGClient), or a window
216/// created via TVirtualX::InitWindow() (id is obtained with
217/// TVirtualX::GetWindowID()).
218
220 : TGWindow(c, id, parent)
221{
222 if (!fgInit && gClient) {
232 fgInit = kTRUE;
233 }
234
235 WindowAttributes_t attributes;
236 // Initialize some values - needed for batch mode!
237 attributes.fX = 0;
238 attributes.fY = 0;
239 attributes.fWidth = 100;
240 attributes.fHeight = 100;
241 attributes.fBorderWidth = 4;
242 attributes.fYourEventMask = 0;
243 gVirtualX->GetWindowAttributes(id, attributes);
244
245 fDNDState = 0;
246 fX = attributes.fX;
247 fY = attributes.fY;
248 fWidth = attributes.fWidth;
249 fHeight = attributes.fHeight;
250 fBorderWidth = attributes.fBorderWidth;
251 fEventMask = (UInt_t) attributes.fYourEventMask;
252 fBackground = 0;
253 fOptions = 0;
254 fMinWidth = 0;
255 fMinHeight = 0;
258 fFE = 0;
259
261}
262
263////////////////////////////////////////////////////////////////////////////////
264/// Destructor.
265
267{
268}
269
270////////////////////////////////////////////////////////////////////////////////
271/// Delete window. Use single shot timer to call final delete method.
272/// We use this indirect way since deleting the window in its own
273/// execution "thread" can cause side effects because frame methods
274/// can still be called while the window object has already been deleted.
275
277{
278 if (gDNDManager) {
279 if (gDNDManager->GetMainFrame() == this)
281 }
283 // coverity[returned_null]
284 // coverity[dereference]
285 TTimer::SingleShot(150, IsA()->GetName(), this, "ReallyDelete()");
286 }
288}
289
290////////////////////////////////////////////////////////////////////////////////
291/// Change frame background color.
292
294{
295 fBackground = back;
296 gVirtualX->SetWindowBackground(fId, back);
297 fClient->NeedRedraw(this);
298}
299
300////////////////////////////////////////////////////////////////////////////////
301/// Return frame foreground color.
302
304{
305 return fgBlackPixel;
306}
307
308////////////////////////////////////////////////////////////////////////////////
309/// Set background color (override from TGWindow base class).
310/// Same effect as ChangeBackground().
311
313{
314 fBackground = back;
316}
317
318////////////////////////////////////////////////////////////////////////////////
319/// Change frame options. Options is an OR of the EFrameTypes.
320
323 if ((options & (kDoubleBorder | kSunkenFrame | kRaisedFrame)) !=
326 if (options & (kSunkenFrame | kRaisedFrame))
327 fBorderWidth = (gClient->GetStyle() > 1) ? 1 : (fOptions & kDoubleBorder) ? 2 : 1;
328 else
329 fBorderWidth = 0;
330 }
331 }
332
333 fOptions = options;
334}
335
336////////////////////////////////////////////////////////////////////////////////
337/// Add events specified in the emask to the events the frame should handle.
338
340{
341 fEventMask |= emask;
342 gVirtualX->SelectInput(fId, fEventMask);
343}
344
345////////////////////////////////////////////////////////////////////////////////
346/// Remove events specified in emask from the events the frame should handle.
347
349{
350 fEventMask &= ~emask;
351 gVirtualX->SelectInput(fId, fEventMask);
352}
353
354////////////////////////////////////////////////////////////////////////////////
355/// Draw 3D rectangle on the frame border.
356
358 UInt_t w, UInt_t h)
359{
360 switch (type) {
361 case kSunkenFrame:
362 gVirtualX->DrawLine(fId, GetShadowGC()(), x, y, x+w-2, y);
363 gVirtualX->DrawLine(fId, GetShadowGC()(), x, y, x, y+h-2);
364 gVirtualX->DrawLine(fId, GetHilightGC()(), x, y+h-1, x+w-1, y+h-1);
365 gVirtualX->DrawLine(fId, GetHilightGC()(), x+w-1, y+h-1, x+w-1, y);
366 break;
367
369 if (gClient->GetStyle() < 2) {
370 gVirtualX->DrawLine(fId, GetShadowGC()(), x, y, x+w-2, y);
371 gVirtualX->DrawLine(fId, GetShadowGC()(), x, y, x, y+h-2);
372 gVirtualX->DrawLine(fId, GetBlackGC()(), x+1, y+1, x+w-3, y+1);
373 gVirtualX->DrawLine(fId, GetBlackGC()(), x+1, y+1, x+1, y+h-3);
374 gVirtualX->DrawLine(fId, GetHilightGC()(), x, y+h-1, x+w-1, y+h-1);
375 gVirtualX->DrawLine(fId, GetHilightGC()(), x+w-1, y+h-1, x+w-1, y);
376 gVirtualX->DrawLine(fId, GetBckgndGC()(), x+1, y+h-2, x+w-2, y+h-2);
377 gVirtualX->DrawLine(fId, GetBckgndGC()(), x+w-2, y+1, x+w-2, y+h-2);
378 }
379 else {
380 gVirtualX->DrawLine(fId, GetShadowGC()(), x, y, x+w-2, y);
381 gVirtualX->DrawLine(fId, GetShadowGC()(), x, y, x, y+h-2);
382 gVirtualX->DrawLine(fId, GetHilightGC()(), x, y+h-1, x+w-1, y+h-1);
383 gVirtualX->DrawLine(fId, GetHilightGC()(), x+w-1, y+h-1, x+w-1, y);
384 }
385 break;
386
387 case kRaisedFrame:
388 gVirtualX->DrawLine(fId, GetHilightGC()(), x, y, x+w-2, y);
389 gVirtualX->DrawLine(fId, GetHilightGC()(), x, y, x, y+h-2);
390 gVirtualX->DrawLine(fId, GetShadowGC()(), x, y+h-1, x+w-1, y+h-1);
391 gVirtualX->DrawLine(fId, GetShadowGC()(), x+w-1, y+h-1, x+w-1, y);
392 break;
393
395 if (gClient->GetStyle() < 2) {
396 gVirtualX->DrawLine(fId, GetHilightGC()(), x, y, x+w-2, y);
397 gVirtualX->DrawLine(fId, GetHilightGC()(), x, y, x, y+h-2);
398 gVirtualX->DrawLine(fId, GetBckgndGC()(), x+1, y+1, x+w-3, y+1);
399 gVirtualX->DrawLine(fId, GetBckgndGC()(), x+1, y+1, x+1, y+h-3);
400 gVirtualX->DrawLine(fId, GetShadowGC()(), x+1, y+h-2, x+w-2, y+h-2);
401 gVirtualX->DrawLine(fId, GetShadowGC()(), x+w-2, y+h-2, x+w-2, y+1);
402 gVirtualX->DrawLine(fId, GetBlackGC()(), x, y+h-1, x+w-1, y+h-1);
403 gVirtualX->DrawLine(fId, GetBlackGC()(), x+w-1, y+h-1, x+w-1, y);
404 }
405 else {
406 gVirtualX->DrawLine(fId, GetHilightGC()(), x, y, x+w-2, y);
407 gVirtualX->DrawLine(fId, GetHilightGC()(), x, y, x, y+h-2);
408 gVirtualX->DrawLine(fId, GetShadowGC()(), x, y+h-1, x+w-1, y+h-1);
409 gVirtualX->DrawLine(fId, GetShadowGC()(), x+w-1, y+h-1, x+w-1, y);
410 }
411 break;
412
413 default:
414 break;
415 }
416}
417
418////////////////////////////////////////////////////////////////////////////////
419/// Draw frame border.
420
422{
424 0, 0, fWidth, fHeight);
425}
426
427////////////////////////////////////////////////////////////////////////////////
428/// Redraw the frame.
429
431{
433 fWidth - (fBorderWidth << 1), fHeight - (fBorderWidth << 1));
434
435 // border will only be drawn if we have a 3D option hint
436 // (kRaisedFrame or kSunkenFrame)
437 DrawBorder();
438}
439
440////////////////////////////////////////////////////////////////////////////////
441/// This event is generated when the frame is resized.
442
444{
445 if ((event->fWidth != fWidth) || (event->fHeight != fHeight)) {
446 fWidth = event->fWidth;
447 fHeight = event->fHeight;
448 Layout();
449 }
450 return kTRUE;
451}
452
453////////////////////////////////////////////////////////////////////////////////
454/// Handle all frame events. Events are dispatched to the specific
455/// event handlers.
456
458{
461
462 TObjectSpy deleteCheck(this);
463
464 switch (event->fType) {
465
466 case kExpose:
468 break;
469
470 case kConfigureNotify:
471 while (gVirtualX->CheckEvent(fId, kConfigureNotify, *event))
472 ;
473 // protection
474 if ((event->fWidth < 32768) && (event->fHeight < 32768)){
475 ProcessedConfigure(event); // emit signal
477 }
478 break;
479
480 case kGKeyPress:
481 case kKeyRelease:
483 break;
484
485 case kFocusIn:
486 case kFocusOut:
488 break;
489
490 case kButtonPress:
491 {
492 Int_t dbl_clk = kFALSE;
493
494 if ((event->fTime - fgLastClick < 350) &&
495 (event->fCode == fgLastButton) &&
496 (TMath::Abs(event->fXRoot - fgDbx) < 6) &&
497 (TMath::Abs(event->fYRoot - fgDby) < 6) &&
498 (event->fWindow == fgDbw))
499 dbl_clk = kTRUE;
500
501 fgLastClick = event->fTime;
502 fgLastButton = event->fCode;
503 fgDbx = event->fXRoot;
504 fgDby = event->fYRoot;
505 fgDbw = event->fWindow;
506
507 if (dbl_clk) {
508 if ((event->fState & kKeyControlMask) &&
511 return kTRUE;
512 }
513
514 if (!HandleDoubleClick(event)) {
516 }
517 } else {
519 }
520 }
521 break;
522
524 {
525 fgLastClick = event->fTime;
526 fgLastButton = event->fCode;
527 fgDbx = event->fXRoot;
528 fgDby = event->fYRoot;
529 fgDbw = event->fWindow;
530
532 }
533 break;
534
535 case kButtonRelease:
537 break;
538
539 case kEnterNotify:
540 case kLeaveNotify:
542 break;
543
544 case kMotionNotify:
545 while (gVirtualX->CheckEvent(fId, kMotionNotify, *event))
546 ;
548 break;
549
550 case kClientMessage:
552 break;
553
554 case kSelectionNotify:
556 break;
557
560 break;
561
562 case kSelectionClear:
564 break;
565
566 case kColormapNotify:
568 break;
569
570 default:
571 //Warning("HandleEvent", "unknown event (%#x) for (%#x)", event->fType, fId);
572 break;
573 }
574
575 if (deleteCheck.GetObject())
576 ProcessedEvent(event); // emit signal
577
578 return kTRUE;
579}
580
581////////////////////////////////////////////////////////////////////////////////
582/// std::cout << fWidth << "x" << fHeight << std::endl;
583
585{
586 return TGDimension(fWidth, fHeight);
587}
588
589
590////////////////////////////////////////////////////////////////////////////////
591/// Move frame.
592
594{
595 if (x != fX || y != fY) {
597 fX = x; fY = y;
598 }
599}
600
601////////////////////////////////////////////////////////////////////////////////
602/// Resize the frame.
603/// If w=0 && h=0 - Resize to default size
604
606{
607 if (w != fWidth || h != fHeight) {
608 TGDimension siz(0,0);
609 siz = GetDefaultSize();
610 fWidth = w ? w : siz.fWidth;
611 fHeight = h ? h : siz.fHeight;
613 Layout();
614 }
615}
616
617////////////////////////////////////////////////////////////////////////////////
618/// Resize the frame.
619
621{
622 Resize(size.fWidth, size.fHeight);
623}
624
625////////////////////////////////////////////////////////////////////////////////
626/// Move and/or resize the frame.
627/// If w=0 && h=0 - Resize to default size
628
630{
631 // we do it anyway as we don't know if it's only a move or only a resize
632 TGDimension siz(0,0);
633 siz = GetDefaultSize();
634 fWidth = w ? w : siz.fWidth;
635 fHeight = h ? h : siz.fHeight;
636 fX = x; fY = y;
638 Layout();
639}
640
641////////////////////////////////////////////////////////////////////////////////
642/// Send message (i.e. event) to window w. Message is encoded in one long
643/// as message type and up to two long parameters.
644
646{
648
649 if (w) {
650 event.fType = kClientMessage;
651 event.fFormat = 32;
652 event.fHandle = gROOT_MESSAGE;
653
654 event.fWindow = w->GetId();
655 event.fUser[0] = msg;
656 event.fUser[1] = parm1;
657 event.fUser[2] = parm2;
658 event.fUser[3] = 0;
659 event.fUser[4] = 0;
660
661 gVirtualX->SendEvent(w->GetId(), &event);
662 }
663}
664
665////////////////////////////////////////////////////////////////////////////////
666/// Handle a client message. Client messages are the ones sent via
667/// TGFrame::SendMessage (typically by widgets).
668
670{
671 if (gDNDManager) {
673 }
674 if (event->fHandle == gROOT_MESSAGE) {
675 ProcessMessage(event->fUser[0], event->fUser[1], event->fUser[2]);
676 }
677 return kTRUE;
678}
679
680////////////////////////////////////////////////////////////////////////////////
681/// Get default frame background.
682
684{
685 static Bool_t init = kFALSE;
686 if (!init && gClient) {
687 fgDefaultFrameBackground = gClient->GetResourcePool()->GetFrameBgndColor();
688 init = kTRUE;
689 }
691}
692
693////////////////////////////////////////////////////////////////////////////////
694/// Get default selected frame background.
695
697{
698 static Bool_t init = kFALSE;
699 if (!init && gClient) {
700 fgDefaultSelectedBackground = gClient->GetResourcePool()->GetSelectedBgndColor();
701 init = kTRUE;
702 }
704}
705
706////////////////////////////////////////////////////////////////////////////////
707/// Get white pixel value.
708
710{
711 static Bool_t init = kFALSE;
712 if (!init && gClient) {
713 fgWhitePixel = gClient->GetResourcePool()->GetWhiteColor();
714 init = kTRUE;
715 }
716 return fgWhitePixel;
717}
718
719////////////////////////////////////////////////////////////////////////////////
720/// Get black pixel value.
721
723{
724 static Bool_t init = kFALSE;
725 if (!init && gClient) {
726 fgBlackPixel = gClient->GetResourcePool()->GetBlackColor();
727 init = kTRUE;
728 }
729 return fgBlackPixel;
730}
731
732////////////////////////////////////////////////////////////////////////////////
733/// Get black graphics context.
734
736{
737 if (!fgBlackGC && gClient)
738 fgBlackGC = gClient->GetResourcePool()->GetBlackGC();
739 return *fgBlackGC;
740}
741
742////////////////////////////////////////////////////////////////////////////////
743/// Get white graphics context.
744
746{
747 if (!fgWhiteGC && gClient)
748 fgWhiteGC = gClient->GetResourcePool()->GetWhiteGC();
749 return *fgWhiteGC;
750}
751
752////////////////////////////////////////////////////////////////////////////////
753/// Get highlight color graphics context.
754
756{
757 if (!fgHilightGC && gClient)
758 fgHilightGC = gClient->GetResourcePool()->GetFrameHiliteGC();
759 return *fgHilightGC;
760}
761
762////////////////////////////////////////////////////////////////////////////////
763/// Get shadow color graphics context.
764
766{
767 if (!fgShadowGC && gClient)
768 fgShadowGC = gClient->GetResourcePool()->GetFrameShadowGC();
769 return *fgShadowGC;
770}
771
772////////////////////////////////////////////////////////////////////////////////
773/// Get background color graphics context.
774
776{
777 if (!fgBckgndGC && gClient)
778 fgBckgndGC = gClient->GetResourcePool()->GetFrameBckgndGC();
779 return *fgBckgndGC;
780}
781
782////////////////////////////////////////////////////////////////////////////////
783/// Get time of last mouse click.
784
786{
787 return fgLastClick;
788}
789
790////////////////////////////////////////////////////////////////////////////////
791/// Print window id.
792
794{
795 TString opt = option;
796 if (opt.Contains("tree")) {
798 return;
799 }
800
801 std::cout << option << ClassName() << ":\tid=" << fId << " parent=" << fParent->GetId();
802 std::cout << " x=" << fX << " y=" << fY;
803 std::cout << " w=" << fWidth << " h=" << fHeight << std::endl;
804}
805
806////////////////////////////////////////////////////////////////////////////////
807/// SetDragType
808
810{
811}
812
813////////////////////////////////////////////////////////////////////////////////
814/// SetDropType
815
817{
818}
819
820////////////////////////////////////////////////////////////////////////////////
821/// Returns drag source type.
822/// If frame is not "draggable" - return zero
823
825{
826 return fClient->IsEditable();
827}
828
829////////////////////////////////////////////////////////////////////////////////
830/// Returns drop target type.
831/// If frame cannot accept drop - return zero
832
834{
835 return 0;
836}
837
838////////////////////////////////////////////////////////////////////////////////
839/// Go into GUI building mode.
840
842{
843 if (GetEditDisabled()) return;
845 if (!gDragManager) return;
846
847 TGCompositeFrame *comp = 0;
848
850 comp = (TGCompositeFrame *)this;
852 comp = (TGCompositeFrame*)fParent;
853 }
854 if (comp) comp->SetEditable(on);
855}
856
857////////////////////////////////////////////////////////////////////////////////
858/// Create a composite frame. A composite frame has in addition to a TGFrame
859/// also a layout manager and a list of child frames.
860
862 UInt_t options, Pixel_t back) : TGFrame(p, w, h, options, back)
863{
864 fLayoutManager = 0;
865 fList = new TList;
869 if (!fgDefaultHints)
871
874 else
876
878}
879
880////////////////////////////////////////////////////////////////////////////////
881/// Create a frame using an externally created window. For example
882/// to register the root window (called by TGClient), or a window
883/// created via TVirtualX::InitWindow() (id is obtained with TVirtualX::GetWindowID()).
884
886 : TGFrame(c, id, parent)
887{
888 fLayoutManager = 0;
889 fList = new TList;
893 if (!fgDefaultHints)
895
897
899}
900
901////////////////////////////////////////////////////////////////////////////////
902/// Delete a composite frame.
903
905{
906 if (fMustCleanup != kNoCleanup) {
907 Cleanup();
908 } else {
909 TGFrameElement *el = 0;
910 TIter next(fList);
911
912 while ((el = (TGFrameElement *) next())) {
913 fList->Remove(el);
914 delete el;
915 }
916 }
917
918 delete fList;
919 delete fLayoutManager;
920 fList = 0;
921 fLayoutManager = 0;
922}
923
924////////////////////////////////////////////////////////////////////////////////
925/// Return kTRUE if frame is being edited.
926
928{
929 return (fClient->GetRoot() == (TGWindow*)this);
930}
931
932////////////////////////////////////////////////////////////////////////////////
933/// Switch ON/OFF edit mode.
934/// If edit mode is ON it is possible:
935///
936/// 1. embed other ROOT GUI application (a la ActiveX)
937///
938/// For example:
939/// TGMainFrame *m = new TGMainFrame(gClient->GetRoot(), 500, 500);
940/// m->SetEditable();
941/// gSystem->Load("$ROOTSYS/test/Aclock"); // load Aclock demo
942/// Aclock a;
943/// gROOT->Macro("$ROOTSYS/tutorials/gui/guitest.C");
944/// m->SetEditable(0);
945/// m->MapWindow();
946///
947
949{
950 if (on && ((fEditDisabled & kEditDisable) ||
952
953 if (on) {
954 fClient->SetRoot(this);
955 } else {
956 fClient->SetRoot(0);
957 }
959}
960
961////////////////////////////////////////////////////////////////////////////////
962/// Cleanup and delete all objects contained in this composite frame.
963/// This will delete all objects added via AddFrame().
964/// CAUTION: all objects (frames and layout hints) must be unique, i.e.
965/// cannot be shared.
966
968{
969 if (!fList) return;
970
971 TGFrameElement *el;
972 TIter next(fList);
973
974 while ((el = (TGFrameElement *) next())) {
975 if (el->fFrame) {
976 el->fFrame->SetFrameElement(0);
977 if (!gVirtualX->InheritsFrom("TGX11") && !gVirtualX->InheritsFrom("TGCocoa"))
978 el->fFrame->DestroyWindow();
979 delete el->fFrame;
980 }
981
982 if (el->fLayout && (el->fLayout != fgDefaultHints) &&
983 (el->fLayout->References() > 0)) {
985 if (!el->fLayout->References()) {
986 el->fLayout->fFE = 0;
987 delete el->fLayout;
988 }
989 }
990 fList->Remove(el);
991 delete el;
992 }
993}
994
995////////////////////////////////////////////////////////////////////////////////
996/// Set the layout manager for the composite frame.
997/// The layout manager is adopted by the frame and will be deleted
998/// by the frame.
999
1001{
1002 if (l) {
1003 delete fLayoutManager;
1004 fLayoutManager = l;
1005 } else
1006 Error("SetLayoutManager", "no layout manager specified");
1007}
1008
1009////////////////////////////////////////////////////////////////////////////////
1010/// Set broken layout. No Layout method is called.
1011
1013{
1014 fLayoutBroken = on;
1015}
1016
1017////////////////////////////////////////////////////////////////////////////////
1018/// Set edit disable flag for this frame and subframes
1019///
1020/// - if (on & kEditDisable) - disable edit for this frame and all subframes.
1021
1023{
1024 fEditDisabled = on;
1025 UInt_t set = on & kEditDisable;
1026
1027 // propagate only kEditDisable
1028 if (set == kEditDisable) {
1029
1030 TGFrameElement *el;
1031 TIter next(fList);
1032 while ((el = (TGFrameElement *) next())) {
1033 if (el->fFrame) {
1034 el->fFrame->SetEditDisabled(set);
1035 }
1036 }
1037 }
1038}
1039
1040////////////////////////////////////////////////////////////////////////////////
1041/// Change composite frame options. Options is an OR of the EFrameTypes.
1042
1044{
1045 TGFrame::ChangeOptions(options);
1046
1047 if (options & kHorizontalFrame)
1049 else if (options & kVerticalFrame)
1051}
1052
1053////////////////////////////////////////////////////////////////////////////////
1054/// Turn on automatic cleanup of child frames in dtor.
1055///
1056/// if mode = kNoCleanup - no automatic cleanup
1057/// if mode = kLocalCleanup - automatic cleanup in this composite frame only
1058/// if mode = kDeepCleanup - automatic deep cleanup in this composite frame
1059/// and all child composite frames (hierarchical)
1060///
1061/// Attention!
1062/// Hierarchical cleaning is dangerous and must be used with caution.
1063/// There are many GUI components (in ROOT and in user code) which do not
1064/// use Clean method in destructor ("custom deallocation").
1065/// Adding such component to GUI container which is using hierarchical
1066/// cleaning will produce seg. violation when container is deleted.
1067/// The reason is double deletion: first when Clean method is invoked,
1068/// then at "custom deallocation".
1069/// We are going to correct all ROOT code to make it to be
1070/// consistent with hierarchical cleaning scheme.
1071
1073{
1074 if (mode == fMustCleanup)
1075 return;
1076
1078
1079 if (fMustCleanup == kDeepCleanup) {
1080 TGFrameElement *el;
1081 TIter next(fList);
1082
1083 while ((el = (TGFrameElement *) next())) {
1086 }
1087 }
1088 }
1089}
1090
1091////////////////////////////////////////////////////////////////////////////////
1092/// Find frame-element holding frame f.
1093
1095{
1096 if (!fList) return 0;
1097
1098 TGFrameElement *el;
1099 TIter next(fList);
1100
1101 while ((el = (TGFrameElement *) next()))
1102 if (el->fFrame == f)
1103 return el;
1104
1105 return 0;
1106}
1107
1108////////////////////////////////////////////////////////////////////////////////
1109/// Add frame to the composite frame using the specified layout hints.
1110/// If no hints are specified default hints TGLayoutHints(kLHintsNormal,0,0,0,0)
1111/// will be used. Most of the time, however, you will want to provide
1112/// specific hints. User specified hints can be reused many times
1113/// and need to be destroyed by the user. The added frames cannot not be
1114/// added to different composite frames but still need to be deleted by
1115/// the user.
1116
1118{
1120 fList->Add(nw);
1121
1122 // in case of recursive cleanup, propagate cleanup setting to all
1123 // child composite frames
1125 f->SetCleanup(kDeepCleanup);
1126}
1127
1128////////////////////////////////////////////////////////////////////////////////
1129/// Remove all frames from composite frame.
1130
1132{
1133 if (!fList) return;
1134
1135 TGFrameElement *el;
1136 TIter next(fList);
1137
1138 while ((el = (TGFrameElement *) next())) {
1139 fList->Remove(el);
1140 if (el->fLayout) el->fLayout->RemoveReference();
1141// el->fFrame->SetFrameElement(0);
1142 delete el;
1143 }
1144}
1145
1146////////////////////////////////////////////////////////////////////////////////
1147/// Remove frame from composite frame.
1148
1150{
1152
1153 if (el) {
1154 fList->Remove(el);
1155 if (el->fLayout) el->fLayout->RemoveReference();
1156 f->SetFrameElement(0);
1157 delete el;
1158 }
1159}
1160
1161////////////////////////////////////////////////////////////////////////////////
1162/// Map all sub windows that are part of the composite frame.
1163
1165{
1166 if (!fMapSubwindows) {
1167 //MapWindow();
1168 return;
1169 }
1170
1172
1173 if (!fList) return;
1174
1175 TGFrameElement *el;
1176 TIter next(fList);
1177
1178 while ((el = (TGFrameElement *) next())) {
1179 if (el->fFrame) {
1180 el->fFrame->MapSubwindows();
1182 if (fe) fe->fState |= kIsVisible;
1183 }
1184 }
1185}
1186
1187////////////////////////////////////////////////////////////////////////////////
1188/// Hide sub frame.
1189
1191{
1193
1194 if (el) {
1195 el->fState = 0;
1196 el->fFrame->UnmapWindow();
1197 Layout();
1198 }
1199}
1200
1201////////////////////////////////////////////////////////////////////////////////
1202/// Show sub frame.
1203
1205{
1207
1208 if (el) {
1209 el->fState = 1;
1210 el->fFrame->MapWindow();
1211 Layout();
1212 }
1213}
1214
1215////////////////////////////////////////////////////////////////////////////////
1216/// Get state of sub frame.
1217
1219{
1221
1222 if (el)
1223 return el->fState;
1224 else
1225 return 0;
1226}
1227
1228////////////////////////////////////////////////////////////////////////////////
1229/// Get state of sub frame.
1230
1232{
1234
1235 if (el)
1236 return (el->fState & kIsVisible);
1237 else
1238 return kFALSE;
1239}
1240
1241////////////////////////////////////////////////////////////////////////////////
1242/// Get state of sub frame.
1243
1245{
1247
1248 if (el)
1249 return (el->fState & kIsArranged);
1250 else
1251 return kFALSE;
1252}
1253
1254////////////////////////////////////////////////////////////////////////////////
1255/// Layout the elements of the composite frame.
1256
1258{
1259 if (IsLayoutBroken()) return;
1261}
1262
1263////////////////////////////////////////////////////////////////////////////////
1264/// Print all frames in this composite frame.
1265
1267{
1268 TString opt = option;
1269 if (opt.Contains("tree")) {
1271 return;
1272 }
1273
1274 TGFrameElement *el;
1275 TIter next(fList);
1276 TString tab = option;
1277
1278 TGFrame::Print(tab.Data());
1279 tab += " ";
1280 while ((el = (TGFrameElement*)next())) {
1281 el->fFrame->Print(tab.Data());
1282 }
1283}
1284
1285////////////////////////////////////////////////////////////////////////////////
1286/// Change background color for this frame and all subframes.
1287
1289{
1291 TGFrameElement *el;
1292
1293 TIter next(fList);
1294
1295 while ((el = (TGFrameElement*)next())) {
1296 el->fFrame->SetBackgroundColor(back);
1298 ((TGCompositeFrame*)el->fFrame)->ChangeSubframesBackground(back);
1299 }
1301 }
1302 fClient->NeedRedraw(this);
1303}
1304
1305////////////////////////////////////////////////////////////////////////////////
1306/// Get frame located at specified point.
1307
1309{
1310 if (!Contains(x, y)) return 0;
1311
1312 if (!fList) return this;
1313
1314 TGFrame *f;
1315 TGFrameElement *el;
1316 TIter next(fList);
1317
1318 while ((el = (TGFrameElement *) next())) {
1319 //if (el->fFrame->IsVisible()) { //for this need to move IsVisible to TGFrame
1320 if (el->fState & kIsVisible) {
1321 f = el->fFrame->GetFrameFromPoint(x - el->fFrame->GetX(),
1322 y - el->fFrame->GetY());
1323 if (f) return f;
1324 }
1325 }
1326 return this;
1327}
1328
1329////////////////////////////////////////////////////////////////////////////////
1330/// Translate coordinates to child frame.
1331
1333 Int_t &fx, Int_t &fy)
1334{
1335 if (child == this) {
1336 fx = x;
1337 fy = y;
1338 return kTRUE;
1339 }
1340
1341 if (!Contains(x, y)) return kFALSE;
1342
1343 if (!fList) return kFALSE;
1344
1345 TGFrameElement *el;
1346 TIter next(fList);
1347
1348 while ((el = (TGFrameElement *) next())) {
1349 if (el->fFrame == child) {
1350 fx = x - el->fFrame->GetX();
1351 fy = y - el->fFrame->GetY();
1352 return kTRUE;
1353 } else if (el->fFrame->IsComposite()) {
1354 if (((TGCompositeFrame *)el->fFrame)->TranslateCoordinates(child,
1355 x - el->fFrame->GetX(), y - el->fFrame->GetY(), fx, fy))
1356 return kTRUE;
1357 }
1358 }
1359 return kFALSE;
1360}
1361
1362////////////////////////////////////////////////////////////////////////////////
1363/// Handle drag enter event.
1364
1366{
1367 if (fClient && fClient->IsEditable() &&
1368 (fId != fClient->GetRoot()->GetId())) {
1369
1370 // the dragged frame cannot be dropped
1372
1373 //
1374 if (IsEditable()) {
1375 return kTRUE;
1376 }
1377
1378 Float_t r, g, b;
1380 r *= 1.12;
1381 g *= 1.13;
1382 b *= 1.12;
1383 Pixel_t back = TColor::RGB2Pixel(r, g, b);
1384 gVirtualX->SetWindowBackground(fId, back);
1385 DoRedraw();
1386 return kTRUE;
1387 }
1388
1389 return kFALSE;
1390}
1391
1392////////////////////////////////////////////////////////////////////////////////
1393/// Handle drag leave event.
1394
1396{
1397 if (fClient && fClient->IsEditable() &&
1398 (fId != fClient->GetRoot()->GetId())) {
1399
1401
1402 gVirtualX->SetWindowBackground(fId, fBackground);
1403 DoRedraw();
1404 return kTRUE;
1405 }
1406
1407 return kFALSE;
1408}
1409
1410////////////////////////////////////////////////////////////////////////////////
1411/// Handle drag motion event.
1412
1414{
1415 return kFALSE;
1416}
1417
1418////////////////////////////////////////////////////////////////////////////////
1419/// Handle drop event.
1420
1422 TGLayoutHints *lo)
1423{
1424 if (fClient && fClient->IsEditable() && frame && (x >= 0) && (y >= 0) &&
1425 (x + frame->GetWidth() <= fWidth) && (y + frame->GetHeight() <= fHeight)) {
1426
1428
1429 frame->ReparentWindow(this, x, y);
1430 AddFrame(frame, lo);
1431 frame->MapWindow();
1433 return kTRUE;
1434 }
1435
1436 return kFALSE;
1437}
1438
1439
1440////////////////////////////////////////////////////////////////////////////////
1441/// Create a top level main frame. A main frame interacts
1442/// with the window manager.
1443
1445 UInt_t options) : TGCompositeFrame(p, w, h, options | kMainFrame)
1446{
1447 // WMDeleteNotify causes the system to send a kClientMessage to the
1448 // window with fFormat=32 and fUser[0]=gWM_DELETE_WINDOW when window
1449 // closed via WM
1450
1451 gVirtualX->WMDeleteNotify(fId);
1452
1453 fBindList = new TList;
1454
1455 fMWMValue = 0;
1456 fMWMFuncs = 0;
1457 fMWMInput = 0;
1458 fWMX = -1;
1459 fWMY = -1;
1460 fWMWidth = (UInt_t) -1;
1461 fWMHeight = (UInt_t) -1;
1462 fWMMinWidth = (UInt_t) -1;
1463 fWMMinHeight = (UInt_t) -1;
1464 fWMMaxWidth = (UInt_t) -1;
1465 fWMMaxHeight = (UInt_t) -1;
1466 fWMWidthInc = (UInt_t) -1;
1467 fWMHeightInc = (UInt_t) -1;
1469
1470 gVirtualX->GrabKey(fId, gVirtualX->KeysymToKeycode(kKey_s),
1471 kKeyControlMask, kTRUE);//grab CTRL+s
1472 gVirtualX->GrabKey(fId, gVirtualX->KeysymToKeycode(kKey_s),
1473 kKeyControlMask | kKeyMod2Mask, kTRUE);//grab CTRL+s also if NumLock is active
1474 if (p == fClient->GetDefaultRoot()) {
1478 gVirtualX->SetMWMHints(fId, fMWMValue, fMWMFuncs, fMWMInput);
1479 }
1480 // if parent is editing/embeddable add this frame to the parent
1481 if (fClient->IsEditable() && (p == fClient->GetRoot())) {
1482 TGCompositeFrame *frame;
1484 frame = (TGCompositeFrame*)p;
1486
1487 // used during paste operation
1490 }
1491 }
1492 }
1493 //AddInput(kButtonPressMask); // to allow Drag and Drop
1494 // Create Drag&Drop Manager and define a few DND types
1495 fDNDTypeList = new Atom_t[3];
1496 fDNDTypeList[0] = gVirtualX->InternAtom("application/root", kFALSE);
1497 fDNDTypeList[1] = gVirtualX->InternAtom("text/uri-list", kFALSE);
1498 fDNDTypeList[2] = 0;
1499 if (!gDNDManager)
1500 new TGDNDManager(this, fDNDTypeList);
1501 SetWindowName();
1502}
1503
1504////////////////////////////////////////////////////////////////////////////////
1505/// TGMainFrame destructor.
1506
1508{
1509 delete [] fDNDTypeList;
1510 if (fBindList) {
1511 fBindList->Delete();
1512 delete fBindList;
1513 }
1514 gVirtualX->GrabKey(fId, gVirtualX->KeysymToKeycode(kKey_s),
1516 gVirtualX->GrabKey(fId, gVirtualX->KeysymToKeycode(kKey_s),
1518}
1519
1520////////////////////////////////////////////////////////////////////////////////
1521/// Opens dialog window allowing user to save the frame contents
1522/// as a ROOT macro or as an image.
1523/// Returns kTRUE if something was saved.
1524///
1525/// This is bound to Ctrl-S by default.
1526
1528{
1529 static TString dir(".");
1530 static Bool_t overwr = kFALSE;
1531
1532 Bool_t repeat_save;
1533 do {
1534 repeat_save = kFALSE;
1535
1536 TGFileInfo fi;
1538 fi.SetIniDir(dir);
1539 fi.fOverwrite = overwr;
1540 new TGFileDialog(fClient->GetDefaultRoot(), this, kFDSave, &fi);
1541 if (!fi.fFilename) return kFALSE;
1542 dir = fi.fIniDir;
1543 overwr = fi.fOverwrite;
1544 const Bool_t res = SaveFrameAsCodeOrImage(fi.fFilename);
1545 if (!res) {
1546 Int_t retval;
1547 new TGMsgBox(fClient->GetDefaultRoot(), this, "Error...",
1548 TString::Format("file (%s) cannot be saved with this extension",
1549 fi.fFilename),
1551 repeat_save = (retval == kMBRetry);
1552 }
1553 } while (repeat_save);
1554
1555 return kTRUE;
1556}
1557
1558////////////////////////////////////////////////////////////////////////////////
1559/// Saves the frame contents as a ROOT macro or as an image,
1560/// depending on the extension of the fileName argument.
1561/// If preexisting, the file is overwritten.
1562/// Returns kTRUE if something was saved.
1563
1565{
1566 static TString dir(".");
1567
1568 const TString fname = gSystem->UnixPathName(fileName);
1569 if (fname.EndsWith(".C")) {
1571 main->SaveSource(fname.Data(), "");
1572 } else {
1574 if (fname.EndsWith("gif")) {
1575 gtype = TImage::kGif;
1576 } else if (fname.EndsWith(".png")) {
1577 gtype = TImage::kPng;
1578 } else if (fname.EndsWith(".jpg")) {
1579 gtype = TImage::kJpeg;
1580 } else if (fname.EndsWith(".tiff")) {
1581 gtype = TImage::kTiff;
1582 } else if (fname.EndsWith(".xpm")) {
1583 gtype = TImage::kXpm;
1584 }
1585 if (gtype != TImage::kUnknown) {
1586 Int_t saver = gErrorIgnoreLevel;
1588 TImage *img = TImage::Create();
1589 RaiseWindow();
1590 img->FromWindow(GetId());
1591 img->WriteImage(fname, gtype);
1592 gErrorIgnoreLevel = saver;
1593 delete img;
1594 } else {
1595 Error("SaveFrameAsCodeOrImage", "File cannot be saved with this extension");
1596 return kFALSE;
1597 }
1598 }
1599
1600 return kTRUE;
1601}
1602
1603////////////////////////////////////////////////////////////////////////////////
1604/// Handle keyboard events.
1605
1607{
1608 if (fBindList) {
1609
1610 TIter next(fBindList);
1611 TGMapKey *m;
1612 TGFrame *w = 0;
1613
1614 while ((m = (TGMapKey *) next())) {
1615 if (m->fKeyCode == event->fCode) {
1616 w = (TGFrame *) m->fWindow;
1617 if (w->HandleKey(event)) return kTRUE;
1618 }
1619 }
1620 }
1621
1622 if ((event->fType == kGKeyPress) && (event->fState & kKeyControlMask)) {
1623 UInt_t keysym;
1624 char str[2];
1625 gVirtualX->LookupString(event, str, sizeof(str), keysym);
1626
1627 if ((keysym & ~0x20) == kKey_S) { // case insensitive ctrl-s
1628 return SaveFrameAsCodeOrImage();
1629 }
1630 }
1631 return kFALSE;
1632}
1633
1634////////////////////////////////////////////////////////////////////////////////
1635/// Bind key to a window.
1636
1638{
1639 TList *list = fBindList;
1640 Handle_t id = fId;
1641
1642 if (fClient->IsEditable()) {
1644 list = main->GetBindList();
1645 id = main->GetId();
1646 }
1647
1648 if (list) {
1649 TGMapKey *m = new TGMapKey(keycode, (TGWindow *)w);
1650 list->Add(m);
1651 gVirtualX->GrabKey(id, keycode, modifier, kTRUE);
1652 return kTRUE;
1653 }
1654 return kFALSE;
1655}
1656
1657////////////////////////////////////////////////////////////////////////////////
1658/// Remove key binding.
1659
1661{
1662 if (fBindList) {
1663 TIter next(fBindList);
1664 TGMapKey *m;
1665 while ((m = (TGMapKey *) next())) {
1666 if (m->fKeyCode == (UInt_t) keycode) {
1667 fBindList->Remove(m);
1668 delete m;
1669 gVirtualX->GrabKey(fId, keycode, modifier, kFALSE);
1670 return;
1671 }
1672 }
1673 }
1674}
1675
1676////////////////////////////////////////////////////////////////////////////////
1677/// Handle mouse button events.
1678
1680{
1681 if (event->fType == kButtonRelease) {
1683 }
1685}
1686
1687
1688////////////////////////////////////////////////////////////////////////////////
1689/// Handle mouse motion events.
1690
1692{
1694 gDNDManager->Drag(event->fXRoot, event->fYRoot,
1696 }
1698}
1699
1700////////////////////////////////////////////////////////////////////////////////
1701/// Handle primary selection event.
1702
1704{
1705 if ((Atom_t)event->fUser[1] == TGDNDManager::GetDNDSelection()) {
1706 if (gDNDManager)
1708 }
1710}
1711
1712////////////////////////////////////////////////////////////////////////////////
1713/// Handle selection request event.
1714
1716{
1717 if ((Atom_t)event->fUser[1] == TGDNDManager::GetDNDSelection()) {
1718 if (gDNDManager)
1720 }
1722}
1723
1724////////////////////////////////////////////////////////////////////////////////
1725/// Handle client messages sent to this frame.
1726
1728{
1730
1731 if ((event->fFormat == 32) && ((Atom_t)event->fUser[0] == gWM_DELETE_WINDOW) &&
1732 (event->fHandle != gROOT_MESSAGE)) {
1733 Emit("CloseWindow()");
1735 CloseWindow();
1736 }
1737 return kTRUE;
1738}
1739
1740////////////////////////////////////////////////////////////////////////////////
1741/// Send close message to self. This method should be called from
1742/// a button to close this window.
1743
1745{
1746 Event_t event;
1747
1748 event.fType = kClientMessage;
1749 event.fFormat = 32;
1750 event.fHandle = gWM_DELETE_WINDOW;
1751
1752 event.fWindow = GetId();
1753 event.fUser[0] = (Long_t) gWM_DELETE_WINDOW;
1754 event.fUser[1] = 0;
1755 event.fUser[2] = 0;
1756 event.fUser[3] = 0;
1757 event.fUser[4] = 0;
1758
1759 gVirtualX->SendEvent(GetId(), &event);
1760}
1761
1762////////////////////////////////////////////////////////////////////////////////
1763/// Close and delete main frame. We get here in response to ALT+F4 or
1764/// a window manager close command. To terminate the application when this
1765/// happens override this method and call gApplication->Terminate(0) or
1766/// make a connection to this signal (if after the slot this method
1767/// should not be called call DontCallClose() in the slot).
1768/// By default the window will be deleted.
1769
1771{
1772 DeleteWindow();
1773}
1774
1775////////////////////////////////////////////////////////////////////////////////
1776/// Typically call this method in the slot connected to the CloseWindow()
1777/// signal to prevent the calling of the default or any derived CloseWindow()
1778/// methods to prevent premature or double deletion of this window.
1779
1781{
1783}
1784
1785////////////////////////////////////////////////////////////////////////////////
1786/// Set window name. This is typically done via the window manager.
1787
1789{
1790 if (!name) {
1792 } else {
1793 fWindowName = name;
1794 gVirtualX->SetWindowName(fId, (char *)name);
1795 }
1796}
1797
1798////////////////////////////////////////////////////////////////////////////////
1799/// Set window icon name. This is typically done via the window manager.
1800
1802{
1803 fIconName = name;
1804 gVirtualX->SetIconName(fId, (char *)name);
1805}
1806
1807////////////////////////////////////////////////////////////////////////////////
1808/// Set window icon pixmap by name. This is typically done via the window
1809/// manager. Icon can be in any image format supported by TImage, e.g.
1810/// GIF, XPM, PNG, JPG .. or even PS, PDF (see EImageFileTypes in TImage.h
1811/// for the full list of supported formats).
1812///
1813/// For example,
1814/// main_frame->SetIconPixmap("/home/root/icons/bld_rgb.png");
1815
1816const TGPicture *TGMainFrame::SetIconPixmap(const char *iconName)
1817{
1818 fIconPixmap = iconName;
1819 const TGPicture *iconPic = fClient->GetPicture(iconName);
1820 if (iconPic) {
1821 Pixmap_t pic = iconPic->GetPicture();
1822 gVirtualX->SetIconPixmap(fId, pic);
1823 return iconPic;
1824 } else
1825 return 0;
1826}
1827
1828////////////////////////////////////////////////////////////////////////////////
1829/// Set window icon by xpm array. That allows to have icons
1830/// builtin to the source code.
1831///
1832/// For example,
1833/// \code{.cpp}
1834/// #include "/home/root/icons/bld_rgb.xpm"
1835/// //bld_rgb.xpm contains char *bld_rgb[] array
1836/// main_frame->SetIconPixmap(bld_rgb);
1837/// \endcode
1838
1839void TGMainFrame::SetIconPixmap(char **xpm_array)
1840{
1841 TImage *img = TImage::Create();
1842 if (!img) return;
1843 img->SetImageBuffer(xpm_array, TImage::kXpm);
1844 Pixmap_t pic = img->GetPixmap();
1845 if (pic) {
1846 gVirtualX->SetIconPixmap(fId, pic);
1847 } else {
1848 Warning("SetIconPixmap", "Failed to set window icon from xpm array.");
1849 }
1850 delete img;
1851}
1852
1853////////////////////////////////////////////////////////////////////////////////
1854/// Set the windows class and resource name. Used to get the right
1855/// resources from the resource database. However, ROOT applications
1856/// will typically use the .rootrc file for this.
1857
1858void TGMainFrame::SetClassHints(const char *className, const char *resourceName)
1859{
1860 fClassName = className;
1861 fResourceName = resourceName;
1862 gVirtualX->SetClassHints(fId, (char *)className, (char *)resourceName);
1863}
1864
1865////////////////////////////////////////////////////////////////////////////////
1866/// Set decoration style for MWM-compatible wm (mwm, ncdwm, fvwm?).
1867
1869{
1870 if (fClient->IsEditable() && (fParent == fClient->GetRoot())) return;
1871
1872 fMWMValue = value;
1873 fMWMFuncs = funcs;
1874 fMWMInput = input;
1875 gVirtualX->SetMWMHints(fId, value, funcs, input);
1876}
1877
1878////////////////////////////////////////////////////////////////////////////////
1879/// Give the window manager a window position hint.
1880
1882{
1883 if (fClient->IsEditable() && (fParent == fClient->GetRoot())) return;
1884
1885 fWMX = x;
1886 fWMY = y;
1887 gVirtualX->SetWMPosition(fId, x, y);
1888}
1889
1890////////////////////////////////////////////////////////////////////////////////
1891/// Give the window manager a window size hint.
1892
1894{
1895 if (fClient->IsEditable() && (fParent == fClient->GetRoot())) return;
1896
1897 fWMWidth = w;
1898 fWMHeight = h;
1899 gVirtualX->SetWMSize(fId, w, h);
1900}
1901
1902////////////////////////////////////////////////////////////////////////////////
1903/// Give the window manager minimum and maximum size hints. Also
1904/// specify via winc and hinc the resize increments.
1905
1909{
1910 if (fClient->IsEditable() && (fParent == fClient->GetRoot())) return;
1911
1916 fWMWidthInc = winc;
1918 gVirtualX->SetWMSizeHints(fId, wmin, hmin, wmax, hmax, winc, hinc);
1919}
1920
1921////////////////////////////////////////////////////////////////////////////////
1922/// Set the initial state of the window. Either kNormalState or kIconicState.
1923
1925{
1926 if (fClient->IsEditable() && (fParent == fClient->GetRoot())) return;
1927
1928 fWMInitState = state;
1929 gVirtualX->SetWMState(fId, state);
1930}
1931
1932
1933////////////////////////////////////////////////////////////////////////////////
1934/// Create a transient window. A transient window is typically used for
1935/// dialog boxes.
1936
1938 UInt_t w, UInt_t h, UInt_t options)
1939 : TGMainFrame(p, w, h, options | kTransientFrame)
1940{
1941 fMain = main;
1942 if (!fMain && gClient)
1943 fMain = gClient->GetRoot();
1944
1945 if (fMain) {
1946 gVirtualX->SetWMTransientHint(fId, fMain->GetId());
1947 }
1948}
1949
1950////////////////////////////////////////////////////////////////////////////////
1951/// Position transient frame centered relative to the parent frame.
1952/// If fMain is 0 (i.e. TGTransientFrame is acting just like a
1953/// TGMainFrame) and croot is true, the window will be centered on
1954/// the root window, otherwise no action is taken and the default
1955/// wm placement will be used.
1956
1958{
1959 Int_t x=0, y=0, ax, ay;
1960 Window_t wdummy;
1961
1964
1965 if (fMain) {
1966
1967 switch (pos) {
1968 case kCenter:
1969 x = (Int_t)(((TGFrame *) fMain)->GetWidth() - fWidth) >> 1;
1970 y = (Int_t)(((TGFrame *) fMain)->GetHeight() - fHeight) >> 1;
1971 break;
1972 case kRight:
1973 x = (Int_t)(((TGFrame *) fMain)->GetWidth() - (fWidth >> 1));
1974 y = (Int_t)(((TGFrame *) fMain)->GetHeight() - fHeight) >> 1;
1975 break;
1976 case kLeft:
1977 x = (Int_t)(-1 * (Int_t)(fWidth >> 1));
1978 y = (Int_t)(((TGFrame *) fMain)->GetHeight() - fHeight) >> 1;
1979 break;
1980 case kTop:
1981 x = (Int_t)(((TGFrame *) fMain)->GetWidth() - fWidth) >> 1;
1982 y = (Int_t)(-1 * (Int_t)(fHeight >> 1));
1983 break;
1984 case kBottom:
1985 x = (Int_t)(((TGFrame *) fMain)->GetWidth() - fWidth) >> 1;
1986 y = (Int_t)(((TGFrame *) fMain)->GetHeight() - (fHeight >> 1));
1987 break;
1988 case kTopLeft:
1989 x = (Int_t)(-1 * (Int_t)(fWidth >> 1));
1990 y = (Int_t)(-1 * (Int_t)(fHeight >> 1));
1991 break;
1992 case kTopRight:
1993 x = (Int_t)(((TGFrame *) fMain)->GetWidth() - (fWidth >> 1));
1994 y = (Int_t)(-1 * (Int_t)(fHeight >> 1));
1995 break;
1996 case kBottomLeft:
1997 x = (Int_t)(-1 * (Int_t)(fWidth >> 1));
1998 y = (Int_t)(((TGFrame *) fMain)->GetHeight() - (fHeight >> 1));
1999 break;
2000 case kBottomRight:
2001 x = (Int_t)(((TGFrame *) fMain)->GetWidth() - (fWidth >> 1));
2002 y = (Int_t)(((TGFrame *) fMain)->GetHeight() - (fHeight >> 1));
2003 break;
2004 }
2005
2006 gVirtualX->TranslateCoordinates(fMain->GetId(), GetParent()->GetId(),
2007 x, y, ax, ay, wdummy);
2008 if (!gVirtualX->InheritsFrom("TGWin32")) {
2009 if (ax < 10)
2010 ax = 10;
2011 else if (ax + fWidth + 10 > dw)
2012 ax = dw - fWidth - 10;
2013
2014 if (ay < 20)
2015 ay = 20;
2016 else if (ay + fHeight + 50 > dh)
2017 ay = dh - fHeight - 50;
2018 }
2019
2020 } else if (croot) {
2021
2022 switch (pos) {
2023 case kCenter:
2024 x = (dw - fWidth) >> 1;
2025 y = (dh - fHeight) >> 1;
2026 break;
2027 case kRight:
2028 x = dw - (fWidth >> 1);
2029 y = (dh - fHeight) >> 1;
2030 break;
2031 case kLeft:
2032 x = -1 * (Int_t)(fWidth >> 1);
2033 y = (dh - fHeight) >> 1;
2034 break;
2035 case kTop:
2036 x = (dw - fWidth) >> 1;
2037 y = -1 * (Int_t)(fHeight >> 1);
2038 break;
2039 case kBottom:
2040 x = (dw - fWidth) >> 1;
2041 y = dh - (fHeight >> 1);
2042 break;
2043 case kTopLeft:
2044 x = -1 * (Int_t)(fWidth >> 1);
2045 y = -1 * (Int_t)(fHeight >> 1);
2046 break;
2047 case kTopRight:
2048 x = dw - (fWidth >> 1);
2049 y = -1 * (Int_t)(fHeight >> 1);
2050 break;
2051 case kBottomLeft:
2052 x = -1 * (Int_t)(fWidth >> 1);
2053 y = dh - (fHeight >> 1);
2054 break;
2055 case kBottomRight:
2056 x = dw - (fWidth >> 1);
2057 y = dh - (fHeight >> 1);
2058 break;
2059 }
2060
2061 ax = x;
2062 ay = y;
2063
2064 } else {
2065
2066 return;
2067
2068 }
2069
2070 Move(ax, ay);
2071 SetWMPosition(ax, ay);
2072}
2073
2074////////////////////////////////////////////////////////////////////////////////
2075/// Create a group frame. The title will be adopted and deleted by the
2076/// group frame.
2077
2079 UInt_t options, GContext_t norm,
2080 FontStruct_t font, Pixel_t back) :
2081 TGCompositeFrame(p, 1, 1, options, back)
2082{
2083 fText = title;
2084 fFontStruct = font;
2085 fNormGC = norm;
2086 fTitlePos = kLeft;
2088
2089 int max_ascent, max_descent;
2090 gVirtualX->GetFontProperties(fFontStruct, max_ascent, max_descent);
2091 fBorderWidth = max_ascent + max_descent + 1;
2092}
2093
2094////////////////////////////////////////////////////////////////////////////////
2095/// Create a group frame.
2096
2097TGGroupFrame::TGGroupFrame(const TGWindow *p, const char *title,
2098 UInt_t options, GContext_t norm,
2099 FontStruct_t font, Pixel_t back) :
2100 TGCompositeFrame(p, 1, 1, options, back)
2101{
2102 fText = new TGString(!p && !title ? GetName() : title);
2103 fFontStruct = font;
2104 fNormGC = norm;
2105 fTitlePos = kLeft;
2107
2108 int max_ascent, max_descent;
2109 gVirtualX->GetFontProperties(fFontStruct, max_ascent, max_descent);
2110 fBorderWidth = max_ascent + max_descent + 1;
2111
2112 SetWindowName();
2113}
2114
2115////////////////////////////////////////////////////////////////////////////////
2116/// Delete a group frame.
2117
2119{
2120 if (fHasOwnFont) {
2121 TGGCPool *pool = fClient->GetGCPool();
2122 TGGC *gc = pool->FindGC(fNormGC);
2123 pool->FreeGC(gc);
2124 }
2125 delete fText;
2126}
2127
2128////////////////////////////////////////////////////////////////////////////////
2129/// Returns default size.
2130
2132{
2133 UInt_t tw = gVirtualX->TextWidth(fFontStruct, fText->GetString(),
2134 fText->GetLength()) + 24;
2135
2137
2138 return tw>dim.fWidth ? TGDimension(tw, dim.fHeight) : dim;
2139}
2140
2141////////////////////////////////////////////////////////////////////////////////
2142/// Redraw the group frame. Need special DoRedraw() since we need to
2143/// redraw with fBorderWidth=0.
2144
2146{
2147 gVirtualX->ClearArea(fId, 0, 0, fWidth, fHeight);
2148
2149 DrawBorder();
2150}
2151
2152
2153////////////////////////////////////////////////////////////////////////////////
2154/// Changes text color.
2155/// If local is true color is changed locally, otherwise - globally.
2156
2158{
2160 TGGC *gc = pool->FindGC(fNormGC);
2161
2162 if (gc && local) {
2163 gc = pool->GetGC((GCValues_t*)gc->GetAttributes(), kTRUE); // copy
2165 }
2166 if (gc) {
2167 gc->SetForeground(color);
2168 fNormGC = gc->GetGC();
2169 }
2170 fClient->NeedRedraw(this);
2171}
2172
2173////////////////////////////////////////////////////////////////////////////////
2174/// Changes text font.
2175/// If local is true font is changed locally - otherwise globally.
2176
2178{
2179 FontH_t v = gVirtualX->GetFontHandle(font);
2180 if (!v) return;
2181
2182 fFontStruct = font;
2183
2185 TGGC *gc = pool->FindGC(fNormGC);
2186
2187 if (gc && local) {
2188 gc = pool->GetGC((GCValues_t*)gc->GetAttributes(), kTRUE); // copy
2190 }
2191 if (gc) {
2192 gc->SetFont(v);
2193 fNormGC = gc->GetGC();
2194 }
2195 fClient->NeedRedraw(this);
2196}
2197
2198////////////////////////////////////////////////////////////////////////////////
2199/// Changes text font specified by name.
2200/// If local is true font is changed locally - otherwise globally.
2201
2202void TGGroupFrame::SetTextFont(const char *fontName, Bool_t local)
2203{
2204 TGFont *font = fClient->GetFont(fontName);
2205
2206 if (font) {
2207 SetTextFont(font->GetFontStruct(), local);
2208 }
2209}
2210
2211////////////////////////////////////////////////////////////////////////////////
2212/// Returns kTRUE if text attributes are unique,
2213/// returns kFALSE if text attributes are shared (global).
2214
2216{
2217 return fHasOwnFont;
2218}
2219
2220////////////////////////////////////////////////////////////////////////////////
2221/// Draw border of around the group frame.
2222///
2223/// if frame is kRaisedFrame - a frame border is of "wall style",
2224/// otherwise of "groove style".
2225
2227{
2228 Int_t x, y, l, t, r, b, gl, gr, sep, max_ascent, max_descent;
2229
2230 UInt_t tw = gVirtualX->TextWidth(fFontStruct, fText->GetString(), fText->GetLength());
2231 gVirtualX->GetFontProperties(fFontStruct, max_ascent, max_descent);
2232
2233 l = 0;
2234 t = (max_ascent + max_descent + 2) >> 1;
2235 r = fWidth - 1;
2236 // next three lines are for backward compatibility in case of horizontal layout
2237 // coverity[returned_null]
2238 // coverity[dereference]
2242 b = fHeight - 1;
2243 else
2244 b = fHeight - t;
2245
2246 sep = 3;
2247 UInt_t rr = 5 + (sep << 1) + tw;
2248
2249 switch (fTitlePos) {
2250 case kRight:
2251 gl = fWidth>rr ? Int_t(fWidth - rr) : 5 + sep;
2252 break;
2253 case kCenter:
2254 gl = fWidth>tw ? Int_t((fWidth - tw)>>1) - sep : 5 + sep;
2255 break;
2256 case kLeft:
2257 default:
2258 gl = 5 + sep;
2259 }
2260 gr = gl + tw + (sep << 1);
2261
2262 switch (fOptions & (kSunkenFrame | kRaisedFrame)) {
2263 case kRaisedFrame:
2264 gVirtualX->DrawLine(fId, GetHilightGC()(), l, t, gl, t);
2265 gVirtualX->DrawLine(fId, GetShadowGC()(), l+1, t+1, gl, t+1);
2266
2267 gVirtualX->DrawLine(fId, GetHilightGC()(), gr, t, r-1, t);
2268 gVirtualX->DrawLine(fId, GetShadowGC()(), gr, t+1, r-2, t+1);
2269
2270 gVirtualX->DrawLine(fId, GetHilightGC()(), r-1, t, r-1, b-1);
2271 gVirtualX->DrawLine(fId, GetShadowGC()(), r, t, r, b);
2272
2273 gVirtualX->DrawLine(fId, GetHilightGC()(), r-1, b-1, l, b-1);
2274 gVirtualX->DrawLine(fId, GetShadowGC()(), r, b, l, b);
2275
2276 gVirtualX->DrawLine(fId, GetHilightGC()(), l, b-1, l, t);
2277 gVirtualX->DrawLine(fId, GetShadowGC()(), l+1, b-2, l+1, t+1);
2278 break;
2279 case kSunkenFrame:
2280 default:
2281 gVirtualX->DrawLine(fId, GetShadowGC()(), l, t, gl, t);
2282 gVirtualX->DrawLine(fId, GetHilightGC()(), l+1, t+1, gl, t+1);
2283
2284 gVirtualX->DrawLine(fId, GetShadowGC()(), gr, t, r-1, t);
2285 gVirtualX->DrawLine(fId, GetHilightGC()(), gr, t+1, r-2, t+1);
2286
2287 gVirtualX->DrawLine(fId, GetShadowGC()(), r-1, t, r-1, b-1);
2288 gVirtualX->DrawLine(fId, GetHilightGC()(), r, t, r, b);
2289
2290 gVirtualX->DrawLine(fId, GetShadowGC()(), r-1, b-1, l, b-1);
2291 gVirtualX->DrawLine(fId, GetHilightGC()(), r, b, l, b);
2292
2293 gVirtualX->DrawLine(fId, GetShadowGC()(), l, b-1, l, t);
2294 gVirtualX->DrawLine(fId, GetHilightGC()(), l+1, b-2, l+1, t+1);
2295 break;
2296 }
2297
2298 x = gl + sep;
2299 y = 1;
2300
2301 fText->Draw(fId, fNormGC, x, y + max_ascent);
2302}
2303
2304////////////////////////////////////////////////////////////////////////////////
2305/// Set or change title of the group frame. Title TGString is adopted
2306/// by the TGGroupFrame.
2307
2309{
2310 if (!title) {
2311 Warning("SetTitle", "title cannot be 0, try \"\"");
2312 title = new TGString("");
2313 }
2314
2315 delete fText;
2316
2317 fText = title;
2318 fClient->NeedRedraw(this);
2319}
2320
2321////////////////////////////////////////////////////////////////////////////////
2322/// Set or change title of the group frame.
2323
2324void TGGroupFrame::SetTitle(const char *title)
2325{
2326 if (!title) {
2327 Error("SetTitle", "title cannot be 0, try \"\"");
2328 return;
2329 }
2330
2331 SetTitle(new TGString(title));
2332}
2333
2334////////////////////////////////////////////////////////////////////////////////
2335/// Return default font structure in use.
2336
2338{
2339 if (!fgDefaultFont && gClient)
2340 fgDefaultFont = gClient->GetResourcePool()->GetDefaultFont();
2341 return fgDefaultFont->GetFontStruct();
2342}
2343
2344////////////////////////////////////////////////////////////////////////////////
2345/// Return default graphics context in use.
2346
2348{
2349 if (!fgDefaultGC && gClient)
2350 fgDefaultGC = gClient->GetResourcePool()->GetFrameGC();
2351 return *fgDefaultGC;
2352}
2353
2354////////////////////////////////////////////////////////////////////////////////
2355/// Header Frame constructor.
2356
2358 UInt_t options, Pixel_t back) :
2359 TGHorizontalFrame(p, w, h, options | kVerticalFrame, back)
2360{
2362 fSplitCursor = gVirtualX->CreateCursor(kArrowHor);
2363 fOverSplitter = false;
2364 fOverButton = -1;
2365 fLastButton = -1;
2366 fNColumns = 1;
2367 fColHeader = 0;
2368 fSplitHeader = 0;
2369
2370 gVirtualX->GrabButton(fId, kAnyButton, kAnyModifier,
2372 kNone, kNone);
2374}
2375
2376////////////////////////////////////////////////////////////////////////////////
2377/// Set columns information in the header frame.
2378
2380 TGVFileSplitter **splitHeader)
2381{
2382 fNColumns = nColumns;
2383 fColHeader = colHeader;
2384 fSplitHeader = splitHeader;
2385}
2386
2387////////////////////////////////////////////////////////////////////////////////
2388/// Handle mouse button event in header frame.
2389
2391{
2392 if ( event->fY > 0 &&
2393 event->fY <= (Int_t) this->GetHeight() ) {
2394 for (Int_t i = 1; i < fNColumns; ++i ) {
2395 if ( event->fX < fColHeader[i]->GetX() &&
2396 event->fX >= fColHeader[i-1]->GetX() ) {
2397 if ( fOverSplitter ) {
2398 if ( event->fX <= fColHeader[i-1]->GetX() + 5 )
2400 else
2402 } else {
2403 if ( event->fType == kButtonPress ) {
2404 fLastButton = i - 1;
2405 } else {
2406 fLastButton = -1;
2407 }
2408 event->fX -= fColHeader[i-1]->GetX();
2410 }
2411 break;
2412 }
2413 }
2414 }
2415
2416 return kTRUE;
2417}
2418
2419////////////////////////////////////////////////////////////////////////////////
2420/// Handle double click mouse event in header frame.
2421
2423{
2424 if ( event->fY > 0 &&
2425 event->fY <= (Int_t) this->GetHeight() ) {
2426 for (Int_t i = 1; i < fNColumns; ++i ) {
2427 if ( event->fX < fColHeader[i]->GetX() &&
2428 event->fX >= fColHeader[i-1]->GetX() ) {
2429 if ( fOverSplitter ) {
2430 if ( event->fX <= fColHeader[i-1]->GetX() + 5 )
2432 else
2434 } else {
2435 event->fX -= fColHeader[i-1]->GetX();
2437 }
2438 break;
2439 }
2440 }
2441 }
2442
2443 return kTRUE;
2444}
2445
2446////////////////////////////////////////////////////////////////////////////////
2447/// Handle mouse motion events in header frame.
2448
2450{
2451 if ( event->fY > 0 &&
2452 event->fY <= (Int_t) this->GetHeight() ) {
2453 Bool_t inMiddle = false;
2454
2455 for (Int_t i = 1; i < fNColumns; ++i ) {
2456 if ( event->fX > fColHeader[i]->GetX() - 5 &&
2457 event->fX < fColHeader[i]->GetX() + 5 ) {
2458 inMiddle = true;
2459 }
2460 if ( event->fX < fColHeader[i]->GetX() &&
2461 event->fX >= fColHeader[i-1]->GetX() ) {
2462 fOverButton = i - 1;
2463 }
2464 }
2465 fOverSplitter = inMiddle;
2466 if ( fOverSplitter ) {
2467 gVirtualX->SetCursor(fId, fSplitCursor);
2468 }
2469 else {
2470 gVirtualX->SetCursor(fId, kNone);
2471 }
2472 }
2473 return kTRUE;
2474}
2475
2476////////////////////////////////////////////////////////////////////////////////
2477/// Save a user color in a C++ macro file - used in SavePrimitive().
2478
2479void TGFrame::SaveUserColor(std::ostream &out, Option_t *option)
2480{
2481 char quote = '"';
2482
2483 if (gROOT->ClassSaved(TGFrame::Class())) {
2484 out << std::endl;
2485 } else {
2486 // declare a color variable to reflect required user changes
2487 out << std::endl;
2488 out << " ULong_t ucolor; // will reflect user color changes" << std::endl;
2489 }
2490 ULong_t ucolor;
2491 if (option && !strcmp(option, "slider"))
2492 ucolor = GetDefaultFrameBackground();
2493 else
2494 ucolor = GetBackground();
2495 if ((ucolor != fgUserColor) || (ucolor == GetWhitePixel())) {
2496 const char *ucolorname = TColor::PixelAsHexString(ucolor);
2497 out << " gClient->GetColorByName(" << quote << ucolorname << quote
2498 << ",ucolor);" << std::endl;
2499 fgUserColor = ucolor;
2500 }
2501}
2502
2503////////////////////////////////////////////////////////////////////////////////
2504/// Returns a frame option string - used in SavePrimitive().
2505
2507{
2508 TString options;
2509
2510 if (!GetOptions()) {
2511 options = "kChildFrame";
2512 } else {
2513 if (fOptions & kMainFrame) {
2514 if (options.Length() == 0) options = "kMainFrame";
2515 else options += " | kMainFrame";
2516 }
2517 if (fOptions & kVerticalFrame) {
2518 if (options.Length() == 0) options = "kVerticalFrame";
2519 else options += " | kVerticalFrame";
2520 }
2521 if (fOptions & kHorizontalFrame) {
2522 if (options.Length() == 0) options = "kHorizontalFrame";
2523 else options += " | kHorizontalFrame";
2524 }
2525 if (fOptions & kSunkenFrame) {
2526 if (options.Length() == 0) options = "kSunkenFrame";
2527 else options += " | kSunkenFrame";
2528 }
2529 if (fOptions & kRaisedFrame) {
2530 if (options.Length() == 0) options = "kRaisedFrame";
2531 else options += " | kRaisedFrame";
2532 }
2533 if (fOptions & kDoubleBorder) {
2534 if (options.Length() == 0) options = "kDoubleBorder";
2535 else options += " | kDoubleBorder";
2536 }
2537 if (fOptions & kFitWidth) {
2538 if (options.Length() == 0) options = "kFitWidth";
2539 else options += " | kFitWidth";
2540 }
2541 if (fOptions & kFixedWidth) {
2542 if (options.Length() == 0) options = "kFixedWidth";
2543 else options += " | kFixedWidth";
2544 }
2545 if (fOptions & kFitHeight) {
2546 if (options.Length() == 0) options = "kFitHeight";
2547 else options += " | kFitHeight";
2548 }
2549 if (fOptions & kFixedHeight) {
2550 if (options.Length() == 0) options = "kFixedHeight";
2551 else options += " | kFixedHeight";
2552 }
2553 if (fOptions & kOwnBackground) {
2554 if (options.Length() == 0) options = "kOwnBackground";
2555 else options += " | kOwnBackground";
2556 }
2557 if (fOptions & kTransientFrame) {
2558 if (options.Length() == 0) options = "kTransientFrame";
2559 else options += " | kTransientFrame";
2560 }
2561 if (fOptions & kTempFrame) {
2562 if (options.Length() == 0) options = "kTempFrame";
2563 else options += " | kTempFrame";
2564 }
2565 }
2566 return options;
2567}
2568
2569////////////////////////////////////////////////////////////////////////////////
2570/// Returns MWM decoration hints as a string - used in SavePrimitive().
2571
2573{
2574 TString hints;
2575
2576 if (fMWMValue) {
2577 if (fMWMValue & kMWMDecorAll) {
2578 if (hints.Length() == 0) hints = "kMWMDecorAll";
2579 else hints += " | kMWMDecorAll";
2580 }
2581 if (fMWMValue & kMWMDecorBorder) {
2582 if (hints.Length() == 0) hints = "kMWMDecorBorder";
2583 else hints += " | kMWMDecorBorder";
2584 }
2586 if (hints.Length() == 0) hints = "kMWMDecorResizeH";
2587 else hints += " | kMWMDecorResizeH";
2588 }
2589 if (fMWMValue & kMWMDecorTitle) {
2590 if (hints.Length() == 0) hints = "kMWMDecorTitle";
2591 else hints += " | kMWMDecorTitle";
2592 }
2593 if (fMWMValue & kMWMDecorMenu) {
2594 if (hints.Length() == 0) hints = "kMWMDecorMenu";
2595 else hints += " | kMWMDecorMenu";
2596 }
2598 if (hints.Length() == 0) hints = "kMWMDecorMinimize";
2599 else hints += " | kMWMDecorMinimize";
2600 }
2602 if (hints.Length() == 0) hints = "kMWMDecorMaximize";
2603 else hints += " | kMWMDecorMaximize";
2604 }
2605 }
2606 return hints;
2607}
2608
2609////////////////////////////////////////////////////////////////////////////////
2610/// Returns MWM function hints as a string - used in SavePrimitive().
2611
2613{
2614 TString hints;
2615
2616 if (fMWMFuncs) {
2617
2618 if (fMWMFuncs & kMWMFuncAll) {
2619 if (hints.Length() == 0) hints = "kMWMFuncAll";
2620 else hints += " | kMWMFuncAll";
2621 }
2622 if (fMWMFuncs & kMWMFuncResize) {
2623 if (hints.Length() == 0) hints = "kMWMFuncResize";
2624 else hints += " | kMWMFuncResize";
2625 }
2626 if (fMWMFuncs & kMWMFuncMove) {
2627 if (hints.Length() == 0) hints = "kMWMFuncMove";
2628 else hints += " | kMWMFuncMove";
2629 }
2631 if (hints.Length() == 0) hints = "kMWMFuncMinimize";
2632 else hints += " | kMWMFuncMinimize";
2633 }
2635 if (hints.Length() == 0) hints = "kMWMFuncMaximize";
2636 else hints += " | kMWMFuncMaximize";
2637 }
2638 if (fMWMFuncs & kMWMFuncClose) {
2639 if (hints.Length() == 0) hints = "kMWMFuncClose";
2640 else hints += " | kMWMFuncClose";
2641 }
2642 }
2643 return hints;
2644}
2645
2646////////////////////////////////////////////////////////////////////////////////
2647/// Returns MWM input mode hints as a string - used in SavePrimitive().
2648
2650{
2651 TString hints;
2652
2653 if (fMWMInput == 0) hints = "kMWMInputModeless";
2654
2655 if (fMWMInput == 1) hints = "kMWMInputPrimaryApplicationModal";
2656
2657 if (fMWMInput == 2) hints = "kMWMInputSystemModal";
2658
2659 if (fMWMInput == 3) hints = "kMWMInputFullApplicationModal";
2660
2661 return hints;
2662}
2663
2664////////////////////////////////////////////////////////////////////////////////
2665/// Auxiliary protected method used to save subframes.
2666
2668{
2669 if (fLayoutBroken)
2670 out << " " << GetName() << "->SetLayoutBroken(kTRUE);" << std::endl;
2671
2672 if (!fList) return;
2673
2674 char quote = '"';
2675
2676 TGFrameElement *el;
2677 static TGHSplitter *hsplit = 0;
2678 static TGVSplitter *vsplit = 0;
2679 TList *signalslist;
2680 TList *connlist;
2681 TQConnection *conn;
2682 TString signal_name, slot_name;
2683
2684 TIter next(fList);
2685
2686 while ((el = (TGFrameElement *) next())) {
2687
2688 // Don't save hidden (unmapped) frames having a parent different
2689 // than this frame. Solves a problem with shared frames
2690 // (e.g. shared menus in the new Browser)
2691 if ((!(el->fState & kIsVisible)) && (el->fFrame->GetParent() != this))
2692 continue;
2693
2694 // Remember if the frame to be saved is a TG(H,V)Splitter
2695 // See comments below and in TG[H/V]Splitter::SavePrimitive()
2696 if (el->fFrame->InheritsFrom("TGVSplitter")) {
2697 vsplit = (TGVSplitter *)el->fFrame;
2698 if (vsplit->GetLeft())
2699 vsplit = 0;
2700 }
2701 else if (el->fFrame->InheritsFrom("TGHSplitter")) {
2702 hsplit = (TGHSplitter *)el->fFrame;
2703 if (hsplit->GetAbove())
2704 hsplit = 0;
2705 }
2706 el->fFrame->SavePrimitive(out, option);
2707 out << " " << GetName() << "->AddFrame(" << el->fFrame->GetName();
2708 el->fLayout->SavePrimitive(out, option);
2709 out << ");"<< std::endl;
2710 if (IsLayoutBroken()) {
2711 out << " " << el->fFrame->GetName() << "->MoveResize(";
2712 out << el->fFrame->GetX() << "," << el->fFrame->GetY() << ",";
2713 out << el->fFrame->GetWidth() << "," << el->fFrame->GetHeight();
2714 out << ");" << std::endl;
2715 }
2716 // TG(H,V)Splitter->SetFrame(theframe) can only be saved _AFTER_
2717 // having saved "theframe", when "theframe" is either at right
2718 // or below the splitter (that means after the splitter in the
2719 // list of frames), otherwise "theframe" would be undefined
2720 // (aka used before to be created)...
2721 if (vsplit && el->fFrame == vsplit->GetFrame()) {
2722 out << " " << vsplit->GetName() << "->SetFrame(" << vsplit->GetFrame()->GetName();
2723 if (vsplit->GetLeft()) out << ",kTRUE);" << std::endl;
2724 else out << ",kFALSE);"<< std::endl;
2725 vsplit = 0;
2726 }
2727 if (hsplit && el->fFrame == hsplit->GetFrame()) {
2728 out << " " << hsplit->GetName() << "->SetFrame(" << hsplit->GetFrame()->GetName();
2729 if (hsplit->GetAbove()) out << ",kTRUE);" << std::endl;
2730 else out << ",kFALSE);"<< std::endl;
2731 hsplit = 0;
2732 }
2733
2734 if (!(el->fState & kIsVisible)) {
2736 }
2737
2738 // saving signals/slots
2739 signalslist = (TList*)el->fFrame->GetListOfSignals();
2740 if (!signalslist) continue;
2741 connlist = (TList*)signalslist->Last();
2742 if (connlist) {
2743 conn = (TQConnection*)connlist->Last();
2744 if (conn) {
2745 signal_name = connlist->GetName();
2746 slot_name = conn->GetName();
2747 Int_t eq = slot_name.First('=');
2748 Int_t rb = slot_name.First(')');
2749 if (eq != -1)
2750 slot_name.Remove(eq, rb-eq);
2751 out << " " << el->fFrame->GetName() << "->Connect(" << quote << signal_name
2752 << quote << ", 0, 0, " << quote << slot_name << quote << ");" << std::endl;
2753
2754 TList *lsl = (TList *)gROOT->GetListOfSpecials()->FindObject("ListOfSlots");
2755 if (lsl) {
2756 TObjString *slotel = (TObjString *)lsl->FindObject(slot_name);
2757 if (!slotel)
2758 lsl->Add(new TObjString(slot_name));
2759 }
2760 }
2761 }
2762 }
2763 out << std::endl;
2764}
2765
2766////////////////////////////////////////////////////////////////////////////////
2767/// Save a composite frame widget as a C++ statement(s) on output stream out.
2768
2769void TGCompositeFrame::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
2770{
2772
2773 if (!strcmp(GetName(),"")) {
2774 SetName(Form("fCompositeframe%d",fgCounter));
2775 fgCounter++;
2776 }
2777
2778 out << std::endl << " // composite frame" << std::endl;
2779 out << " TGCompositeFrame *";
2780 out << GetName() << " = new TGCompositeFrame(" << fParent->GetName()
2781 << "," << GetWidth() << "," << GetHeight();
2782
2784 if (!GetOptions()) {
2785 out << ");" << std::endl;
2786 } else {
2787 out << "," << GetOptionString() <<");" << std::endl;
2788 }
2789 } else {
2790 out << "," << GetOptionString() << ",ucolor);" << std::endl;
2791 }
2792 if (option && strstr(option, "keep_names"))
2793 out << " " << GetName() << "->SetName(\"" << GetName() << "\");" << std::endl;
2794
2795 // setting layout manager if it differs from the composite frame type
2796 // coverity[returned_null]
2797 // coverity[dereference]
2799 if ((GetOptions() & kHorizontalFrame) &&
2801 ;
2802 } else if ((GetOptions() & kVerticalFrame) &&
2804 ;
2805 } else {
2806 out << " " << GetName() <<"->SetLayoutManager(";
2807 lm->SavePrimitive(out, option);
2808 out << ");"<< std::endl;
2809 }
2810
2812}
2813
2814////////////////////////////////////////////////////////////////////////////////
2815/// Save the GUI main frame widget in a C++ macro file.
2816
2818{
2819 // iteration over all active classes to exclude the base ones
2820 TString opt = option;
2821 TBits *bc = new TBits();
2822 TClass *c1, *c2, *c3;
2823 UInt_t k = 0; // will mark k-bit of TBits if the class is a base class
2824
2825 TIter nextc1(gROOT->GetListOfClasses());
2826 //gROOT->GetListOfClasses()->ls(); // valid. test
2827 while((c1 = (TClass *)nextc1())) {
2828
2829 // resets bit TClass::kClassSaved for all classes
2830 c1->ResetBit(TClass::kClassSaved);
2831
2832 TIter nextc2(gROOT->GetListOfClasses());
2833 while ((c2 = (TClass *)nextc2())) {
2834 if (c1==c2) continue;
2835 else {
2836 c3 = c2->GetBaseClass(c1);
2837 if (c3 != 0) {
2838 bc->SetBitNumber(k, kTRUE);
2839 break;
2840 }
2841 }
2842 }
2843 k++;
2844 }
2845
2846 TList *ilist = new TList(); // will contain include file names without '.h'
2847 ilist->SetName("ListOfIncludes");
2848 gROOT->GetListOfSpecials()->Add(ilist);
2849 k=0;
2850
2851 // completes list of include file names
2852 TIter nextdo(gROOT->GetListOfClasses());
2853 while ((c2 = (TClass *)nextdo())) {
2854 // for used GUI header files
2855 if (bc->TestBitNumber(k) == 0 && c2->InheritsFrom(TGObject::Class()) == 1) {
2856 // for any used ROOT header files activate the line below, comment the line above
2857 //if (bc->TestBitNumber(k) == 0) {
2858 const char *iname;
2859 iname = c2->GetDeclFileName();
2860 if (iname[0] && strstr(iname,".h")) {
2861 const char *lastsl = strrchr(iname,'/');
2862 if (lastsl) iname = lastsl + 1;
2863 char *tname = new char[strlen(iname)+1];
2864 Int_t i=0;
2865 while (*iname != '.') {
2866 tname[i] = *iname;
2867 i++; iname++;
2868 }
2869 tname[i] = 0; //tname = include file name without '.h'
2870
2871 TObjString *iel = (TObjString *)ilist->FindObject(tname);
2872 if (!iel) {
2873 ilist->Add(new TObjString(tname));
2874 }
2875 // Weird, but when saving a canvas, the following two classes
2876 // may be missing if the toolbar has not been displayed...
2877 if (strstr(tname, "TRootCanvas")) {
2878 if (!ilist->FindObject("TGDockableFrame"))
2879 ilist->Add(new TObjString("TGDockableFrame"));
2880 if (!ilist->FindObject("TG3DLine"))
2881 ilist->Add(new TObjString("TG3DLine"));
2882 }
2883 delete [] tname;
2884 }
2885 k++; continue;
2886 }
2887 k++;
2888 }
2889
2890 char quote = '"';
2891 std::ofstream out;
2892
2893 TString ff = filename && strlen(filename) ? filename : "Rootappl.C";
2894
2895 // Computes the main method name.
2896 const char *fname = gSystem->BaseName(ff.Data());
2897 Int_t lenfname = strlen(fname);
2898 char *sname = new char[lenfname+1];
2899
2900 Int_t i = 0;
2901 while ((*fname != '.') && (i < lenfname)) {
2902 sname[i] = *fname;
2903 i++; fname++;
2904 }
2905 if (i == lenfname)
2906 ff += ".C";
2907 sname[i] = 0;
2908
2909 out.open(ff.Data(), std::ios::out);
2910 if (!out.good()) {
2911 Error("SaveSource", "cannot open file: %s", ff.Data());
2912 delete [] sname;
2913 return;
2914 }
2915
2916 // writes include files in C++ macro
2917 TObjString *inc;
2918 ilist = (TList *)gROOT->GetListOfSpecials()->FindObject("ListOfIncludes");
2919
2920 if (!ilist) {
2921 delete [] sname;
2922 return;
2923 }
2924
2925 // write macro header, date/time stamp as string, and the used Root version
2926 TDatime t;
2927 out <<"// Mainframe macro generated from application: "<< gApplication->Argv(0) << std::endl;
2928 out <<"// By ROOT version "<< gROOT->GetVersion() <<" on "<<t.AsSQLString()<< std::endl;
2929 out << std::endl;
2930
2931 TIter nexti(ilist);
2932 while((inc = (TObjString *)nexti())) {
2933 out << "#ifndef ROOT_" << inc->GetString() << std::endl;
2934 out << "#include " << quote << inc->GetString() << ".h" << quote << std::endl;
2935 out << "#endif" << std::endl;
2936 if (strstr(inc->GetString(),"TRootEmbeddedCanvas")) {
2937 out << "#ifndef ROOT_TCanvas" << std::endl;
2938 out << "#include " << quote << "TCanvas.h" << quote << std::endl;
2939 out << "#endif" << std::endl;
2940 }
2941 }
2942 out << std::endl << "#include " << quote << "Riostream.h" << quote << std::endl;
2943 // deletes created ListOfIncludes
2944 gROOT->GetListOfSpecials()->Remove(ilist);
2945 ilist->Delete();
2946 delete ilist;
2947 delete bc;
2948
2949 // writes the macro entry point equal to the fname
2950 out << std::endl;
2951 out << "void " << sname << "()" << std::endl;
2952 out <<"{"<< std::endl;
2953 delete [] sname;
2954
2956
2957 // saving slots
2958 TList *lSlots = new TList;
2959 lSlots->SetName("ListOfSlots");
2960 gROOT->GetListOfSpecials()->Add(lSlots);
2961
2963
2964 if (strlen(fClassName) || strlen(fResourceName)) {
2965 out << " " << GetName() << "->SetClassHints(" << quote << fClassName
2966 << quote << "," << quote << fResourceName << quote << ");" << std::endl;
2967 }
2968
2970 if (fMWMValue || fMWMFuncs || fMWMInput) {
2971 out << " " << GetName() << "->SetMWMHints(";
2972 out << GetMWMvalueString() << "," << std::endl;
2973 out << " ";
2974 out << GetMWMfuncString() << "," << std::endl;
2975 out << " ";
2976 out << GetMWMinpString() << ");"<< std::endl;
2977 }
2978
2979/// GetWMPosition(fWMX, fWMY);
2980/// if ((fWMX != -1) || (fWMY != -1)) {
2981/// out <<" "<<GetName()<<"->SetWMPosition("<<fWMX<<","<<fWMY<<");"<<std::endl;
2982/// } // does not work - fixed via Move() below...
2983
2985 if (fWMWidth != UInt_t(-1) || fWMHeight != UInt_t(-1)) {
2986 out <<" "<<GetName()<<"->SetWMSize("<<fWMWidth<<","<<fWMHeight<<");"<<std::endl;
2987 }
2988
2990 if (fWMMinWidth != UInt_t(-1) || fWMMinHeight != UInt_t(-1) ||
2991 fWMMaxWidth != UInt_t(-1) || fWMMaxHeight != UInt_t(-1) ||
2992 fWMWidthInc != UInt_t(-1) || fWMHeightInc != UInt_t(-1)) {
2993 out <<" "<<GetName()<<"->SetWMSizeHints("<<fWMMinWidth<<","<<fWMMinHeight
2994 <<","<<fWMMaxWidth<<","<<fWMMaxHeight
2995 <<","<<fWMWidthInc<<","<<fWMHeightInc <<");"<<std::endl;
2996 }
2997
2998 out << " " <<GetName()<< "->MapSubwindows();" << std::endl;
2999
3001 TGFrame *fhidden;
3002 while ((fhidden = (TGFrame*)nexth())) {
3003 out << " " <<fhidden->GetName()<< "->UnmapWindow();" << std::endl;
3004 }
3005
3006 out << std::endl;
3008
3009 Bool_t usexy = kFALSE;
3010 // coverity[returned_null]
3011 // coverity[dereference]
3013 if (lm->InheritsFrom("TGXYLayout"))
3014 usexy = kTRUE;
3015
3016 if (!usexy)
3017 out << " " <<GetName()<< "->Resize("<< GetName()<< "->GetDefaultSize());" << std::endl;
3018 else
3019 out << " " <<GetName()<< "->Resize("<< GetWidth()<<","<<GetHeight()<<");"<<std::endl;
3020
3021 out << " " <<GetName()<< "->MapWindow();" <<std::endl;
3022
3024 if ((fWMX != -1) || (fWMY != -1)) {
3025 out <<" "<<GetName()<<"->Move("<<fWMX<<","<<fWMY<<");"<<std::endl;
3026 }
3027
3028 // needed in case the frame was resized
3029 // otherwise the frame became bigger showing all hidden widgets (layout algorithm)
3030 if (!usexy) out << " " <<GetName()<< "->Resize("<< GetWidth()<<","<<GetHeight()<<");"<<std::endl;
3031 out << "} " << std::endl;
3032
3033 // writing slots
3034 TList *sl = (TList *)gROOT->GetListOfSpecials()->FindObject("ListOfSlots");
3035 if (sl) {
3036 TIter nextsl(sl);
3037 TObjString *slobj;
3038 Int_t pnumber = 1;
3039
3040 while ((slobj = (TObjString*) nextsl())) {
3041 TString s = slobj->GetString();
3042 TString p = "";
3043 Int_t lb, rb, eq;
3044 lb = s.First('(');
3045 rb = s.First(')');
3046 eq = s.First('=');
3047 out << std::endl;
3048
3049 if (rb - lb > 1 && eq == -1) {
3050 p = TString::Format(" par%d", pnumber);
3051 s.Insert(rb, p);
3052 pnumber++;
3053 out << "void " << s << std::endl;
3054 out << "{" << std::endl;
3055 s = slobj->GetString();
3056 s[rb] = ' ';
3057 out << " std::cout << " << quote << "Slot " << s << quote
3058 << " <<" << p << " << " << quote << ")" << quote
3059 << " << std::endl; " << std::endl;
3060 } else {
3061 if (eq != -1) {
3062 s.Remove(eq, rb-eq);
3063 out << "void " << s << std::endl;
3064 out << "{" << std::endl;
3065 out << " std::cout << " << quote << "Slot " << s
3066 << quote << " << std::endl; " << std::endl;
3067 } else {
3068 out << "void " << slobj->GetString() << std::endl;
3069 out << "{" << std::endl;
3070 out << " std::cout << " << quote << "Slot " << slobj->GetString()
3071 << quote << " << std::endl; " << std::endl;
3072 }
3073 }
3074 out << "}" << std::endl;
3075 }
3076 gROOT->GetListOfSpecials()->Remove(sl);
3077 sl->Delete();
3078 delete sl;
3079 }
3080 out.close();
3081
3082 if (!opt.Contains("quiet"))
3083 printf(" C++ macro file %s has been generated\n", gSystem->BaseName(ff.Data()));
3084
3085 // reset bit TClass::kClassSaved for all classes
3086 nextc1.Reset();
3087 while((c1=(TClass*)nextc1())) {
3088 c1->ResetBit(TClass::kClassSaved);
3089 }
3090}
3091
3092////////////////////////////////////////////////////////////////////////////////
3093/// Save a main frame widget as a C++ statement(s) on output stream out.
3094
3095void TGMainFrame::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
3096{
3097 if (fParent != gClient->GetDefaultRoot()) { // frame is embedded
3098 fOptions &= ~kMainFrame;
3101 return;
3102 }
3103
3104 char quote = '"';
3105
3106 out << std::endl << " // main frame" << std::endl;
3107 out << " TGMainFrame *";
3108 out << GetName() << " = new TGMainFrame(gClient->GetRoot(),10,10," // layout alg.
3109 << GetOptionString() << ");" <<std::endl;
3110 if (option && strstr(option, "keep_names"))
3111 out << " " << GetName() << "->SetName(\"" << GetName() << "\");" << std::endl;
3112
3113 // setting layout manager if it differs from the main frame type
3114 // coverity[returned_null]
3115 // coverity[dereference]
3117 if ((GetOptions() & kHorizontalFrame) &&
3119 ;
3120 } else if ((GetOptions() & kVerticalFrame) &&
3122 ;
3123 } else {
3124 out << " " << GetName() <<"->SetLayoutManager(";
3125 lm->SavePrimitive(out, option);
3126 out << ");"<< std::endl;
3127 }
3128
3130
3131 if (strlen(fWindowName)) {
3132 out << " " << GetName() << "->SetWindowName(" << quote << GetWindowName()
3133 << quote << ");" << std::endl;
3134 }
3135 if (strlen(fIconName)) {
3136 out <<" "<<GetName()<< "->SetIconName("<<quote<<GetIconName()<<quote<<");"<<std::endl;
3137 }
3138 if (strlen(fIconPixmap)) {
3139 out << " " << GetName() << "->SetIconPixmap(" << quote << GetIconPixmap()
3140 << quote << ");" << std::endl;
3141 }
3142}
3143
3144////////////////////////////////////////////////////////////////////////////////
3145/// Save a horizontal frame widget as a C++ statement(s) on output stream out.
3146
3147void TGHorizontalFrame::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
3148{
3150
3151 out << std::endl << " // horizontal frame" << std::endl;
3152 out << " TGHorizontalFrame *";
3153 out << GetName() << " = new TGHorizontalFrame(" << fParent->GetName()
3154 << "," << GetWidth() << "," << GetHeight();
3155
3157 if (!GetOptions()) {
3158 out << ");" << std::endl;
3159 } else {
3160 out << "," << GetOptionString() <<");" << std::endl;
3161 }
3162 } else {
3163 out << "," << GetOptionString() << ",ucolor);" << std::endl;
3164 }
3165 if (option && strstr(option, "keep_names"))
3166 out << " " << GetName() << "->SetName(\"" << GetName() << "\");" << std::endl;
3167
3168 // setting layout manager if it differs from the main frame type
3169 // coverity[returned_null]
3170 // coverity[dereference]
3172 if ((GetOptions() & kHorizontalFrame) &&
3174 ;
3175 } else if ((GetOptions() & kVerticalFrame) &&
3177 ;
3178 } else {
3179 out << " " << GetName() <<"->SetLayoutManager(";
3180 lm->SavePrimitive(out, option);
3181 out << ");"<< std::endl;
3182 }
3183
3185}
3186
3187////////////////////////////////////////////////////////////////////////////////
3188/// Save a vertical frame widget as a C++ statement(s) on output stream out.
3189
3190void TGVerticalFrame::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
3191{
3193
3194 out << std::endl << " // vertical frame" << std::endl;
3195 out << " TGVerticalFrame *";
3196 out << GetName() << " = new TGVerticalFrame(" << fParent->GetName()
3197 << "," << GetWidth() << "," << GetHeight();
3198
3200 if (!GetOptions()) {
3201 out <<");" << std::endl;
3202 } else {
3203 out << "," << GetOptionString() <<");" << std::endl;
3204 }
3205 } else {
3206 out << "," << GetOptionString() << ",ucolor);" << std::endl;
3207 }
3208 if (option && strstr(option, "keep_names"))
3209 out << " " << GetName() << "->SetName(\"" << GetName() << "\");" << std::endl;
3210
3211 // setting layout manager if it differs from the main frame type
3212 // coverity[returned_null]
3213 // coverity[dereference]
3215 if ((GetOptions() & kHorizontalFrame) &&
3217 ;
3218 } else if ((GetOptions() & kVerticalFrame) &&
3220 ;
3221 } else {
3222 out << " " << GetName() <<"->SetLayoutManager(";
3223 lm->SavePrimitive(out, option);
3224 out << ");"<< std::endl;
3225 }
3226
3228}
3229
3230////////////////////////////////////////////////////////////////////////////////
3231/// Save a frame widget as a C++ statement(s) on output stream out.
3232
3233void TGFrame::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
3234{
3236
3237 out << " TGFrame *";
3238 out << GetName() << " = new TGFrame("<< fParent->GetName()
3239 << "," << GetWidth() << "," << GetHeight();
3240
3242 if (!GetOptions()) {
3243 out <<");" << std::endl;
3244 } else {
3245 out << "," << GetOptionString() <<");" << std::endl;
3246 }
3247 } else {
3248 out << "," << GetOptionString() << ",ucolor);" << std::endl;
3249 }
3250 if (option && strstr(option, "keep_names"))
3251 out << " " << GetName() << "->SetName(\"" << GetName() << "\");" << std::endl;
3252}
3253
3254////////////////////////////////////////////////////////////////////////////////
3255/// Save a group frame widget as a C++ statement(s) on output stream out.
3256
3257void TGGroupFrame::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
3258{
3259 char quote = '"';
3260
3261 // font + GC
3262 option = GetName()+5; // unique digit id of the name
3263 TString parGC, parFont;
3264 // coverity[returned_null]
3265 // coverity[dereference]
3266 parFont.Form("%s::GetDefaultFontStruct()",IsA()->GetName());
3267 // coverity[returned_null]
3268 // coverity[dereference]
3269 parGC.Form("%s::GetDefaultGC()()",IsA()->GetName());
3270
3271 if ((GetDefaultFontStruct() != fFontStruct) || (GetDefaultGC()() != fNormGC)) {
3272 TGFont *ufont = gClient->GetResourcePool()->GetFontPool()->FindFont(fFontStruct);
3273 if (ufont) {
3274 ufont->SavePrimitive(out, option);
3275 parFont.Form("ufont->GetFontStruct()");
3276 }
3277
3278 TGGC *userGC = gClient->GetResourcePool()->GetGCPool()->FindGC(fNormGC);
3279 if (userGC) {
3280 userGC->SavePrimitive(out, option);
3281 parGC.Form("uGC->GetGC()");
3282 }
3283 }
3284
3286
3287 out << std::endl << " // " << quote << GetTitle() << quote << " group frame" << std::endl;
3288 out << " TGGroupFrame *";
3289 out << GetName() <<" = new TGGroupFrame("<<fParent->GetName()
3290 << "," << quote << GetTitle() << quote;
3291
3294 if (fNormGC == GetDefaultGC()()) {
3295 if (GetOptions() & kVerticalFrame) {
3296 out <<");" << std::endl;
3297 } else {
3298 out << "," << GetOptionString() <<");" << std::endl;
3299 }
3300 } else {
3301 out << "," << GetOptionString() << "," << parGC.Data() <<");" << std::endl;
3302 }
3303 } else {
3304 out << "," << GetOptionString() << "," << parGC.Data() << "," << parFont.Data() << ");" << std::endl;
3305 }
3306 } else {
3307 out << "," << GetOptionString() << "," << parGC.Data() << "," << parFont.Data() << ",ucolor);" << std::endl;
3308 }
3309 if (option && strstr(option, "keep_names"))
3310 out << " " << GetName() << "->SetName(\"" << GetName() << "\");" << std::endl;
3311
3312 if (GetTitlePos() != -1)
3313 out << " " << GetName() <<"->SetTitlePos(";
3314 if (GetTitlePos() == 0)
3315 out << "TGGroupFrame::kCenter);" << std::endl;
3316 if (GetTitlePos() == 1)
3317 out << "TGGroupFrame::kRight);" << std::endl;
3318
3320
3321 // setting layout manager
3322 out << " " << GetName() <<"->SetLayoutManager(";
3323 // coverity[returned_null]
3324 // coverity[dereference]
3326 out << ");"<< std::endl;
3327
3328 out << " " << GetName() <<"->Resize(" << GetWidth() << ","
3329 << GetHeight() << ");" << std::endl;
3330}
3331
3332
3333////////////////////////////////////////////////////////////////////////////////
3334/// Save the GUI transient frame widget in a C++ macro file.
3335
3337{
3338 // iterate over all active classes to exclude the base ones
3339
3340 TString opt = option;
3341 TBits *bc = new TBits();
3342 TClass *c1, *c2, *c3;
3343 UInt_t k = 0; // will mark k-bit of TBits if the class is a base class
3344
3345 TIter nextc1(gROOT->GetListOfClasses());
3346 while((c1 = (TClass *)nextc1())) {
3347
3348 // resets bit TClass::kClassSaved for all classes
3349 c1->ResetBit(TClass::kClassSaved);
3350
3351 TIter nextc2(gROOT->GetListOfClasses());
3352 while ((c2 = (TClass *)nextc2())) {
3353 if (c1==c2) continue;
3354 else {
3355 c3 = c2->GetBaseClass(c1);
3356 if (c3 != 0) {
3357 bc->SetBitNumber(k, kTRUE);
3358 break;
3359 }
3360 }
3361 }
3362 k++;
3363 }
3364
3365 TList *ilist = new TList(); // will contain include file names without '.h'
3366 ilist->SetName("ListOfIncludes");
3367 gROOT->GetListOfSpecials()->Add(ilist);
3368 k=0;
3369
3370 // completes list of include file names
3371 TIter nextdo(gROOT->GetListOfClasses());
3372 while ((c2 = (TClass *)nextdo())) {
3373 // to have only used GUI header files
3374 if (bc->TestBitNumber(k) == 0 && c2->InheritsFrom(TGObject::Class()) == 1) {
3375 // for any used ROOT header files activate the line below, comment the line above
3376 //if (bc->TestBitNumber(k) == 0) {
3377 const char *iname;
3378 iname = c2->GetDeclFileName();
3379 if (iname[0] && strstr(iname,".h")) {
3380 const char *lastsl = strrchr(iname,'/');
3381 if (lastsl) iname = lastsl + 1;
3382 char *tname = new char[strlen(iname)+1];
3383 Int_t i=0;
3384 while (*iname != '.') {
3385 tname[i] = *iname;
3386 i++; iname++;
3387 }
3388 tname[i] = 0; //tname = include file name without '.h'
3389
3390 TObjString *iel = (TObjString *)ilist->FindObject(tname);
3391 if (!iel) {
3392 ilist->Add(new TObjString(tname));
3393 }
3394 delete [] tname;
3395 }
3396 k++; continue;
3397 }
3398 k++;
3399 }
3400
3401 char quote = '"';
3402 std::ofstream out;
3403
3404 TString ff = filename && strlen(filename) ? filename : "Rootdlog.C";
3405
3406 // Computes the main method name.
3407 const char *fname = gSystem->BaseName(ff.Data());
3408 Int_t lenfname = strlen(fname);
3409 char *sname = new char[lenfname+1];
3410
3411 Int_t i = 0;
3412 while ((*fname != '.') && (i < lenfname)) {
3413 sname[i] = *fname;
3414 i++; fname++;
3415 }
3416 if (i == lenfname)
3417 ff += ".C";
3418 sname[i] = 0;
3419
3420 out.open(ff.Data(), std::ios::out);
3421 if (!out.good()) {
3422 Error("SaveSource", "cannot open file: %s", ff.Data());
3423 delete [] sname;
3424 return;
3425 }
3426
3427 // writes include files in C++ macro
3428 TObjString *inc;
3429 ilist = (TList *)gROOT->GetListOfSpecials()->FindObject("ListOfIncludes");
3430
3431 if (!ilist) {
3432 delete [] sname;
3433 return;
3434 }
3435
3436 // write macro header, date/time stamp as string, and the used Root version
3437 TDatime t;
3438 out <<"// Dialog macro generated from application: "<< gApplication->Argv(0) << std::endl;
3439 out <<"// By ROOT version "<< gROOT->GetVersion() <<" on "<<t.AsSQLString()<< std::endl;
3440 out << std::endl;
3441
3442 out << "#if !defined( __CINT__) || defined (__MAKECINT__)" << std::endl << std::endl;
3443
3444 TIter nexti(ilist);
3445 while((inc = (TObjString *)nexti())) {
3446 out <<"#ifndef ROOT_"<< inc->GetString() << std::endl;
3447 out <<"#include "<< quote << inc->GetString() <<".h"<< quote << std::endl;
3448 out <<"#endif" << std::endl;
3449 if (strstr(inc->GetString(),"TRootEmbeddedCanvas")) {
3450 out <<"#ifndef ROOT_TCanvas"<< std::endl;
3451 out <<"#include "<< quote <<"TCanvas.h"<< quote << std::endl;
3452 out <<"#endif" << std::endl;
3453 }
3454 }
3455 out << std::endl << "#include " << quote << "Riostream.h" << quote << std::endl;
3456 out << std::endl << "#endif" << std::endl;
3457 // deletes created ListOfIncludes
3458 gROOT->GetListOfSpecials()->Remove(ilist);
3459 ilist->Delete();
3460 delete ilist;
3461 delete bc;
3462
3463 // writes the macro entry point equal to the fname
3464 out << std::endl;
3465 out << "void " << sname << "()" << std::endl;
3466 delete [] sname;
3467
3468 // Save GUI widgets as a C++ macro in a file
3469 out <<"{"<< std::endl;
3470
3472
3473 // saving slots
3474 TList *lSlots = new TList;
3475 lSlots->SetName("ListOfSlots");
3476 gROOT->GetListOfSpecials()->Add(lSlots);
3477
3479
3480 if (strlen(fClassName) || strlen(fResourceName)) {
3481 out<<" "<<GetName()<< "->SetClassHints("<<quote<<fClassName<<quote
3482 <<"," <<quote<<fResourceName<<quote
3483 <<");"<<std::endl;
3484 }
3485
3487 if (fMWMValue || fMWMFuncs || fMWMInput) {
3488 out << " " << GetName() << "->SetMWMHints(";
3489 out << GetMWMvalueString() << "," << std::endl;
3490 out << " ";
3491 out << GetMWMfuncString() << "," << std::endl;
3492 out << " ";
3493 out << GetMWMinpString() << ");"<< std::endl;
3494 }
3495
3497 if ((fWMX != -1) || (fWMY != -1)) {
3498 out <<" "<<GetName()<<"->SetWMPosition("<<fWMX<<","<<fWMY<<");"<<std::endl;
3499 }
3500
3502 if (fWMWidth != UInt_t(-1) || fWMHeight != UInt_t(-1)) {
3503 out <<" "<<GetName()<<"->SetWMSize("<<fWMWidth<<","<<fWMHeight<<");"<<std::endl;
3504 }
3505
3507 if (fWMMinWidth != UInt_t(-1) || fWMMinHeight != UInt_t(-1) ||
3508 fWMMaxWidth != UInt_t(-1) || fWMMaxHeight != UInt_t(-1) ||
3509 fWMWidthInc != UInt_t(-1) || fWMHeightInc != UInt_t(-1)) {
3510
3511 out <<" "<<GetName()<<"->SetWMSizeHints("<<fWMMinWidth<<","<<fWMMinHeight
3512 <<","<<fWMMaxWidth<<","<<fWMMaxHeight <<","<<fWMWidthInc<<","<<fWMHeightInc
3513 <<");"<<std::endl;
3514 }
3515
3517 if ((fWMX != -1) || (fWMY != -1)) {
3518 out <<" "<<GetName()<<"->Move("<<fWMX<<","<<fWMY<<");"<<std::endl;
3519 }
3520
3521 out << " " <<GetName()<< "->MapSubwindows();" << std::endl;
3522
3524 TGFrame *fhidden;
3525 while ((fhidden = (TGFrame*)nexth())) {
3526 out << " " <<fhidden->GetName()<< "->UnmapWindow();" << std::endl;
3527 }
3528 out << std::endl;
3530
3531 Bool_t usexy = kFALSE;
3532 // coverity[returned_null]
3533 // coverity[dereference]
3535 if (lm->InheritsFrom("TGXYLayout"))
3536 usexy = kTRUE;
3537
3538 if (!usexy)
3539 out << " " <<GetName()<< "->Resize("<< GetName()<< "->GetDefaultSize());" << std::endl;
3540 else
3541 out << " " <<GetName()<< "->Resize("<< GetWidth()<<","<<GetHeight()<<");"<<std::endl;
3542
3543 out << " " <<GetName()<< "->MapWindow();" <<std::endl;
3544 if (!usexy) out << " " <<GetName()<< "->Resize();" << std::endl;
3545 out << "} " << std::endl;
3546
3547 // writing slots
3548 TList *sl = (TList *)gROOT->GetListOfSpecials()->FindObject("ListOfSlots");
3549 if (sl) {
3550 TIter nextsl(sl);
3551 TObjString *slobj;
3552 Int_t pnumber = 1;
3553
3554 while ((slobj = (TObjString*) nextsl())) {
3555 TString s = slobj->GetString();
3556 TString p = "";
3557 Int_t lb, rb, eq;
3558 lb = s.First('(');
3559 rb = s.First(')');
3560 eq = s.First('=');
3561 out << std::endl;
3562
3563 if (rb - lb > 1 && eq == -1) {
3564 p = TString::Format(" par%d", pnumber);
3565 s.Insert(rb, p);
3566 pnumber++;
3567 out << "void " << s << std::endl;
3568 out << "{" << std::endl;
3569 s = slobj->GetString();
3570 s[rb] = ' ';
3571 out << " std::cout << " << quote << "Slot " << s << quote
3572 << " <<" << p << " << " << quote << ")" << quote
3573 << " << std::endl; " << std::endl;
3574 } else {
3575 if (eq != -1) {
3576 s.Remove(eq, rb-eq);
3577 out << "void " << s << std::endl;
3578 out << "{" << std::endl;
3579 out << " std::cout << " << quote << "Slot " << s
3580 << quote << " << std::endl; " << std::endl;
3581 } else {
3582 out << "void " << slobj->GetString() << std::endl;
3583 out << "{" << std::endl;
3584 out << " std::cout << " << quote << "Slot " << slobj->GetString()
3585 << quote << " << std::endl; " << std::endl;
3586 }
3587 }
3588 out << "}" << std::endl;
3589 }
3590 gROOT->GetListOfSpecials()->Remove(sl);
3591 sl->Delete();
3592 delete sl;
3593 }
3594
3595 out.close();
3596
3597 if (!opt.Contains("quiet"))
3598 printf(" C++ macro file %s has been generated\n", gSystem->BaseName(ff.Data()));
3599
3600 // reset bit TClass::kClassSaved for all classes
3601 nextc1.Reset();
3602 while((c1=(TClass*)nextc1())) {
3603 c1->ResetBit(TClass::kClassSaved);
3604 }
3605}
3606
3607////////////////////////////////////////////////////////////////////////////////
3608/// Save a transient frame widget as a C++ statement(s) on output stream out.
3609
3610void TGTransientFrame::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
3611{
3612 char quote = '"';
3613
3614 out << std::endl << " // transient frame" << std::endl;
3615 out << " TGTransientFrame *";
3616 out << GetName()<<" = new TGTransientFrame(gClient->GetRoot(),0"
3617 << "," << GetWidth() << "," << GetHeight() << "," << GetOptionString() <<");" << std::endl;
3618
3619 if (option && strstr(option, "keep_names"))
3620 out << " " << GetName() << "->SetName(\"" << GetName() << "\");" << std::endl;
3621
3622 // setting layout manager if it differs from transient frame type
3623 // coverity[returned_null]
3624 // coverity[dereference]
3626 if ((GetOptions() & kHorizontalFrame) &&
3628 ;
3629 } else if ((GetOptions() & kVerticalFrame) &&
3631 ;
3632 } else {
3633 out << " " << GetName() <<"->SetLayoutManager(";
3634 lm->SavePrimitive(out, option);
3635 out << ");"<< std::endl;
3636 }
3637
3639
3640 if (strlen(fWindowName)) {
3641 out << " " << GetName() << "->SetWindowName(" << quote << GetWindowName()
3642 << quote << ");" << std::endl;
3643 }
3644 if (strlen(fIconName)) {
3645 out <<" "<<GetName()<< "->SetIconName("<<quote<<GetIconName()<<quote<<");"<<std::endl;
3646 }
3647 if (strlen(fIconPixmap)) {
3648 out << " " << GetName() << "->SetIconPixmap(" << quote << GetIconPixmap()
3649 << quote << ");" << std::endl;
3650 }
3651}
Handle_t Atom_t
WM token.
Definition: GuiTypes.h:37
@ kSelectionClear
Definition: GuiTypes.h:63
@ kColormapNotify
Definition: GuiTypes.h:64
@ kConfigureNotify
Definition: GuiTypes.h:62
@ kGKeyPress
Definition: GuiTypes.h:60
@ kExpose
Definition: GuiTypes.h:62
@ kButtonRelease
Definition: GuiTypes.h:60
@ kSelectionNotify
Definition: GuiTypes.h:63
@ kButtonPress
Definition: GuiTypes.h:60
@ kButtonDoubleClick
Definition: GuiTypes.h:64
@ kFocusOut
Definition: GuiTypes.h:61
@ kMotionNotify
Definition: GuiTypes.h:61
@ kFocusIn
Definition: GuiTypes.h:61
@ kClientMessage
Definition: GuiTypes.h:63
@ kEnterNotify
Definition: GuiTypes.h:61
@ kSelectionRequest
Definition: GuiTypes.h:63
@ kKeyRelease
Definition: GuiTypes.h:60
@ kLeaveNotify
Definition: GuiTypes.h:61
@ kArrowHor
Definition: GuiTypes.h:374
Handle_t Pixmap_t
Pixmap handle.
Definition: GuiTypes.h:30
const Mask_t kButtonPressMask
Definition: GuiTypes.h:161
Handle_t FontH_t
Font handle (as opposed to Font_t which is an index)
Definition: GuiTypes.h:35
const Mask_t kExposureMask
Definition: GuiTypes.h:165
const Mask_t kWAEventMask
Definition: GuiTypes.h:151
Handle_t Window_t
Window handle.
Definition: GuiTypes.h:29
const Mask_t kWABackPixel
Definition: GuiTypes.h:140
const Mask_t kAnyModifier
Definition: GuiTypes.h:210
ULong_t Time_t
Event time.
Definition: GuiTypes.h:42
Handle_t GContext_t
Graphics context handle.
Definition: GuiTypes.h:38
EInitialState
Initial window mapping state.
Definition: GuiTypes.h:345
const Mask_t kPointerMotionMask
Definition: GuiTypes.h:163
@ kFitHeight
Definition: GuiTypes.h:388
@ kRaisedFrame
Definition: GuiTypes.h:384
@ kTempFrame
Definition: GuiTypes.h:393
@ kSunkenFrame
Definition: GuiTypes.h:383
@ kVerticalFrame
Definition: GuiTypes.h:381
@ kDoubleBorder
Definition: GuiTypes.h:385
@ kFixedWidth
Definition: GuiTypes.h:387
@ kFitWidth
Definition: GuiTypes.h:386
@ kHorizontalFrame
Definition: GuiTypes.h:382
@ kFixedHeight
Definition: GuiTypes.h:389
@ kOwnBackground
Definition: GuiTypes.h:391
@ kTransientFrame
Definition: GuiTypes.h:392
@ kMainFrame
Definition: GuiTypes.h:380
const Handle_t kNone
Definition: GuiTypes.h:88
const Mask_t kKeyControlMask
Definition: GuiTypes.h:197
const Mask_t kKeyMod2Mask
typically mod on numeric keys
Definition: GuiTypes.h:199
const Mask_t kStructureNotifyMask
Definition: GuiTypes.h:166
const Mask_t kButtonReleaseMask
Definition: GuiTypes.h:162
ULong_t Pixel_t
Pixel value.
Definition: GuiTypes.h:40
@ kAnyButton
Definition: GuiTypes.h:214
ULongptr_t Handle_t
Generic resource handle.
Definition: GuiTypes.h:26
Handle_t FontStruct_t
Pointer to font structure.
Definition: GuiTypes.h:39
@ kKey_S
Definition: KeySymbols.h:144
@ kKey_s
Definition: KeySymbols.h:176
#define f(i)
Definition: RSha256.hxx:104
#define c(i)
Definition: RSha256.hxx:101
#define h(i)
Definition: RSha256.hxx:106
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
bool Bool_t
Definition: RtypesCore.h:63
int Int_t
Definition: RtypesCore.h:45
const UInt_t kMaxUInt
Definition: RtypesCore.h:111
long Longptr_t
Definition: RtypesCore.h:82
const Bool_t kFALSE
Definition: RtypesCore.h:101
long Long_t
Definition: RtypesCore.h:54
unsigned int UInt_t
Definition: RtypesCore.h:46
float Float_t
Definition: RtypesCore.h:57
const Bool_t kTRUE
Definition: RtypesCore.h:100
unsigned long ULong_t
Definition: RtypesCore.h:55
const char Option_t
Definition: RtypesCore.h:66
#define ClassImp(name)
Definition: Rtypes.h:375
R__EXTERN TApplication * gApplication
Definition: TApplication.h:165
constexpr Int_t kFatal
Definition: TError.h:49
Int_t gErrorIgnoreLevel
Definition: TError.cxx:34
#define gClient
Definition: TGClient.h:157
R__EXTERN TGDNDManager * gDNDManager
Definition: TGDNDManager.h:201
@ kFDSave
Definition: TGFileDialog.h:22
TList * gListOfHiddenFrames
Definition: TGFrame.cxx:145
static const char * gSaveMacroTypes[]
Definition: TGFrame.cxx:134
@ kMWMDecorResizeH
Definition: TGFrame.h:65
@ kMWMFuncAll
Definition: TGFrame.h:49
@ kMWMFuncMove
Definition: TGFrame.h:51
@ kMWMDecorBorder
Definition: TGFrame.h:64
@ kMWMFuncResize
Definition: TGFrame.h:50
@ kMWMDecorMaximize
Definition: TGFrame.h:69
@ kMWMDecorTitle
Definition: TGFrame.h:66
@ kMWMDecorMinimize
Definition: TGFrame.h:68
@ kMWMDecorMenu
Definition: TGFrame.h:67
@ kMWMDecorAll
Definition: TGFrame.h:63
@ kMWMFuncMaximize
Definition: TGFrame.h:53
@ kMWMInputModeless
Definition: TGFrame.h:57
@ kMWMFuncClose
Definition: TGFrame.h:54
@ kMWMFuncMinimize
Definition: TGFrame.h:52
@ kNoCleanup
Definition: TGFrame.h:40
@ kDeepCleanup
Definition: TGFrame.h:42
@ kIsArranged
Definition: TGFrame.h:35
@ kIsVisible
Definition: TGFrame.h:33
@ kLHintsExpandY
Definition: TGLayout.h:31
@ kLHintsExpandX
Definition: TGLayout.h:30
@ kMBRetry
Definition: TGMsgBox.h:35
@ kMBCancel
Definition: TGMsgBox.h:37
@ kMBIconExclamation
Definition: TGMsgBox.h:24
winID h TVirtualViewer3D TVirtualGLPainter p
Option_t Option_t option
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void input
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t hmin
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 filename
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t hmax
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t wmin
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 b
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t r
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize id
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t child
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void on
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void funcs
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t winc
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t modifier
Option_t Option_t TPoint TPoint const char mode
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 g
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 type
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t wmax
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t hinc
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void gc
char name[80]
Definition: TGX11.cxx:110
R__EXTERN TGuiBuilder * gGuiBuilder
Definition: TGuiBuilder.h:66
#define gROOT
Definition: TROOT.h:404
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition: TString.cxx:2447
R__EXTERN TSystem * gSystem
Definition: TSystem.h:559
R__EXTERN TVirtualDragManager * gDragManager
#define gVirtualX
Definition: TVirtualX.h:338
R__EXTERN Atom_t gROOT_MESSAGE
Definition: TVirtualX.h:40
R__EXTERN Atom_t gWM_DELETE_WINDOW
Definition: TVirtualX.h:38
int main(int argc, char *argv[])
Definition: cef_main.cxx:54
char ** Argv() const
Definition: TApplication.h:136
Container of bits.
Definition: TBits.h:26
Bool_t TestBitNumber(UInt_t bitnumber) const
Definition: TBits.h:222
void SetBitNumber(UInt_t bitnumber, Bool_t value=kTRUE)
Definition: TBits.h:206
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
@ kClassSaved
Definition: TClass.h:94
void SetName(const char *name)
Definition: TCollection.h:206
const char * GetName() const override
Return name of this collection.
static ULong_t RGB2Pixel(Int_t r, Int_t g, Int_t b)
Convert r,g,b to graphics system dependent pixel value.
Definition: TColor.cxx:2119
static void Pixel2RGB(ULong_t pixel, Int_t &r, Int_t &g, Int_t &b)
Convert machine dependent pixel value (obtained via RGB2Pixel or via Number2Pixel() or via TColor::Ge...
Definition: TColor.cxx:2157
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:2174
This class stores the date and time with a precision of one second in an unsigned 32 bit word (950130...
Definition: TDatime.h:37
const char * AsSQLString() const
Return the date & time in SQL compatible string format, like: 1997-01-15 20:16:28.
Definition: TDatime.cxx:152
Bool_t HandleButton(Event_t *event) override
Handle mouse button event.
Definition: TGButton.cxx:330
Window client.
Definition: TGClient.h:37
const TGWindow * GetDefaultRoot() const
Returns the root (i.e.
Definition: TGClient.cxx:234
Bool_t IsEditable() const
Definition: TGClient.h:89
const TGWindow * GetRoot() const
Returns current root (i.e.
Definition: TGClient.cxx:224
TGFont * GetFont(const char *font, Bool_t fixedDefault=kTRUE)
Get a font from the font pool.
Definition: TGClient.cxx:348
const TGResourcePool * GetResourcePool() const
Definition: TGClient.h:124
UInt_t GetDisplayHeight() const
Get display height.
Definition: TGClient.cxx:275
const TGPicture * GetPicture(const char *name)
Get picture from the picture pool.
Definition: TGClient.cxx:289
TGGCPool * GetGCPool() const
Definition: TGClient.h:131
void SetRoot(TGWindow *root=nullptr)
Sets the current root (i.e.
Definition: TGClient.cxx:244
Bool_t IsEditDisabled() const
Returns kTRUE if edit/guibuilding is forbidden.
Definition: TGClient.cxx:935
void NeedRedraw(TGWindow *w, Bool_t force=kFALSE)
Set redraw flags.
Definition: TGClient.cxx:372
UInt_t GetDisplayWidth() const
Get display width.
Definition: TGClient.cxx:262
The base class for composite widgets (menu bars, list boxes, etc.).
Definition: TGFrame.h:287
Bool_t HandleDragDrop(TGFrame *frame, Int_t x, Int_t y, TGLayoutHints *lo) override
Handle drop event.
Definition: TGFrame.cxx:1421
TGDimension GetDefaultSize() const override
std::cout << fWidth << "x" << fHeight << std::endl;
Definition: TGFrame.h:316
virtual TGFrameElement * FindFrameElement(TGFrame *f) const
Find frame-element holding frame f.
Definition: TGFrame.cxx:1094
TGLayoutManager * fLayoutManager
layout manager
Definition: TGFrame.h:291
virtual void ChangeSubframesBackground(Pixel_t back)
Change background color for this frame and all subframes.
Definition: TGFrame.cxx:1288
virtual void SetLayoutManager(TGLayoutManager *l)
Set the layout manager for the composite frame.
Definition: TGFrame.cxx:1000
TGFrame * GetFrameFromPoint(Int_t x, Int_t y) override
Get frame located at specified point.
Definition: TGFrame.cxx:1308
Int_t GetState(TGFrame *f) const
Get state of sub frame.
Definition: TGFrame.cxx:1218
void Print(Option_t *option="") const override
Print all frames in this composite frame.
Definition: TGFrame.cxx:1266
virtual void AddFrame(TGFrame *f, TGLayoutHints *l=0)
Add frame to the composite frame using the specified layout hints.
Definition: TGFrame.cxx:1117
Bool_t HandleDragMotion(TGFrame *) override
Handle drag motion event.
Definition: TGFrame.cxx:1413
virtual TGLayoutManager * GetLayoutManager() const
Definition: TGFrame.h:338
Bool_t HandleSelection(Event_t *) override
Definition: TGFrame.h:330
Bool_t HandleDragEnter(TGFrame *) override
Handle drag enter event.
Definition: TGFrame.cxx:1365
virtual void Cleanup()
Cleanup and delete all objects contained in this composite frame.
Definition: TGFrame.cxx:967
Bool_t HandleDragLeave(TGFrame *) override
Handle drag leave event.
Definition: TGFrame.cxx:1395
Int_t fMustCleanup
cleanup mode (see EFrameCleanup)
Definition: TGFrame.h:294
virtual void SavePrimitiveSubframes(std::ostream &out, Option_t *option="")
Auxiliary protected method used to save subframes.
Definition: TGFrame.cxx:2667
void MapSubwindows() override
Map all sub windows that are part of the composite frame.
Definition: TGFrame.cxx:1164
TGCompositeFrame(const TGCompositeFrame &)=delete
virtual Bool_t TranslateCoordinates(TGFrame *child, Int_t x, Int_t y, Int_t &fx, Int_t &fy)
Translate coordinates to child frame.
Definition: TGFrame.cxx:1332
void Layout() override
Layout the elements of the composite frame.
Definition: TGFrame.cxx:1257
Bool_t HandleMotion(Event_t *) override
Definition: TGFrame.h:327
Bool_t fLayoutBroken
no layout manager is used
Definition: TGFrame.h:293
Bool_t fMapSubwindows
kTRUE - map subwindows
Definition: TGFrame.h:295
virtual void ShowFrame(TGFrame *f)
Show sub frame.
Definition: TGFrame.cxx:1204
TList * fList
container of frame elements
Definition: TGFrame.h:292
Bool_t IsEditable() const override
Return kTRUE if frame is being edited.
Definition: TGFrame.cxx:927
void SetCleanup(Int_t mode=kLocalCleanup) override
Turn on automatic cleanup of child frames in dtor.
Definition: TGFrame.cxx:1072
virtual ~TGCompositeFrame()
Delete a composite frame.
Definition: TGFrame.cxx:904
Bool_t IsLayoutBroken() const override
Definition: TGFrame.h:357
Bool_t HandleButton(Event_t *) override
Definition: TGFrame.h:324
Bool_t IsArranged(TGFrame *f) const
Get state of sub frame.
Definition: TGFrame.cxx:1244
virtual void RemoveFrame(TGFrame *f)
Remove frame from composite frame.
Definition: TGFrame.cxx:1149
void SetEditable(Bool_t on=kTRUE) override
Switch ON/OFF edit mode.
Definition: TGFrame.cxx:948
static TGLayoutHints * fgDefaultHints
Definition: TGFrame.h:297
void SavePrimitive(std::ostream &out, Option_t *option="") override
Save a composite frame widget as a C++ statement(s) on output stream out.
Definition: TGFrame.cxx:2769
void SetEditDisabled(UInt_t on=1) override
Set edit disable flag for this frame and subframes.
Definition: TGFrame.cxx:1022
virtual void RemoveAll()
Remove all frames from composite frame.
Definition: TGFrame.cxx:1131
void ChangeOptions(UInt_t options) override
Change composite frame options. Options is an OR of the EFrameTypes.
Definition: TGFrame.cxx:1043
static TClass * Class()
virtual void HideFrame(TGFrame *f)
Hide sub frame.
Definition: TGFrame.cxx:1190
Bool_t IsVisible(TGFrame *f) const
Get state of sub frame.
Definition: TGFrame.cxx:1231
void SetLayoutBroken(Bool_t on=kTRUE) override
Set broken layout. No Layout method is called.
Definition: TGFrame.cxx:1012
Bool_t HandleSelectionRequest(Event_t *event)
Handle selection request event.
Bool_t HandleClientMessage(Event_t *event)
Handle DND related client messages.
Bool_t HandleSelection(Event_t *event)
Handle selection event.
Bool_t IsDragging() const
Definition: TGDNDManager.h:173
void SetMainFrame(TGFrame *main)
Definition: TGDNDManager.h:162
static Atom_t GetDNDSelection()
Bool_t Drag(Int_t x_root, Int_t y_root, Atom_t action, Time_t timestamp)
Process drag event.
Bool_t Drop()
Drop.
TGFrame * GetMainFrame() const
Definition: TGDNDManager.h:161
static Atom_t GetDNDActionCopy()
UInt_t fHeight
Definition: TGDimension.h:21
UInt_t fWidth
Definition: TGDimension.h:20
This class creates a file selection dialog.
Definition: TGFileDialog.h:65
char * fFilename
selected file name
Definition: TGFileDialog.h:46
const char ** fFileTypes
file types used to filter selectable files
Definition: TGFileDialog.h:48
char * fIniDir
on input: initial directory, on output: new directory
Definition: TGFileDialog.h:47
Bool_t fOverwrite
if true overwrite the file with existing name on save
Definition: TGFileDialog.h:50
void SetIniDir(const char *inidir)
Set directory name.
Encapsulate fonts used in the GUI system.
Definition: TGFont.h:140
FontStruct_t GetFontStruct() const
Definition: TGFont.h:184
void SavePrimitive(std::ostream &out, Option_t *="") override
Save the used font as a C++ statement(s) on output stream out.
Definition: TGFont.cxx:1884
TGLayoutHints * fLayout
Definition: TGLayout.h:114
Int_t fState
Definition: TGLayout.h:113
TGFrame * fFrame
Definition: TGLayout.h:112
A subclasses of TGWindow, and is used as base class for some simple widgets (buttons,...
Definition: TGFrame.h:80
virtual void ChangeOptions(UInt_t options)
Change frame options. Options is an OR of the EFrameTypes.
Definition: TGFrame.cxx:321
virtual Bool_t HandleSelectionClear(Event_t *)
Definition: TGFrame.h:170
virtual TGDimension GetDefaultSize() const
std::cout << fWidth << "x" << fHeight << std::endl;
Definition: TGFrame.cxx:584
static Pixel_t GetDefaultSelectedBackground()
Get default selected frame background.
Definition: TGFrame.cxx:696
void AddInput(UInt_t emask)
Add events specified in the emask to the events the frame should handle.
Definition: TGFrame.cxx:339
static const TGGC * fgWhiteGC
Definition: TGFrame.h:106
virtual Int_t GetDragType() const
Returns drag source type.
Definition: TGFrame.cxx:824
virtual void StartGuiBuilding(Bool_t on=kTRUE)
Go into GUI building mode.
Definition: TGFrame.cxx:841
Bool_t IsEditable() const override
Definition: TGFrame.h:213
void MoveResize(Int_t x, Int_t y, UInt_t w=0, UInt_t h=0) override
Move and/or resize the frame.
Definition: TGFrame.cxx:629
static const TGGC & GetBlackGC()
Get black graphics context.
Definition: TGFrame.cxx:735
static Pixel_t GetBlackPixel()
Get black pixel value.
Definition: TGFrame.cxx:722
UInt_t fOptions
frame options
Definition: TGFrame.h:94
virtual Bool_t HandleConfigureNotify(Event_t *event)
This event is generated when the frame is resized.
Definition: TGFrame.cxx:443
Int_t fX
frame x position
Definition: TGFrame.h:85
virtual Bool_t HandleDoubleClick(Event_t *)
Definition: TGFrame.h:162
void Resize(UInt_t w=0, UInt_t h=0) override
Resize the frame.
Definition: TGFrame.cxx:605
UInt_t fMinHeight
minimal frame height
Definition: TGFrame.h:90
void RemoveInput(UInt_t emask)
Remove events specified in emask from the events the frame should handle.
Definition: TGFrame.cxx:348
static Bool_t fgInit
Definition: TGFrame.h:100
virtual Bool_t HandleKey(Event_t *)
Definition: TGFrame.h:165
TGFrame(const TGFrame &)=delete
static Pixel_t GetWhitePixel()
Get white pixel value.
Definition: TGFrame.cxx:709
UInt_t fHeight
frame height
Definition: TGFrame.h:88
static Int_t fgDby
Definition: TGFrame.h:112
virtual Bool_t HandleColormapChange(Event_t *)
Definition: TGFrame.h:171
virtual void SetDropType(Int_t type)
SetDropType.
Definition: TGFrame.cxx:816
virtual void SetDragType(Int_t type)
SetDragType.
Definition: TGFrame.cxx:809
void ReparentWindow(const TGWindow *p, Int_t x=0, Int_t y=0) override
Reparent window, make p the new parent and position the window at position (x,y) in new parent.
Definition: TGFrame.h:202
void SavePrimitive(std::ostream &out, Option_t *option="") override
Save a frame widget as a C++ statement(s) on output stream out.
Definition: TGFrame.cxx:3233
virtual void DrawBorder()
Draw frame border.
Definition: TGFrame.cxx:421
static const TGGC * fgBckgndGC
Definition: TGFrame.h:109
virtual Bool_t ProcessMessage(Longptr_t, Longptr_t, Longptr_t)
Definition: TGFrame.h:183
virtual void Draw3dRectangle(UInt_t type, Int_t x, Int_t y, UInt_t w, UInt_t h)
Draw 3D rectangle on the frame border.
Definition: TGFrame.cxx:357
Int_t fBorderWidth
frame border width
Definition: TGFrame.h:93
void SetBackgroundColor(Pixel_t back) override
Set background color (override from TGWindow base class).
Definition: TGFrame.cxx:312
static const TGGC * fgShadowGC
Definition: TGFrame.h:108
Bool_t HandleEvent(Event_t *event) override
Handle all frame events.
Definition: TGFrame.cxx:457
static Pixel_t fgDefaultSelectedBackground
Definition: TGFrame.h:102
UInt_t fMinWidth
minimal frame width
Definition: TGFrame.h:89
void DoRedraw() override
Redraw the frame.
Definition: TGFrame.cxx:430
void MapWindow() override
map window
Definition: TGFrame.h:204
virtual ~TGFrame()
Destructor.
Definition: TGFrame.cxx:266
@ kDeleteWindowCalled
Definition: TGFrame.h:83
virtual Pixel_t GetForeground() const
Return frame foreground color.
Definition: TGFrame.cxx:303
TGFrameElement * GetFrameElement() const
Definition: TGFrame.h:235
static const TGGC & GetHilightGC()
Get highlight color graphics context.
Definition: TGFrame.cxx:755
static UInt_t fgLastButton
Definition: TGFrame.h:111
TGFrameElement * fFE
pointer to frame element
Definition: TGFrame.h:98
static Pixel_t GetDefaultFrameBackground()
Get default frame background.
Definition: TGFrame.cxx:683
virtual Int_t GetDropType() const
Returns drop target type.
Definition: TGFrame.cxx:833
Int_t fDNDState
EDNDFlags.
Definition: TGFrame.h:97
static Time_t GetLastClick()
Get time of last mouse click.
Definition: TGFrame.cxx:785
void Move(Int_t x, Int_t y) override
Move frame.
Definition: TGFrame.cxx:593
TClass * IsA() const override
Definition: TGFrame.h:283
static const TGGC * fgBlackGC
Definition: TGFrame.h:105
Int_t GetX() const
Definition: TGFrame.h:231
static Int_t fgDbx
Definition: TGFrame.h:112
static UInt_t fgUserColor
Definition: TGFrame.h:114
virtual void DeleteWindow()
Delete window.
Definition: TGFrame.cxx:276
virtual TGFrame * GetFrameFromPoint(Int_t x, Int_t y)
Definition: TGFrame.h:240
virtual UInt_t GetOptions() const
Definition: TGFrame.h:197
TString GetOptionString() const
Returns a frame option string - used in SavePrimitive().
Definition: TGFrame.cxx:2506
static Time_t fgLastClick
Definition: TGFrame.h:110
Int_t fY
frame y position
Definition: TGFrame.h:86
virtual Bool_t HandleFocusChange(Event_t *)
Definition: TGFrame.h:166
virtual Bool_t IsComposite() const
Definition: TGFrame.h:212
virtual void ChangeBackground(Pixel_t back)
Change frame background color.
Definition: TGFrame.cxx:293
UInt_t fMaxWidth
maximal frame width
Definition: TGFrame.h:91
void UnmapWindow() override
unmap window
Definition: TGFrame.h:206
virtual void SendMessage(const TGWindow *w, Longptr_t msg, Longptr_t parm1, Longptr_t parm2)
Send message (i.e.
Definition: TGFrame.cxx:645
virtual void ProcessedConfigure(Event_t *event)
Definition: TGFrame.h:177
static const TGGC & GetShadowGC()
Get shadow color graphics context.
Definition: TGFrame.cxx:765
virtual Bool_t HandleSelectionRequest(Event_t *)
Definition: TGFrame.h:169
virtual Bool_t HandleSelection(Event_t *)
Definition: TGFrame.h:168
void Print(Option_t *option="") const override
Print window id.
Definition: TGFrame.cxx:793
UInt_t fWidth
frame width
Definition: TGFrame.h:87
virtual Bool_t HandleButton(Event_t *)
Definition: TGFrame.h:161
virtual Bool_t HandleMotion(Event_t *)
Definition: TGFrame.h:164
void SetFrameElement(TGFrameElement *fe)
Definition: TGFrame.h:236
UInt_t GetHeight() const
Definition: TGFrame.h:225
virtual void SetCleanup(Int_t=kLocalCleanup)
Definition: TGFrame.h:217
void MapSubwindows() override
map sub windows
Definition: TGFrame.h:200
virtual Bool_t HandleClientMessage(Event_t *event)
Handle a client message.
Definition: TGFrame.cxx:669
Int_t GetY() const
Definition: TGFrame.h:232
virtual void Layout()
Definition: TGFrame.h:199
virtual Pixel_t GetBackground() const
Definition: TGFrame.h:192
UInt_t fEventMask
currently active event mask
Definition: TGFrame.h:96
UInt_t fMaxHeight
maximal frame height
Definition: TGFrame.h:92
virtual Bool_t HandleCrossing(Event_t *)
Definition: TGFrame.h:163
virtual void ProcessedEvent(Event_t *event)
Definition: TGFrame.h:179
static Window_t fgDbw
Definition: TGFrame.h:113
Bool_t Contains(Int_t x, Int_t y) const
Definition: TGFrame.h:238
static const TGGC & GetWhiteGC()
Get white graphics context.
Definition: TGFrame.cxx:745
static Pixel_t fgWhitePixel
Definition: TGFrame.h:103
UInt_t GetWidth() const
Definition: TGFrame.h:224
void SaveUserColor(std::ostream &out, Option_t *)
Save a user color in a C++ macro file - used in SavePrimitive().
Definition: TGFrame.cxx:2479
static TClass * Class()
Pixel_t fBackground
frame background color
Definition: TGFrame.h:95
static Pixel_t fgBlackPixel
Definition: TGFrame.h:104
static const TGGC & GetBckgndGC()
Get background color graphics context.
Definition: TGFrame.cxx:775
static const TGGC * fgHilightGC
Definition: TGFrame.h:107
static Pixel_t fgDefaultFrameBackground
Definition: TGFrame.h:101
Definition: TGGC.h:103
TGGC * GetGC(GCValues_t *values, Bool_t rw=kFALSE)
Get the best matching graphics context depending on values.
Definition: TGGC.cxx:987
void FreeGC(const TGGC *gc)
Delete graphics context if it is not used anymore.
Definition: TGGC.cxx:918
TGGC * FindGC(const TGGC *gc)
Find graphics context. Returns 0 in case gc is not found.
Definition: TGGC.cxx:951
Encapsulate a graphics context used in the low level graphics.
Definition: TGGC.h:22
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:627
A composite frame with a border and a title.
Definition: TGFrame.h:522
void SavePrimitive(std::ostream &out, Option_t *option="") override
Save a group frame widget as a C++ statement(s) on output stream out.
Definition: TGFrame.cxx:3257
static TClass * Class()
TGString * fText
title text
Definition: TGFrame.h:525
Bool_t fHasOwnFont
kTRUE - font defined locally, kFALSE - globally
Definition: TGFrame.h:529
static const TGGC & GetDefaultGC()
Return default graphics context in use.
Definition: TGFrame.cxx:2347
virtual ~TGGroupFrame()
Delete a group frame.
Definition: TGFrame.cxx:2118
static const TGGC * fgDefaultGC
Definition: TGFrame.h:534
TGGroupFrame(const TGGroupFrame &)=delete
Int_t fTitlePos
OPTION={GetMethod="GetTitlePos";SetMethod="SetTitlePos";Items=(-1="Left",0="Center",...
Definition: TGFrame.h:528
static const TGFont * fgDefaultFont
Definition: TGFrame.h:533
void DrawBorder() override
Draw border of around the group frame.
Definition: TGFrame.cxx:2226
TGDimension GetDefaultSize() const override
Returns default size.
Definition: TGFrame.cxx:2131
TClass * IsA() const override
Definition: TGFrame.h:576
void DoRedraw() override
Redraw the group frame.
Definition: TGFrame.cxx:2145
FontStruct_t fFontStruct
title fontstruct
Definition: TGFrame.h:526
virtual void SetTextFont(const char *fontName, Bool_t local=kTRUE)
Changes text font specified by name.
Definition: TGFrame.cxx:2202
GContext_t fNormGC
title graphics context
Definition: TGFrame.h:527
static FontStruct_t GetDefaultFontStruct()
Return default font structure in use.
Definition: TGFrame.cxx:2337
Bool_t HasOwnFont() const
Returns kTRUE if text attributes are unique, returns kFALSE if text attributes are shared (global).
Definition: TGFrame.cxx:2215
virtual void SetTextColor(Pixel_t color, Bool_t local=kTRUE)
Changes text color.
Definition: TGFrame.cxx:2157
Int_t GetTitlePos() const
Definition: TGFrame.h:563
const char * GetTitle() const override
Returns title of object.
Definition: TGFrame.h:571
virtual void SetTitle(TGString *title)
Set or change title of the group frame.
Definition: TGFrame.cxx:2308
const TGFrame * GetFrame() const
Definition: TGSplitter.h:114
Bool_t GetAbove() const
Definition: TGSplitter.h:115
Horizontal Frame used to contain header buttons and splitters in a list view.
Definition: TGFrame.h:580
Bool_t HandleDoubleClick(Event_t *event) override
Handle double click mouse event in header frame.
Definition: TGFrame.cxx:2422
Int_t fLastButton
Indicates the last button clicked if any.
Definition: TGFrame.h:592
void SetColumnsInfo(Int_t nColumns, TGTextButton **colHeader, TGVFileSplitter **splitHeader)
Set columns information in the header frame.
Definition: TGFrame.cxx:2379
TGVFileSplitter ** fSplitHeader
column splitters
Definition: TGFrame.h:588
Bool_t fOverSplitter
Indicates if the cursor is over a splitter.
Definition: TGFrame.h:590
TGHeaderFrame(const TGHeaderFrame &)=delete
Bool_t HandleMotion(Event_t *event) override
Handle mouse motion events in header frame.
Definition: TGFrame.cxx:2449
TGTextButton ** fColHeader
column headers for in detailed mode
Definition: TGFrame.h:587
Cursor_t fSplitCursor
split cursor;
Definition: TGFrame.h:589
Bool_t HandleButton(Event_t *event) override
Handle mouse button event in header frame.
Definition: TGFrame.cxx:2390
Int_t fNColumns
number of columns
Definition: TGFrame.h:586
Int_t fOverButton
Indicates over which button the mouse is.
Definition: TGFrame.h:591
A composite frame that layout their children in horizontal way.
Definition: TGFrame.h:385
void SavePrimitive(std::ostream &out, Option_t *option="") override
Save a horizontal frame widget as a C++ statement(s) on output stream out.
Definition: TGFrame.cxx:3147
static TClass * Class()
This class describes layout hints used by the layout classes.
Definition: TGLayout.h:50
void SavePrimitive(std::ostream &out, Option_t *option="") override
Save layout hints as a C++ statement(s) on output stream out.
Definition: TGLayout.cxx:975
TGFrameElement * fFE
Definition: TGLayout.h:56
Frame layout manager.
Definition: TGLayout.h:135
virtual void Layout()=0
Defines top level windows that interact with the system Window Manager.
Definition: TGFrame.h:397
void GetWMSizeHints(UInt_t &wmin, UInt_t &hmin, UInt_t &wmax, UInt_t &hmax, UInt_t &winc, UInt_t &hinc) const
Definition: TGFrame.h:485
TGMainFrame(const TGMainFrame &)=delete
UInt_t fWMWidthInc
WM width increments.
Definition: TGFrame.h:431
UInt_t fWMHeightInc
WM height increments.
Definition: TGFrame.h:432
Bool_t HandleMotion(Event_t *event) override
Handle mouse motion events.
Definition: TGFrame.cxx:1691
virtual Bool_t SaveFrameAsCodeOrImage()
Opens dialog window allowing user to save the frame contents as a ROOT macro or as an image.
Definition: TGFrame.cxx:1527
virtual void SaveSource(const char *filename="Rootappl.C", Option_t *option="")
Save the GUI main frame widget in a C++ macro file.
Definition: TGFrame.cxx:2817
TString GetMWMfuncString() const
used in SaveSource()
Definition: TGFrame.cxx:2612
void DontCallClose()
Typically call this method in the slot connected to the CloseWindow() signal to prevent the calling o...
Definition: TGFrame.cxx:1780
UInt_t fWMWidth
WM width.
Definition: TGFrame.h:425
UInt_t fWMMinHeight
WM min height.
Definition: TGFrame.h:428
void GetWMPosition(Int_t &x, Int_t &y) const
Definition: TGFrame.h:483
Int_t fWMY
WM y position.
Definition: TGFrame.h:424
UInt_t fWMMinWidth
WM min width.
Definition: TGFrame.h:427
TString fResourceName
WM resource name.
Definition: TGFrame.h:419
UInt_t fMWMValue
MWM decoration hints.
Definition: TGFrame.h:420
void GetWMSize(UInt_t &w, UInt_t &h) const
Definition: TGFrame.h:484
Atom_t * fDNDTypeList
handles DND types
Definition: TGFrame.h:413
virtual void SendCloseMessage()
Send close message to self.
Definition: TGFrame.cxx:1744
void GetMWMHints(UInt_t &value, UInt_t &funcs, UInt_t &input) const
Definition: TGFrame.h:481
void SetClassHints(const char *className, const char *resourceName)
Set the windows class and resource name.
Definition: TGFrame.cxx:1858
Int_t fWMX
WM x position.
Definition: TGFrame.h:423
virtual void CloseWindow()
Close and delete main frame.
Definition: TGFrame.cxx:1770
TString fIconPixmap
icon pixmap name
Definition: TGFrame.h:417
UInt_t fWMMaxWidth
WM max width.
Definition: TGFrame.h:429
Bool_t HandleButton(Event_t *event) override
Handle mouse button events.
Definition: TGFrame.cxx:1679
Bool_t HandleClientMessage(Event_t *event) override
Handle client messages sent to this frame.
Definition: TGFrame.cxx:1727
TString fWindowName
window name
Definition: TGFrame.h:415
@ kDontCallClose
Definition: TGFrame.h:400
UInt_t fWMHeight
WM height.
Definition: TGFrame.h:426
TList * fBindList
list with key bindings
Definition: TGFrame.h:414
virtual ~TGMainFrame()
TGMainFrame destructor.
Definition: TGFrame.cxx:1507
UInt_t fWMMaxHeight
WM max height.
Definition: TGFrame.h:430
void SetWMState(EInitialState state)
Set the initial state of the window. Either kNormalState or kIconicState.
Definition: TGFrame.cxx:1924
virtual Bool_t BindKey(const TGWindow *w, Int_t keycode, Int_t modifier) const
Bind key to a window.
Definition: TGFrame.cxx:1637
UInt_t fMWMFuncs
MWM functions.
Definition: TGFrame.h:421
EInitialState fWMInitState
WM initial state.
Definition: TGFrame.h:433
void SetIconName(const char *name)
Set window icon name. This is typically done via the window manager.
Definition: TGFrame.cxx:1801
TString GetMWMinpString() const
used in SaveSource()
Definition: TGFrame.cxx:2649
void SetWMSize(UInt_t w, UInt_t h)
Give the window manager a window size hint.
Definition: TGFrame.cxx:1893