src/xrc/xh_sizer.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/xrc/xh_sizer.cpp
   3 // Purpose:     XRC resource for wxBoxSizer
   4 // Author:      Vaclav Slavik
   5 // Created:     2000/03/21
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2000 Vaclav Slavik
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 // For compilers that support precompilation, includes "wx.h".
  12 #include "wx/wxprec.h"
  13
  14 #ifdef __BORLANDC__
  15     #pragma hdrstop
  16 #endif
  17
  18 #if wxUSE_XRC
  19
  20 #include "wx/xrc/xh_sizer.h"
  21 #include "wx/sizer.h"
  22 #include "wx/gbsizer.h"
  23 #include "wx/log.h"
  24 #include "wx/statbox.h"
  25 #include "wx/notebook.h"
  26 #include "wx/panel.h"
  27 #include "wx/tokenzr.h"
  28
  29
  30 //-----------------------------------------------------------------------------
  31 // wxSizerXmlHandler
  32 //-----------------------------------------------------------------------------
  33
  34 IMPLEMENT_DYNAMIC_CLASS(wxSizerXmlHandler, wxXmlResourceHandler)
  35
  36 wxSizerXmlHandler::wxSizerXmlHandler()
  37     : wxXmlResourceHandler(),
  38       m_isInside(false),
  39       m_isGBS(false),
  40       m_parentSizer(NULL)
  41 {
  42     XRC_ADD_STYLE(wxHORIZONTAL);
  43     XRC_ADD_STYLE(wxVERTICAL);
  44
  45     // and flags
  46     XRC_ADD_STYLE(wxLEFT);
  47     XRC_ADD_STYLE(wxRIGHT);
  48     XRC_ADD_STYLE(wxTOP);
  49     XRC_ADD_STYLE(wxBOTTOM);
  50     XRC_ADD_STYLE(wxNORTH);
  51     XRC_ADD_STYLE(wxSOUTH);
  52     XRC_ADD_STYLE(wxEAST);
  53     XRC_ADD_STYLE(wxWEST);
  54     XRC_ADD_STYLE(wxALL);
  55
  56     XRC_ADD_STYLE(wxGROW);
  57     XRC_ADD_STYLE(wxEXPAND);
  58     XRC_ADD_STYLE(wxSHAPED);
  59     XRC_ADD_STYLE(wxSTRETCH_NOT);
  60
  61     XRC_ADD_STYLE(wxALIGN_CENTER);
  62     XRC_ADD_STYLE(wxALIGN_CENTRE);
  63     XRC_ADD_STYLE(wxALIGN_LEFT);
  64     XRC_ADD_STYLE(wxALIGN_TOP);
  65     XRC_ADD_STYLE(wxALIGN_RIGHT);
  66     XRC_ADD_STYLE(wxALIGN_BOTTOM);
  67     XRC_ADD_STYLE(wxALIGN_CENTER_HORIZONTAL);
  68     XRC_ADD_STYLE(wxALIGN_CENTRE_HORIZONTAL);
  69     XRC_ADD_STYLE(wxALIGN_CENTER_VERTICAL);
  70     XRC_ADD_STYLE(wxALIGN_CENTRE_VERTICAL);
  71
  72     XRC_ADD_STYLE(wxADJUST_MINSIZE);
  73     XRC_ADD_STYLE(wxFIXED_MINSIZE);
  74 }
  75
  76
  77
  78 bool wxSizerXmlHandler::CanHandle(wxXmlNode *node)
  79 {
  80     return ( (!m_isInside && IsSizerNode(node)) ||
  81              (m_isInside && IsOfClass(node, wxT("sizeritem"))) ||
  82              (m_isInside && IsOfClass(node, wxT("spacer")))
  83         );
  84 }
  85
  86
  87 wxObject* wxSizerXmlHandler::DoCreateResource()
  88 {
  89     if (m_class == wxT("sizeritem"))
  90         return Handle_sizeritem();
  91
  92     else if (m_class == wxT("spacer"))
  93         return Handle_spacer();
  94
  95     else
  96         return Handle_sizer();
  97 }
  98
  99
 100
 101
 102 bool wxSizerXmlHandler::IsSizerNode(wxXmlNode *node)
 103 {
 104     return (IsOfClass(node, wxT("wxBoxSizer"))) ||
 105            (IsOfClass(node, wxT("wxStaticBoxSizer"))) ||
 106            (IsOfClass(node, wxT("wxGridSizer"))) ||
 107            (IsOfClass(node, wxT("wxFlexGridSizer"))) ||
 108            (IsOfClass(node, wxT("wxGridBagSizer")));
 109 }
 110
 111
 112 wxObject* wxSizerXmlHandler::Handle_sizeritem()
 113 {
 114     // find the item to be managed by this sizeritem
 115     wxXmlNode *n = GetParamNode(wxT("object"));
 116     if ( !n )
 117         n = GetParamNode(wxT("object_ref"));
 118
 119     // did we find one?
 120     if (n)
 121     {
 122         // create a sizer item for it
 123         wxSizerItem* sitem = MakeSizerItem();
 124
 125         // now fetch the item to be managed
 126         bool old_gbs = m_isGBS;
 127         bool old_ins = m_isInside;
 128         wxSizer *old_par = m_parentSizer;
 129         m_isInside = false;
 130         if (!IsSizerNode(n)) m_parentSizer = NULL;
 131         wxObject *item = CreateResFromNode(n, m_parent, NULL);
 132         m_isInside = old_ins;
 133         m_parentSizer = old_par;
 134         m_isGBS = old_gbs;
 135
 136         // and figure out what type it is
 137         wxSizer *sizer = wxDynamicCast(item, wxSizer);
 138         wxWindow *wnd = wxDynamicCast(item, wxWindow);
 139
 140         if (sizer)
 141             sitem->SetSizer(sizer);
 142         else if (wnd)
 143             sitem->SetWindow(wnd);
 144         else
 145             wxLogError(wxT("Error in resource."));
 146
 147         // finally, set other wxSizerItem attributes
 148         SetSizerItemAttributes(sitem);
 149
 150         AddSizerItem(sitem);
 151         return item;
 152     }
 153     else /*n == NULL*/
 154     {
 155         wxLogError(wxT("Error in resource: no window/sizer/spacer within sizeritem object."));
 156         return NULL;
 157     }
 158 }
 159
 160
 161 wxObject* wxSizerXmlHandler::Handle_spacer()
 162 {
 163     wxCHECK_MSG(m_parentSizer, NULL, wxT("Incorrect syntax of XRC resource: spacer not within sizer!"));
 164
 165     wxSizerItem* sitem = MakeSizerItem();
 166     SetSizerItemAttributes(sitem);
 167     sitem->SetSpacer(GetSize());
 168     AddSizerItem(sitem);
 169     return NULL;
 170 }
 171
 172
 173 wxObject* wxSizerXmlHandler::Handle_sizer()
 174 {
 175     wxSizer *sizer = NULL;
 176
 177     wxXmlNode *parentNode = m_node->GetParent();
 178
 179     wxCHECK_MSG(m_parentSizer != NULL ||
 180                 (parentNode && parentNode->GetType() == wxXML_ELEMENT_NODE &&
 181                  m_parentAsWindow != NULL &&
 182                  (m_parentAsWindow->IsKindOf(CLASSINFO(wxPanel)) ||
 183                   m_parentAsWindow->IsKindOf(CLASSINFO(wxFrame)) ||
 184                   m_parentAsWindow->IsKindOf(CLASSINFO(wxDialog)))
 185                     ), NULL,
 186                 wxT("Incorrect use of sizer: parent is not 'wxDialog', 'wxFrame' or 'wxPanel'."));
 187
 188     if (m_class == wxT("wxBoxSizer"))
 189         sizer = Handle_wxBoxSizer();
 190
 191     else if (m_class == wxT("wxStaticBoxSizer"))
 192         sizer = Handle_wxStaticBoxSizer();
 193
 194     else if (m_class == wxT("wxGridSizer"))
 195         sizer = Handle_wxGridSizer();
 196
 197     else if (m_class == wxT("wxFlexGridSizer"))
 198         sizer = Handle_wxFlexGridSizer();
 199
 200     else if (m_class == wxT("wxGridBagSizer"))
 201         sizer = Handle_wxGridBagSizer();
 202
 203     if ( !sizer )
 204     {
 205         wxLogError(_T("Failed to create size of class \"%s\""), m_class.c_str());
 206         return NULL;
 207     }
 208
 209     wxSize minsize = GetSize(wxT("minsize"));
 210     if (!(minsize == wxDefaultSize))
 211         sizer->SetMinSize(minsize);
 212
 213     // save state
 214     wxSizer *old_par = m_parentSizer;
 215     bool old_ins = m_isInside;
 216
 217     // set new state
 218     m_parentSizer = sizer;
 219     m_isInside = true;
 220     m_isGBS = (m_class == wxT("wxGridBagSizer"));
 221
 222     CreateChildren(m_parent, true/*only this handler*/);
 223
 224     // restore state
 225     m_isInside = old_ins;
 226     m_parentSizer = old_par;
 227
 228     if (m_parentSizer == NULL) // setup window:
 229     {
 230         m_parentAsWindow->SetSizer(sizer);
 231
 232         wxXmlNode *nd = m_node;
 233         m_node = parentNode;
 234         if (GetSize() == wxDefaultSize)
 235             sizer->Fit(m_parentAsWindow);
 236         m_node = nd;
 237
 238         if (m_parentAsWindow->GetWindowStyle() & (wxMAXIMIZE_BOX | wxRESIZE_BORDER))
 239             sizer->SetSizeHints(m_parentAsWindow);
 240     }
 241
 242     return sizer;
 243 }
 244
 245
 246 wxSizer*  wxSizerXmlHandler::Handle_wxBoxSizer()
 247 {
 248     return new wxBoxSizer(GetStyle(wxT("orient"), wxHORIZONTAL));
 249 }
 250
 251 wxSizer*  wxSizerXmlHandler::Handle_wxStaticBoxSizer()
 252 {
 253     return new wxStaticBoxSizer(
 254             new wxStaticBox(m_parentAsWindow,
 255                             GetID(),
 256                             GetText(wxT("label")),
 257                             wxDefaultPosition, wxDefaultSize,
 258                             0/*style*/,
 259                             GetName()),
 260             GetStyle(wxT("orient"), wxHORIZONTAL));
 261 }
 262
 263 wxSizer*  wxSizerXmlHandler::Handle_wxGridSizer()
 264 {
 265     return new wxGridSizer(GetLong(wxT("rows")), GetLong(wxT("cols")),
 266                            GetDimension(wxT("vgap")), GetDimension(wxT("hgap")));
 267 }
 268
 269
 270 wxSizer*  wxSizerXmlHandler::Handle_wxFlexGridSizer()
 271 {
 272     wxFlexGridSizer *sizer =
 273         new wxFlexGridSizer(GetLong(wxT("rows")), GetLong(wxT("cols")),
 274                             GetDimension(wxT("vgap")), GetDimension(wxT("hgap")));
 275     SetGrowables(sizer, wxT("growablerows"), true);
 276     SetGrowables(sizer, wxT("growablecols"), false);
 277     return sizer;
 278 }
 279
 280
 281 wxSizer*  wxSizerXmlHandler::Handle_wxGridBagSizer()
 282 {
 283     wxGridBagSizer *sizer =
 284         new wxGridBagSizer(GetDimension(wxT("vgap")), GetDimension(wxT("hgap")));
 285     SetGrowables(sizer, wxT("growablerows"), true);
 286     SetGrowables(sizer, wxT("growablecols"), false);
 287     return sizer;
 288 }
 289
 290
 291
 292
 293 void wxSizerXmlHandler::SetGrowables(wxFlexGridSizer* sizer,
 294                                      const wxChar* param,
 295                                      bool rows)
 296 {
 297     wxStringTokenizer tkn;
 298     unsigned long l;
 299     tkn.SetString(GetParamValue(param), wxT(","));
 300     while (tkn.HasMoreTokens())
 301     {
 302         if (!tkn.GetNextToken().ToULong(&l))
 303             wxLogError(wxT("growable[rows|cols] must be comma-separated list of row numbers"));
 304         else {
 305             if (rows)
 306                 sizer->AddGrowableRow(l);
 307             else
 308                 sizer->AddGrowableCol(l);
 309         }
 310     }
 311 }
 312
 313
 314 wxGBPosition wxSizerXmlHandler::GetGBPos(const wxString& param)
 315 {
 316     wxSize sz = GetSize(param);
 317     if (sz.x < 0) sz.x = 0;
 318     if (sz.y < 0) sz.y = 0;
 319     return wxGBPosition(sz.x, sz.y);
 320 }
 321
 322 wxGBSpan wxSizerXmlHandler::GetGBSpan(const wxString& param)
 323 {
 324     wxSize sz = GetSize(param);
 325     if (sz.x < 1) sz.x = 1;
 326     if (sz.y < 1) sz.y = 1;
 327     return wxGBSpan(sz.x, sz.y);
 328 }
 329
 330
 331
 332 wxSizerItem* wxSizerXmlHandler::MakeSizerItem()
 333 {
 334     if (m_isGBS)
 335         return new wxGBSizerItem();
 336     else
 337         return new wxSizerItem();
 338 }
 339
 340 void wxSizerXmlHandler::SetSizerItemAttributes(wxSizerItem* sitem)
 341 {
 342     sitem->SetProportion(GetLong(wxT("option")));  // Should this check for "proportion" too?
 343     sitem->SetFlag(GetStyle(wxT("flag")));
 344     sitem->SetBorder(GetDimension(wxT("border")));
 345     wxSize sz = GetSize(wxT("minsize"));
 346     if (!(sz == wxDefaultSize))
 347         sitem->SetMinSize(sz);
 348     sz = GetSize(wxT("ratio"));
 349     if (!(sz == wxDefaultSize))
 350         sitem->SetRatio(sz);
 351
 352     if (m_isGBS)
 353     {
 354         wxGBSizerItem* gbsitem = (wxGBSizerItem*)sitem;
 355         gbsitem->SetPos(GetGBPos(wxT("cellpos")));
 356         gbsitem->SetSpan(GetGBSpan(wxT("cellspan")));
 357     }
 358 }
 359
 360 void wxSizerXmlHandler::AddSizerItem(wxSizerItem* sitem)
 361 {
 362     if (m_isGBS)
 363         ((wxGridBagSizer*)m_parentSizer)->Add((wxGBSizerItem*)sitem);
 364     else
 365         m_parentSizer->Add(sitem);
 366 }
 367
 368
 369
 370 //-----------------------------------------------------------------------------
 371 // wxStdDialogButtonSizerXmlHandler
 372 //-----------------------------------------------------------------------------
 373
 374 IMPLEMENT_DYNAMIC_CLASS(wxStdDialogButtonSizerXmlHandler, wxXmlResourceHandler)
 375
 376 wxStdDialogButtonSizerXmlHandler::wxStdDialogButtonSizerXmlHandler()
 377     : m_isInside(false), m_parentSizer(NULL)
 378 {
 379 }
 380
 381 wxObject *wxStdDialogButtonSizerXmlHandler::DoCreateResource()
 382 {
 383     if (m_class == wxT("wxStdDialogButtonSizer"))
 384     {
 385         wxASSERT( !m_parentSizer );
 386
 387         wxSizer *s = m_parentSizer = new wxStdDialogButtonSizer;
 388         m_isInside = true;
 389
 390         CreateChildren(m_parent, true/*only this handler*/);
 391
 392         m_parentSizer->Realize();
 393
 394         m_isInside = false;
 395         m_parentSizer = NULL;
 396
 397         return s;
 398     }
 399     else // m_class == "button"
 400     {
 401         wxASSERT( m_parentSizer );
 402
 403         // find the item to be managed by this sizeritem
 404         wxXmlNode *n = GetParamNode(wxT("object"));
 405         if ( !n )
 406             n = GetParamNode(wxT("object_ref"));
 407
 408         // did we find one?
 409         if (n)
 410         {
 411             wxObject *item = CreateResFromNode(n, m_parent, NULL);
 412             wxButton *button = wxDynamicCast(item, wxButton);
 413
 414             if (button)
 415                 m_parentSizer->AddButton(button);
 416             else
 417                 wxLogError(wxT("Error in resource - expected button."));
 418
 419             return item;
 420         }
 421         else /*n == NULL*/
 422         {
 423             wxLogError(wxT("Error in resource: no button within wxStdDialogButtonSizer."));
 424             return NULL;
 425         }
 426     }
 427 }
 428
 429 bool wxStdDialogButtonSizerXmlHandler::CanHandle(wxXmlNode *node)
 430 {
 431     return (!m_isInside && IsOfClass(node, wxT("wxStdDialogButtonSizer"))) ||
 432            (m_isInside && IsOfClass(node, wxT("button")));
 433 }
 434
 435 #endif // wxUSE_XRC