Logo ROOT   6.12/07
Reference Guide
TGTableLayout.cxx
Go to the documentation of this file.
1 // @(#)root/gui:$Id$
2 // Author: Brett Viren 04/15/2001
3 
4 /*************************************************************************
5  * Copyright (C) 2001, Brett Viren *
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  The Layout algorithm was largely translated from GTK's gtktable.c
25  source. That source is also distributed under LGPL.
26 
27 **************************************************************************/
28 
29 //////////////////////////////////////////////////////////////////////////
30 // //
31 // TGTableLayout //
32 // //
33 // A layout manager, which places child frames in a table arranged in //
34 // rows and columns, making it easy to align many widgets next each to //
35 // other horizontally and vertivally. It uses TGTableLayoutHints //
36 // (not TGLayoutHints!!!) and works like TGMatrixLayout with the //
37 // addition that: //
38 // - Child frames can span more than one column/row. //
39 // - Child frames can resize with the frame. //
40 // - Column and row sizes are not fixed nor (optionally) homogeneous. //
41 // - The number of columns and rows must be fully specified in the //
42 // constructor. //
43 // The gaps between all rows or columns can be specified by 'sep' //
44 // parameter in the constructor. All rows and columns will have the //
45 // same size (set by widest and the highest child frame) if the //
46 // parameter 'homogeneous' is set to kTRUE. //
47 // //
48 // //
49 // TGTableLayoutHints //
50 // //
51 // This class describes layout hints used by the TGTableLayout class. //
52 // It specifies the column/row division number on which to attach the //
53 // child frame. This number starts from 0 and goes to #_columns/#_rows //
54 // respectively (0 indicates the first row/column). //
55 // //
56 // Below are described all parameters of TGTableLayoutHints constructor //
57 // attach_left - the column to the left of the widget; //
58 // attach_right - the column to the right of the widget; //
59 // attach_top - the row above the widget; //
60 // attach_bottom - the row below the widget; //
61 // //
62 // hints - layout hints (combination of ELayoutHints) //
63 // //
64 // The next parameters determine the extra padding added around the //
65 // child frame. By default these are 0. //
66 // padleft - determines the extra padding added on the left //
67 // padright - determines the extra padding added on the right //
68 // padtop - determines the extra padding added on the top //
69 // padbottom - determines the extra padding added on the bottom //
70 // //
71 //////////////////////////////////////////////////////////////////////////
72 
73 
74 #include "TGTableLayout.h"
75 #include "TGFrame.h"
76 #include "TList.h"
77 #include "Rtypes.h"
78 #include "Riostream.h"
79 
80 
83 
84 ////////////////////////////////////////////////////////////////////////////////
85 /// TGTableLayout constructor.
86 /// Note:
87 /// - Number of rows first, number of Columns second
88 /// - homogeneous == true means all table cells are the same size,
89 /// set by the widest and the highest child frame.
90 /// - s gives the amount of separation in pixels between cells
91 /// - h are the hints, see TGTableLayoutHints.
92 
94  Bool_t homogeneous, Int_t sep, Int_t hints)
95 {
96  fMain = main;
97  fList = fMain->GetList();
98  fSep = sep;
99  fHints = hints;
100  fNrows = nrows;
101  fNcols = ncols;
102  fRow = 0;
103  fCol = 0;
104  fHomogeneous = homogeneous;
105 }
106 
107 ////////////////////////////////////////////////////////////////////////////////
108 /// TGTableLayout constructor.
109 
111 {
112  if (fRow) delete [] fRow;
113  if (fCol) delete [] fCol;
114 }
115 
116 ////////////////////////////////////////////////////////////////////////////////
117 /// Find the sizes of rows and columns needed to statisfy
118 /// children's layout policies.
119 
121 {
122  // This is equiv to GTK's requisition stage
123 
129 }
130 
131 ////////////////////////////////////////////////////////////////////////////////
132 /// Initialize values needed to determine the size of rows and columns.
133 
135 {
136  if (fRow) delete [] fRow;
137  if (fCol) delete [] fCol;
138  fRow = new TableData_t[fNrows];
139  fCol = new TableData_t[fNcols];
140 
141  // Find max of each row and column
142 
143  UInt_t i;
144  for (i = 0; i < fNrows; ++i) fRow[i].fDefSize = 0;
145  for (i = 0; i < fNcols; ++i) fCol[i].fDefSize = 0;
146 }
147 
148 ////////////////////////////////////////////////////////////////////////////////
149 /// Determine the size of rows/cols needed for singly attached children.
150 
152 {
153  TIter next(fList);
154  TGFrameElement *ptr;
155 
156  while ((ptr = (TGFrameElement *) next())) {
157  if (ptr->fState == 0) continue;
158  TGTableLayoutHints *layout =
159  dynamic_cast<TGTableLayoutHints*>(ptr->fLayout);
160  if (!layout) {
161  Error("FindRowColSizesSinglyAttached", "didn't get TGTableLayoutHints from %s, layout = 0x%lx",
162  ptr->fFrame->GetName(), (ULong_t)ptr->fLayout);
163  return;
164  }
165  UInt_t col = layout->GetAttachLeft();
166  if (col == (layout->GetAttachRight() - 1))
167  fCol[col].fDefSize = TMath::Max(fCol[col].fDefSize,
168  ptr->fFrame->GetDefaultWidth() +
169  layout->GetPadLeft() +
170  layout->GetPadRight());
171 
172  UInt_t row = layout->GetAttachTop();
173  if (row == (layout->GetAttachBottom() - 1))
174  fRow[row].fDefSize = TMath::Max(fRow[row].fDefSize,
175  ptr->fFrame->GetDefaultHeight() +
176  layout->GetPadTop() +
177  layout->GetPadBottom());
178  }
179 }
180 
181 ////////////////////////////////////////////////////////////////////////////////
182 /// If the table is homogeneous make sure all col/rows are same
183 /// size as biggest col/row.
184 
186 {
187  if (!fHomogeneous) return;
188 
189  UInt_t max_width = 0, max_height = 0, col, row;
190 
191  // find max
192  for (col = 0; col < fNcols; ++col)
193  max_width = TMath::Max(max_width,fCol[col].fDefSize);
194 
195  for (row = 0; row < fNrows; ++row)
196  max_height = TMath::Max(max_height,fRow[row].fDefSize);
197 
198  // set max
199  for (col = 0; col < fNcols; ++col) fCol[col].fDefSize = max_width;
200  for (row = 0; row < fNrows; ++row) fRow[row].fDefSize = max_height;
201 }
202 
203 ////////////////////////////////////////////////////////////////////////////////
204 /// Checks any children which span multiple col/rows.
205 
207 {
208  TIter next(fList);
209  TGFrameElement *ptr;
210 
211  while ((ptr = (TGFrameElement *) next())) {
212  if (ptr->fState == 0) continue;
213  TGTableLayoutHints *layout =
214  dynamic_cast<TGTableLayoutHints*>(ptr->fLayout);
215  if (!layout) {
216  Error("FindRowColSizesMultiplyAttached", "didn't get TGTableLayoutHints");
217  return;
218  }
219  UInt_t left = layout->GetAttachLeft();
220  UInt_t right = layout->GetAttachRight();
221  if (left != right-1) { // child spans multi-columns
222  UInt_t width = 0, col;
223  for (col = left; col < right; ++col) width += fCol[col].fDefSize;
224 
225  // If more space needed, divide space evenly among the columns
226  UInt_t child_width = ptr->fFrame->GetDefaultWidth() +
227  layout->GetPadLeft() + layout->GetPadRight();
228 
229  if (width < child_width) {
230  width = child_width - width;
231  for (col = left; col < right; ++col) {
232  UInt_t extra = width / (right - col);
233  fCol[col].fDefSize += extra;
234  width -= extra;
235  }
236  }
237  }
238  UInt_t top = layout->GetAttachTop();
239  UInt_t bottom = layout->GetAttachBottom();
240  if (top != bottom-1) { // child spans multi-rows
241  UInt_t height = 0, row;
242  for (row = top; row < bottom; ++row) height += fRow[row].fDefSize;
243 
244  // If more space needed, divide space evenly among the rows
245  UInt_t child_height = ptr->fFrame->GetDefaultHeight() +
246  layout->GetPadTop() + layout->GetPadBottom();
247 
248  if (height < child_height) {
249  height = child_height - height;
250  for (row = top; row < bottom; ++row) {
251  UInt_t extra = height / (bottom - row);
252  fRow[row].fDefSize += extra;
253  height -= extra;
254  }
255  }
256  }
257  }
258 }
259 
260 ////////////////////////////////////////////////////////////////////////////////
261 /// If main frame is bigger or smaller than all children,
262 /// expand/shrink to fill. This is symmetric under row<-->col
263 /// switching so it is abstracted out to a normal function to save typing.
264 
266  TableData_t *thing, Bool_t homogeneous)
267 {
268  if (homogeneous) {
269  UInt_t ind, nshrink=0, nexpand=0, cur_size=0;
270 
271  for (ind = 0; ind < nthings; ++ind)
272  cur_size += thing[ind].fDefSize;
273 
274  if (cur_size < real_size) {
275  for (ind = 0; ind < nthings; ++ind)
276  if (thing[ind].fExpand) { ++ nexpand; break; }
277  if (nexpand > 0) {
278  UInt_t size = real_size;
279  for (ind = 0; ind < nthings; ++ ind) {
280  UInt_t extra = size / (nthings - ind);
281  thing[ind].fRealSize = TMath::Max(1U, extra);
282  size -= extra;
283  }
284  }
285  }
286  if (cur_size > real_size) {
287  for (ind = 0; ind < nthings; ++ind)
288  if (thing[ind].fShrink) { ++ nshrink; break; }
289  if (nshrink > 0) {
290  UInt_t size = real_size;
291  for (ind = 0; ind < nthings; ++ ind) {
292  UInt_t extra = size / (nthings - ind);
293  thing[ind].fRealSize = TMath::Max(1U, extra);
294  size -= extra;
295  }
296  }
297  }
298  } else {
299  UInt_t ind, nshrink=0, nexpand=0, size=0;
300  for (ind = 0; ind < nthings; ++ind) {
301  size += thing[ind].fDefSize;
302  if (thing[ind].fExpand) ++ nexpand;
303  if (thing[ind].fShrink) ++ nshrink;
304  }
305 
306  // Did main frame expand?
307  if ((size < real_size) && (nexpand >= 1)) {
308  size = real_size - size;
309  for (ind = 0; ind < nthings; ++ind) {
310  if (thing[ind].fExpand) {
311  UInt_t extra = size / nexpand;
312  thing[ind].fRealSize += extra;
313  size -= extra;
314  --nexpand;
315  }
316  }
317  }
318 
319  // Did main frame shrink?
320  if (size > real_size) {
321  UInt_t total_nshrink = nshrink;
322  UInt_t extra = size - real_size;
323  while (total_nshrink > 0 && extra > 0) {
324  nshrink = total_nshrink;
325  for (ind = 0; ind < nthings; ++ind)
326  if (thing[ind].fShrink) {
327  UInt_t size2 = thing[ind].fRealSize;
328  thing[ind].fRealSize = TMath::Max(1U,thing[ind].fRealSize - extra / nshrink);
329  extra -= size2 - thing[ind].fRealSize;
330  --nshrink;
331  if (thing[ind].fRealSize < 2) {
332  total_nshrink -= 1;
333  thing[ind].fShrink = kFALSE;
334  }
335  }
336  }
337  }
338  } // not homogeneous
339 }
340 
341 ////////////////////////////////////////////////////////////////////////////////
342 /// This gets the new sizes needed to fit the table to the parent
343 /// frame. To be called after FindRowColSizes.
344 
346 {
348  UInt_t border_width = fMain->GetBorderWidth();
349 
350  SetRowColResize(fMain->GetWidth() - (fNcols-1)*fSep - 2*border_width,
352  SetRowColResize(fMain->GetHeight() - (fNrows-1)*fSep - 2*border_width,
354 }
355 
356 ////////////////////////////////////////////////////////////////////////////////
357 /// Initialize rows/cols. By default they do not expand and they
358 /// do shrink. What the children want determine what the rows/cols do.
359 
361 {
362  UInt_t col;
363  for (col = 0; col < fNcols; ++col) {
364  fCol[col].fRealSize = fCol[col].fDefSize;
365  fCol[col].fNeedExpand = kFALSE;
366  fCol[col].fNeedShrink = kTRUE;
367  fCol[col].fExpand = kFALSE;
368  fCol[col].fShrink = kTRUE;
369  fCol[col].fEmpty = kTRUE;
370  }
371  UInt_t row;
372  for (row = 0; row < fNrows; ++row) {
373  fRow[row].fRealSize = fRow[row].fDefSize;
374  fRow[row].fNeedExpand = kFALSE;
375  fRow[row].fNeedShrink = kTRUE;
376  fRow[row].fExpand = kFALSE;
377  fRow[row].fShrink = kTRUE;
378  fRow[row].fEmpty = kTRUE;
379  }
380 
381  // Check single row/col children for expand/shrink-ability
382  TIter next(fList);
383  TGFrameElement *ptr;
384  while ((ptr = (TGFrameElement*) next())) {
385  TGTableLayoutHints *layout =
386  dynamic_cast<TGTableLayoutHints*>(ptr->fLayout);
387  if (!layout) {
388  Error("SetRowColSizesInit", "didn't get TGTableLayoutHints");
389  return;
390  }
391  ULong_t hints = layout->GetLayoutHints();
392 
393  // columns
394  if (layout->GetAttachLeft() == layout->GetAttachRight()-1) {
395  if (hints & kLHintsExpandX)
396  fCol[layout->GetAttachLeft()].fExpand = kTRUE;
397  if (!(hints & kLHintsShrinkX))
398  fCol[layout->GetAttachLeft()].fShrink = kFALSE;
399  fCol[layout->GetAttachLeft()].fEmpty = kFALSE;
400  }
401  // rows
402  if (layout->GetAttachTop() == layout->GetAttachBottom()-1) {
403  if (hints & kLHintsExpandY)
404  fRow[layout->GetAttachTop()].fExpand = kTRUE;
405  if (!(hints & kLHintsShrinkY))
406  fRow[layout->GetAttachTop()].fShrink = kFALSE;
407  fRow[layout->GetAttachTop()].fEmpty = kFALSE;
408  }
409  }
410 
411  // Do same for children of spanning multiple col/rows
412  next.Reset();
413  while ((ptr = (TGFrameElement*) next())) {
414  TGTableLayoutHints *layout =
415  dynamic_cast<TGTableLayoutHints*>(ptr->fLayout);
416  if (!layout) {
417  Error("SetRowColSizesInit", "didn't get TGTableLayoutHints");
418  return;
419  }
420  ULong_t hints = layout->GetLayoutHints();
421 
422  // columns
423  UInt_t left = layout->GetAttachLeft();
424  UInt_t right = layout->GetAttachRight();
425  if (left != right - 1) {
426  for (col = left; col < right; ++col) fCol[col].fEmpty = kFALSE;
427  Bool_t has_expand=kFALSE, has_shrink=kTRUE;
428  if (hints & kLHintsExpandX) {
429  for (col = left; col < right; ++col)
430  if (fCol[col].fExpand) { has_expand = kTRUE; break; }
431  if (!has_expand)
432  for (col = left; col < right; ++col)
433  fCol[col].fNeedExpand = kTRUE;
434  }
435  if (!(hints & kLHintsShrinkX)) {
436  for (col = left; col < right; ++col)
437  if (!fCol[col].fShrink) { has_shrink = kFALSE; break;}
438  if (has_shrink)
439  for (col = left; col < right; ++col)
440  fCol[col].fNeedShrink = kFALSE;
441  }
442  }
443 
444  // rows
445  UInt_t top = layout->GetAttachTop();
446  UInt_t bottom = layout->GetAttachBottom();
447  if (top != bottom - 1) {
448  for (row = top; row < bottom; ++row) fRow[row].fEmpty = kFALSE;
449  Bool_t has_expand=kFALSE, has_shrink=kTRUE;
450  if (hints & kLHintsExpandY) {
451  for (row = top; row < bottom; ++row)
452  if (fRow[row].fExpand) { has_expand = kTRUE; break; }
453  if (!has_expand)
454  for (row = top; row < bottom; ++row)
455  fRow[row].fNeedExpand = kTRUE;
456  }
457  if (!(hints & kLHintsShrinkY)) {
458  for (row = top; row < bottom; ++row)
459  if (!fRow[row].fShrink) { has_shrink = kFALSE; break;}
460  if (has_shrink)
461  for (row = top; row < bottom; ++row)
462  fRow[row].fNeedShrink = kFALSE;
463  }
464  }
465  }
466 
467  // Set expand/shrink flags
468  for (col = 0; col < fNcols; ++col) {
469  if (fCol[col].fEmpty) {
470  fCol[col].fExpand = kFALSE;
471  fCol[col].fShrink = kFALSE;
472  } else {
473  if (fCol[col].fNeedExpand) fCol[col].fExpand = kTRUE;
474  if (!fCol[col].fNeedShrink) fCol[col].fShrink = kFALSE;
475  }
476  }
477  for (row = 0; row < fNrows; ++row) {
478  if (fRow[row].fEmpty) {
479  fRow[row].fExpand = kFALSE;
480  fRow[row].fShrink = kFALSE;
481  } else {
482  if (fRow[row].fNeedExpand) fRow[row].fExpand = kTRUE;
483  if (!fRow[row].fNeedShrink) fRow[row].fShrink = kFALSE;
484  }
485  }
486 }
487 
488 ////////////////////////////////////////////////////////////////////////////////
489 /// Sanity check various values.
490 
492 {
493  TIter next(fList);
494  TGFrameElement *ptr;
495  UInt_t nerrors = 0;
496  while ((ptr = (TGFrameElement*) next())) {
497  TGTableLayoutHints *layout =
498  dynamic_cast<TGTableLayoutHints*>(ptr->fLayout);
499  if (!layout) {
500  Error("CheckSanity", "didn't get TGTableLayoutHints");
501  return;
502  }
503 
504  UInt_t right = layout->GetAttachRight();
505  UInt_t left = layout->GetAttachLeft();
506  UInt_t top = layout->GetAttachTop();
507  UInt_t bottom = layout->GetAttachBottom();
508 
509  if (left == right) {
510  ++nerrors;
511  Error("CheckSanity", "AttachLeft == AttachRight");
512  }
513  if (left > right) {
514  ++nerrors;
515  Error("CheckSanity", "AttachLeft > AttachRight");
516  }
517  if (left > fNcols-1) {
518  ++nerrors;
519  Error("CheckSanity", "AttachLeft illegal value: %u", left);
520  }
521  if (right < 1 || right > fNcols) {
522  ++nerrors;
523  Error("CheckSanity", "AttachRight illegal value: %u", right);
524  }
525 
526  if (top == bottom) {
527  ++nerrors;
528  Error("CheckSanity", "AttachTop == AttachBottom");
529  }
530  if (top > bottom) {
531  ++nerrors;
532  Error("CheckSanity", "AttachTop > AttachBottom");
533  }
534  if (top > fNrows-1) {
535  ++nerrors;
536  Error("CheckSanity", "AttachTop illegal value: %u", top);
537  }
538  if (bottom < 1 || bottom > fNrows) {
539  ++nerrors;
540  Error("CheckSanity", "AttachBottom illegal value: %u", bottom);
541  }
542 
543  }
544  if (nerrors) {
545  Error("CheckSanity", "errors in %u x %u table", fNcols, fNrows);
546  }
547 }
548 
549 ////////////////////////////////////////////////////////////////////////////////
550 /// Make a table layout of all frames in the list.
551 
553 {
554  CheckSanity();
555 
556  FindRowColSizes();
557 
558  SetRowColSizes();
559 
560  // Do the layout
561  TIter next(fList);
562  TGFrameElement *ptr;
563  UInt_t border_width = fMain->GetBorderWidth();
564  while ((ptr = (TGFrameElement*) next())) {
565  TGTableLayoutHints *layout =
566  dynamic_cast<TGTableLayoutHints*>(ptr->fLayout);
567  if (!layout) {
568  Error("TGTableLayout::Layout", "didn't get TGTableLayoutHints");
569  return;
570  }
571  ULong_t hints = layout->GetLayoutHints();
572  TGDimension size = ptr->fFrame->GetDefaultSize();
573 
574  UInt_t right = layout->GetAttachRight();
575  UInt_t left = layout->GetAttachLeft();
576  UInt_t top = layout->GetAttachTop();
577  UInt_t bottom = layout->GetAttachBottom();
578 
579  // Find location and size of cell in which to fit the child frame.
580  UInt_t col, cell_x = border_width + left*fSep;
581  for (col = 0; col < left; ++col) cell_x += fCol[col].fRealSize;
582 
583  UInt_t row, cell_y = border_width + top*fSep;
584  for (row = 0; row < top; ++row) cell_y += fRow[row].fRealSize;
585 
586  UInt_t cell_width = (right-left-1)*fSep;
587  for (col=left; col < right; ++col)
588  cell_width += fCol[col].fRealSize;
589 
590  UInt_t cell_height = (bottom-top-1)*fSep;
591  for (row=top; row < bottom; ++row)
592  cell_height += fRow[row].fRealSize;
593 
594  UInt_t pad_left = layout->GetPadLeft();
595  UInt_t pad_right = layout->GetPadRight();
596  UInt_t pad_bottom = layout->GetPadBottom();
597  UInt_t pad_top = layout->GetPadTop();
598 
599  // find size of child frame
600  UInt_t ww,hh;
601  if (hints & kLHintsFillX)
602  ww = cell_width - pad_left - pad_right;
603  else
604  ww = size.fWidth;
605  if (hints & kLHintsFillY)
606  hh = cell_height - pad_top - pad_bottom;
607  else
608  hh = size.fHeight;
609 
610  // Find location of child frame
611  UInt_t xx;
612  if (hints & kLHintsFillX) // Fill beats right/center/left hints
613  xx = cell_x + pad_left;
614  else if (hints & kLHintsRight)
615  xx = cell_x + cell_width - pad_right - ww;
616  else if (hints & kLHintsCenterX)
617  xx = cell_x + cell_width/2 - ww/2; // padding?
618  else // defaults to kLHintsLeft
619  xx = cell_x + pad_left;
620 
621  UInt_t yy;
622  if (hints & kLHintsFillY) // Fill beats top/center/bottom hings
623  yy = cell_y + pad_top;
624  else if (hints & kLHintsBottom)
625  yy = cell_y + cell_height - pad_bottom - hh;
626  else if (hints & kLHintsCenterY)
627  yy = cell_y + cell_height/2 - hh/2; // padding?
628  else // defaults to kLHintsTop
629  yy = cell_y + pad_top;
630 
631  ptr->fFrame->MoveResize(xx,yy,ww,hh);
632  ptr->fFrame->Layout();
633 
634  }
635 }
636 
637 ////////////////////////////////////////////////////////////////////////////////
638 /// Return default dimension of the table layout.
639 
641 {
642  TGDimension msize = fMain->GetSize();
643  UInt_t options = fMain->GetOptions();
644 
645  if ((options & kFixedWidth) && (options & kFixedHeight))
646  return msize;
647 
648  Int_t border_width = fMain->GetBorderWidth();
649 
650  TGDimension size(2*border_width + (fNcols-1)*fSep,
651  2*border_width + (fNrows-1)*fSep);
652 
653  UInt_t col, row;
654  if (fCol)
655  for (col = 0; col < fNcols; ++col) size.fWidth += fCol[col].fDefSize;
656  if (fRow)
657  for (row = 0; row < fNrows; ++row) size.fHeight += fRow[row].fDefSize;
658 
659  if (options & kFixedWidth) size.fWidth = msize.fWidth;
660  if (options & kFixedHeight) size.fHeight = msize.fHeight;
661  return size;
662 }
663 
664 // ________________________________________________________________________
665 void TGTableLayoutHints::SavePrimitive(std::ostream &out, Option_t * /*= ""*/)
666 {
667 
668  // Save table layout hints as a C++ statement(s) on output stream out.
669 
670  TString hints;
671  UInt_t pad = GetPadLeft()+GetPadRight()+GetPadTop()+GetPadBottom();
672 
673  if (!GetLayoutHints()) return;
674 
675  if ((fLayoutHints == kLHintsNormal) && (pad == 0)) return;
676 
677  if (fLayoutHints & kLHintsLeft) {
678  if (hints.Length() == 0) hints = "kLHintsLeft";
679  else hints += " | kLHintsLeft";
680  }
681  if (fLayoutHints & kLHintsCenterX) {
682  if (hints.Length() == 0) hints = "kLHintsCenterX";
683  else hints += " | kLHintsCenterX";
684  }
685  if (fLayoutHints & kLHintsRight) {
686  if (hints.Length() == 0) hints = "kLHintsRight";
687  else hints += " | kLHintsRight";
688  }
689  if (fLayoutHints & kLHintsTop) {
690  if (hints.Length() == 0) hints = "kLHintsTop";
691  else hints += " | kLHintsTop";
692  }
693  if (fLayoutHints & kLHintsCenterY) {
694  if (hints.Length() == 0) hints = "kLHintsCenterY";
695  else hints += " | kLHintsCenterY";
696  }
697  if (fLayoutHints & kLHintsBottom) {
698  if (hints.Length() == 0) hints = "kLHintsBottom";
699  else hints += " | kLHintsBottom";
700  }
701  if (fLayoutHints & kLHintsExpandX) {
702  if (hints.Length() == 0) hints = "kLHintsExpandX";
703  else hints += " | kLHintsExpandX";
704  }
705  if (fLayoutHints & kLHintsExpandY) {
706  if (hints.Length() == 0) hints = "kLHintsExpandY";
707  else hints += " | kLHintsExpandY";
708  }
709  if (fLayoutHints & kLHintsShrinkX) {
710  if (hints.Length() == 0) hints = "kLHintsShrinkX";
711  else hints += " | kLHintsShrinkX";
712  }
713  if (fLayoutHints & kLHintsShrinkY) {
714  if (hints.Length() == 0) hints = "kLHintsShrinkY";
715  else hints += " | kLHintsShrinkY";
716  }
717  if (fLayoutHints & kLHintsFillX) {
718  if (hints.Length() == 0) hints = "kLHintsFillX";
719  else hints += " | kLHintsFillX";
720  }
721  if (fLayoutHints & kLHintsFillY) {
722  if (hints.Length() == 0) hints = "kLHintsFillY";
723  else hints += " | kLHintsFillY";
724  }
725  out << ", new TGTableLayoutHints(" << GetAttachLeft() << "," << GetAttachRight()
726  << "," << GetAttachTop() << "," << GetAttachBottom()
727  << "," << hints;
728 
729  if (pad) {
730  out << "," << GetPadLeft() << "," << GetPadRight()
731  << "," << GetPadTop() << "," << GetPadBottom();
732  }
733  out << ")";
734 }
735 
736 // __________________________________________________________________________
737 void TGTableLayout::SavePrimitive(std::ostream &out, Option_t * /*= ""*/)
738 {
739 
740  // Save table layout as a C++ statement(s) on output stream.
741 
742  out << " new TGTableLayout(" << fMain->GetName() << "," << fNrows << "," << fNcols;
743 
744  if (fSep) {
745  if (fHomogeneous == kTRUE)
746  out << ", kTRUE";
747  else
748  out << ", kFALSE";
749  out << fSep;
750  }
751  out << ")";
752  // hints parameter is not used/saved currently
753 
754 }
virtual TGDimension GetDefaultSize() const
std::cout << fWidth << "x" << fHeight << std::endl;
Definition: TGFrame.cxx:566
virtual void SavePrimitive(std::ostream &out, Option_t *="")
Save a primitive as a C++ statement(s) on output stream "out".
UInt_t GetAttachLeft() const
Definition: TGTableLayout.h:60
Int_t GetBorderWidth() const
Definition: TGFrame.h:280
virtual UInt_t GetOptions() const
Definition: TGFrame.h:244
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
ULong_t GetLayoutHints() const
Definition: TGLayout.h:89
const char Option_t
Definition: RtypesCore.h:62
UInt_t GetHeight() const
Definition: TGFrame.h:272
UInt_t GetAttachTop() const
Definition: TGTableLayout.h:62
TGTableLayout(const TGTableLayout &)
Bool_t fHomogeneous
Basic string class.
Definition: TString.h:125
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
void FindRowColSizesHomogeneous()
If the table is homogeneous make sure all col/rows are same size as biggest col/row.
UInt_t GetWidth() const
Definition: TGFrame.h:271
Int_t fState
Definition: TGLayout.h:120
void Reset()
Definition: TCollection.h:250
TGLayoutHints * fLayout
Definition: TGLayout.h:121
TGCompositeFrame * fMain
TableData_t * fRow
virtual void Layout()
Definition: TGFrame.h:246
int main(int argc, char **argv)
virtual TList * GetList() const
Definition: TGFrame.h:369
virtual void Layout()
Make a table layout of all frames in the list.
void SetRowColSizesInit()
Initialize rows/cols.
UInt_t fHeight
Definition: TGDimension.h:30
UInt_t GetAttachRight() const
Definition: TGTableLayout.h:61
void FindRowColSizesSinglyAttached()
Determine the size of rows/cols needed for singly attached children.
UInt_t fWidth
Definition: TGDimension.h:29
TableData_t * fCol
void FindRowColSizesMultiplyAttached()
Checks any children which span multiple col/rows.
virtual const char * GetName() const
Return unique name, used in SavePrimitive methods.
Definition: TGWindow.cxx:221
Int_t GetPadLeft() const
Definition: TGLayout.h:92
UInt_t GetAttachBottom() const
Definition: TGTableLayout.h:63
unsigned int UInt_t
Definition: RtypesCore.h:42
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:880
Ssiz_t Length() const
Definition: TString.h:386
void CheckSanity()
Sanity check various values.
TGFrame * fFrame
Definition: TGLayout.h:119
virtual UInt_t GetDefaultWidth() const
Definition: TGFrame.h:237
static void SetRowColResize(UInt_t real_size, UInt_t nthings, TableData_t *thing, Bool_t homogeneous)
If main frame is bigger or smaller than all children, expand/shrink to fill.
const Bool_t kFALSE
Definition: RtypesCore.h:88
void SetRowColSizes()
This gets the new sizes needed to fit the table to the parent frame.
TGDimension GetSize() const
Definition: TGFrame.h:277
void FindRowColSizes()
Find the sizes of rows and columns needed to statisfy children&#39;s layout policies. ...
virtual UInt_t GetDefaultHeight() const
Definition: TGFrame.h:238
virtual ~TGTableLayout()
TGTableLayout constructor.
#define ClassImp(name)
Definition: Rtypes.h:359
Int_t GetPadRight() const
Definition: TGLayout.h:93
unsigned long ULong_t
Definition: RtypesCore.h:51
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:200
void FindRowColSizesInit()
Initialize values needed to determine the size of rows and columns.
Int_t GetPadTop() const
Definition: TGLayout.h:90
virtual TGDimension GetDefaultSize() const
Return default dimension of the table layout.
const Bool_t kTRUE
Definition: RtypesCore.h:87
virtual void SavePrimitive(std::ostream &out, Option_t *="")
Save a primitive as a C++ statement(s) on output stream "out".
Int_t GetPadBottom() const
Definition: TGLayout.h:91