FWCompactVerticalLayout.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     Core
// Class  :     FWCompactVerticalLayout
// 
// Implementation:
//     <Notes on implementation>
//
// Original Author:  Chris Jones
//         Created:  Tue Mar 17 12:10:42 CDT 2009
//

// system include files
#include <algorithm>
#include <iostream>
#include "TGFrame.h"

// user include files
#include "Fireworks/Core/src/FWCompactVerticalLayout.h"

//
// constants, enums and typedefs
//

//
// static data member definitions
//

//
// constructors and destructor
//
FWCompactVerticalLayout::FWCompactVerticalLayout(TGCompositeFrame* iMain):
TGVerticalLayout(iMain)
{
}

// FWCompactVerticalLayout::FWCompactVerticalLayout(const FWCompactVerticalLayout& rhs)
// {
//    // do actual copying here;
// }

FWCompactVerticalLayout::~FWCompactVerticalLayout()
{
}

//
// assignment operators
//
// const FWCompactVerticalLayout& FWCompactVerticalLayout::operator=(const FWCompactVerticalLayout& rhs)
// {
//   //An exception safe implementation is
//   FWCompactVerticalLayout temp(rhs);
//   swap(rhs);
//
//   return *this;
// }

//
// member functions
//
//______________________________________________________________________________
void FWCompactVerticalLayout::Layout()
{
   // Make a vertical layout of all frames in the list.
   
   TGFrameElement *ptr;
   TGLayoutHints  *layout;
   Int_t    nb_expand = 0;
   Int_t    top, bottom;
   ULong_t  hints;
   UInt_t   extra_space = 0;
   Int_t    exp = 0;
   Int_t    exp_max = 0;
   Int_t    remain;
   Int_t    x = 0, y = 0;
   Int_t    bw = fMain->GetBorderWidth();
   TGDimension size(0,0), csize(0,0);
   TGDimension msize = fMain->GetSize();
   UInt_t pad_left, pad_top, pad_right, pad_bottom;
   Int_t size_expand=0, esize_expand=0, rem_expand=0, tmp_expand = 0;
   
   if (!fList) return;
   
   fModified = kFALSE;
   
   bottom = msize.fHeight - (top = bw);
   remain = msize.fHeight - (bw << 1);
   
   std::vector<int> expandSizes;
   expandSizes.reserve(fList->GetSize());
   TIter next(fList);
   while ((ptr = (TGFrameElement *) next())) {
      if (ptr->fState & kIsVisible) {
         layout = ptr->fLayout;
         size = ptr->fFrame->GetDefaultSize();
         size.fHeight += layout->GetPadTop() + layout->GetPadBottom();
         hints = layout->GetLayoutHints();
         if ((hints & kLHintsExpandY) || (hints & kLHintsCenterY)) {
            nb_expand++;
            exp += size.fHeight;
            if (hints & kLHintsExpandY) { 
               exp_max = 0;
               expandSizes.push_back(size.fHeight);
            }
            else exp_max = TMath::Max(exp_max, (Int_t)size.fHeight);
         } else {
            remain -= size.fHeight;
            if (remain < 0)
               remain = 0;
         }
      }
   }
   
   if (nb_expand) {
      size_expand = remain/nb_expand;
      
      if (size_expand < exp_max)
         esize_expand = (remain - exp)/nb_expand;
      rem_expand = remain % nb_expand;
   }
   
   std::sort(expandSizes.begin(), expandSizes.end(),std::less<int>());
   //Now see if expanded widgets exceed their max sizes
   for(std::vector<int>::iterator it = expandSizes.begin(), itEnd = expandSizes.end();
       it != itEnd;
       ++it) {
      if(*it > size_expand) {
         break;
      }
      remain -= *it;
      --nb_expand;
      if(remain<0) {remain=0;}
      if(nb_expand>0) {
         size_expand = remain/nb_expand;
      } else {
         size_expand=msize.fHeight - (bw << 1);
      }
   }
   
   next.Reset();
   while ((ptr = (TGFrameElement *) next())) {
      if (ptr->fState & kIsVisible) {
         hints = (layout = ptr->fLayout)->GetLayoutHints();
         csize      = ptr->fFrame->GetDefaultSize();
         pad_left   = layout->GetPadLeft();
         pad_top    = layout->GetPadTop();
         pad_right  = layout->GetPadRight();
         pad_bottom = layout->GetPadBottom();
         
         if (hints & kLHintsRight) {
            x = msize.fWidth - bw - csize.fWidth - pad_right;
         } else if (hints & kLHintsCenterX) {
            x = (msize.fWidth - (bw << 1) - csize.fWidth) >> 1;
         } else { // defaults to kLHintsLeft
            x = pad_left + bw;
         }
         
         if (hints & kLHintsExpandX) {
            size.fWidth = msize.fWidth - (bw << 1) - pad_left - pad_right;
            x = pad_left + bw;
         } else {
            size.fWidth = csize.fWidth;
         }
         
         if (hints & kLHintsExpandY) {
            if (size_expand >= exp_max)
               if(static_cast<int>(csize.fHeight) > size_expand) {
                  size.fHeight = size_expand - pad_top - pad_bottom;
               } else {
                  size.fHeight = csize.fHeight;
               }
            else
               size.fHeight = csize.fHeight + esize_expand;
            
            tmp_expand += rem_expand;
            if (tmp_expand >= nb_expand) {
               size.fHeight++;
               tmp_expand -= nb_expand;
            }
         } else {
            size.fHeight = csize.fHeight;
            if (hints & kLHintsCenterY) {
               if (size_expand >= exp_max) {
                  extra_space = (size_expand - pad_top - pad_bottom - size.fHeight) >> 1;
               } else {
                  extra_space = esize_expand >> 1;
               }
               top += extra_space;
            }
         }
         
         if (hints & kLHintsBottom) {
            y = bottom - size.fHeight - pad_bottom;
            bottom -= size.fHeight + pad_top + pad_bottom;
         } else { // kLHintsTop by default
            y = top + pad_top;
            top += size.fHeight + pad_top + pad_bottom;
         }
         
         if (hints & kLHintsCenterY)
            top += extra_space;
         
         if (size.fWidth > 32768)
            size.fWidth = 1;
         if (size.fHeight > 32768)
            size.fHeight = 1;
         ptr->fFrame->MoveResize(x, y, size.fWidth, size.fHeight);
         
         fModified = fModified || (ptr->fFrame->GetX() != x) || 
         (ptr->fFrame->GetY() != y) ||
         (ptr->fFrame->GetWidth() != size.fWidth) ||
         (ptr->fFrame->GetHeight() != size.fHeight);
      }
   }

}

//______________________________________________________________________________
TGDimension FWCompactVerticalLayout::GetDefaultSize() const
{
   // Return default dimension of the vertical layout.
   
   TGFrameElement *ptr;
   TGDimension     size(0,0), msize = fMain->GetSize(), csize;
   UInt_t options = fMain->GetOptions();
   
   if ((options & kFixedWidth) && (options & kFixedHeight))
      return msize;
   
   TIter next(fList);
   while ((ptr = (TGFrameElement *) next())) {
      if (ptr->fState & kIsVisible) {
         csize = ptr->fFrame->GetDefaultSize();
         size.fWidth = TMath::Max(size.fWidth, csize.fWidth + ptr->fLayout->GetPadLeft() +
                                  ptr->fLayout->GetPadRight());
         size.fHeight += csize.fHeight + ptr->fLayout->GetPadTop() +
         ptr->fLayout->GetPadBottom();
      }
   }
   
   size.fWidth  += fMain->GetBorderWidth() << 1;
   size.fHeight += fMain->GetBorderWidth() << 1;
   
   if (options & kFixedWidth)  size.fWidth  = msize.fWidth;
   if (options & kFixedHeight) size.fHeight = msize.fHeight;
   
   return size;
}

//
// const member functions
//

//
// static member functions
//