ROOT logo
// @(#)root/gui:$Id: TGTableLayout.cxx 34223 2010-06-30 11:01:48Z bellenot $
// Author: Brett Viren   04/15/2001

/*************************************************************************
 * Copyright (C) 2001, Brett Viren                                       *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
/**************************************************************************

    This source is based on Xclass95, a Win95-looking GUI toolkit.
    Copyright (C) 1996, 1997 David Barth, Ricky Ralston, Hector Peraza.

    Xclass95 is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

**************************************************************************/
/**************************************************************************

    The Layout algorithm was largely translated from GTK's gtktable.c
    source.  That source is also distributed under LGPL.

**************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TGTableLayout                                                        //
//                                                                      //
// A layout manager, which places child frames in a table arranged in   //
// rows and columns, making it easy to align many widgets next each to  //
// other horizontally and vertivally. It uses TGTableLayoutHints        //
// (not TGLayoutHints!!!) and works like TGMatrixLayout with the        //
// addition that:                                                       //
//  - Child frames can span more than one column/row.                   //
//  - Child frames can resize with the frame.                           //
//  - Column and row sizes are not fixed nor (optionally) homogeneous.  //
//  - The number of columns and rows must be fully specified in the     //
//    constructor.                                                      //
// The gaps between all rows or columns can be specified by 'sep'       //
// parameter in the constructor. All rows and columns will have the     //
// same size (set by widest and the highest child frame) if the         //
// parameter 'homogeneous' is set to kTRUE.                             //
//                                                                      //
//                                                                      //
// TGTableLayoutHints                                                   //
//                                                                      //
// This class describes layout hints used by the TGTableLayout class.   //
// It specifies the column/row division number on which to attach the   //
// child frame. This number starts from 0 and goes to #_columns/#_rows  //
// respectively (0 indicates the first row/column).                     //
//                                                                      //
// Below are described all parameters of TGTableLayoutHints constructor //
//     attach_left   - the column to the left of the widget;            //
//     attach_right  - the column to the right of the widget;           //
//     attach_top    - the row above the widget;                        //
//     attach_bottom - the row below the widget;                        //
//                                                                      //
//     hints - layout hints (combination of ELayoutHints)               //
//                                                                      //
// The next parameters determine the extra padding added around the     //
// child frame. By default these are 0.                                 //
//     padleft   - determines the extra padding added on the left       //
//     padright  - determines the extra padding added on the right      //
//     padtop    - determines the extra padding added on the top        //
//     padbottom - determines the extra padding added on the bottom     //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


#include "TGTableLayout.h"
#include "TGFrame.h"
#include "TList.h"
#include "Rtypes.h"
#include "Riostream.h"


ClassImp(TGTableLayout)
ClassImp(TGTableLayoutHints)

//______________________________________________________________________________
TGTableLayout::TGTableLayout(TGCompositeFrame *main, UInt_t nrows, UInt_t ncols,
                             Bool_t homogeneous, Int_t sep, Int_t hints)
{
   // TGTableLayout constructor.
   // Note:
   // - Number of rows first, number of Columns second
   // - homogeneous == true means all table cells are the same size,
   //   set by the widest and the highest child frame.
   // - s gives the amount of separation in pixels between cells
   // - h are the hints, see TGTableLayoutHints.

   fMain    = main;
   fList    = fMain->GetList();
   fSep     = sep;
   fHints   = hints;
   fNrows   = nrows;
   fNcols   = ncols;
   fRow     = 0;
   fCol     = 0;
   fHomogeneous = homogeneous;
}

//______________________________________________________________________________
TGTableLayout::~TGTableLayout()
{
   // TGTableLayout constructor.

   if (fRow) delete [] fRow;
   if (fCol) delete [] fCol;
}

//______________________________________________________________________________
void TGTableLayout::FindRowColSizes()
{
   // Find the sizes of rows and columns needed to statisfy
   // children's layout policies.

   // This is equiv to GTK's requisition stage

   FindRowColSizesInit();
   FindRowColSizesSinglyAttached();
   FindRowColSizesHomogeneous();
   FindRowColSizesMultiplyAttached();
   FindRowColSizesHomogeneous();
}

//______________________________________________________________________________
void TGTableLayout::FindRowColSizesInit()
{
   // Initialize values needed to determine the size of rows and columns.

   if (fRow) delete [] fRow;
   if (fCol) delete [] fCol;
   fRow = new TableData_t[fNrows];
   fCol = new TableData_t[fNcols];

   // Find max of each row and column

   UInt_t i;
   for (i = 0; i < fNrows; ++i) fRow[i].fDefSize = 0;
   for (i = 0; i < fNcols; ++i) fCol[i].fDefSize = 0;
}

//______________________________________________________________________________
void TGTableLayout::FindRowColSizesSinglyAttached()
{
   // Determine the size of rows/cols needed for singly attached children.

   TIter next(fList);
   TGFrameElement *ptr;

   while ((ptr = (TGFrameElement *) next())) {
      if (ptr->fState == 0) continue;
      TGTableLayoutHints *layout =
            dynamic_cast<TGTableLayoutHints*>(ptr->fLayout);
      if (!layout) {
         Error("FindRowColSizesSinglyAttached", "didn't get TGTableLayoutHints from %s, layout = 0x%lx",
               ptr->fFrame->GetName(), (ULong_t)ptr->fLayout);
         return;
      }
      UInt_t col = layout->GetAttachLeft();
      if (col == (layout->GetAttachRight() - 1))
         fCol[col].fDefSize = TMath::Max(fCol[col].fDefSize,
                                         ptr->fFrame->GetDefaultWidth() +
                                         layout->GetPadLeft() +
                                         layout->GetPadRight());

      UInt_t row = layout->GetAttachTop();
      if (row == (layout->GetAttachBottom() - 1))
         fRow[row].fDefSize = TMath::Max(fRow[row].fDefSize,
                                         ptr->fFrame->GetDefaultHeight() +
                                         layout->GetPadTop() +
                                         layout->GetPadBottom());
   }
}

//______________________________________________________________________________
void TGTableLayout::FindRowColSizesHomogeneous()
{
   // If the table is homogeneous make sure all col/rows are same
   // size as biggest col/row.

   if (!fHomogeneous) return;

   UInt_t max_width = 0, max_height = 0, col, row;

   // find max
   for (col = 0; col < fNcols; ++col)
      max_width = TMath::Max(max_width,fCol[col].fDefSize);

   for (row = 0; row < fNrows; ++row)
      max_height = TMath::Max(max_height,fRow[row].fDefSize);

   // set max
   for (col = 0; col < fNcols; ++col) fCol[col].fDefSize = max_width;
   for (row = 0; row < fNrows; ++row) fRow[row].fDefSize = max_height;
}

//______________________________________________________________________________
void TGTableLayout::FindRowColSizesMultiplyAttached()
{
   // Checks any children which span multiple col/rows.

   TIter next(fList);
   TGFrameElement *ptr;

   while ((ptr = (TGFrameElement *) next())) {
      if (ptr->fState == 0) continue;
      TGTableLayoutHints *layout =
            dynamic_cast<TGTableLayoutHints*>(ptr->fLayout);
      if (!layout) {
         Error("FindRowColSizesMultiplyAttached", "didn't get TGTableLayoutHints");
         return;
      }
      UInt_t left   = layout->GetAttachLeft();
      UInt_t right  = layout->GetAttachRight();
      if (left != right-1) {  // child spans multi-columns
         UInt_t width = 0, col;
         for (col = left; col < right; ++col) width += fCol[col].fDefSize;

         // If more space needed, divide space evenly among the columns
         UInt_t child_width = ptr->fFrame->GetDefaultWidth() +
                              layout->GetPadLeft() + layout->GetPadRight();

         if (width < child_width) {
            width = child_width - width;
            for (col = left; col < right; ++col) {
               UInt_t extra = width / (right - col);
               fCol[col].fDefSize += extra;
               width -= extra;
            }
         }
      }
      UInt_t top    = layout->GetAttachTop();
      UInt_t bottom = layout->GetAttachBottom();
      if (top != bottom-1) {  // child spans multi-rows
         UInt_t height = 0, row;
         for (row = top; row < bottom; ++row) height += fRow[row].fDefSize;

         // If more space needed, divide space evenly among the rows
         UInt_t child_height = ptr->fFrame->GetDefaultHeight() +
                               layout->GetPadTop() + layout->GetPadBottom();

         if (height < child_height) {
            height = child_height - height;
            for (row = top; row < bottom; ++row) {
               UInt_t extra = height / (bottom - row);
               fRow[row].fDefSize += extra;
               height -= extra;
            }
         }
      }
   }
}

//______________________________________________________________________________
void TGTableLayout::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. This is symmetric under row<-->col
   // switching so it is abstracted out to a normal function to save typing.

   if (homogeneous) {
      UInt_t ind, nshrink=0, nexpand=0, cur_size=0;

      for (ind = 0; ind < nthings; ++ind)
         cur_size += thing[ind].fDefSize;

      if (cur_size < real_size) {
         for (ind = 0; ind < nthings; ++ind)
            if (thing[ind].fExpand) { ++ nexpand; break; }
         if (nexpand > 0) {
            UInt_t size = real_size;
            for (ind = 0; ind < nthings; ++ ind) {
               UInt_t extra = size / (nthings - ind);
               thing[ind].fRealSize = TMath::Max(1U, extra);
               size -= extra;
            }
         }
      }
      if (cur_size > real_size) {
         for (ind = 0; ind < nthings; ++ind)
            if (thing[ind].fShrink) { ++ nshrink; break; }
         if (nshrink > 0) {
            UInt_t size = real_size;
            for (ind = 0; ind < nthings; ++ ind) {
               UInt_t extra = size / (nthings - ind);
               thing[ind].fRealSize = TMath::Max(1U, extra);
               size -= extra;
            }
         }
      }
   } else {
      UInt_t ind, nshrink=0, nexpand=0, size=0;
      for (ind = 0; ind < nthings; ++ind) {
         size += thing[ind].fDefSize;
         if (thing[ind].fExpand) ++ nexpand;
         if (thing[ind].fShrink) ++ nshrink;
      }

      // Did main frame expand?
      if ((size < real_size) && (nexpand >= 1)) {
         size = real_size - size;
         for (ind = 0; ind < nthings; ++ind) {
            if (thing[ind].fExpand) {
               UInt_t extra = size / nexpand;
               thing[ind].fRealSize += extra;
               size -= extra;
               --nexpand;
            }
         }
      }

      // Did main frame shrink?
      if (size > real_size) {
         UInt_t total_nshrink = nshrink;
         UInt_t extra = size - real_size;
         while (total_nshrink > 0 && extra > 0) {
            nshrink = total_nshrink;
            for (ind = 0; ind < nthings; ++ind)
               if (thing[ind].fShrink) {
                  UInt_t size2 = thing[ind].fRealSize;
                  thing[ind].fRealSize = TMath::Max(1U,thing[ind].fRealSize - extra / nshrink);
                  extra -= size2 - thing[ind].fRealSize;
                  --nshrink;
                  if (thing[ind].fRealSize < 2) {
                     total_nshrink -= 1;
                     thing[ind].fShrink = kFALSE;
                  }
               }
         }
      }
   } // not homogeneous
}

//______________________________________________________________________________
void TGTableLayout::SetRowColSizes()
{
   // This gets the new sizes needed to fit the table to the parent
   // frame. To be called after FindRowColSizes.

   SetRowColSizesInit();
   UInt_t border_width = fMain->GetBorderWidth();

   SetRowColResize(fMain->GetWidth() - (fNcols-1)*fSep - 2*border_width,
                   fNcols, fCol, fHomogeneous);
   SetRowColResize(fMain->GetHeight() - (fNrows-1)*fSep - 2*border_width,
                   fNrows, fRow, fHomogeneous);
}

//______________________________________________________________________________
void TGTableLayout::SetRowColSizesInit()
{
   // Initialize rows/cols. By default they do not expand and they
   // do shrink. What the children want determine what the rows/cols do.

   UInt_t col;
   for (col = 0; col < fNcols; ++col) {
      fCol[col].fRealSize = fCol[col].fDefSize;
      fCol[col].fNeedExpand = kFALSE;
      fCol[col].fNeedShrink = kTRUE;
      fCol[col].fExpand = kFALSE;
      fCol[col].fShrink = kTRUE;
      fCol[col].fEmpty = kTRUE;
   }
   UInt_t row;
   for (row = 0; row < fNrows; ++row) {
      fRow[row].fRealSize = fRow[row].fDefSize;
      fRow[row].fNeedExpand = kFALSE;
      fRow[row].fNeedShrink = kTRUE;
      fRow[row].fExpand = kFALSE;
      fRow[row].fShrink = kTRUE;
      fRow[row].fEmpty = kTRUE;
   }

   // Check single row/col children for expand/shrink-ability
   TIter next(fList);
   TGFrameElement *ptr;
   while ((ptr = (TGFrameElement*) next())) {
      TGTableLayoutHints *layout =
            dynamic_cast<TGTableLayoutHints*>(ptr->fLayout);
      if (!layout) {
         Error("SetRowColSizesInit", "didn't get TGTableLayoutHints");
         return;
      }
      ULong_t hints = layout->GetLayoutHints();

      // columns
      if (layout->GetAttachLeft() == layout->GetAttachRight()-1) {
         if (hints & kLHintsExpandX)
            fCol[layout->GetAttachLeft()].fExpand = kTRUE;
         if (!(hints & kLHintsShrinkX))
            fCol[layout->GetAttachLeft()].fShrink = kFALSE;
         fCol[layout->GetAttachLeft()].fEmpty = kFALSE;
      }
      // rows
      if (layout->GetAttachTop() == layout->GetAttachBottom()-1) {
         if (hints & kLHintsExpandY)
            fRow[layout->GetAttachTop()].fExpand = kTRUE;
         if (!(hints & kLHintsShrinkY))
            fRow[layout->GetAttachTop()].fShrink = kFALSE;
         fRow[layout->GetAttachTop()].fEmpty = kFALSE;
      }
   }

   // Do same for children of spanning multiple col/rows
   next.Reset();
   while ((ptr = (TGFrameElement*) next())) {
      TGTableLayoutHints *layout =
            dynamic_cast<TGTableLayoutHints*>(ptr->fLayout);
      if (!layout) {
         Error("SetRowColSizesInit", "didn't get TGTableLayoutHints");
         return;
      }
      ULong_t hints = layout->GetLayoutHints();

      // columns
      UInt_t left = layout->GetAttachLeft();
      UInt_t right = layout->GetAttachRight();
      if (left != right - 1) {
         for (col = left; col < right; ++col) fCol[col].fEmpty = kFALSE;
         Bool_t has_expand=kFALSE, has_shrink=kTRUE;
         if (hints & kLHintsExpandX) {
            for (col = left; col < right; ++col)
               if (fCol[col].fExpand) { has_expand = kTRUE; break; }
            if (!has_expand)
               for (col = left; col < right; ++col)
                  fCol[col].fNeedExpand = kTRUE;
         }
         if (!(hints & kLHintsShrinkX)) {
            for (col = left; col < right; ++col)
               if (!fCol[col].fShrink) { has_shrink = kFALSE; break;}
            if (has_shrink)
               for (col = left; col < right; ++col)
                  fCol[col].fNeedShrink = kFALSE;
         }
      }

      // rows
      UInt_t top = layout->GetAttachTop();
      UInt_t bottom = layout->GetAttachBottom();
      if (top != bottom - 1) {
         for (row = top; row < bottom; ++row) fRow[row].fEmpty = kFALSE;
         Bool_t has_expand=kFALSE, has_shrink=kTRUE;
         if (hints & kLHintsExpandY) {
            for (row = top; row < bottom; ++row)
               if (fRow[row].fExpand) { has_expand = kTRUE; break; }
            if (!has_expand)
               for (row = top; row < bottom; ++row)
                  fRow[row].fNeedExpand = kTRUE;
         }
         if (!(hints & kLHintsShrinkY)) {
            for (row = top; row < bottom; ++row)
               if (!fRow[row].fShrink) { has_shrink = kFALSE; break;}
            if (has_shrink)
               for (row = top; row < bottom; ++row)
                  fRow[row].fNeedShrink = kFALSE;
         }
      }
   }

   // Set expand/shrink flags
   for (col = 0; col < fNcols; ++col) {
      if (fCol[col].fEmpty) {
         fCol[col].fExpand = kFALSE;
         fCol[col].fShrink = kFALSE;
      } else {
         if (fCol[col].fNeedExpand) fCol[col].fExpand = kTRUE;
         if (!fCol[col].fNeedShrink) fCol[col].fShrink = kFALSE;
      }
   }
   for (row = 0; row < fNrows; ++row) {
      if (fRow[row].fEmpty) {
         fRow[row].fExpand = kFALSE;
         fRow[row].fShrink = kFALSE;
      } else {
         if (fRow[row].fNeedExpand) fRow[row].fExpand = kTRUE;
         if (!fRow[row].fNeedShrink) fRow[row].fShrink = kFALSE;
      }
   }
}

//______________________________________________________________________________
void TGTableLayout::CheckSanity()
{
   // Sanity check various values.

   TIter next(fList);
   TGFrameElement *ptr;
   UInt_t nerrors = 0;
   while ((ptr = (TGFrameElement*) next())) {
      TGTableLayoutHints *layout =
            dynamic_cast<TGTableLayoutHints*>(ptr->fLayout);
      if (!layout) {
         Error("CheckSanity", "didn't get TGTableLayoutHints");
         return;
      }

      UInt_t right  = layout->GetAttachRight();
      UInt_t left   = layout->GetAttachLeft();
      UInt_t top    = layout->GetAttachTop();
      UInt_t bottom = layout->GetAttachBottom();

      if (left == right) {
         ++nerrors;
         Error("CheckSanity", "AttachLeft == AttachRight");
      }
      if (left > right) {
         ++nerrors;
         Error("CheckSanity", "AttachLeft > AttachRight");
      }
      if (left > fNcols-1) {
         ++nerrors;
         Error("CheckSanity", "AttachLeft illegal value: %u", left);
      }
      if (right < 1 || right > fNcols) {
         ++nerrors;
         Error("CheckSanity", "AttachRight illegal value: %u", right);
      }

      if (top == bottom) {
         ++nerrors;
         Error("CheckSanity", "AttachTop == AttachBottom");
      }
      if (top > bottom) {
         ++nerrors;
         Error("CheckSanity", "AttachTop > AttachBottom");
      }
      if (top > fNrows-1) {
         ++nerrors;
         Error("CheckSanity", "AttachTop illegal value: %u", top);
      }
      if (bottom < 1 || bottom > fNrows) {
         ++nerrors;
         Error("CheckSanity", "AttachBottom illegal value: %u", bottom);
      }

   }
   if (nerrors) {
      Error("CheckSanity", "errors in %u x %u table", fNcols, fNrows);
   }
}

//______________________________________________________________________________
void TGTableLayout::Layout()
{
    // Make a table layout of all frames in the list.

   CheckSanity();

   FindRowColSizes();

   SetRowColSizes();

   // Do the layout
   TIter next(fList);
   TGFrameElement *ptr;
   UInt_t border_width = fMain->GetBorderWidth();
   while ((ptr = (TGFrameElement*) next())) {
      TGTableLayoutHints *layout = 
            dynamic_cast<TGTableLayoutHints*>(ptr->fLayout);
      if (!layout) {
         Error("TGTableLayout::Layout", "didn't get TGTableLayoutHints");
         return;
      }
      ULong_t hints = layout->GetLayoutHints();
      TGDimension size = ptr->fFrame->GetDefaultSize();

      UInt_t right  = layout->GetAttachRight();
      UInt_t left   = layout->GetAttachLeft();
      UInt_t top    = layout->GetAttachTop();
      UInt_t bottom = layout->GetAttachBottom();

      // Find location and size of cell in which to fit the child frame.
      UInt_t col, cell_x = border_width + left*fSep;
      for (col = 0; col < left; ++col) cell_x += fCol[col].fRealSize;

      UInt_t row, cell_y = border_width + top*fSep;
      for (row = 0; row < top; ++row) cell_y += fRow[row].fRealSize;

      UInt_t cell_width = (right-left-1)*fSep;
      for (col=left; col < right; ++col)
         cell_width += fCol[col].fRealSize;

      UInt_t cell_height = (bottom-top-1)*fSep;
      for (row=top; row < bottom; ++row)
         cell_height += fRow[row].fRealSize;

      UInt_t pad_left   = layout->GetPadLeft();
      UInt_t pad_right  = layout->GetPadRight();
      UInt_t pad_bottom = layout->GetPadBottom();
      UInt_t pad_top    = layout->GetPadTop();

      // find size of child frame
      UInt_t ww,hh;
      if (hints & kLHintsFillX)
         ww = cell_width  - pad_left - pad_right;
      else
         ww = size.fWidth;
      if (hints & kLHintsFillY)
         hh = cell_height - pad_top - pad_bottom;
      else
         hh = size.fHeight;

      // Find location of child frame
      UInt_t xx;
      if (hints & kLHintsFillX) // Fill beats right/center/left hints
         xx = cell_x + pad_left;
      else if (hints & kLHintsRight)
         xx = cell_x + cell_width - pad_right - ww;
      else if (hints & kLHintsCenterX)
         xx = cell_x + cell_width/2 - ww/2; // padding?
      else                    // defaults to kLHintsLeft
         xx = cell_x + pad_left;

      UInt_t yy;
      if (hints & kLHintsFillY) // Fill beats top/center/bottom hings
         yy = cell_y + pad_top;
      else if (hints & kLHintsBottom)
         yy = cell_y + cell_height - pad_bottom - hh;
      else if (hints & kLHintsCenterY)
         yy = cell_y + cell_height/2 - hh/2; // padding?
      else                    // defaults to kLHintsTop
         yy = cell_y + pad_top;

      ptr->fFrame->MoveResize(xx,yy,ww,hh);
      ptr->fFrame->Layout();

   }
}

//______________________________________________________________________________
TGDimension TGTableLayout::GetDefaultSize() const
{
   // Return default dimension of the table layout.

   TGDimension msize = fMain->GetSize();
   UInt_t options = fMain->GetOptions();

   if ((options & kFixedWidth) && (options & kFixedHeight))
      return msize;

   Int_t border_width = fMain->GetBorderWidth();

   TGDimension size(2*border_width + (fNcols-1)*fSep,
                    2*border_width + (fNrows-1)*fSep);

   UInt_t col, row;
   if (fCol)
      for (col = 0; col < fNcols; ++col) size.fWidth += fCol[col].fDefSize;
   if (fRow)
      for (row = 0; row < fNrows; ++row) size.fHeight += fRow[row].fDefSize;

   if (options & kFixedWidth)  size.fWidth = msize.fWidth;
   if (options & kFixedHeight) size.fHeight = msize.fHeight;
   return size;
}

// ________________________________________________________________________
void TGTableLayoutHints::SavePrimitive(ostream &out, Option_t * /*= ""*/)
{

   // Save table layout hints as a C++ statement(s) on output stream out.

   TString hints;
   UInt_t pad = GetPadLeft()+GetPadRight()+GetPadTop()+GetPadBottom();

   if (!GetLayoutHints()) return;

   if ((fLayoutHints == kLHintsNormal) && (pad == 0)) return;

   if (fLayoutHints & kLHintsLeft) {
      if (hints.Length() == 0) hints  = "kLHintsLeft";
      else                     hints += " | kLHintsLeft";
   }
   if (fLayoutHints & kLHintsCenterX) {
      if  (hints.Length() == 0) hints  = "kLHintsCenterX";
      else                     hints += " | kLHintsCenterX";
   }
   if (fLayoutHints & kLHintsRight) {
      if (hints.Length() == 0) hints  = "kLHintsRight";
      else                     hints += " | kLHintsRight";
   }
   if (fLayoutHints & kLHintsTop) {
      if (hints.Length() == 0) hints  = "kLHintsTop";
      else                     hints += " | kLHintsTop";
   }
   if (fLayoutHints & kLHintsCenterY) {
      if (hints.Length() == 0) hints  = "kLHintsCenterY";
      else                     hints += " | kLHintsCenterY";
   }
   if (fLayoutHints & kLHintsBottom) {
      if (hints.Length() == 0) hints  = "kLHintsBottom";
      else                     hints += " | kLHintsBottom";
   }
   if (fLayoutHints & kLHintsExpandX) {
      if (hints.Length() == 0) hints  = "kLHintsExpandX";
      else                     hints += " | kLHintsExpandX";
   }
   if (fLayoutHints & kLHintsExpandY) {
      if (hints.Length() == 0) hints  = "kLHintsExpandY";
      else                     hints += " | kLHintsExpandY";
   }
   if (fLayoutHints & kLHintsShrinkX) {
      if (hints.Length() == 0) hints  = "kLHintsShrinkX";
      else                     hints += " | kLHintsShrinkX";
   }
   if (fLayoutHints & kLHintsShrinkY) {
      if (hints.Length() == 0) hints  = "kLHintsShrinkY";
      else                     hints += " | kLHintsShrinkY";
   }
   if (fLayoutHints & kLHintsFillX) {
      if (hints.Length() == 0) hints  = "kLHintsFillX";
      else                     hints += " | kLHintsFillX";
   }
   if (fLayoutHints & kLHintsFillY) {
      if (hints.Length() == 0) hints  = "kLHintsFillY";
      else                     hints += " | kLHintsFillY";
   }
   out << ", new TGTableLayoutHints(" << GetAttachLeft() << "," << GetAttachRight()
       << "," << GetAttachTop()  << "," << GetAttachBottom()
       << "," << hints;

   if (pad) {
      out << "," << GetPadLeft() << "," << GetPadRight()
          << "," << GetPadTop()  << "," << GetPadBottom();
   }
   out << ")";
}

// __________________________________________________________________________
void TGTableLayout::SavePrimitive(ostream &out, Option_t * /*= ""*/)
{

   // Save table layout as a C++ statement(s) on output stream.

   out << " new TGTableLayout(" << fMain->GetName() << "," << fNrows << "," << fNcols;

   if (fSep) {
      if (fHomogeneous == kTRUE)
         out << ", kTRUE";
      else
         out << ", kFALSE";
   out << fSep;
   }
   out  << ")";
   // hints parameter is not used/saved currently

}
 TGTableLayout.cxx:1
 TGTableLayout.cxx:2
 TGTableLayout.cxx:3
 TGTableLayout.cxx:4
 TGTableLayout.cxx:5
 TGTableLayout.cxx:6
 TGTableLayout.cxx:7
 TGTableLayout.cxx:8
 TGTableLayout.cxx:9
 TGTableLayout.cxx:10
 TGTableLayout.cxx:11
 TGTableLayout.cxx:12
 TGTableLayout.cxx:13
 TGTableLayout.cxx:14
 TGTableLayout.cxx:15
 TGTableLayout.cxx:16
 TGTableLayout.cxx:17
 TGTableLayout.cxx:18
 TGTableLayout.cxx:19
 TGTableLayout.cxx:20
 TGTableLayout.cxx:21
 TGTableLayout.cxx:22
 TGTableLayout.cxx:23
 TGTableLayout.cxx:24
 TGTableLayout.cxx:25
 TGTableLayout.cxx:26
 TGTableLayout.cxx:27
 TGTableLayout.cxx:28
 TGTableLayout.cxx:29
 TGTableLayout.cxx:30
 TGTableLayout.cxx:31
 TGTableLayout.cxx:32
 TGTableLayout.cxx:33
 TGTableLayout.cxx:34
 TGTableLayout.cxx:35
 TGTableLayout.cxx:36
 TGTableLayout.cxx:37
 TGTableLayout.cxx:38
 TGTableLayout.cxx:39
 TGTableLayout.cxx:40
 TGTableLayout.cxx:41
 TGTableLayout.cxx:42
 TGTableLayout.cxx:43
 TGTableLayout.cxx:44
 TGTableLayout.cxx:45
 TGTableLayout.cxx:46
 TGTableLayout.cxx:47
 TGTableLayout.cxx:48
 TGTableLayout.cxx:49
 TGTableLayout.cxx:50
 TGTableLayout.cxx:51
 TGTableLayout.cxx:52
 TGTableLayout.cxx:53
 TGTableLayout.cxx:54
 TGTableLayout.cxx:55
 TGTableLayout.cxx:56
 TGTableLayout.cxx:57
 TGTableLayout.cxx:58
 TGTableLayout.cxx:59
 TGTableLayout.cxx:60
 TGTableLayout.cxx:61
 TGTableLayout.cxx:62
 TGTableLayout.cxx:63
 TGTableLayout.cxx:64
 TGTableLayout.cxx:65
 TGTableLayout.cxx:66
 TGTableLayout.cxx:67
 TGTableLayout.cxx:68
 TGTableLayout.cxx:69
 TGTableLayout.cxx:70
 TGTableLayout.cxx:71
 TGTableLayout.cxx:72
 TGTableLayout.cxx:73
 TGTableLayout.cxx:74
 TGTableLayout.cxx:75
 TGTableLayout.cxx:76
 TGTableLayout.cxx:77
 TGTableLayout.cxx:78
 TGTableLayout.cxx:79
 TGTableLayout.cxx:80
 TGTableLayout.cxx:81
 TGTableLayout.cxx:82
 TGTableLayout.cxx:83
 TGTableLayout.cxx:84
 TGTableLayout.cxx:85
 TGTableLayout.cxx:86
 TGTableLayout.cxx:87
 TGTableLayout.cxx:88
 TGTableLayout.cxx:89
 TGTableLayout.cxx:90
 TGTableLayout.cxx:91
 TGTableLayout.cxx:92
 TGTableLayout.cxx:93
 TGTableLayout.cxx:94
 TGTableLayout.cxx:95
 TGTableLayout.cxx:96
 TGTableLayout.cxx:97
 TGTableLayout.cxx:98
 TGTableLayout.cxx:99
 TGTableLayout.cxx:100
 TGTableLayout.cxx:101
 TGTableLayout.cxx:102
 TGTableLayout.cxx:103
 TGTableLayout.cxx:104
 TGTableLayout.cxx:105
 TGTableLayout.cxx:106
 TGTableLayout.cxx:107
 TGTableLayout.cxx:108
 TGTableLayout.cxx:109
 TGTableLayout.cxx:110
 TGTableLayout.cxx:111
 TGTableLayout.cxx:112
 TGTableLayout.cxx:113
 TGTableLayout.cxx:114
 TGTableLayout.cxx:115
 TGTableLayout.cxx:116
 TGTableLayout.cxx:117
 TGTableLayout.cxx:118
 TGTableLayout.cxx:119
 TGTableLayout.cxx:120
 TGTableLayout.cxx:121
 TGTableLayout.cxx:122
 TGTableLayout.cxx:123
 TGTableLayout.cxx:124
 TGTableLayout.cxx:125
 TGTableLayout.cxx:126
 TGTableLayout.cxx:127
 TGTableLayout.cxx:128
 TGTableLayout.cxx:129
 TGTableLayout.cxx:130
 TGTableLayout.cxx:131
 TGTableLayout.cxx:132
 TGTableLayout.cxx:133
 TGTableLayout.cxx:134
 TGTableLayout.cxx:135
 TGTableLayout.cxx:136
 TGTableLayout.cxx:137
 TGTableLayout.cxx:138
 TGTableLayout.cxx:139
 TGTableLayout.cxx:140
 TGTableLayout.cxx:141
 TGTableLayout.cxx:142
 TGTableLayout.cxx:143
 TGTableLayout.cxx:144
 TGTableLayout.cxx:145
 TGTableLayout.cxx:146
 TGTableLayout.cxx:147
 TGTableLayout.cxx:148
 TGTableLayout.cxx:149
 TGTableLayout.cxx:150
 TGTableLayout.cxx:151
 TGTableLayout.cxx:152
 TGTableLayout.cxx:153
 TGTableLayout.cxx:154
 TGTableLayout.cxx:155
 TGTableLayout.cxx:156
 TGTableLayout.cxx:157
 TGTableLayout.cxx:158
 TGTableLayout.cxx:159
 TGTableLayout.cxx:160
 TGTableLayout.cxx:161
 TGTableLayout.cxx:162
 TGTableLayout.cxx:163
 TGTableLayout.cxx:164
 TGTableLayout.cxx:165
 TGTableLayout.cxx:166
 TGTableLayout.cxx:167
 TGTableLayout.cxx:168
 TGTableLayout.cxx:169
 TGTableLayout.cxx:170
 TGTableLayout.cxx:171
 TGTableLayout.cxx:172
 TGTableLayout.cxx:173
 TGTableLayout.cxx:174
 TGTableLayout.cxx:175
 TGTableLayout.cxx:176
 TGTableLayout.cxx:177
 TGTableLayout.cxx:178
 TGTableLayout.cxx:179
 TGTableLayout.cxx:180
 TGTableLayout.cxx:181
 TGTableLayout.cxx:182
 TGTableLayout.cxx:183
 TGTableLayout.cxx:184
 TGTableLayout.cxx:185
 TGTableLayout.cxx:186
 TGTableLayout.cxx:187
 TGTableLayout.cxx:188
 TGTableLayout.cxx:189
 TGTableLayout.cxx:190
 TGTableLayout.cxx:191
 TGTableLayout.cxx:192
 TGTableLayout.cxx:193
 TGTableLayout.cxx:194
 TGTableLayout.cxx:195
 TGTableLayout.cxx:196
 TGTableLayout.cxx:197
 TGTableLayout.cxx:198
 TGTableLayout.cxx:199
 TGTableLayout.cxx:200
 TGTableLayout.cxx:201
 TGTableLayout.cxx:202
 TGTableLayout.cxx:203
 TGTableLayout.cxx:204
 TGTableLayout.cxx:205
 TGTableLayout.cxx:206
 TGTableLayout.cxx:207
 TGTableLayout.cxx:208
 TGTableLayout.cxx:209
 TGTableLayout.cxx:210
 TGTableLayout.cxx:211
 TGTableLayout.cxx:212
 TGTableLayout.cxx:213
 TGTableLayout.cxx:214
 TGTableLayout.cxx:215
 TGTableLayout.cxx:216
 TGTableLayout.cxx:217
 TGTableLayout.cxx:218
 TGTableLayout.cxx:219
 TGTableLayout.cxx:220
 TGTableLayout.cxx:221
 TGTableLayout.cxx:222
 TGTableLayout.cxx:223
 TGTableLayout.cxx:224
 TGTableLayout.cxx:225
 TGTableLayout.cxx:226
 TGTableLayout.cxx:227
 TGTableLayout.cxx:228
 TGTableLayout.cxx:229
 TGTableLayout.cxx:230
 TGTableLayout.cxx:231
 TGTableLayout.cxx:232
 TGTableLayout.cxx:233
 TGTableLayout.cxx:234
 TGTableLayout.cxx:235
 TGTableLayout.cxx:236
 TGTableLayout.cxx:237
 TGTableLayout.cxx:238
 TGTableLayout.cxx:239
 TGTableLayout.cxx:240
 TGTableLayout.cxx:241
 TGTableLayout.cxx:242
 TGTableLayout.cxx:243
 TGTableLayout.cxx:244
 TGTableLayout.cxx:245
 TGTableLayout.cxx:246
 TGTableLayout.cxx:247
 TGTableLayout.cxx:248
 TGTableLayout.cxx:249
 TGTableLayout.cxx:250
 TGTableLayout.cxx:251
 TGTableLayout.cxx:252
 TGTableLayout.cxx:253
 TGTableLayout.cxx:254
 TGTableLayout.cxx:255
 TGTableLayout.cxx:256
 TGTableLayout.cxx:257
 TGTableLayout.cxx:258
 TGTableLayout.cxx:259
 TGTableLayout.cxx:260
 TGTableLayout.cxx:261
 TGTableLayout.cxx:262
 TGTableLayout.cxx:263
 TGTableLayout.cxx:264
 TGTableLayout.cxx:265
 TGTableLayout.cxx:266
 TGTableLayout.cxx:267
 TGTableLayout.cxx:268
 TGTableLayout.cxx:269
 TGTableLayout.cxx:270
 TGTableLayout.cxx:271
 TGTableLayout.cxx:272
 TGTableLayout.cxx:273
 TGTableLayout.cxx:274
 TGTableLayout.cxx:275
 TGTableLayout.cxx:276
 TGTableLayout.cxx:277
 TGTableLayout.cxx:278
 TGTableLayout.cxx:279
 TGTableLayout.cxx:280
 TGTableLayout.cxx:281
 TGTableLayout.cxx:282
 TGTableLayout.cxx:283
 TGTableLayout.cxx:284
 TGTableLayout.cxx:285
 TGTableLayout.cxx:286
 TGTableLayout.cxx:287
 TGTableLayout.cxx:288
 TGTableLayout.cxx:289
 TGTableLayout.cxx:290
 TGTableLayout.cxx:291
 TGTableLayout.cxx:292
 TGTableLayout.cxx:293
 TGTableLayout.cxx:294
 TGTableLayout.cxx:295
 TGTableLayout.cxx:296
 TGTableLayout.cxx:297
 TGTableLayout.cxx:298
 TGTableLayout.cxx:299
 TGTableLayout.cxx:300
 TGTableLayout.cxx:301
 TGTableLayout.cxx:302
 TGTableLayout.cxx:303
 TGTableLayout.cxx:304
 TGTableLayout.cxx:305
 TGTableLayout.cxx:306
 TGTableLayout.cxx:307
 TGTableLayout.cxx:308
 TGTableLayout.cxx:309
 TGTableLayout.cxx:310
 TGTableLayout.cxx:311
 TGTableLayout.cxx:312
 TGTableLayout.cxx:313
 TGTableLayout.cxx:314
 TGTableLayout.cxx:315
 TGTableLayout.cxx:316
 TGTableLayout.cxx:317
 TGTableLayout.cxx:318
 TGTableLayout.cxx:319
 TGTableLayout.cxx:320
 TGTableLayout.cxx:321
 TGTableLayout.cxx:322
 TGTableLayout.cxx:323
 TGTableLayout.cxx:324
 TGTableLayout.cxx:325
 TGTableLayout.cxx:326
 TGTableLayout.cxx:327
 TGTableLayout.cxx:328
 TGTableLayout.cxx:329
 TGTableLayout.cxx:330
 TGTableLayout.cxx:331
 TGTableLayout.cxx:332
 TGTableLayout.cxx:333
 TGTableLayout.cxx:334
 TGTableLayout.cxx:335
 TGTableLayout.cxx:336
 TGTableLayout.cxx:337
 TGTableLayout.cxx:338
 TGTableLayout.cxx:339
 TGTableLayout.cxx:340
 TGTableLayout.cxx:341
 TGTableLayout.cxx:342
 TGTableLayout.cxx:343
 TGTableLayout.cxx:344
 TGTableLayout.cxx:345
 TGTableLayout.cxx:346
 TGTableLayout.cxx:347
 TGTableLayout.cxx:348
 TGTableLayout.cxx:349
 TGTableLayout.cxx:350
 TGTableLayout.cxx:351
 TGTableLayout.cxx:352
 TGTableLayout.cxx:353
 TGTableLayout.cxx:354
 TGTableLayout.cxx:355
 TGTableLayout.cxx:356
 TGTableLayout.cxx:357
 TGTableLayout.cxx:358
 TGTableLayout.cxx:359
 TGTableLayout.cxx:360
 TGTableLayout.cxx:361
 TGTableLayout.cxx:362
 TGTableLayout.cxx:363
 TGTableLayout.cxx:364
 TGTableLayout.cxx:365
 TGTableLayout.cxx:366
 TGTableLayout.cxx:367
 TGTableLayout.cxx:368
 TGTableLayout.cxx:369
 TGTableLayout.cxx:370
 TGTableLayout.cxx:371
 TGTableLayout.cxx:372
 TGTableLayout.cxx:373
 TGTableLayout.cxx:374
 TGTableLayout.cxx:375
 TGTableLayout.cxx:376
 TGTableLayout.cxx:377
 TGTableLayout.cxx:378
 TGTableLayout.cxx:379
 TGTableLayout.cxx:380
 TGTableLayout.cxx:381
 TGTableLayout.cxx:382
 TGTableLayout.cxx:383
 TGTableLayout.cxx:384
 TGTableLayout.cxx:385
 TGTableLayout.cxx:386
 TGTableLayout.cxx:387
 TGTableLayout.cxx:388
 TGTableLayout.cxx:389
 TGTableLayout.cxx:390
 TGTableLayout.cxx:391
 TGTableLayout.cxx:392
 TGTableLayout.cxx:393
 TGTableLayout.cxx:394
 TGTableLayout.cxx:395
 TGTableLayout.cxx:396
 TGTableLayout.cxx:397
 TGTableLayout.cxx:398
 TGTableLayout.cxx:399
 TGTableLayout.cxx:400
 TGTableLayout.cxx:401
 TGTableLayout.cxx:402
 TGTableLayout.cxx:403
 TGTableLayout.cxx:404
 TGTableLayout.cxx:405
 TGTableLayout.cxx:406
 TGTableLayout.cxx:407
 TGTableLayout.cxx:408
 TGTableLayout.cxx:409
 TGTableLayout.cxx:410
 TGTableLayout.cxx:411
 TGTableLayout.cxx:412
 TGTableLayout.cxx:413
 TGTableLayout.cxx:414
 TGTableLayout.cxx:415
 TGTableLayout.cxx:416
 TGTableLayout.cxx:417
 TGTableLayout.cxx:418
 TGTableLayout.cxx:419
 TGTableLayout.cxx:420
 TGTableLayout.cxx:421
 TGTableLayout.cxx:422
 TGTableLayout.cxx:423
 TGTableLayout.cxx:424
 TGTableLayout.cxx:425
 TGTableLayout.cxx:426
 TGTableLayout.cxx:427
 TGTableLayout.cxx:428
 TGTableLayout.cxx:429
 TGTableLayout.cxx:430
 TGTableLayout.cxx:431
 TGTableLayout.cxx:432
 TGTableLayout.cxx:433
 TGTableLayout.cxx:434
 TGTableLayout.cxx:435
 TGTableLayout.cxx:436
 TGTableLayout.cxx:437
 TGTableLayout.cxx:438
 TGTableLayout.cxx:439
 TGTableLayout.cxx:440
 TGTableLayout.cxx:441
 TGTableLayout.cxx:442
 TGTableLayout.cxx:443
 TGTableLayout.cxx:444
 TGTableLayout.cxx:445
 TGTableLayout.cxx:446
 TGTableLayout.cxx:447
 TGTableLayout.cxx:448
 TGTableLayout.cxx:449
 TGTableLayout.cxx:450
 TGTableLayout.cxx:451
 TGTableLayout.cxx:452
 TGTableLayout.cxx:453
 TGTableLayout.cxx:454
 TGTableLayout.cxx:455
 TGTableLayout.cxx:456
 TGTableLayout.cxx:457
 TGTableLayout.cxx:458
 TGTableLayout.cxx:459
 TGTableLayout.cxx:460
 TGTableLayout.cxx:461
 TGTableLayout.cxx:462
 TGTableLayout.cxx:463
 TGTableLayout.cxx:464
 TGTableLayout.cxx:465
 TGTableLayout.cxx:466
 TGTableLayout.cxx:467
 TGTableLayout.cxx:468
 TGTableLayout.cxx:469
 TGTableLayout.cxx:470
 TGTableLayout.cxx:471
 TGTableLayout.cxx:472
 TGTableLayout.cxx:473
 TGTableLayout.cxx:474
 TGTableLayout.cxx:475
 TGTableLayout.cxx:476
 TGTableLayout.cxx:477
 TGTableLayout.cxx:478
 TGTableLayout.cxx:479
 TGTableLayout.cxx:480
 TGTableLayout.cxx:481
 TGTableLayout.cxx:482
 TGTableLayout.cxx:483
 TGTableLayout.cxx:484
 TGTableLayout.cxx:485
 TGTableLayout.cxx:486
 TGTableLayout.cxx:487
 TGTableLayout.cxx:488
 TGTableLayout.cxx:489
 TGTableLayout.cxx:490
 TGTableLayout.cxx:491
 TGTableLayout.cxx:492
 TGTableLayout.cxx:493
 TGTableLayout.cxx:494
 TGTableLayout.cxx:495
 TGTableLayout.cxx:496
 TGTableLayout.cxx:497
 TGTableLayout.cxx:498
 TGTableLayout.cxx:499
 TGTableLayout.cxx:500
 TGTableLayout.cxx:501
 TGTableLayout.cxx:502
 TGTableLayout.cxx:503
 TGTableLayout.cxx:504
 TGTableLayout.cxx:505
 TGTableLayout.cxx:506
 TGTableLayout.cxx:507
 TGTableLayout.cxx:508
 TGTableLayout.cxx:509
 TGTableLayout.cxx:510
 TGTableLayout.cxx:511
 TGTableLayout.cxx:512
 TGTableLayout.cxx:513
 TGTableLayout.cxx:514
 TGTableLayout.cxx:515
 TGTableLayout.cxx:516
 TGTableLayout.cxx:517
 TGTableLayout.cxx:518
 TGTableLayout.cxx:519
 TGTableLayout.cxx:520
 TGTableLayout.cxx:521
 TGTableLayout.cxx:522
 TGTableLayout.cxx:523
 TGTableLayout.cxx:524
 TGTableLayout.cxx:525
 TGTableLayout.cxx:526
 TGTableLayout.cxx:527
 TGTableLayout.cxx:528
 TGTableLayout.cxx:529
 TGTableLayout.cxx:530
 TGTableLayout.cxx:531
 TGTableLayout.cxx:532
 TGTableLayout.cxx:533
 TGTableLayout.cxx:534
 TGTableLayout.cxx:535
 TGTableLayout.cxx:536
 TGTableLayout.cxx:537
 TGTableLayout.cxx:538
 TGTableLayout.cxx:539
 TGTableLayout.cxx:540
 TGTableLayout.cxx:541
 TGTableLayout.cxx:542
 TGTableLayout.cxx:543
 TGTableLayout.cxx:544
 TGTableLayout.cxx:545
 TGTableLayout.cxx:546
 TGTableLayout.cxx:547
 TGTableLayout.cxx:548
 TGTableLayout.cxx:549
 TGTableLayout.cxx:550
 TGTableLayout.cxx:551
 TGTableLayout.cxx:552
 TGTableLayout.cxx:553
 TGTableLayout.cxx:554
 TGTableLayout.cxx:555
 TGTableLayout.cxx:556
 TGTableLayout.cxx:557
 TGTableLayout.cxx:558
 TGTableLayout.cxx:559
 TGTableLayout.cxx:560
 TGTableLayout.cxx:561
 TGTableLayout.cxx:562
 TGTableLayout.cxx:563
 TGTableLayout.cxx:564
 TGTableLayout.cxx:565
 TGTableLayout.cxx:566
 TGTableLayout.cxx:567
 TGTableLayout.cxx:568
 TGTableLayout.cxx:569
 TGTableLayout.cxx:570
 TGTableLayout.cxx:571
 TGTableLayout.cxx:572
 TGTableLayout.cxx:573
 TGTableLayout.cxx:574
 TGTableLayout.cxx:575
 TGTableLayout.cxx:576
 TGTableLayout.cxx:577
 TGTableLayout.cxx:578
 TGTableLayout.cxx:579
 TGTableLayout.cxx:580
 TGTableLayout.cxx:581
 TGTableLayout.cxx:582
 TGTableLayout.cxx:583
 TGTableLayout.cxx:584
 TGTableLayout.cxx:585
 TGTableLayout.cxx:586
 TGTableLayout.cxx:587
 TGTableLayout.cxx:588
 TGTableLayout.cxx:589
 TGTableLayout.cxx:590
 TGTableLayout.cxx:591
 TGTableLayout.cxx:592
 TGTableLayout.cxx:593
 TGTableLayout.cxx:594
 TGTableLayout.cxx:595
 TGTableLayout.cxx:596
 TGTableLayout.cxx:597
 TGTableLayout.cxx:598
 TGTableLayout.cxx:599
 TGTableLayout.cxx:600
 TGTableLayout.cxx:601
 TGTableLayout.cxx:602
 TGTableLayout.cxx:603
 TGTableLayout.cxx:604
 TGTableLayout.cxx:605
 TGTableLayout.cxx:606
 TGTableLayout.cxx:607
 TGTableLayout.cxx:608
 TGTableLayout.cxx:609
 TGTableLayout.cxx:610
 TGTableLayout.cxx:611
 TGTableLayout.cxx:612
 TGTableLayout.cxx:613
 TGTableLayout.cxx:614
 TGTableLayout.cxx:615
 TGTableLayout.cxx:616
 TGTableLayout.cxx:617
 TGTableLayout.cxx:618
 TGTableLayout.cxx:619
 TGTableLayout.cxx:620
 TGTableLayout.cxx:621
 TGTableLayout.cxx:622
 TGTableLayout.cxx:623
 TGTableLayout.cxx:624
 TGTableLayout.cxx:625
 TGTableLayout.cxx:626
 TGTableLayout.cxx:627
 TGTableLayout.cxx:628
 TGTableLayout.cxx:629
 TGTableLayout.cxx:630
 TGTableLayout.cxx:631
 TGTableLayout.cxx:632
 TGTableLayout.cxx:633
 TGTableLayout.cxx:634
 TGTableLayout.cxx:635
 TGTableLayout.cxx:636
 TGTableLayout.cxx:637
 TGTableLayout.cxx:638
 TGTableLayout.cxx:639
 TGTableLayout.cxx:640
 TGTableLayout.cxx:641
 TGTableLayout.cxx:642
 TGTableLayout.cxx:643
 TGTableLayout.cxx:644
 TGTableLayout.cxx:645
 TGTableLayout.cxx:646
 TGTableLayout.cxx:647
 TGTableLayout.cxx:648
 TGTableLayout.cxx:649
 TGTableLayout.cxx:650
 TGTableLayout.cxx:651
 TGTableLayout.cxx:652
 TGTableLayout.cxx:653
 TGTableLayout.cxx:654
 TGTableLayout.cxx:655
 TGTableLayout.cxx:656
 TGTableLayout.cxx:657
 TGTableLayout.cxx:658
 TGTableLayout.cxx:659
 TGTableLayout.cxx:660
 TGTableLayout.cxx:661
 TGTableLayout.cxx:662
 TGTableLayout.cxx:663
 TGTableLayout.cxx:664
 TGTableLayout.cxx:665
 TGTableLayout.cxx:666
 TGTableLayout.cxx:667
 TGTableLayout.cxx:668
 TGTableLayout.cxx:669
 TGTableLayout.cxx:670
 TGTableLayout.cxx:671
 TGTableLayout.cxx:672
 TGTableLayout.cxx:673
 TGTableLayout.cxx:674
 TGTableLayout.cxx:675
 TGTableLayout.cxx:676
 TGTableLayout.cxx:677
 TGTableLayout.cxx:678
 TGTableLayout.cxx:679
 TGTableLayout.cxx:680
 TGTableLayout.cxx:681
 TGTableLayout.cxx:682
 TGTableLayout.cxx:683
 TGTableLayout.cxx:684
 TGTableLayout.cxx:685
 TGTableLayout.cxx:686
 TGTableLayout.cxx:687
 TGTableLayout.cxx:688
 TGTableLayout.cxx:689
 TGTableLayout.cxx:690
 TGTableLayout.cxx:691
 TGTableLayout.cxx:692
 TGTableLayout.cxx:693
 TGTableLayout.cxx:694
 TGTableLayout.cxx:695
 TGTableLayout.cxx:696
 TGTableLayout.cxx:697
 TGTableLayout.cxx:698
 TGTableLayout.cxx:699
 TGTableLayout.cxx:700
 TGTableLayout.cxx:701
 TGTableLayout.cxx:702
 TGTableLayout.cxx:703
 TGTableLayout.cxx:704
 TGTableLayout.cxx:705
 TGTableLayout.cxx:706
 TGTableLayout.cxx:707
 TGTableLayout.cxx:708
 TGTableLayout.cxx:709
 TGTableLayout.cxx:710
 TGTableLayout.cxx:711
 TGTableLayout.cxx:712
 TGTableLayout.cxx:713
 TGTableLayout.cxx:714
 TGTableLayout.cxx:715
 TGTableLayout.cxx:716
 TGTableLayout.cxx:717
 TGTableLayout.cxx:718
 TGTableLayout.cxx:719
 TGTableLayout.cxx:720
 TGTableLayout.cxx:721
 TGTableLayout.cxx:722
 TGTableLayout.cxx:723
 TGTableLayout.cxx:724
 TGTableLayout.cxx:725
 TGTableLayout.cxx:726
 TGTableLayout.cxx:727
 TGTableLayout.cxx:728
 TGTableLayout.cxx:729
 TGTableLayout.cxx:730
 TGTableLayout.cxx:731
 TGTableLayout.cxx:732
 TGTableLayout.cxx:733
 TGTableLayout.cxx:734
 TGTableLayout.cxx:735
 TGTableLayout.cxx:736
 TGTableLayout.cxx:737
 TGTableLayout.cxx:738
 TGTableLayout.cxx:739
 TGTableLayout.cxx:740
 TGTableLayout.cxx:741
 TGTableLayout.cxx:742
 TGTableLayout.cxx:743
 TGTableLayout.cxx:744
 TGTableLayout.cxx:745
 TGTableLayout.cxx:746
 TGTableLayout.cxx:747
 TGTableLayout.cxx:748
 TGTableLayout.cxx:749
 TGTableLayout.cxx:750
 TGTableLayout.cxx:751
 TGTableLayout.cxx:752
 TGTableLayout.cxx:753
 TGTableLayout.cxx:754