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
  22 #ifndef WX_PRECOMP
  23     #include "wx/log.h"
  24     #include "wx/panel.h"
  25     #include "wx/statbox.h"
  26     #include "wx/sizer.h"
  27     #include "wx/frame.h"
  28     #include "wx/dialog.h"
  29     #include "wx/button.h"
  30     #include "wx/scrolwin.h"
  31 #endif
  32
  33 #include "wx/gbsizer.h"
  34 #include "wx/wrapsizer.h"
  35 #include "wx/notebook.h"
  36 #include "wx/tokenzr.h"
  37
  38
  39 //-----------------------------------------------------------------------------
  40 // wxSizerXmlHandler
  41 //-----------------------------------------------------------------------------
  42
  43 IMPLEMENT_DYNAMIC_CLASS(wxSizerXmlHandler, wxXmlResourceHandler)
  44
  45 wxSizerXmlHandler::wxSizerXmlHandler()
  46                   :wxXmlResourceHandler(),
  47                    m_isInside(false),
  48                    m_isGBS(false),
  49                    m_parentSizer(NULL)
  50 {
  51     XRC_ADD_STYLE(wxHORIZONTAL);
  52     XRC_ADD_STYLE(wxVERTICAL);
  53
  54     // and flags
  55     XRC_ADD_STYLE(wxLEFT);
  56     XRC_ADD_STYLE(wxRIGHT);
  57     XRC_ADD_STYLE(wxTOP);
  58     XRC_ADD_STYLE(wxBOTTOM);
  59     XRC_ADD_STYLE(wxNORTH);
  60     XRC_ADD_STYLE(wxSOUTH);
  61     XRC_ADD_STYLE(wxEAST);
  62     XRC_ADD_STYLE(wxWEST);
  63     XRC_ADD_STYLE(wxALL);
  64
  65     XRC_ADD_STYLE(wxGROW);
  66     XRC_ADD_STYLE(wxEXPAND);
  67     XRC_ADD_STYLE(wxSHAPED);
  68     XRC_ADD_STYLE(wxSTRETCH_NOT);
  69
  70     XRC_ADD_STYLE(wxALIGN_CENTER);
  71     XRC_ADD_STYLE(wxALIGN_CENTRE);
  72     XRC_ADD_STYLE(wxALIGN_LEFT);
  73     XRC_ADD_STYLE(wxALIGN_TOP);
  74     XRC_ADD_STYLE(wxALIGN_RIGHT);
  75     XRC_ADD_STYLE(wxALIGN_BOTTOM);
  76     XRC_ADD_STYLE(wxALIGN_CENTER_HORIZONTAL);
  77     XRC_ADD_STYLE(wxALIGN_CENTRE_HORIZONTAL);
  78     XRC_ADD_STYLE(wxALIGN_CENTER_VERTICAL);
  79     XRC_ADD_STYLE(wxALIGN_CENTRE_VERTICAL);
  80
  81     XRC_ADD_STYLE(wxFIXED_MINSIZE);
  82     XRC_ADD_STYLE(wxRESERVE_SPACE_EVEN_IF_HIDDEN);
  83
  84     // this flag doesn't do anything any more but we can just ignore its
  85     // occurrences in the old resource files instead of raising a fuss because
  86     // of it
  87     AddStyle("wxADJUST_MINSIZE", 0);
  88
  89     // wxWrapSizer-specific flags
  90     XRC_ADD_STYLE(wxEXTEND_LAST_ON_EACH_LINE);
  91     XRC_ADD_STYLE(wxREMOVE_LEADING_SPACES);
  92 }
  93
  94
  95
  96 bool wxSizerXmlHandler::CanHandle(wxXmlNode *node)
  97 {
  98     return ( (!m_isInside && IsSizerNode(node)) ||
  99              (m_isInside && IsOfClass(node, wxT("sizeritem"))) ||
 100              (m_isInside && IsOfClass(node, wxT("spacer")))
 101         );
 102 }
 103
 104
 105 wxObject* wxSizerXmlHandler::DoCreateResource()
 106 {
 107     if (m_class == wxT("sizeritem"))
 108         return Handle_sizeritem();
 109
 110     else if (m_class == wxT("spacer"))
 111         return Handle_spacer();
 112
 113     else
 114         return Handle_sizer();
 115 }
 116
 117
 118 wxSizer* wxSizerXmlHandler::DoCreateSizer(const wxString& name)
 119 {
 120     if (name == wxT("wxBoxSizer"))
 121         return Handle_wxBoxSizer();
 122 #if wxUSE_STATBOX
 123     else if (name == wxT("wxStaticBoxSizer"))
 124         return Handle_wxStaticBoxSizer();
 125 #endif
 126     else if (name == wxT("wxGridSizer"))
 127     {
 128         if ( !ValidateGridSizerChildren() )
 129             return NULL;
 130         return Handle_wxGridSizer();
 131     }
 132     else if (name == wxT("wxFlexGridSizer"))
 133     {
 134         return Handle_wxFlexGridSizer();
 135     }
 136     else if (name == wxT("wxGridBagSizer"))
 137     {
 138         return Handle_wxGridBagSizer();
 139     }
 140     else if (name == wxT("wxWrapSizer"))
 141     {
 142         return Handle_wxWrapSizer();
 143     }
 144
 145     ReportError(wxString::Format("unknown sizer class \"%s\"", name));
 146     return NULL;
 147 }
 148
 149
 150
 151 bool wxSizerXmlHandler::IsSizerNode(wxXmlNode *node) const
 152 {
 153     return (IsOfClass(node, wxT("wxBoxSizer"))) ||
 154            (IsOfClass(node, wxT("wxStaticBoxSizer"))) ||
 155            (IsOfClass(node, wxT("wxGridSizer"))) ||
 156            (IsOfClass(node, wxT("wxFlexGridSizer"))) ||
 157            (IsOfClass(node, wxT("wxGridBagSizer"))) ||
 158            (IsOfClass(node, wxT("wxWrapSizer")));
 159 }
 160
 161
 162 wxObject* wxSizerXmlHandler::Handle_sizeritem()
 163 {
 164     // find the item to be managed by this sizeritem
 165     wxXmlNode *n = GetParamNode(wxT("object"));
 166     if ( !n )
 167         n = GetParamNode(wxT("object_ref"));
 168
 169     // did we find one?
 170     if (n)
 171     {
 172         // create a sizer item for it
 173         wxSizerItem* sitem = MakeSizerItem();
 174
 175         // now fetch the item to be managed
 176         bool old_gbs = m_isGBS;
 177         bool old_ins = m_isInside;
 178         wxSizer *old_par = m_parentSizer;
 179         m_isInside = false;
 180         if (!IsSizerNode(n)) m_parentSizer = NULL;
 181         wxObject *item = CreateResFromNode(n, m_parent, NULL);
 182         m_isInside = old_ins;
 183         m_parentSizer = old_par;
 184         m_isGBS = old_gbs;
 185
 186         // and figure out what type it is
 187         wxSizer *sizer = wxDynamicCast(item, wxSizer);
 188         wxWindow *wnd = wxDynamicCast(item, wxWindow);
 189
 190         if (sizer)
 191             sitem->AssignSizer(sizer);
 192         else if (wnd)
 193             sitem->AssignWindow(wnd);
 194         else
 195             ReportError(n, "unexpected item in sizer");
 196
 197         // finally, set other wxSizerItem attributes
 198         SetSizerItemAttributes(sitem);
 199
 200         AddSizerItem(sitem);
 201         return item;
 202     }
 203     else /*n == NULL*/
 204     {
 205         ReportError("no window/sizer/spacer within sizeritem object");
 206         return NULL;
 207     }
 208 }
 209
 210
 211 wxObject* wxSizerXmlHandler::Handle_spacer()
 212 {
 213     if ( !m_parentSizer )
 214     {
 215         ReportError("spacer only allowed inside a sizer");
 216         return NULL;
 217     }
 218
 219     wxSizerItem* sitem = MakeSizerItem();
 220     SetSizerItemAttributes(sitem);
 221     sitem->AssignSpacer(GetSize());
 222     AddSizerItem(sitem);
 223     return NULL;
 224 }
 225
 226
 227 wxObject* wxSizerXmlHandler::Handle_sizer()
 228 {
 229     wxXmlNode *parentNode = m_node->GetParent();
 230
 231     if ( !m_parentSizer &&
 232             (!parentNode || parentNode->GetType() != wxXML_ELEMENT_NODE ||
 233              !m_parentAsWindow) )
 234     {
 235         ReportError("sizer must have a window parent");
 236         return NULL;
 237     }
 238
 239     // Create the sizer of the appropriate class.
 240     wxSizer * const sizer = DoCreateSizer(m_class);
 241
 242     // creation of sizer failed for some (already reported) reason, so exit:
 243     if ( !sizer )
 244         return NULL;
 245
 246     wxSize minsize = GetSize(wxT("minsize"));
 247     if (!(minsize == wxDefaultSize))
 248         sizer->SetMinSize(minsize);
 249
 250     // save state
 251     wxSizer *old_par = m_parentSizer;
 252     bool old_ins = m_isInside;
 253
 254     // set new state
 255     m_parentSizer = sizer;
 256     m_isInside = true;
 257     m_isGBS = (m_class == wxT("wxGridBagSizer"));
 258
 259     wxObject* parent = m_parent;
 260 #if wxUSE_STATBOX
 261     // wxStaticBoxSizer's child controls should be parented by the box itself,
 262     // not its parent.
 263     wxStaticBoxSizer* const stsizer = wxDynamicCast(sizer, wxStaticBoxSizer);
 264     if ( stsizer )
 265         parent = stsizer->GetStaticBox();
 266 #endif // wxUSE_STATBOX
 267
 268     CreateChildren(parent, true/*only this handler*/);
 269
 270     // set growable rows and cols for sizers which support this
 271     if ( wxFlexGridSizer *flexsizer = wxDynamicCast(sizer, wxFlexGridSizer) )
 272     {
 273         SetGrowables(flexsizer, wxT("growablerows"), true);
 274         SetGrowables(flexsizer, wxT("growablecols"), false);
 275     }
 276
 277     // restore state
 278     m_isInside = old_ins;
 279     m_parentSizer = old_par;
 280
 281     if (m_parentSizer == NULL) // setup window:
 282     {
 283         m_parentAsWindow->SetSizer(sizer);
 284
 285         wxXmlNode *nd = m_node;
 286         m_node = parentNode;
 287         if (GetSize() == wxDefaultSize)
 288         {
 289             if ( wxDynamicCast(m_parentAsWindow, wxScrolledWindow) != NULL )
 290             {
 291                 sizer->FitInside(m_parentAsWindow);
 292             }
 293             else
 294             {
 295                 sizer->Fit(m_parentAsWindow);
 296             }
 297         }
 298         m_node = nd;
 299
 300         if (m_parentAsWindow->IsTopLevel())
 301         {
 302             sizer->SetSizeHints(m_parentAsWindow);
 303         }
 304     }
 305
 306     return sizer;
 307 }
 308
 309
 310 wxSizer*  wxSizerXmlHandler::Handle_wxBoxSizer()
 311 {
 312     return new wxBoxSizer(GetStyle(wxT("orient"), wxHORIZONTAL));
 313 }
 314
 315 #if wxUSE_STATBOX
 316 wxSizer*  wxSizerXmlHandler::Handle_wxStaticBoxSizer()
 317 {
 318     return new wxStaticBoxSizer(
 319             new wxStaticBox(m_parentAsWindow,
 320                             GetID(),
 321                             GetText(wxT("label")),
 322                             wxDefaultPosition, wxDefaultSize,
 323                             0/*style*/,
 324                             GetName()),
 325             GetStyle(wxT("orient"), wxHORIZONTAL));
 326 }
 327 #endif // wxUSE_STATBOX
 328
 329 wxSizer*  wxSizerXmlHandler::Handle_wxGridSizer()
 330 {
 331     return new wxGridSizer(GetLong(wxT("rows")), GetLong(wxT("cols")),
 332                            GetDimension(wxT("vgap")), GetDimension(wxT("hgap")));
 333 }
 334
 335
 336 wxFlexGridSizer* wxSizerXmlHandler::Handle_wxFlexGridSizer()
 337 {
 338     if ( !ValidateGridSizerChildren() )
 339         return NULL;
 340     return new wxFlexGridSizer(GetLong(wxT("rows")), GetLong(wxT("cols")),
 341                                GetDimension(wxT("vgap")), GetDimension(wxT("hgap")));
 342 }
 343
 344
 345 wxGridBagSizer* wxSizerXmlHandler::Handle_wxGridBagSizer()
 346 {
 347     if ( !ValidateGridSizerChildren() )
 348         return NULL;
 349     return new wxGridBagSizer(GetDimension(wxT("vgap")), GetDimension(wxT("hgap")));
 350 }
 351
 352 wxSizer*  wxSizerXmlHandler::Handle_wxWrapSizer()
 353 {
 354     wxWrapSizer *sizer = new wxWrapSizer(GetStyle("orient"), GetStyle("flag"));
 355     return sizer;
 356 }
 357
 358
 359 bool wxSizerXmlHandler::ValidateGridSizerChildren()
 360 {
 361     int rows = GetLong("rows");
 362     int cols = GetLong("cols");
 363
 364     if  ( rows && cols )
 365     {
 366         // fixed number of cells, need to verify children count
 367         int children = 0;
 368         for ( wxXmlNode *n = m_node->GetChildren(); n; n = n->GetNext() )
 369         {
 370             if ( n->GetType() == wxXML_ELEMENT_NODE &&
 371                  (n->GetName() == "object" || n->GetName() == "object_ref") )
 372             {
 373                 children++;
 374             }
 375         }
 376
 377         if ( children > rows * cols )
 378         {
 379             ReportError
 380             (
 381                 wxString::Format
 382                 (
 383                     "too many children in grid sizer: %d > %d x %d"
 384                     " (consider omitting the number of rows or columns)",
 385                     children,
 386                     cols,
 387                     rows
 388                 )
 389             );
 390             return false;
 391         }
 392     }
 393
 394     return true;
 395 }
 396
 397
 398 void wxSizerXmlHandler::SetGrowables(wxFlexGridSizer* sizer,
 399                                      const wxChar* param,
 400                                      bool rows)
 401 {
 402     int nrows, ncols;
 403     sizer->CalcRowsCols(nrows, ncols);
 404     const int nslots = rows ? nrows : ncols;
 405
 406     wxStringTokenizer tkn;
 407     tkn.SetString(GetParamValue(param), wxT(","));
 408
 409     while (tkn.HasMoreTokens())
 410     {
 411         unsigned long l;
 412         if (!tkn.GetNextToken().ToULong(&l))
 413         {
 414             ReportParamError
 415             (
 416                 param,
 417                 "value must be comma-separated list of row numbers"
 418             );
 419             break;
 420         }
 421
 422         if ( (int)l >= nslots )
 423         {
 424             ReportParamError
 425             (
 426                 param,
 427                 wxString::Format
 428                 (
 429                     "invalid %s index %d: must be less than %d",
 430                     rows ? "row" : "column",
 431                     l,
 432                     nslots
 433                 )
 434             );
 435
 436             // ignore incorrect value, still try to process the rest
 437             continue;
 438         }
 439
 440         if (rows)
 441             sizer->AddGrowableRow(l);
 442         else
 443             sizer->AddGrowableCol(l);
 444     }
 445 }
 446
 447
 448 wxGBPosition wxSizerXmlHandler::GetGBPos(const wxString& param)
 449 {
 450     wxSize sz = GetSize(param);
 451     if (sz.x < 0) sz.x = 0;
 452     if (sz.y < 0) sz.y = 0;
 453     return wxGBPosition(sz.x, sz.y);
 454 }
 455
 456 wxGBSpan wxSizerXmlHandler::GetGBSpan(const wxString& param)
 457 {
 458     wxSize sz = GetSize(param);
 459     if (sz.x < 1) sz.x = 1;
 460     if (sz.y < 1) sz.y = 1;
 461     return wxGBSpan(sz.x, sz.y);
 462 }
 463
 464
 465
 466 wxSizerItem* wxSizerXmlHandler::MakeSizerItem()
 467 {
 468     if (m_isGBS)
 469         return new wxGBSizerItem();
 470     else
 471         return new wxSizerItem();
 472 }
 473
 474 void wxSizerXmlHandler::SetSizerItemAttributes(wxSizerItem* sitem)
 475 {
 476     sitem->SetProportion(GetLong(wxT("option")));  // Should this check for "proportion" too?
 477     sitem->SetFlag(GetStyle(wxT("flag")));
 478     sitem->SetBorder(GetDimension(wxT("border")));
 479     wxSize sz = GetSize(wxT("minsize"));
 480     if (!(sz == wxDefaultSize))
 481         sitem->SetMinSize(sz);
 482     sz = GetSize(wxT("ratio"));
 483     if (!(sz == wxDefaultSize))
 484         sitem->SetRatio(sz);
 485
 486     if (m_isGBS)
 487     {
 488         wxGBSizerItem* gbsitem = (wxGBSizerItem*)sitem;
 489         gbsitem->SetPos(GetGBPos(wxT("cellpos")));
 490         gbsitem->SetSpan(GetGBSpan(wxT("cellspan")));
 491     }
 492
 493     // record the id of the item, if any, for use by XRCSIZERITEM()
 494     sitem->SetId(GetID());
 495 }
 496
 497 void wxSizerXmlHandler::AddSizerItem(wxSizerItem* sitem)
 498 {
 499     if (m_isGBS)
 500         ((wxGridBagSizer*)m_parentSizer)->Add((wxGBSizerItem*)sitem);
 501     else
 502         m_parentSizer->Add(sitem);
 503 }
 504
 505
 506
 507 //-----------------------------------------------------------------------------
 508 // wxStdDialogButtonSizerXmlHandler
 509 //-----------------------------------------------------------------------------
 510 #if wxUSE_BUTTON
 511
 512 IMPLEMENT_DYNAMIC_CLASS(wxStdDialogButtonSizerXmlHandler, wxXmlResourceHandler)
 513
 514 wxStdDialogButtonSizerXmlHandler::wxStdDialogButtonSizerXmlHandler()
 515     : m_isInside(false), m_parentSizer(NULL)
 516 {
 517 }
 518
 519 wxObject *wxStdDialogButtonSizerXmlHandler::DoCreateResource()
 520 {
 521     if (m_class == wxT("wxStdDialogButtonSizer"))
 522     {
 523         wxASSERT( !m_parentSizer );
 524
 525         wxSizer *s = m_parentSizer = new wxStdDialogButtonSizer;
 526         m_isInside = true;
 527
 528         CreateChildren(m_parent, true/*only this handler*/);
 529
 530         m_parentSizer->Realize();
 531
 532         m_isInside = false;
 533         m_parentSizer = NULL;
 534
 535         return s;
 536     }
 537     else // m_class == "button"
 538     {
 539         wxASSERT( m_parentSizer );
 540
 541         // find the item to be managed by this sizeritem
 542         wxXmlNode *n = GetParamNode(wxT("object"));
 543         if ( !n )
 544             n = GetParamNode(wxT("object_ref"));
 545
 546         // did we find one?
 547         if (n)
 548         {
 549             wxObject *item = CreateResFromNode(n, m_parent, NULL);
 550             wxButton *button = wxDynamicCast(item, wxButton);
 551
 552             if (button)
 553                 m_parentSizer->AddButton(button);
 554             else
 555                 ReportError(n, "expected wxButton");
 556
 557             return item;
 558         }
 559         else /*n == NULL*/
 560         {
 561             ReportError("no button within wxStdDialogButtonSizer");
 562             return NULL;
 563         }
 564     }
 565 }
 566
 567 bool wxStdDialogButtonSizerXmlHandler::CanHandle(wxXmlNode *node)
 568 {
 569     return (!m_isInside && IsOfClass(node, wxT("wxStdDialogButtonSizer"))) ||
 570            (m_isInside && IsOfClass(node, wxT("button")));
 571 }
 572 #endif // wxUSE_BUTTON
 573
 574 #endif // wxUSE_XRC