Logo ROOT   6.18/05
Reference Guide
TGTab.cxx
Go to the documentation of this file.
1// @(#)root/gui:$Id$
2// Author: Fons Rademakers 13/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// //
25// TGTab, TGTabElement, TGTabLayout //
26// //
27// A tab widget contains a set of composite frames each with a little //
28// tab with a name (like a set of folders with tabs). //
29// //
30// The TGTab is user callable. The TGTabElement and TGTabLayout are //
31// service classes of the tab widget. //
32// //
33// Clicking on a tab will bring the associated composite frame to the //
34// front and generate the following event: //
35// kC_COMMAND, kCM_TAB, tab id, 0. //
36// //
37//////////////////////////////////////////////////////////////////////////
38
39#include "TGTab.h"
40#include "TGResourcePool.h"
41#include "TList.h"
42#include "Riostream.h"
43#include "TClass.h"
44#include "TGPicture.h"
45
47const TGGC *TGTab::fgDefaultGC = 0;
48
52
53
54////////////////////////////////////////////////////////////////////////////////
55/// Create a tab element. Text is adopted by tab element.
56
58 GContext_t norm, FontStruct_t font,
59 UInt_t options, ULong_t back) :
60 TGFrame(p, w, h, options, back)
61{
62 fClosePic = 0;
63 fClosePicD = 0;
66 fText = text;
67 fBorderWidth = 0;
68 fTWidth = 0;
69 fNormGC = norm;
70 fFontStruct = font;
72
73 fClosePic = fClient->GetPicture("closetab.png");
74 fClosePicD = fClient->GetPicture("closetab_d.png");
75 int max_ascent, max_descent;
76 if (fText)
78 gVirtualX->GetFontProperties(fFontStruct, max_ascent, max_descent);
79 fTHeight = max_ascent + max_descent;
83}
84
85////////////////////////////////////////////////////////////////////////////////
86/// Delete tab element.
87
89{
90 if (fClosePic) gClient->FreePicture(fClosePic);
91 if (fClosePicD) gClient->FreePicture(fClosePicD);
92 if (fText) delete fText;
93}
94
95////////////////////////////////////////////////////////////////////////////////
96/// Draw little tab element.
97
99{
100 gVirtualX->DrawLine(fId, GetHilightGC()(), 0, fHeight-1, 0, 2);
101 gVirtualX->DrawLine(fId, GetHilightGC()(), 0, 2, 2, 0);
102 gVirtualX->DrawLine(fId, GetHilightGC()(), 2, 0, fWidth-3, 0);
103 gVirtualX->DrawLine(fId, GetShadowGC()(), fWidth-2, 1, fWidth-2, fHeight-1);
104 if (gClient->GetStyle() < 2) {
105 gVirtualX->DrawLine(fId, GetBlackGC()(), fWidth-2, 1, fWidth-1, 2);
106 gVirtualX->DrawLine(fId, GetBlackGC()(), fWidth-1, 2, fWidth-1, fHeight-2);
107 }
108 gVirtualX->DrawLine(fId, GetHilightGC()(), fWidth-1, fHeight-1, fWidth-1, fHeight-1);
109
110 if (fText) {
111 int max_ascent, max_descent;
112 gVirtualX->GetFontProperties(fFontStruct, max_ascent, max_descent);
113 if (fEnabled) {
114 fText->Draw(fId, fNormGC, 6, max_ascent+3);
115 } else {
116 fText->Draw(fId, GetHilightGC()(), 7, max_ascent + 1);
117 fText->Draw(fId, GetShadowGC()(), 6, max_ascent);
118 }
119 }
120 if (fShowClose && fClosePic && fClosePicD) {
121 if (fEnabled && fActive)
123 else
125 }
126}
127
128////////////////////////////////////////////////////////////////////////////////
129/// Handle button event in the tab widget. Basically we only handle
130/// button events in the small tabs.
131
133{
134 if (event->fType == kButtonPress) {
135 TGTab* main = (TGTab*)fParent;
136 if (main) {
137 if (fShowClose && event->fWindow == GetId() &&
138 (UInt_t)event->fX > fTWidth+12 && (UInt_t)event->fX < fTWidth+26 &&
139 (UInt_t)event->fY > fHeight/2-7 && (UInt_t)event->fY < fHeight/2+7) {
140 if (main->GetTabTab(main->GetCurrent()) == this) {
141 main->CloseTab(main->GetCurrent()); // emit signal
142 //main->RemoveTab(main->GetCurrent());
143 return kTRUE;
144 }
145 }
146 TGFrameElement *el;
147 TIter next(main->GetList());
148
149 next(); // skip first container
150
151 Int_t i = 0;
152 Int_t c = main->GetCurrent();
153 while ((el = (TGFrameElement *) next())) {
154 if (el->fFrame->GetId() == (Window_t)event->fWindow)
155 c = i;
156 next(); i++;
157 }
158
159 // change tab and generate event
160 main->SetTab(c);
161 }
162 }
163 return kTRUE;
164}
165
166////////////////////////////////////////////////////////////////////////////////
167/// Return default size of tab element.
168
170{
172 return TGDimension(TMath::Max(fTWidth+30, (UInt_t)45), fTHeight+6);
173 else
174 return TGDimension(TMath::Max(fTWidth+12, (UInt_t)45), fTHeight+6);
175}
176
177////////////////////////////////////////////////////////////////////////////////
178/// Set new tab text.
179
181{
182 if (fText) delete fText;
183 fText = text;
184
185 int max_ascent, max_descent;
187 gVirtualX->GetFontProperties(fFontStruct, max_ascent, max_descent);
188 fTHeight = max_ascent + max_descent;
189
190 fClient->NeedRedraw(this);
191}
192
193////////////////////////////////////////////////////////////////////////////////
194/// Show/hide close icon on the tab element, then apply layout
195/// to compute correct elements size.
196
198{
199 TGTab* main = (TGTab*)fParent;
200 fShowClose = show;
203 else
205 if (main)
206 main->GetLayoutManager()->Layout();
207}
208
209////////////////////////////////////////////////////////////////////////////////
210/// Create a tab layout manager.
211
213{
214 fMain = main;
215 fList = fMain->GetList();
216}
217
218////////////////////////////////////////////////////////////////////////////////
219/// Layout the tab widget.
220
222{
223 Int_t i, xtab;
224 UInt_t tw;
225 UInt_t tabh = fMain->GetTabHeight(), bw = fMain->GetBorderWidth();
226 UInt_t w = fMain->GetWidth();
227 UInt_t h = fMain->GetHeight();
228
229 xtab = 2;
230
231 fMain->GetContainer()->MoveResize(0, tabh, w, h - tabh);
232
233 // first frame is the container, so take next...
234 TGFrameElement *el, *elnxt;
235 TIter next(fList);
236 i = 0;
237 next(); // skip first
238 while ((el = (TGFrameElement *) next())) {
239 elnxt = (TGFrameElement *) next();
240 tw = el->fFrame->GetDefaultWidth();
241 if (i == fMain->GetCurrent()) {
242 el->fFrame->MoveResize(xtab-2, 0, tw+3, tabh+1);
243 if (elnxt) elnxt->fFrame->RaiseWindow();
244 el->fFrame->RaiseWindow();
245 } else {
246 el->fFrame->MoveResize(xtab, 2, tw, tabh-1);
247 el->fFrame->LowerWindow();
248 }
249 UInt_t nw = (w - (bw << 1));
250 if (nw > 32768) nw = 1;
251 UInt_t nh = (h - tabh - (bw << 1));
252 if (nh > 32768) nh = 1;
253 if (elnxt) {
254 elnxt->fFrame->MoveResize(bw, tabh + bw, nw, nh);
255 elnxt->fFrame->Layout();
256 }
257 xtab += (Int_t)tw;
258 i++;
259 }
260}
261
262////////////////////////////////////////////////////////////////////////////////
263/// Get default size of tab widget.
264
266{
267 TGDimension dsize, dsize_te;
268 TGDimension size(0,0), size_te(0,0);
269
270 TGFrameElement *el, *elnxt;
271 TIter next(fList);
272 next(); // skip first container
273 while ((el = (TGFrameElement *)next())) {
274 dsize_te = el->fFrame->GetDefaultSize();
275 size_te.fWidth += dsize_te.fWidth;
276 elnxt = (TGFrameElement *) next();
277 if (elnxt) {
278 dsize = elnxt->fFrame->GetDefaultSize();
279 if (size.fWidth < dsize.fWidth) size.fWidth = dsize.fWidth;
280 if (size.fHeight < dsize.fHeight) size.fHeight = dsize.fHeight;
281 }
282 }
283
284 // check if tab elements make a larger width than the containers
285 if (size.fWidth < size_te.fWidth) size.fWidth = size_te.fWidth;
286
287 size.fWidth += fMain->GetBorderWidth() << 1;
288 size.fHeight += fMain->GetTabHeight() + (fMain->GetBorderWidth() << 1);
289
290 return size;
291}
292
293
294////////////////////////////////////////////////////////////////////////////////
295/// Create tab widget.
296
298 GContext_t norm, FontStruct_t font,
299 UInt_t options, ULong_t back) :
300 TGCompositeFrame(p, w, h, options, back)
301{
302 fMsgWindow = p;
303
304 fBorderWidth = 2;
305 fCurrent = 0;
306 fRemoved = new TList;
307
308 fNormGC = norm;
309 fFontStruct = font;
310
311 int max_ascent, max_descent;
312 gVirtualX->GetFontProperties(fFontStruct, max_ascent, max_descent);
313 fTabh = max_ascent + max_descent + 6;
314
315 SetLayoutManager(new TGTabLayout(this));
316
317 // we need this in order to avoid border blinking when switching tabs...
321
324}
325
326////////////////////////////////////////////////////////////////////////////////
327/// Delete tab widget. This deletes the tab windows and the containers.
328/// The tab string is deleted by the TGTabElement dtor.
329
331{
332 Cleanup();
333 fRemoved->Delete();
334 delete fRemoved;
335}
336
337////////////////////////////////////////////////////////////////////////////////
338/// Add a tab to the tab widget. Returns the new container, which
339/// is owned by the tab widget. The text is adopted by the tab widget.
340
342{
343 TGTabElement *te = new TGTabElement(this, text, 50, 20, fNormGC, fFontStruct);
344 AddFrame(te, 0);
345
346 TGCompositeFrame* cf = new TGCompositeFrame(this, fWidth, fHeight-21);
347 AddFrame(cf, 0);
349
350 te->MapWindow();
351 cf->MapWindow();
352
353 return cf;
354}
355
356////////////////////////////////////////////////////////////////////////////////
357/// Add a tab to the tab widget. Returns the new container. The container
358/// is owned by the tab widget.
359
361{
362 return AddTab(new TGString(text));
363}
364
365////////////////////////////////////////////////////////////////////////////////
366/// Add a tab to the tab widget and fill it with given TGCompositeFrame.
367
368void TGTab::AddTab(const char *text, TGCompositeFrame *cf)
369{
370 AddTab(new TGString(text), cf);
371}
372
373////////////////////////////////////////////////////////////////////////////////
374/// Add a tab to the tab widget and fill it with given TGCompositeFrame.
375
377{
378 TGTabElement *te = new TGTabElement(this, text, 50, 20, fNormGC, fFontStruct);
379 AddFrame(te, 0);
380
381 AddFrame(cf, 0);
383
384 te->MapWindow();
385 cf->MapWindow();
386}
387
388////////////////////////////////////////////////////////////////////////////////
389/// Remove container and tab of tab with index tabIndex.
390/// Does NOT remove the container contents!
391
392void TGTab::RemoveTab(Int_t tabIndex, Bool_t storeRemoved)
393{
394 if (tabIndex < 0) {
395 tabIndex = fCurrent;
396 }
397
398 TGFrameElement *elTab, *elCont;
399 Int_t count = 0;
400
401 // Notify (signal) for removed tab "tabIndex"
402 Removed(tabIndex);
403
404 TIter next(fList) ;
405 next() ; // skip first container
406
407 while ((elTab = (TGFrameElement *) next())) {
408 elCont = (TGFrameElement *) next();
409
410 if (count == tabIndex) {
411 elCont->fFrame->UnmapWindow(); // will be destroyed later
412 TGFrame *frame = elTab->fFrame;
413 RemoveFrame(elTab->fFrame);
414 frame->DestroyWindow();
415 delete frame;
416 if (storeRemoved)
417 fRemoved->Add(elCont->fFrame); // delete only in dtor
418 RemoveFrame(elCont->fFrame);
419 if (tabIndex == fCurrent) {
420 // select another tab only if the current is the one we delete
421 SetTab(0);
422 } else
423 fCurrent--;
424 break;
425 }
426 count++;
427 }
428
430}
431
432////////////////////////////////////////////////////////////////////////////////
433/// Enable or disable tab.
434
436{
437 TGTabElement *te = GetTabTab(tabIndex);
438 if (te) {
439 te->SetEnabled(on);
440 fClient->NeedRedraw(te);
441 }
442}
443
444////////////////////////////////////////////////////////////////////////////////
445/// Returns true if tab is enabled.
446
448{
449 TGTabElement *te = GetTabTab(tabIndex);
450
451 return te ? te->IsEnabled() : kFALSE;
452}
453
454////////////////////////////////////////////////////////////////////////////////
455/// Make tabIdx the current tab. Utility method called by SetTab and
456/// HandleButton().
457
458void TGTab::ChangeTab(Int_t tabIndex, Bool_t emit)
459{
460 TGTabElement *te = GetTabTab(tabIndex);
461 if (!te || !te->IsEnabled()) return;
462
463 if (tabIndex != fCurrent) {
464 if (GetTabTab(fCurrent)) {
467 }
468 TGFrameElement *el, *elnxt;
469 UInt_t tw;
470 Int_t xtab = 2;
471 Int_t count = 0;
472
473 TIter next(fList);
474 next(); // skip first container
475
476 fCurrent = tabIndex;
477 while ((el = (TGFrameElement *) next())) {
478 elnxt = (TGFrameElement *) next();
479 tw = el->fFrame->GetDefaultWidth();
480 if (count == fCurrent) {
481 el->fFrame->MoveResize(xtab-2, 0, tw+3, fTabh+1);
482 if (elnxt) elnxt->fFrame->RaiseWindow();
483 el->fFrame->RaiseWindow();
484 } else {
485 el->fFrame->MoveResize(xtab, 2, tw, fTabh-1);
486 el->fFrame->LowerWindow();
487 }
488 xtab += tw;
489 count++;
490 }
491 if (emit) {
495 }
498 }
499}
500
501////////////////////////////////////////////////////////////////////////////////
502/// Brings the composite frame with the index tabIndex to the
503/// front and generate the following event if the front tab has changed:
504/// kC_COMMAND, kCM_TAB, tab id, 0.
505/// Returns kFALSE if tabIndex is a not valid index
506
508{
509 // check if tabIndex is a valid index
510 if (tabIndex < 0)
511 return kFALSE;
512
513 // count the tabs
514 TIter next(fList);
515 Int_t count = 0;
516 while (next())
517 count++;
518
519 count = count / 2 - 1;
520 if (tabIndex > count)
521 return kFALSE;
522
523 // change tab and generate event
524 ChangeTab(tabIndex, emit);
525
526 return kTRUE;
527}
528
529////////////////////////////////////////////////////////////////////////////////
530/// Brings the composite frame with the name to the
531/// front and generate the following event if the front tab has changed:
532/// kC_COMMAND, kCM_TAB, tab id, 0.
533/// Returns kFALSE if tab with name does not exist.
534
535Bool_t TGTab::SetTab(const char *name, Bool_t emit)
536{
537 TGFrameElement *el;
538 Int_t count = 0;
539 TGTabElement *tab = 0;
540
541 TIter next(fList);
542 next(); // skip first container
543
544 while ((el = (TGFrameElement *) next())) {
545 next(); // skip tab containter
546 tab = (TGTabElement *)el->fFrame;
547
548 if (*(tab->GetText()) == name) {
549 // change tab and generate event
550 ChangeTab(count, emit);
551 return kTRUE;
552 }
553 count++;
554 }
555
556 return kFALSE;
557}
558
559////////////////////////////////////////////////////////////////////////////////
560/// Return container of tab with index tabIndex.
561/// Return 0 in case tabIndex is out of range.
562
564{
565 if (tabIndex < 0) return 0;
566
567 TGFrameElement *el;
568 Int_t count = 0;
569
570 TIter next(fList);
571 next(); // skip first container
572
573 while (next()) {
574 el = (TGFrameElement *) next();
575 if (el && count == tabIndex)
576 return (TGCompositeFrame *) el->fFrame;
577 count++;
578 }
579
580 return 0;
581}
582
583////////////////////////////////////////////////////////////////////////////////
584/// Return the tab container of tab with string name.
585/// Returns 0 in case name is not found.
586
588{
589 TGFrameElement *el;
590 TGTabElement *tab = 0;
591 TGCompositeFrame *comp = 0;
592
593 TIter next(fList);
594 next();
595
596 while ((el = (TGFrameElement *) next())) {
597 tab = (TGTabElement *) el->fFrame;
598 el = (TGFrameElement *) next();
599 comp = (TGCompositeFrame *) el->fFrame;
600 if (*tab->GetText() == name){
601 return comp;
602 }
603 }
604
605 return 0;
606}
607
608////////////////////////////////////////////////////////////////////////////////
609/// Return the tab element of tab with index tabIndex.
610/// Returns 0 in case tabIndex is out of range.
611
613{
614 if (tabIndex < 0) return 0;
615
616 TGFrameElement *el;
617 Int_t count = 0;
618
619 TIter next(fList);
620 next(); // skip first container
621
622 while ((el = (TGFrameElement *) next())) {
623 next();
624 if (count == tabIndex)
625 return (TGTabElement *) el->fFrame;
626 count++;
627 }
628
629 return 0;
630}
631
632////////////////////////////////////////////////////////////////////////////////
633/// Return the tab element of tab with string name.
634/// Returns 0 in case name is not found.
635
637{
638 TGFrameElement *el;
639 TGTabElement *tab = 0;
640
641 TIter next(fList);
642 next();
643
644 while ((el = (TGFrameElement *) next())) {
645 tab = (TGTabElement *)el->fFrame;
646 if (name == *(tab->GetText())) {
647 return tab;
648 }
649 next();
650 }
651
652 return 0;
653}
654
655////////////////////////////////////////////////////////////////////////////////
656/// Return number of tabs.
657
659{
660 Int_t count = 0;
661
662 TIter next(fList);
663 next(); // skip first container
664
665 while (next()) {
666 next();
667 count++;
668 }
669
670 return count;
671}
672
673////////////////////////////////////////////////////////////////////////////////
674/// Return default font structure in use.
675
677{
678 if (!fgDefaultFont)
679 fgDefaultFont = gClient->GetResourcePool()->GetDefaultFont();
681}
682
683////////////////////////////////////////////////////////////////////////////////
684/// Return default graphics context in use.
685
687{
688 if (!fgDefaultGC)
689 fgDefaultGC = gClient->GetResourcePool()->GetFrameGC();
690 return *fgDefaultGC;
691}
692
693////////////////////////////////////////////////////////////////////////////////
694/// Create new tab. Used in context menu.
695
696void TGTab::NewTab(const char *text)
697{
699 if (text)
700 name = text;
701 else
702 name = TString::Format("tab%d", GetNumberOfTabs()+1);
703 AddTab(name.Data());
704
706}
707
708////////////////////////////////////////////////////////////////////////////////
709/// Set text to current tab.
710
711void TGTab::SetText(const char *text)
712{
715}
716
717////////////////////////////////////////////////////////////////////////////////
718/// Return layout manager.
719
721{
722 TGTab *tab = (TGTab*)this;
723
724 if (tab->fLayoutManager->IsA() != TGTabLayout::Class()) {
725 tab->SetLayoutManager(new TGTabLayout(tab));
726 }
727
728 return tab->fLayoutManager;
729}
730
731////////////////////////////////////////////////////////////////////////////////
732/// Save a tab widget as a C++ statement(s) on output stream out.
733
734void TGTab::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
735{
736 char quote = '"';
737
738 // font + GC
739 option = GetName()+5; // unique digit id of the name
740 TString parGC, parFont;
741 parFont.Form("%s::GetDefaultFontStruct()",IsA()->GetName());
742 parGC.Form("%s::GetDefaultGC()()",IsA()->GetName());
743
744 if ((GetDefaultFontStruct() != fFontStruct) || (GetDefaultGC()() != fNormGC)) {
745 TGFont *ufont = gClient->GetResourcePool()->GetFontPool()->FindFont(fFontStruct);
746 if (ufont) {
747 ufont->SavePrimitive(out, option);
748 parFont.Form("ufont->GetFontStruct()");
749 }
750
751 TGGC *userGC = gClient->GetResourcePool()->GetGCPool()->FindGC(fNormGC);
752 if (userGC) {
753 userGC->SavePrimitive(out, option);
754 parGC.Form("uGC->GetGC()");
755 }
756 }
757
759
760 out << std::endl << " // tab widget" << std::endl;
761
762 out << " TGTab *";
763 out << GetName() << " = new TGTab(" << fParent->GetName()
764 << "," << GetWidth() << "," << GetHeight();
765
767 if (GetOptions() == kChildFrame) {
769 if (fNormGC == GetDefaultGC()()) {
770 out <<");" << std::endl;
771 } else {
772 out << "," << parGC.Data() <<");" << std::endl;
773 }
774 } else {
775 out << "," << parGC.Data() << "," << parFont.Data() <<");" << std::endl;
776 }
777 } else {
778 out << "," << parGC.Data() << "," << parFont.Data() << "," << GetOptionString() <<");" << std::endl;
779 }
780 } else {
781 out << "," << parGC.Data() << "," << parFont.Data() << "," << GetOptionString() << ",ucolor);" << std::endl;
782 }
783 if (option && strstr(option, "keep_names"))
784 out << " " << GetName() << "->SetName(\"" << GetName() << "\");" << std::endl;
785
787 TGLayoutManager * lm;
788 for (Int_t i=0; i<GetNumberOfTabs(); i++) {
789 cf = GetTabContainer(i);
790 if (!cf || !GetTabTab(i)) continue;
791 out << std::endl << " // container of " << quote
792 << GetTabTab(i)->GetString() << quote << std::endl;
793 out << " TGCompositeFrame *" << cf->GetName() << ";" << std::endl;
794 out << " " << cf->GetName() << " = " << GetName()
795 << "->AddTab(" << quote << GetTabTab(i)->GetString()
796 << quote << ");" << std::endl;
797 lm = cf->GetLayoutManager();
798 if (lm) {
799 if ((cf->GetOptions() & kHorizontalFrame) &&
801 ;
802 } else if ((GetOptions() & kVerticalFrame) &&
804 ;
805 } else {
806 out << " " << cf->GetName() <<"->SetLayoutManager(";
807 lm->SavePrimitive(out, option);
808 out << ");" << std::endl;
809 }
810 if (!IsEnabled(i)) {
811 out << " " << GetName() << "->SetEnabled(" << i << ", kFALSE);" << std::endl;
812 }
813 }
814 cf->SavePrimitiveSubframes(out, option);
815
816 if (GetTabTab(i)->IsCloseShown()) {
817 out << " TGTabElement *tab" << i << " = "
818 << GetName() << "->GetTabTab(" << i << ");" << std::endl;
819 out << " tab" << i << "->ShowClose(kTRUE);" << std::endl;
820 }
822 GetTabTab(i)->SaveUserColor(out, option);
823 out << " TGTabElement *tab" << i << " = "
824 << GetName() << "->GetTabTab(" << i << ");" << std::endl;
825 out << " tab" << i << "->ChangeBackground(ucolor);" << std::endl;
826 }
827
828 }
829 out << std::endl << " " << GetName() << "->SetTab(" << GetCurrent() << ");" << std::endl;
830 out << std::endl << " " << GetName() << "->Resize(" << GetName()
831 << "->GetDefaultSize());" << std::endl;
832}
833
834// __________________________________________________________________________
835void TGTabLayout::SavePrimitive(std::ostream &out, Option_t * /*= ""*/)
836{
837 // Save tab layout manager as a C++ statement(s) on out stream.
838
839 out << "new TGTabLayout(" << fMain->GetName() << ")";
840
841}
void Class()
Definition: Class.C:29
@ kButtonPress
Definition: GuiTypes.h:59
const Mask_t kButtonPressMask
Definition: GuiTypes.h:160
const Mask_t kAnyModifier
Definition: GuiTypes.h:209
const Handle_t kNone
Definition: GuiTypes.h:87
Handle_t GContext_t
Definition: GuiTypes.h:37
Handle_t FontStruct_t
Definition: GuiTypes.h:38
@ kButton1
Definition: GuiTypes.h:213
Handle_t Window_t
Definition: GuiTypes.h:28
#define c(i)
Definition: RSha256.hxx:101
#define h(i)
Definition: RSha256.hxx:106
int Int_t
Definition: RtypesCore.h:41
unsigned int UInt_t
Definition: RtypesCore.h:42
const Bool_t kFALSE
Definition: RtypesCore.h:88
unsigned long ULong_t
Definition: RtypesCore.h:51
bool Bool_t
Definition: RtypesCore.h:59
const Bool_t kTRUE
Definition: RtypesCore.h:87
const char Option_t
Definition: RtypesCore.h:62
#define ClassImp(name)
Definition: Rtypes.h:365
#define gClient
Definition: TGClient.h:166
@ kChildFrame
Definition: TGFrame.h:57
@ kRaisedFrame
Definition: TGFrame.h:62
@ kVerticalFrame
Definition: TGFrame.h:59
@ kDoubleBorder
Definition: TGFrame.h:63
@ kHorizontalFrame
Definition: TGFrame.h:60
char name[80]
Definition: TGX11.cxx:109
#define gVirtualX
Definition: TVirtualX.h:345
Int_t MK_MSG(EWidgetMessageTypes msg, EWidgetMessageTypes submsg)
@ kCM_TAB
@ kC_COMMAND
void ProcessLine(TString cmd, Long_t msg, Long_t parm1, Long_t parm2)
Execute string "cmd" via the interpreter.
Definition: TGClient.cxx:913
const TGPicture * GetPicture(const char *name)
Get picture from the picture pool.
Definition: TGClient.cxx:289
void NeedRedraw(TGWindow *w, Bool_t force=kFALSE)
Set redraw flags.
Definition: TGClient.cxx:372
TGLayoutManager * fLayoutManager
Definition: TGFrame.h:350
virtual void SetLayoutManager(TGLayoutManager *l)
Set the layout manager for the composite frame.
Definition: TGFrame.cxx:982
virtual TList * GetList() const
Definition: TGFrame.h:369
TGCompositeFrame(const TGCompositeFrame &)
virtual void AddFrame(TGFrame *f, TGLayoutHints *l=0)
Add frame to the composite frame using the specified layout hints.
Definition: TGFrame.cxx:1099
virtual TGLayoutManager * GetLayoutManager() const
Definition: TGFrame.h:397
virtual void Cleanup()
Cleanup and delete all objects contained in this composite frame.
Definition: TGFrame.cxx:949
virtual void SavePrimitiveSubframes(std::ostream &out, Option_t *option="")
Auxilary protected method used to save subframes.
Definition: TGFrame.cxx:2621
TList * fList
Definition: TGFrame.h:351
virtual void SetEditDisabled(UInt_t on=1)
Set edit disable flag for this frame and subframes.
Definition: TGFrame.cxx:1004
virtual void RemoveFrame(TGFrame *f)
Remove frame from composite frame.
Definition: TGFrame.cxx:1131
UInt_t fHeight
Definition: TGDimension.h:30
UInt_t fWidth
Definition: TGDimension.h:29
Definition: TGFont.h:149
FontStruct_t GetFontStruct() const
Definition: TGFont.h:193
virtual void SavePrimitive(std::ostream &out, Option_t *="")
Save the used font as a C++ statement(s) on output stream out.
Definition: TGFont.cxx:1869
TGFrame * fFrame
Definition: TGLayout.h:119
virtual TGDimension GetDefaultSize() const
std::cout << fWidth << "x" << fHeight << std::endl;
Definition: TGFrame.cxx:566
static const TGGC & GetBlackGC()
Get black graphics context.
Definition: TGFrame.cxx:717
Int_t GetBorderWidth() const
Definition: TGFrame.h:280
UInt_t fHeight
Definition: TGFrame.h:135
virtual UInt_t GetDefaultWidth() const
Definition: TGFrame.h:237
Int_t fBorderWidth
Definition: TGFrame.h:140
static const TGGC & GetHilightGC()
Get highlight color graphics context.
Definition: TGFrame.cxx:737
virtual void SendMessage(const TGWindow *w, Long_t msg, Long_t parm1, Long_t parm2)
Send message (i.e.
Definition: TGFrame.cxx:627
static Pixel_t GetDefaultFrameBackground()
Get default frame background.
Definition: TGFrame.cxx:665
virtual UInt_t GetOptions() const
Definition: TGFrame.h:244
TString GetOptionString() const
Returns a frame option string - used in SavePrimitive().
Definition: TGFrame.cxx:2460
static const TGGC & GetShadowGC()
Get shadow color graphics context.
Definition: TGFrame.cxx:747
virtual void Resize(UInt_t w=0, UInt_t h=0)
Resize the frame.
Definition: TGFrame.cxx:587
UInt_t fWidth
Definition: TGFrame.h:134
UInt_t GetHeight() const
Definition: TGFrame.h:272
virtual void Layout()
Definition: TGFrame.h:246
virtual Pixel_t GetBackground() const
Definition: TGFrame.h:239
virtual void MoveResize(Int_t x, Int_t y, UInt_t w=0, UInt_t h=0)
Move and/or resize the frame.
Definition: TGFrame.cxx:611
virtual void MapWindow()
Definition: TGFrame.h:251
UInt_t GetWidth() const
Definition: TGFrame.h:271
void SaveUserColor(std::ostream &out, Option_t *)
Save a user color in a C++ macro file - used in SavePrimitive().
Definition: TGFrame.cxx:2433
Pixel_t fBackground
Definition: TGFrame.h:142
virtual void UnmapWindow()
Definition: TGFrame.h:253
Definition: TGGC.h:31
void SavePrimitive(std::ostream &out, Option_t *option="")
Save graphics context info as a C++ statement(s) on output stream out.
Definition: TGGC.cxx:625
virtual void Layout()=0
TGClient * fClient
Definition: TGObject.h:37
Handle_t GetId() const
Definition: TGObject.h:47
Handle_t fId
Definition: TGObject.h:36
void Draw(Option_t *="")
Default Draw method for all objects.
Definition: TGPicture.h:57
Int_t GetLength() const
Definition: TGString.h:39
const char * GetString() const
Definition: TGString.h:40
virtual void Draw(Drawable_t id, GContext_t gc, Int_t x, Int_t y)
Draw string.
Definition: TGString.cxx:51
virtual TGDimension GetDefaultSize() const
Return default size of tab element.
Definition: TGTab.cxx:169
virtual ~TGTabElement()
Delete tab element.
Definition: TGTab.cxx:88
Bool_t fActive
Definition: TGTab.h:142
Bool_t fShowClose
Definition: TGTab.h:141
TGString * fText
Definition: TGTab.h:133
void SetText(TGString *text)
Set new tab text.
Definition: TGTab.cxx:180
GContext_t fNormGC
Definition: TGTab.h:136
virtual void DrawBorder()
Draw little tab element.
Definition: TGTab.cxx:98
virtual void SetEnabled(Bool_t on=kTRUE)
Definition: TGTab.h:162
Bool_t fEnabled
Definition: TGTab.h:140
const char * GetString() const
Definition: TGTab.h:159
UInt_t fTHeight
Definition: TGTab.h:139
FontStruct_t fFontStruct
Definition: TGTab.h:137
const TGPicture * fClosePic
Definition: TGTab.h:134
UInt_t fTWidth
Definition: TGTab.h:138
const TGString * GetText() const
Definition: TGTab.h:158
TGTabElement(const TGTabElement &)
virtual void SetActive(Bool_t on=kTRUE)
Definition: TGTab.h:167
const TGPicture * fClosePicD
Definition: TGTab.h:135
virtual void ShowClose(Bool_t on=kTRUE)
Show/hide close icon on the tab element, then apply layout to compute correct elements size.
Definition: TGTab.cxx:197
Bool_t IsEnabled() const
Definition: TGTab.h:163
virtual Bool_t HandleButton(Event_t *event)
Handle button event in the tab widget.
Definition: TGTab.cxx:132
TList * fList
Definition: TGTab.h:44
TGTab * fMain
Definition: TGTab.h:43
virtual void Layout()
Layout the tab widget.
Definition: TGTab.cxx:221
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save a primitive as a C++ statement(s) on output stream "out".
Definition: TGTab.cxx:835
TGTabLayout(const TGTabLayout &)
virtual TGDimension GetDefaultSize() const
Get default size of tab widget.
Definition: TGTab.cxx:265
Definition: TGTab.h:62
static FontStruct_t GetDefaultFontStruct()
Return default font structure in use.
Definition: TGTab.cxx:676
virtual TGLayoutManager * GetLayoutManager() const
Return layout manager.
Definition: TGTab.cxx:720
TGTab(const TGTab &)
virtual void NewTab(const char *text="tab")
Create new tab. Used in context menu.
Definition: TGTab.cxx:696
TGCompositeFrame * GetContainer() const
Definition: TGTab.h:104
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save a tab widget as a C++ statement(s) on output stream out.
Definition: TGTab.cxx:734
TGCompositeFrame * fContainer
Definition: TGTab.h:67
virtual void SetEnabled(Int_t tabIndex, Bool_t on=kTRUE)
Enable or disable tab.
Definition: TGTab.cxx:435
virtual void SetText(const char *text="tab")
Set text to current tab.
Definition: TGTab.cxx:711
FontStruct_t fFontStruct
Definition: TGTab.h:69
static const TGGC & GetDefaultGC()
Return default graphics context in use.
Definition: TGTab.cxx:686
virtual void Removed(Int_t id)
Definition: TGTab.h:121
TGTabElement * GetTabTab(Int_t tabIndex) const
Return the tab element of tab with index tabIndex.
Definition: TGTab.cxx:612
Int_t fCurrent
Definition: TGTab.h:65
GContext_t fNormGC
Definition: TGTab.h:70
Int_t GetNumberOfTabs() const
Return number of tabs.
Definition: TGTab.cxx:658
static const TGGC * fgDefaultGC
Definition: TGTab.h:75
virtual Bool_t SetTab(Int_t tabIndex, Bool_t emit=kTRUE)
Brings the composite frame with the index tabIndex to the front and generate the following event if t...
Definition: TGTab.cxx:507
Int_t GetCurrent() const
Definition: TGTab.h:105
UInt_t fTabh
Definition: TGTab.h:66
TList * fRemoved
Definition: TGTab.h:68
virtual void RemoveTab(Int_t tabIndex=-1, Bool_t storeRemoved=kTRUE)
Remove container and tab of tab with index tabIndex.
Definition: TGTab.cxx:392
virtual void Selected(Int_t id)
Definition: TGTab.h:122
void ChangeTab(Int_t tabIndex, Bool_t emit=kTRUE)
Make tabIdx the current tab.
Definition: TGTab.cxx:458
UInt_t GetTabHeight() const
Definition: TGTab.h:112
virtual ~TGTab()
Delete tab widget.
Definition: TGTab.cxx:330
TGCompositeFrame * GetTabContainer(Int_t tabIndex) const
Return container of tab with index tabIndex.
Definition: TGTab.cxx:563
virtual TGCompositeFrame * AddTab(TGString *text)
Add a tab to the tab widget.
Definition: TGTab.cxx:341
TGTabElement * GetCurrentTab() const
Definition: TGTab.h:111
static const TGFont * fgDefaultFont
Definition: TGTab.h:74
TString fCommand
Definition: TGWidget.h:61
const TGWindow * fMsgWindow
Definition: TGWidget.h:60
Bool_t IsEnabled() const
Definition: TGWidget.h:81
virtual const char * GetName() const
Return unique name, used in SavePrimitive methods.
Definition: TGWindow.cxx:221
virtual void LowerWindow()
Definition: TGWindow.h:95
const TGWindow * fParent
Definition: TGWindow.h:37
@ kEditDisableResize
Definition: TGWindow.h:63
@ kEditDisableLayout
Definition: TGWindow.h:62
@ kEditDisableBtnEnable
Definition: TGWindow.h:66
@ kEditDisableGrab
Definition: TGWindow.h:61
@ kEditDisable
Definition: TGWindow.h:59
virtual void DestroyWindow()
Definition: TGWindow.h:92
virtual void RaiseWindow()
Definition: TGWindow.h:94
UInt_t fEditDisabled
Definition: TGWindow.h:41
A doubly linked list.
Definition: TList.h:44
virtual void Add(TObject *obj)
Definition: TList.h:87
virtual void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition: TList.cxx:467
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save a primitive as a C++ statement(s) on output stream "out".
Definition: TObject.cxx:664
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:443
Basic string class.
Definition: TString.h:131
const char * Data() const
Definition: TString.h:364
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Definition: TString.cxx:2311
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition: TString.cxx:2289
TText * text
int main(int argc, char **argv)
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:212
EGEventType fType
Definition: GuiTypes.h:174
Int_t fY
Definition: GuiTypes.h:177
Window_t fWindow
Definition: GuiTypes.h:175
Int_t fX
Definition: GuiTypes.h:177