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