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 // Copyright:   (c) 2000 Vaclav Slavik
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #ifdef __BORLANDC__
  14     #pragma hdrstop
  15 #endif
  16
  17 #if wxUSE_XRC
  18
  19 #include "wx/xrc/xh_sizer.h"
  20
  21 #ifndef WX_PRECOMP
  22     #include "wx/log.h"
  23     #include "wx/panel.h"
  24     #include "wx/statbox.h"
  25     #include "wx/sizer.h"
  26     #include "wx/frame.h"
  27     #include "wx/dialog.h"
  28     #include "wx/button.h"
  29     #include "wx/scrolwin.h"
  30 #endif
  31
  32 #include "wx/gbsizer.h"
  33 #include "wx/wrapsizer.h"
  34 #include "wx/notebook.h"
  35 #include "wx/tokenzr.h"
  36
  37 #include "wx/xml/xml.h"
  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         SetFlexibleMode(flexsizer);
 274         SetGrowables(flexsizer, wxT("growablerows"), true);
 275         SetGrowables(flexsizer, wxT("growablecols"), false);
 276     }
 277
 278     // restore state
 279     m_isInside = old_ins;
 280     m_parentSizer = old_par;
 281
 282     if (m_parentSizer == NULL) // setup window:
 283     {
 284         m_parentAsWindow->SetSizer(sizer);
 285
 286         wxXmlNode *nd = m_node;
 287         m_node = parentNode;
 288         if (GetSize() == wxDefaultSize)
 289         {
 290             if ( wxDynamicCast(m_parentAsWindow, wxScrolledWindow) != NULL )
 291             {
 292                 sizer->FitInside(m_parentAsWindow);
 293             }
 294             else
 295             {
 296                 sizer->Fit(m_parentAsWindow);
 297             }
 298         }
 299         m_node = nd;
 300
 301         if (m_parentAsWindow->IsTopLevel())
 302         {
 303             sizer->SetSizeHints(m_parentAsWindow);
 304         }
 305     }
 306
 307     return sizer;
 308 }
 309
 310
 311 wxSizer*  wxSizerXmlHandler::Handle_wxBoxSizer()
 312 {
 313     return new wxBoxSizer(GetStyle(wxT("orient"), wxHORIZONTAL));
 314 }
 315
 316 #if wxUSE_STATBOX
 317 wxSizer*  wxSizerXmlHandler::Handle_wxStaticBoxSizer()
 318 {
 319     return new wxStaticBoxSizer(
 320             new wxStaticBox(m_parentAsWindow,
 321                             GetID(),
 322                             GetText(wxT("label")),
 323                             wxDefaultPosition, wxDefaultSize,
 324                             0/*style*/,
 325                             GetName()),
 326             GetStyle(wxT("orient"), wxHORIZONTAL));
 327 }
 328 #endif // wxUSE_STATBOX
 329
 330 wxSizer*  wxSizerXmlHandler::Handle_wxGridSizer()
 331 {
 332     return new wxGridSizer(GetLong(wxT("rows")), GetLong(wxT("cols")),
 333                            GetDimension(wxT("vgap")), GetDimension(wxT("hgap")));
 334 }
 335
 336
 337 wxFlexGridSizer* wxSizerXmlHandler::Handle_wxFlexGridSizer()
 338 {
 339     if ( !ValidateGridSizerChildren() )
 340         return NULL;
 341     return new wxFlexGridSizer(GetLong(wxT("rows")), GetLong(wxT("cols")),
 342                                GetDimension(wxT("vgap")), GetDimension(wxT("hgap")));
 343 }
 344
 345
 346 wxGridBagSizer* wxSizerXmlHandler::Handle_wxGridBagSizer()
 347 {
 348     if ( !ValidateGridSizerChildren() )
 349         return NULL;
 350     return new wxGridBagSizer(GetDimension(wxT("vgap")), GetDimension(wxT("hgap")));
 351 }
 352
 353 wxSizer*  wxSizerXmlHandler::Handle_wxWrapSizer()
 354 {
 355     wxWrapSizer *sizer = new wxWrapSizer(GetStyle("orient"), GetStyle("flag"));
 356     return sizer;
 357 }
 358
 359
 360 bool wxSizerXmlHandler::ValidateGridSizerChildren()
 361 {
 362     int rows = GetLong("rows");
 363     int cols = GetLong("cols");
 364
 365     if  ( rows && cols )
 366     {
 367         // fixed number of cells, need to verify children count
 368         int children = 0;
 369         for ( wxXmlNode *n = m_node->GetChildren(); n; n = n->GetNext() )
 370         {
 371             if ( n->GetType() == wxXML_ELEMENT_NODE &&
 372                  (n->GetName() == "object" || n->GetName() == "object_ref") )
 373             {
 374                 children++;
 375             }
 376         }
 377
 378         if ( children > rows * cols )
 379         {
 380             ReportError
 381             (
 382                 wxString::Format
 383                 (
 384                     "too many children in grid sizer: %d > %d x %d"
 385                     " (consider omitting the number of rows or columns)",
 386                     children,
 387                     cols,
 388                     rows
 389                 )
 390             );
 391             return false;
 392         }
 393     }
 394
 395     return true;
 396 }
 397
 398
 399 void wxSizerXmlHandler::SetFlexibleMode(wxFlexGridSizer* fsizer)
 400 {
 401     if (HasParam(wxT("flexibledirection")))
 402     {
 403         wxString dir = GetParamValue(wxT("flexibledirection"));
 404
 405         if (dir == wxT("wxVERTICAL"))
 406             fsizer->SetFlexibleDirection(wxVERTICAL);
 407         else if (dir == wxT("wxHORIZONTAL"))
 408             fsizer->SetFlexibleDirection(wxHORIZONTAL);
 409         else if (dir == wxT("wxBOTH"))
 410             fsizer->SetFlexibleDirection(wxBOTH);
 411         else
 412         {
 413             ReportParamError
 414             (
 415                 wxT("flexibledirection"),
 416                 wxString::Format("unknown direction \"%s\"", dir)
 417             );
 418         }
 419     }
 420
 421     if (HasParam(wxT("nonflexiblegrowmode")))
 422     {
 423         wxString mode = GetParamValue(wxT("nonflexiblegrowmode"));
 424
 425         if (mode == wxT("wxFLEX_GROWMODE_NONE"))
 426             fsizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_NONE);
 427         else if (mode == wxT("wxFLEX_GROWMODE_SPECIFIED"))
 428             fsizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
 429         else if (mode == wxT("wxFLEX_GROWMODE_ALL"))
 430             fsizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_ALL);
 431         else
 432         {
 433             ReportParamError
 434             (
 435                 wxT("nonflexiblegrowmode"),
 436                 wxString::Format("unknown grow mode \"%s\"", mode)
 437             );
 438         }
 439     }
 440 }
 441
 442
 443 void wxSizerXmlHandler::SetGrowables(wxFlexGridSizer* sizer,
 444                                      const wxChar* param,
 445                                      bool rows)
 446 {
 447     int nrows, ncols;
 448     sizer->CalcRowsCols(nrows, ncols);
 449     const int nslots = rows ? nrows : ncols;
 450
 451     wxStringTokenizer tkn;
 452     tkn.SetString(GetParamValue(param), wxT(","));
 453
 454     while (tkn.HasMoreTokens())
 455     {
 456         wxString propStr;
 457         wxString idxStr = tkn.GetNextToken().BeforeFirst(wxT(':'), &propStr);
 458
 459         unsigned long li;
 460         if (!idxStr.ToULong(&li))
 461         {
 462             ReportParamError
 463             (
 464                 param,
 465                 "value must be a comma-separated list of numbers"
 466             );
 467             break;
 468         }
 469
 470         unsigned long lp = 0;
 471         if (!propStr.empty())
 472         {
 473             if (!propStr.ToULong(&lp))
 474             {
 475                 ReportParamError
 476                 (
 477                     param,
 478                     "value must be a comma-separated list of numbers"
 479                 );
 480                 break;
 481             }
 482         }
 483
 484         const int n = static_cast<int>(li);
 485         if ( n >= nslots )
 486         {
 487             ReportParamError
 488             (
 489                 param,
 490                 wxString::Format
 491                 (
 492                     "invalid %s index %d: must be less than %d",
 493                     rows ? "row" : "column",
 494                     n,
 495                     nslots
 496                 )
 497             );
 498
 499             // ignore incorrect value, still try to process the rest
 500             continue;
 501         }
 502
 503         if (rows)
 504             sizer->AddGrowableRow(n, static_cast<int>(lp));
 505         else
 506             sizer->AddGrowableCol(n, static_cast<int>(lp));
 507     }
 508 }
 509
 510
 511 wxGBPosition wxSizerXmlHandler::GetGBPos(const wxString& param)
 512 {
 513     wxSize sz = GetSize(param);
 514     if (sz.x < 0) sz.x = 0;
 515     if (sz.y < 0) sz.y = 0;
 516     return wxGBPosition(sz.x, sz.y);
 517 }
 518
 519 wxGBSpan wxSizerXmlHandler::GetGBSpan(const wxString& param)
 520 {
 521     wxSize sz = GetSize(param);
 522     if (sz.x < 1) sz.x = 1;
 523     if (sz.y < 1) sz.y = 1;
 524     return wxGBSpan(sz.x, sz.y);
 525 }
 526
 527
 528
 529 wxSizerItem* wxSizerXmlHandler::MakeSizerItem()
 530 {
 531     if (m_isGBS)
 532         return new wxGBSizerItem();
 533     else
 534         return new wxSizerItem();
 535 }
 536
 537 void wxSizerXmlHandler::SetSizerItemAttributes(wxSizerItem* sitem)
 538 {
 539     sitem->SetProportion(GetLong(wxT("option")));  // Should this check for "proportion" too?
 540     sitem->SetFlag(GetStyle(wxT("flag")));
 541     sitem->SetBorder(GetDimension(wxT("border")));
 542     wxSize sz = GetSize(wxT("minsize"));
 543     if (!(sz == wxDefaultSize))
 544         sitem->SetMinSize(sz);
 545     sz = GetSize(wxT("ratio"));
 546     if (!(sz == wxDefaultSize))
 547         sitem->SetRatio(sz);
 548
 549     if (m_isGBS)
 550     {
 551         wxGBSizerItem* gbsitem = (wxGBSizerItem*)sitem;
 552         gbsitem->SetPos(GetGBPos(wxT("cellpos")));
 553         gbsitem->SetSpan(GetGBSpan(wxT("cellspan")));
 554     }
 555
 556     // record the id of the item, if any, for use by XRCSIZERITEM()
 557     sitem->SetId(GetID());
 558 }
 559
 560 void wxSizerXmlHandler::AddSizerItem(wxSizerItem* sitem)
 561 {
 562     if (m_isGBS)
 563         ((wxGridBagSizer*)m_parentSizer)->Add((wxGBSizerItem*)sitem);
 564     else
 565         m_parentSizer->Add(sitem);
 566 }
 567
 568
 569
 570 //-----------------------------------------------------------------------------
 571 // wxStdDialogButtonSizerXmlHandler
 572 //-----------------------------------------------------------------------------
 573 #if wxUSE_BUTTON
 574
 575 IMPLEMENT_DYNAMIC_CLASS(wxStdDialogButtonSizerXmlHandler, wxXmlResourceHandler)
 576
 577 wxStdDialogButtonSizerXmlHandler::wxStdDialogButtonSizerXmlHandler()
 578     : m_isInside(false), m_parentSizer(NULL)
 579 {
 580 }
 581
 582 wxObject *wxStdDialogButtonSizerXmlHandler::DoCreateResource()
 583 {
 584     if (m_class == wxT("wxStdDialogButtonSizer"))
 585     {
 586         wxASSERT( !m_parentSizer );
 587
 588         wxSizer *s = m_parentSizer = new wxStdDialogButtonSizer;
 589         m_isInside = true;
 590
 591         CreateChildren(m_parent, true/*only this handler*/);
 592
 593         m_parentSizer->Realize();
 594
 595         m_isInside = false;
 596         m_parentSizer = NULL;
 597
 598         return s;
 599     }
 600     else // m_class == "button"
 601     {
 602         wxASSERT( m_parentSizer );
 603
 604         // find the item to be managed by this sizeritem
 605         wxXmlNode *n = GetParamNode(wxT("object"));
 606         if ( !n )
 607             n = GetParamNode(wxT("object_ref"));
 608
 609         // did we find one?
 610         if (n)
 611         {
 612             wxObject *item = CreateResFromNode(n, m_parent, NULL);
 613             wxButton *button = wxDynamicCast(item, wxButton);
 614
 615             if (button)
 616                 m_parentSizer->AddButton(button);
 617             else
 618                 ReportError(n, "expected wxButton");
 619
 620             return item;
 621         }
 622         else /*n == NULL*/
 623         {
 624             ReportError("no button within wxStdDialogButtonSizer");
 625             return NULL;
 626         }
 627     }
 628 }
 629
 630 bool wxStdDialogButtonSizerXmlHandler::CanHandle(wxXmlNode *node)
 631 {
 632     return (!m_isInside && IsOfClass(node, wxT("wxStdDialogButtonSizer"))) ||
 633            (m_isInside && IsOfClass(node, wxT("button")));
 634 }
 635 #endif // wxUSE_BUTTON
 636
 637 #endif // wxUSE_XRC