]> git.saurik.com Git - wxWidgets.git/blob - src/xrc/xh_sizer.cpp
Fix another crash when conversion fails in Unix PostScript code.
[wxWidgets.git] / 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