]> git.saurik.com Git - wxWidgets.git/blob - src/xrc/xh_sizer.cpp
added XRC handler for wxFileCtrl (closes #10785)
[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 // 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
119
120 bool wxSizerXmlHandler::IsSizerNode(wxXmlNode *node)
121 {
122 return (IsOfClass(node, wxT("wxBoxSizer"))) ||
123 (IsOfClass(node, wxT("wxStaticBoxSizer"))) ||
124 (IsOfClass(node, wxT("wxGridSizer"))) ||
125 (IsOfClass(node, wxT("wxFlexGridSizer"))) ||
126 (IsOfClass(node, wxT("wxGridBagSizer"))) ||
127 (IsOfClass(node, wxT("wxWrapSizer")));
128 }
129
130
131 wxObject* wxSizerXmlHandler::Handle_sizeritem()
132 {
133 // find the item to be managed by this sizeritem
134 wxXmlNode *n = GetParamNode(wxT("object"));
135 if ( !n )
136 n = GetParamNode(wxT("object_ref"));
137
138 // did we find one?
139 if (n)
140 {
141 // create a sizer item for it
142 wxSizerItem* sitem = MakeSizerItem();
143
144 // now fetch the item to be managed
145 bool old_gbs = m_isGBS;
146 bool old_ins = m_isInside;
147 wxSizer *old_par = m_parentSizer;
148 m_isInside = false;
149 if (!IsSizerNode(n)) m_parentSizer = NULL;
150 wxObject *item = CreateResFromNode(n, m_parent, NULL);
151 m_isInside = old_ins;
152 m_parentSizer = old_par;
153 m_isGBS = old_gbs;
154
155 // and figure out what type it is
156 wxSizer *sizer = wxDynamicCast(item, wxSizer);
157 wxWindow *wnd = wxDynamicCast(item, wxWindow);
158
159 if (sizer)
160 sitem->AssignSizer(sizer);
161 else if (wnd)
162 sitem->AssignWindow(wnd);
163 else
164 ReportError(n, "unexpected item in sizer");
165
166 // finally, set other wxSizerItem attributes
167 SetSizerItemAttributes(sitem);
168
169 AddSizerItem(sitem);
170 return item;
171 }
172 else /*n == NULL*/
173 {
174 ReportError("no window/sizer/spacer within sizeritem object");
175 return NULL;
176 }
177 }
178
179
180 wxObject* wxSizerXmlHandler::Handle_spacer()
181 {
182 if ( !m_parentSizer )
183 {
184 ReportError("spacer only allowed inside a sizer");
185 return NULL;
186 }
187
188 wxSizerItem* sitem = MakeSizerItem();
189 SetSizerItemAttributes(sitem);
190 sitem->AssignSpacer(GetSize());
191 AddSizerItem(sitem);
192 return NULL;
193 }
194
195
196 wxObject* wxSizerXmlHandler::Handle_sizer()
197 {
198 wxSizer *sizer = NULL;
199 wxFlexGridSizer *flexsizer = NULL;
200
201 wxXmlNode *parentNode = m_node->GetParent();
202
203 if ( !m_parentSizer &&
204 (!parentNode || parentNode->GetType() != wxXML_ELEMENT_NODE ||
205 !m_parentAsWindow) )
206 {
207 ReportError("sizer must have a window parent");
208 return NULL;
209 }
210
211 if (m_class == wxT("wxBoxSizer"))
212 sizer = Handle_wxBoxSizer();
213 #if wxUSE_STATBOX
214 else if (m_class == wxT("wxStaticBoxSizer"))
215 sizer = Handle_wxStaticBoxSizer();
216 #endif
217 else if (m_class == wxT("wxGridSizer"))
218 {
219 if ( !ValidateGridSizerChildren() )
220 return NULL;
221 sizer = Handle_wxGridSizer();
222 }
223 else if (m_class == wxT("wxFlexGridSizer"))
224 {
225 flexsizer = Handle_wxFlexGridSizer();
226 sizer = flexsizer;
227 }
228 else if (m_class == wxT("wxGridBagSizer"))
229 {
230 flexsizer = Handle_wxGridBagSizer();
231 sizer = flexsizer;
232 }
233 else if (m_class == wxT("wxWrapSizer"))
234 {
235 sizer = Handle_wxWrapSizer();
236 }
237 else
238 {
239 ReportError(wxString::Format("unknown sizer class \"%s\"", m_class));
240 }
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 CreateChildren(m_parent, true/*only this handler*/);
260
261 // set growable rows and cols for sizers which support this
262 if ( flexsizer )
263 {
264 SetGrowables(flexsizer, wxT("growablerows"), true);
265 SetGrowables(flexsizer, wxT("growablecols"), false);
266 }
267
268 // restore state
269 m_isInside = old_ins;
270 m_parentSizer = old_par;
271
272 if (m_parentSizer == NULL) // setup window:
273 {
274 m_parentAsWindow->SetSizer(sizer);
275
276 wxXmlNode *nd = m_node;
277 m_node = parentNode;
278 if (GetSize() == wxDefaultSize)
279 {
280 if ( wxDynamicCast(m_parentAsWindow, wxScrolledWindow) != NULL )
281 {
282 sizer->FitInside(m_parentAsWindow);
283 }
284 else
285 {
286 sizer->Fit(m_parentAsWindow);
287 }
288 }
289 m_node = nd;
290
291 if (m_parentAsWindow->IsTopLevel())
292 {
293 sizer->SetSizeHints(m_parentAsWindow);
294 }
295 }
296
297 return sizer;
298 }
299
300
301 wxSizer* wxSizerXmlHandler::Handle_wxBoxSizer()
302 {
303 return new wxBoxSizer(GetStyle(wxT("orient"), wxHORIZONTAL));
304 }
305
306 #if wxUSE_STATBOX
307 wxSizer* wxSizerXmlHandler::Handle_wxStaticBoxSizer()
308 {
309 return new wxStaticBoxSizer(
310 new wxStaticBox(m_parentAsWindow,
311 GetID(),
312 GetText(wxT("label")),
313 wxDefaultPosition, wxDefaultSize,
314 0/*style*/,
315 GetName()),
316 GetStyle(wxT("orient"), wxHORIZONTAL));
317 }
318 #endif // wxUSE_STATBOX
319
320 wxSizer* wxSizerXmlHandler::Handle_wxGridSizer()
321 {
322 return new wxGridSizer(GetLong(wxT("rows")), GetLong(wxT("cols")),
323 GetDimension(wxT("vgap")), GetDimension(wxT("hgap")));
324 }
325
326
327 wxFlexGridSizer* wxSizerXmlHandler::Handle_wxFlexGridSizer()
328 {
329 if ( !ValidateGridSizerChildren() )
330 return NULL;
331 return new wxFlexGridSizer(GetLong(wxT("rows")), GetLong(wxT("cols")),
332 GetDimension(wxT("vgap")), GetDimension(wxT("hgap")));
333 }
334
335
336 wxGridBagSizer* wxSizerXmlHandler::Handle_wxGridBagSizer()
337 {
338 if ( !ValidateGridSizerChildren() )
339 return NULL;
340 return new wxGridBagSizer(GetDimension(wxT("vgap")), GetDimension(wxT("hgap")));
341 }
342
343 wxSizer* wxSizerXmlHandler::Handle_wxWrapSizer()
344 {
345 wxWrapSizer *sizer = new wxWrapSizer(GetStyle("orient"), GetStyle("flag"));
346 return sizer;
347 }
348
349
350 bool wxSizerXmlHandler::ValidateGridSizerChildren()
351 {
352 int rows = GetLong("rows");
353 int cols = GetLong("cols");
354
355 if ( rows && cols )
356 {
357 // fixed number of cells, need to verify children count
358 int children = 0;
359 for ( wxXmlNode *n = m_node->GetChildren(); n; n = n->GetNext() )
360 {
361 if ( n->GetType() == wxXML_ELEMENT_NODE &&
362 (n->GetName() == "object" || n->GetName() == "object_ref") )
363 {
364 children++;
365 }
366 }
367
368 if ( children > rows * cols )
369 {
370 ReportError
371 (
372 wxString::Format
373 (
374 "too many children in grid sizer: %d > %d x %d"
375 " (consider omitting the number of rows or columns)",
376 children,
377 cols,
378 rows
379 )
380 );
381 return false;
382 }
383 }
384
385 return true;
386 }
387
388
389 void wxSizerXmlHandler::SetGrowables(wxFlexGridSizer* sizer,
390 const wxChar* param,
391 bool rows)
392 {
393 int nrows, ncols;
394 sizer->CalcRowsCols(nrows, ncols);
395 const int nslots = rows ? nrows : ncols;
396
397 wxStringTokenizer tkn;
398 tkn.SetString(GetParamValue(param), wxT(","));
399
400 while (tkn.HasMoreTokens())
401 {
402 unsigned long l;
403 if (!tkn.GetNextToken().ToULong(&l))
404 {
405 ReportParamError
406 (
407 param,
408 "value must be comma-separated list of row numbers"
409 );
410 break;
411 }
412
413 if ( (int)l >= nslots )
414 {
415 ReportParamError
416 (
417 param,
418 wxString::Format
419 (
420 "invalid %s index %d: must be less than %d",
421 rows ? "row" : "column",
422 l,
423 nslots
424 )
425 );
426
427 // ignore incorrect value, still try to process the rest
428 continue;
429 }
430
431 if (rows)
432 sizer->AddGrowableRow(l);
433 else
434 sizer->AddGrowableCol(l);
435 }
436 }
437
438
439 wxGBPosition wxSizerXmlHandler::GetGBPos(const wxString& param)
440 {
441 wxSize sz = GetSize(param);
442 if (sz.x < 0) sz.x = 0;
443 if (sz.y < 0) sz.y = 0;
444 return wxGBPosition(sz.x, sz.y);
445 }
446
447 wxGBSpan wxSizerXmlHandler::GetGBSpan(const wxString& param)
448 {
449 wxSize sz = GetSize(param);
450 if (sz.x < 1) sz.x = 1;
451 if (sz.y < 1) sz.y = 1;
452 return wxGBSpan(sz.x, sz.y);
453 }
454
455
456
457 wxSizerItem* wxSizerXmlHandler::MakeSizerItem()
458 {
459 if (m_isGBS)
460 return new wxGBSizerItem();
461 else
462 return new wxSizerItem();
463 }
464
465 void wxSizerXmlHandler::SetSizerItemAttributes(wxSizerItem* sitem)
466 {
467 sitem->SetProportion(GetLong(wxT("option"))); // Should this check for "proportion" too?
468 sitem->SetFlag(GetStyle(wxT("flag")));
469 sitem->SetBorder(GetDimension(wxT("border")));
470 wxSize sz = GetSize(wxT("minsize"));
471 if (!(sz == wxDefaultSize))
472 sitem->SetMinSize(sz);
473 sz = GetSize(wxT("ratio"));
474 if (!(sz == wxDefaultSize))
475 sitem->SetRatio(sz);
476
477 if (m_isGBS)
478 {
479 wxGBSizerItem* gbsitem = (wxGBSizerItem*)sitem;
480 gbsitem->SetPos(GetGBPos(wxT("cellpos")));
481 gbsitem->SetSpan(GetGBSpan(wxT("cellspan")));
482 }
483
484 // record the id of the item, if any, for use by XRCSIZERITEM()
485 sitem->SetId(GetID());
486 }
487
488 void wxSizerXmlHandler::AddSizerItem(wxSizerItem* sitem)
489 {
490 if (m_isGBS)
491 ((wxGridBagSizer*)m_parentSizer)->Add((wxGBSizerItem*)sitem);
492 else
493 m_parentSizer->Add(sitem);
494 }
495
496
497
498 //-----------------------------------------------------------------------------
499 // wxStdDialogButtonSizerXmlHandler
500 //-----------------------------------------------------------------------------
501 #if wxUSE_BUTTON
502
503 IMPLEMENT_DYNAMIC_CLASS(wxStdDialogButtonSizerXmlHandler, wxXmlResourceHandler)
504
505 wxStdDialogButtonSizerXmlHandler::wxStdDialogButtonSizerXmlHandler()
506 : m_isInside(false), m_parentSizer(NULL)
507 {
508 }
509
510 wxObject *wxStdDialogButtonSizerXmlHandler::DoCreateResource()
511 {
512 if (m_class == wxT("wxStdDialogButtonSizer"))
513 {
514 wxASSERT( !m_parentSizer );
515
516 wxSizer *s = m_parentSizer = new wxStdDialogButtonSizer;
517 m_isInside = true;
518
519 CreateChildren(m_parent, true/*only this handler*/);
520
521 m_parentSizer->Realize();
522
523 m_isInside = false;
524 m_parentSizer = NULL;
525
526 return s;
527 }
528 else // m_class == "button"
529 {
530 wxASSERT( m_parentSizer );
531
532 // find the item to be managed by this sizeritem
533 wxXmlNode *n = GetParamNode(wxT("object"));
534 if ( !n )
535 n = GetParamNode(wxT("object_ref"));
536
537 // did we find one?
538 if (n)
539 {
540 wxObject *item = CreateResFromNode(n, m_parent, NULL);
541 wxButton *button = wxDynamicCast(item, wxButton);
542
543 if (button)
544 m_parentSizer->AddButton(button);
545 else
546 ReportError(n, "expected wxButton");
547
548 return item;
549 }
550 else /*n == NULL*/
551 {
552 ReportError("no button within wxStdDialogButtonSizer");
553 return NULL;
554 }
555 }
556 }
557
558 bool wxStdDialogButtonSizerXmlHandler::CanHandle(wxXmlNode *node)
559 {
560 return (!m_isInside && IsOfClass(node, wxT("wxStdDialogButtonSizer"))) ||
561 (m_isInside && IsOfClass(node, wxT("button")));
562 }
563 #endif // wxUSE_BUTTON
564
565 #endif // wxUSE_XRC