src/gui/game/HGroup.cpp

   1 /*
   2     Fail game engine
   3     Copyright 2007 Antoine Chavasse <a.chavasse@gmail.com>
   4
   5     This file is part of Fail.
   6
   7     Fail is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License version 3
   9     as published by the Free Software Foundation.
  10
  11     Fail is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19 #include "gui/game/HGroup.h"
  20 #include "gui/game/Theme.h"
  21 #include <vector>
  22
  23 using namespace fail;
  24 using namespace fail::gui::game;
  25
  26 HGroup::HGroup( Container* pParent_ ) :
  27         SimpleContainer( pParent_ ),
  28         m_Spacing( 2.f )
  29 {
  30 }
  31
  32 void HGroup::reLayout()
  33 {
  34         calcMinMax();
  35
  36         const math::Vector2f& minsize = getMinSize();
  37         const math::Vector2f& maxsize = getMaxSize();
  38         math::Rectf rect( getRect() );
  39
  40         if(     rect.width() < minsize.x() ||
  41                 rect.width() > maxsize.x() ||
  42                 rect.height() < minsize.y() ||
  43                 rect.height() > maxsize.y() )
  44                 m_pParent->reLayout();
  45         else
  46                 layout();
  47 }
  48
  49 void HGroup::calcMinMax()
  50 {
  51         SimpleContainer::calcMinMax();
  52
  53         bool bUnlimited = false;
  54         math::Vector2f min, max;
  55         float spacing = 0.f;
  56
  57         WidgetList::const_iterator it;
  58         for( it = m_Children.begin(); it != m_Children.end(); ++it )
  59         {
  60                 spacing += m_Spacing;
  61                 const math::Vector2f& cmin = ( *it )->getMinSize();
  62                 const math::Vector2f& cmax = ( *it )->getMaxSize();
  63
  64                 min.x() += cmin.x();
  65                 max.x() += cmax.x();
  66                 if( !cmax.x() )
  67                         bUnlimited = true;
  68
  69                 if( cmin.y() > min.y() )
  70                         min.y() = cmin.y();
  71
  72                 if( cmax.y() > max.y() )
  73                         max.y() = cmax.y();
  74         }
  75
  76         spacing -= m_Spacing;
  77         min.x() += spacing;
  78         max.x() += spacing;
  79
  80         if( max.y() && max.y() < min.y() )
  81                 max.y() = min.y();
  82
  83         if( bUnlimited )
  84                 max.x() = 0.f;
  85
  86         setMinSize( min );
  87         setMaxSize( max );
  88 }
  89
  90 enum WidgetLayoutState
  91 {
  92         s_Free,
  93         s_Min,
  94         s_Max
  95 };
  96
  97 void HGroup::layout()
  98 {
  99         WidgetList::size_type numchildren = m_Children.size();
 100
 101         const math::Rectf& r( getRect() );
 102         float FreeSpace = r.width() - m_Spacing * static_cast< float >( numchildren - 1 );
 103
 104         // Currently, all children have a weight of 1. I'll implement weighted layout
 105         // if I need it (aka if I feel like it).
 106         float TotalWeight = static_cast< float >( numchildren );
 107
 108         std::vector< WidgetLayoutState > states( numchildren );
 109         bool bMoreSpace = true;
 110         WidgetList::const_iterator it;
 111         int i;
 112
 113         // Outer loop: loop until the inner loop manage to go through all the children
 114         // without changing their layout state.
 115         do
 116         {
 117                 for( it = m_Children.begin(), i = 0; it != m_Children.end(); ++it, ++i )
 118                 {
 119                         const math::Vector2f& min = ( *it )->getMinSize();
 120                         const math::Vector2f& max = ( *it )->getMaxSize();
 121
 122                         if( states[i] == s_Free )
 123                         {
 124                                 float size = FreeSpace / TotalWeight;
 125                                 if( size < min.x() )
 126                                 {
 127                                         states[i] = s_Min;
 128                                         TotalWeight -= 1.f;
 129                                         FreeSpace -= min.x();
 130                                         bMoreSpace = false;
 131                                         break;
 132                                 }
 133
 134                                 if( max.x() && size > max.x() )
 135                                 {
 136                                         states[i] = s_Max;
 137                                         TotalWeight -= 1.f;
 138                                         FreeSpace -= max.x();
 139                                         bMoreSpace = true;
 140                                         break;
 141                                 }
 142                         }
 143                         else
 144                         {
 145                                 if( bMoreSpace && states[i] == s_Min )
 146                                 {
 147                                         TotalWeight += 1.f;
 148                                         FreeSpace += min.x();
 149                                         float size = FreeSpace / TotalWeight;
 150                                         if( size > min.x() )
 151                                         {
 152                                                 states[i] = s_Free;
 153                                                 break;
 154                                         }
 155                                         else
 156                                         {
 157                                                 TotalWeight -= 1.f;
 158                                                 FreeSpace -= min.x();
 159                                         }
 160                                 }
 161
 162                                 if( !bMoreSpace && states[i] == s_Max )
 163                                 {
 164                                         TotalWeight += 1.f;
 165                                         FreeSpace += max.x();
 166                                         float size = FreeSpace / TotalWeight;
 167                                         if( size < max.x() )
 168                                         {
 169                                                 states[i] = s_Free;
 170                                                 break;
 171                                         }
 172                                         else
 173                                         {
 174                                                 TotalWeight -= 1.f;
 175                                                 FreeSpace -= max.x();
 176                                         }
 177                                 }
 178                         }
 179                 }
 180         } while( it != m_Children.end() );
 181
 182         math::Rectf crect;
 183
 184         for( it = m_Children.begin(), i = 0; it != m_Children.end(); ++it, ++i )
 185         {
 186                 const math::Vector2f& min = ( *it )->getMinSize();
 187                 const math::Vector2f& max = ( *it )->getMaxSize();
 188
 189                 crect.height() = r.height();
 190                 if( crect.height() < min.y() )
 191                         crect.height() = min.y();
 192                 if( max.y() && crect.height() > max.y() )
 193                         crect.height() = max.y();
 194
 195                 switch( states[i] )
 196                 {
 197                         case s_Free:
 198                                 crect.width() = FreeSpace / TotalWeight;
 199                                 break;
 200
 201                         case s_Min:
 202                                 crect.width() = min.x();
 203                                 break;
 204
 205                         case s_Max:
 206                                 crect.width() = max.x();
 207                                 break;
 208                 }
 209
 210                 ( *it )->setRect( crect );
 211                 crect.left() += crect.width() + m_Spacing;
 212         }
 213
 214         SimpleContainer::layout();
 215 }