]> git.saurik.com Git - wxWidgets.git/blob - src/common/resource.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
added test for env var expansion
[wxWidgets.git] / src / common / resource.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: resource.cpp
3 // Purpose: Resource system
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 04/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart and Markus Holzem
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "resource.h"
14 #endif
15
16 // For compilers that support precompilation, includes "wx.h".
17 #include "wx/wxprec.h"
18
19 #ifdef __BORLANDC__
20 #pragma hdrstop
21 #endif
22
23 #if wxUSE_WX_RESOURCES
24
25 #ifdef __VISUALC__
26 #pragma warning(disable:4706) // assignment within conditional expression
27 #endif // VC++
28
29 #ifndef WX_PRECOMP
30 #include "wx/defs.h"
31 #include "wx/setup.h"
32 #include "wx/list.h"
33 #include "wx/hash.h"
34 #include "wx/gdicmn.h"
35 #include "wx/utils.h"
36 #include "wx/types.h"
37 #include "wx/menu.h"
38 #include "wx/stattext.h"
39 #include "wx/button.h"
40 #include "wx/bmpbuttn.h"
41 #include "wx/radiobox.h"
42 #include "wx/listbox.h"
43 #include "wx/choice.h"
44 #include "wx/checkbox.h"
45 #include "wx/settings.h"
46 #include "wx/slider.h"
47 #include "wx/icon.h"
48 #include "wx/statbox.h"
49 #include "wx/statbmp.h"
50 #include "wx/gauge.h"
51 #include "wx/textctrl.h"
52 #include "wx/msgdlg.h"
53 #include "wx/intl.h"
54 #endif
55
56 #include "wx/treebase.h"
57 #include "wx/listctrl.h"
58
59 #if wxUSE_RADIOBTN
60 #include "wx/radiobut.h"
61 #endif
62
63 #if wxUSE_SCROLLBAR
64 #include "wx/scrolbar.h"
65 #endif
66
67 #if wxUSE_COMBOBOX
68 #include "wx/combobox.h"
69 #endif
70
71 #include "wx/validate.h"
72
73 #include "wx/log.h"
74
75 #include <ctype.h>
76 #include <math.h>
77 #include <stdlib.h>
78 #include <string.h>
79
80 #include "wx/resource.h"
81 #include "wx/string.h"
82 #include "wx/wxexpr.h"
83
84 #include "wx/settings.h"
85 #include "wx/stream.h"
86
87 // Forward (private) declarations
88 bool wxResourceInterpretResources(wxResourceTable& table, wxExprDatabase& db);
89 wxItemResource *wxResourceInterpretDialog(wxResourceTable& table, wxExpr *expr, bool isPanel = FALSE);
90 wxItemResource *wxResourceInterpretControl(wxResourceTable& table, wxExpr *expr);
91 wxItemResource *wxResourceInterpretMenu(wxResourceTable& table, wxExpr *expr);
92 wxItemResource *wxResourceInterpretMenuBar(wxResourceTable& table, wxExpr *expr);
93 wxItemResource *wxResourceInterpretString(wxResourceTable& table, wxExpr *expr);
94 wxItemResource *wxResourceInterpretBitmap(wxResourceTable& table, wxExpr *expr);
95 wxItemResource *wxResourceInterpretIcon(wxResourceTable& table, wxExpr *expr);
96 // Interpret list expression
97 wxFont wxResourceInterpretFontSpec(wxExpr *expr);
98
99 bool wxResourceReadOneResource(FILE *fd, wxExprDatabase& db, bool *eof, wxResourceTable *table = (wxResourceTable *) NULL);
100 bool wxResourceReadOneResource(wxInputStream *fd, wxExprDatabase& db, bool *eof, wxResourceTable *table) ;
101 bool wxResourceParseIncludeFile(const wxString& f, wxResourceTable *table = (wxResourceTable *) NULL);
102
103 wxResourceTable *wxDefaultResourceTable = (wxResourceTable *) NULL;
104
105 char *wxResourceBuffer = (char *) NULL;
106 long wxResourceBufferSize = 0;
107 long wxResourceBufferCount = 0;
108 int wxResourceStringPtr = 0;
109
110 void wxInitializeResourceSystem()
111 {
112 wxDefaultResourceTable = new wxResourceTable;
113 }
114
115 void wxCleanUpResourceSystem()
116 {
117 delete wxDefaultResourceTable;
118 if (wxResourceBuffer)
119 delete[] wxResourceBuffer;
120 }
121
122 void wxLogWarning(char *msg)
123 {
124 wxMessageBox(msg, _("Warning"), wxOK);
125 }
126
127 IMPLEMENT_DYNAMIC_CLASS(wxItemResource, wxObject)
128 IMPLEMENT_DYNAMIC_CLASS(wxResourceTable, wxHashTable)
129
130 wxItemResource::wxItemResource()
131 {
132 m_itemType = "";
133 m_title = "";
134 m_name = "";
135 m_windowStyle = 0;
136 m_x = m_y = m_width = m_height = 0;
137 m_value1 = m_value2 = m_value3 = m_value5 = 0;
138 m_value4 = "";
139 m_windowId = 0;
140 m_exStyle = 0;
141 }
142
143 wxItemResource::~wxItemResource()
144 {
145 wxNode *node = m_children.First();
146 while (node)
147 {
148 wxItemResource *item = (wxItemResource *)node->Data();
149 delete item;
150 delete node;
151 node = m_children.First();
152 }
153 }
154
155 /*
156 * Resource table
157 */
158
159 wxResourceTable::wxResourceTable():wxHashTable(wxKEY_STRING), identifiers(wxKEY_STRING)
160 {
161 }
162
163 wxResourceTable::~wxResourceTable()
164 {
165 ClearTable();
166 }
167
168 wxItemResource *wxResourceTable::FindResource(const wxString& name) const
169 {
170 wxItemResource *item = (wxItemResource *)Get(WXSTRINGCAST name);
171 return item;
172 }
173
174 void wxResourceTable::AddResource(wxItemResource *item)
175 {
176 wxString name = item->GetName();
177 if (name == wxT(""))
178 name = item->GetTitle();
179 if (name == wxT(""))
180 name = wxT("no name");
181
182 // Delete existing resource, if any.
183 Delete(name);
184
185 Put(name, item);
186 }
187
188 bool wxResourceTable::DeleteResource(const wxString& name)
189 {
190 wxItemResource *item = (wxItemResource *)Delete(WXSTRINGCAST name);
191 if (item)
192 {
193 // See if any resource has this as its child; if so, delete from
194 // parent's child list.
195 BeginFind();
196 wxNode *node = (wxNode *) NULL;
197 node = Next();
198 while (node != NULL)
199 {
200 wxItemResource *parent = (wxItemResource *)node->Data();
201 if (parent->GetChildren().Member(item))
202 {
203 parent->GetChildren().DeleteObject(item);
204 break;
205 }
206 node = Next();
207 }
208
209 delete item;
210 return TRUE;
211 }
212 else
213 return FALSE;
214 }
215
216 bool wxResourceTable::ParseResourceFile( wxInputStream *is )
217 {
218 wxExprDatabase db;
219 int len = is->StreamSize() ;
220
221 bool eof = FALSE;
222 while ( is->TellI() + 10 < len) // it's a hack because the streams dont support EOF
223 {
224 wxResourceReadOneResource(is, db, &eof, this) ;
225 }
226 return wxResourceInterpretResources(*this, db);
227 }
228
229 bool wxResourceTable::ParseResourceFile(const wxString& filename)
230 {
231 wxExprDatabase db;
232
233 FILE *fd = wxFopen(filename, _T("r"));
234 if (!fd)
235 return FALSE;
236 bool eof = FALSE;
237 while (wxResourceReadOneResource(fd, db, &eof, this) && !eof)
238 {
239 // Loop
240 }
241 fclose(fd);
242 return wxResourceInterpretResources(*this, db);
243 }
244
245 bool wxResourceTable::ParseResourceData(const wxString& data)
246 {
247 wxExprDatabase db;
248 if (!db.ReadFromString(data))
249 {
250 wxLogWarning(_("Ill-formed resource file syntax."));
251 return FALSE;
252 }
253
254 return wxResourceInterpretResources(*this, db);
255 }
256
257 bool wxResourceTable::RegisterResourceBitmapData(const wxString& name, char bits[], int width, int height)
258 {
259 // Register pre-loaded bitmap data
260 wxItemResource *item = new wxItemResource;
261 // item->SetType(wxRESOURCE_TYPE_XBM_DATA);
262 item->SetType(wxT("wxXBMData"));
263 item->SetName(name);
264 item->SetValue1((long)bits);
265 item->SetValue2((long)width);
266 item->SetValue3((long)height);
267 AddResource(item);
268 return TRUE;
269 }
270
271 bool wxResourceTable::RegisterResourceBitmapData(const wxString& name, char **data)
272 {
273 // Register pre-loaded bitmap data
274 wxItemResource *item = new wxItemResource;
275 // item->SetType(wxRESOURCE_TYPE_XPM_DATA);
276 item->SetType(wxT("wxXPMData"));
277 item->SetName(name);
278 item->SetValue1((long)data);
279 AddResource(item);
280 return TRUE;
281 }
282
283 bool wxResourceTable::SaveResource(const wxString& WXUNUSED(filename))
284 {
285 return FALSE;
286 }
287
288 void wxResourceTable::ClearTable()
289 {
290 BeginFind();
291 wxNode *node = Next();
292 while (node)
293 {
294 wxNode *next = Next();
295 wxItemResource *item = (wxItemResource *)node->Data();
296 delete item;
297 delete node;
298 node = next;
299 }
300 }
301
302 wxControl *wxResourceTable::CreateItem(wxWindow *parent, const wxItemResource* childResource, const wxItemResource* parentResource) const
303 {
304 int id = childResource->GetId();
305 if ( id == 0 )
306 id = -1;
307
308 bool dlgUnits = ((parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS) != 0);
309
310 wxControl *control = (wxControl *) NULL;
311 wxString itemType(childResource->GetType());
312
313 wxPoint pos;
314 wxSize size;
315 if (dlgUnits)
316 {
317 pos = parent->ConvertDialogToPixels(wxPoint(childResource->GetX(), childResource->GetY()));
318 size = parent->ConvertDialogToPixels(wxSize(childResource->GetWidth(), childResource->GetHeight()));
319 }
320 else
321 {
322 pos = wxPoint(childResource->GetX(), childResource->GetY());
323 size = wxSize(childResource->GetWidth(), childResource->GetHeight());
324 }
325
326 if (itemType == wxString(wxT("wxButton")) || itemType == wxString(wxT("wxBitmapButton")))
327 {
328 if (childResource->GetValue4() != wxT(""))
329 {
330 // Bitmap button
331 wxBitmap bitmap = childResource->GetBitmap();
332 if (!bitmap.Ok())
333 {
334 bitmap = wxResourceCreateBitmap(childResource->GetValue4(), (wxResourceTable *)this);
335 ((wxItemResource*) childResource)->SetBitmap(bitmap);
336 }
337 if (!bitmap.Ok())
338 #if defined(__WXPM__)
339 //
340 // OS/2 uses integer id's to access resources, not file name strings
341 //
342 bitmap.LoadFile(wxCROSS_BITMAP, wxBITMAP_TYPE_BMP_RESOURCE);
343 #else
344 bitmap.LoadFile("cross_bmp", wxBITMAP_TYPE_BMP_RESOURCE);
345 #endif
346 control = new wxBitmapButton(parent, id, bitmap, pos, size,
347 childResource->GetStyle() | wxBU_AUTODRAW, wxDefaultValidator, childResource->GetName());
348 }
349 else
350 // Normal, text button
351 control = new wxButton(parent, id, childResource->GetTitle(), pos, size,
352 childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
353 }
354 else if (itemType == wxString(wxT("wxMessage")) || itemType == wxString(wxT("wxStaticText")) ||
355 itemType == wxString(wxT("wxStaticBitmap")))
356 {
357 if (childResource->GetValue4() != wxT("") || itemType == wxString(wxT("wxStaticBitmap")) )
358 {
359 // Bitmap message
360 wxBitmap bitmap = childResource->GetBitmap();
361 if (!bitmap.Ok())
362 {
363 bitmap = wxResourceCreateBitmap(childResource->GetValue4(), (wxResourceTable *)this);
364 ((wxItemResource*) childResource)->SetBitmap(bitmap);
365 }
366 #if wxUSE_BITMAP_MESSAGE
367 #ifdef __WXMSW__
368 // Use a default bitmap
369 if (!bitmap.Ok())
370 bitmap.LoadFile("cross_bmp", wxBITMAP_TYPE_BMP_RESOURCE);
371 #endif
372
373 if (bitmap.Ok())
374 control = new wxStaticBitmap(parent, id, bitmap, pos, size,
375 childResource->GetStyle(), childResource->GetName());
376 #endif
377 }
378 else
379 {
380 control = new wxStaticText(parent, id, childResource->GetTitle(), pos, size,
381 childResource->GetStyle(), childResource->GetName());
382 }
383 }
384 else if (itemType == wxString(wxT("wxText")) || itemType == wxString(wxT("wxTextCtrl")) || itemType == wxString(wxT("wxMultiText")))
385 {
386 control = new wxTextCtrl(parent, id, childResource->GetValue4(), pos, size,
387 childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
388 }
389 else if (itemType == wxString(wxT("wxCheckBox")))
390 {
391 control = new wxCheckBox(parent, id, childResource->GetTitle(), pos, size,
392 childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
393
394 ((wxCheckBox *)control)->SetValue((childResource->GetValue1() != 0));
395 }
396 #if wxUSE_GAUGE
397 else if (itemType == wxString(wxT("wxGauge")))
398 {
399 control = new wxGauge(parent, id, (int)childResource->GetValue2(), pos, size,
400 childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
401
402 ((wxGauge *)control)->SetValue((int)childResource->GetValue1());
403 }
404 #endif
405 #if wxUSE_RADIOBTN
406 else if (itemType == wxString(wxT("wxRadioButton")))
407 {
408 control = new wxRadioButton(parent, id, childResource->GetTitle(), // (int)childResource->GetValue1(),
409 pos, size,
410 childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
411 }
412 #endif
413 #if wxUSE_SCROLLBAR
414 else if (itemType == wxString(wxT("wxScrollBar")))
415 {
416 control = new wxScrollBar(parent, id, pos, size,
417 childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
418 /*
419 ((wxScrollBar *)control)->SetValue((int)childResource->GetValue1());
420 ((wxScrollBar *)control)->SetPageSize((int)childResource->GetValue2());
421 ((wxScrollBar *)control)->SetObjectLength((int)childResource->GetValue3());
422 ((wxScrollBar *)control)->SetViewLength((int)(long)childResource->GetValue5());
423 */
424 ((wxScrollBar *)control)->SetScrollbar((int)childResource->GetValue1(),(int)childResource->GetValue2(),
425 (int)childResource->GetValue3(),(int)(long)childResource->GetValue5(),FALSE);
426
427 }
428 #endif
429 else if (itemType == wxString(wxT("wxSlider")))
430 {
431 control = new wxSlider(parent, id, (int)childResource->GetValue1(),
432 (int)childResource->GetValue2(), (int)childResource->GetValue3(), pos, size,
433 childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
434 }
435 else if (itemType == wxString(wxT("wxGroupBox")) || itemType == wxString(wxT("wxStaticBox")))
436 {
437 control = new wxStaticBox(parent, id, childResource->GetTitle(), pos, size,
438 childResource->GetStyle(), childResource->GetName());
439 }
440 else if (itemType == wxString(wxT("wxListBox")))
441 {
442 wxStringList& stringList = childResource->GetStringValues();
443 wxString *strings = (wxString *) NULL;
444 int noStrings = 0;
445 if (stringList.Number() > 0)
446 {
447 noStrings = stringList.Number();
448 strings = new wxString[noStrings];
449 wxNode *node = stringList.First();
450 int i = 0;
451 while (node)
452 {
453 strings[i] = (wxChar *)node->Data();
454 i ++;
455 node = node->Next();
456 }
457 }
458 control = new wxListBox(parent, id, pos, size,
459 noStrings, strings, childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
460
461 if (strings)
462 delete[] strings;
463 }
464 else if (itemType == wxString(wxT("wxChoice")))
465 {
466 wxStringList& stringList = childResource->GetStringValues();
467 wxString *strings = (wxString *) NULL;
468 int noStrings = 0;
469 if (stringList.Number() > 0)
470 {
471 noStrings = stringList.Number();
472 strings = new wxString[noStrings];
473 wxNode *node = stringList.First();
474 int i = 0;
475 while (node)
476 {
477 strings[i] = (wxChar *)node->Data();
478 i ++;
479 node = node->Next();
480 }
481 }
482 control = new wxChoice(parent, id, pos, size,
483 noStrings, strings, childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
484
485 if (strings)
486 delete[] strings;
487 }
488 #if wxUSE_COMBOBOX
489 else if (itemType == wxString(wxT("wxComboBox")))
490 {
491 wxStringList& stringList = childResource->GetStringValues();
492 wxString *strings = (wxString *) NULL;
493 int noStrings = 0;
494 if (stringList.Number() > 0)
495 {
496 noStrings = stringList.Number();
497 strings = new wxString[noStrings];
498 wxNode *node = stringList.First();
499 int i = 0;
500 while (node)
501 {
502 strings[i] = (wxChar *)node->Data();
503 i ++;
504 node = node->Next();
505 }
506 }
507 control = new wxComboBox(parent, id, childResource->GetValue4(), pos, size,
508 noStrings, strings, childResource->GetStyle(), wxDefaultValidator, childResource->GetName());
509
510 if (strings)
511 delete[] strings;
512 }
513 #endif
514 else if (itemType == wxString(wxT("wxRadioBox")))
515 {
516 wxStringList& stringList = childResource->GetStringValues();
517 wxString *strings = (wxString *) NULL;
518 int noStrings = 0;
519 if (stringList.Number() > 0)
520 {
521 noStrings = stringList.Number();
522 strings = new wxString[noStrings];
523 wxNode *node = stringList.First();
524 int i = 0;
525 while (node)
526 {
527 strings[i] = (wxChar *)node->Data();
528 i ++;
529 node = node->Next();
530 }
531 }
532 control = new wxRadioBox(parent, (wxWindowID) id, wxString(childResource->GetTitle()), pos, size,
533 noStrings, strings, (int)childResource->GetValue1(), childResource->GetStyle(), wxDefaultValidator,
534 childResource->GetName());
535
536 if (strings)
537 delete[] strings;
538 }
539
540 if ((parentResource->GetResourceStyle() & wxRESOURCE_USE_DEFAULTS) != 0)
541 {
542 // Don't set font; will be inherited from parent.
543 }
544 else
545 {
546 if (control && childResource->GetFont().Ok())
547 {
548 control->SetFont(childResource->GetFont());
549
550 #ifdef __WXMSW__
551 // Force the layout algorithm since the size changes the layout
552 if (control->IsKindOf(CLASSINFO(wxRadioBox)))
553 {
554 control->SetSize(-1, -1, -1, -1, wxSIZE_AUTO_WIDTH|wxSIZE_AUTO_HEIGHT);
555 }
556 #endif
557 }
558 }
559 return control;
560 }
561
562 /*
563 * Interpret database as a series of resources
564 */
565
566 bool wxResourceInterpretResources(wxResourceTable& table, wxExprDatabase& db)
567 {
568 wxNode *node = db.First();
569 while (node)
570 {
571 wxExpr *clause = (wxExpr *)node->Data();
572 wxString functor(clause->Functor());
573
574 wxItemResource *item = (wxItemResource *) NULL;
575 if (functor == wxT("dialog"))
576 item = wxResourceInterpretDialog(table, clause);
577 else if (functor == wxT("panel"))
578 item = wxResourceInterpretDialog(table, clause, TRUE);
579 else if (functor == wxT("menubar"))
580 item = wxResourceInterpretMenuBar(table, clause);
581 else if (functor == wxT("menu"))
582 item = wxResourceInterpretMenu(table, clause);
583 else if (functor == wxT("string"))
584 item = wxResourceInterpretString(table, clause);
585 else if (functor == wxT("bitmap"))
586 item = wxResourceInterpretBitmap(table, clause);
587 else if (functor == wxT("icon"))
588 item = wxResourceInterpretIcon(table, clause);
589
590 if (item)
591 {
592 // Remove any existing resource of same name
593 if (item->GetName() != wxT(""))
594 table.DeleteResource(item->GetName());
595 table.AddResource(item);
596 }
597 node = node->Next();
598 }
599 return TRUE;
600 }
601
602 static const wxChar *g_ValidControlClasses[] =
603 {
604 wxT("wxButton"),
605 wxT("wxBitmapButton"),
606 wxT("wxMessage"),
607 wxT("wxStaticText"),
608 wxT("wxStaticBitmap"),
609 wxT("wxText"),
610 wxT("wxTextCtrl"),
611 wxT("wxMultiText"),
612 wxT("wxListBox"),
613 wxT("wxRadioBox"),
614 wxT("wxRadioButton"),
615 wxT("wxCheckBox"),
616 wxT("wxBitmapCheckBox"),
617 wxT("wxGroupBox"),
618 wxT("wxStaticBox"),
619 wxT("wxSlider"),
620 wxT("wxGauge"),
621 wxT("wxScrollBar"),
622 wxT("wxChoice"),
623 wxT("wxComboBox")
624 };
625
626 static bool wxIsValidControlClass(const wxString& c)
627 {
628 for ( size_t i = 0; i < WXSIZEOF(g_ValidControlClasses); i++ )
629 {
630 if ( c == g_ValidControlClasses[i] )
631 return TRUE;
632 }
633 return FALSE;
634 }
635
636 wxItemResource *wxResourceInterpretDialog(wxResourceTable& table, wxExpr *expr, bool isPanel)
637 {
638 wxItemResource *dialogItem = new wxItemResource;
639 if (isPanel)
640 dialogItem->SetType(wxT("wxPanel"));
641 else
642 dialogItem->SetType(wxT("wxDialog"));
643 wxString style = wxT("");
644 wxString title = wxT("");
645 wxString name = wxT("");
646 wxString backColourHex = wxT("");
647 wxString labelColourHex = wxT("");
648 wxString buttonColourHex = wxT("");
649
650 long windowStyle = wxDEFAULT_DIALOG_STYLE;
651 if (isPanel)
652 windowStyle = 0;
653
654 int x = 0; int y = 0; int width = -1; int height = -1;
655 int isModal = 0;
656 wxExpr *labelFontExpr = (wxExpr *) NULL;
657 wxExpr *buttonFontExpr = (wxExpr *) NULL;
658 wxExpr *fontExpr = (wxExpr *) NULL;
659 expr->GetAttributeValue(wxT("style"), style);
660 expr->GetAttributeValue(wxT("name"), name);
661 expr->GetAttributeValue(wxT("title"), title);
662 expr->GetAttributeValue(wxT("x"), x);
663 expr->GetAttributeValue(wxT("y"), y);
664 expr->GetAttributeValue(wxT("width"), width);
665 expr->GetAttributeValue(wxT("height"), height);
666 expr->GetAttributeValue(wxT("modal"), isModal);
667 expr->GetAttributeValue(wxT("label_font"), &labelFontExpr);
668 expr->GetAttributeValue(wxT("button_font"), &buttonFontExpr);
669 expr->GetAttributeValue(wxT("font"), &fontExpr);
670 expr->GetAttributeValue(wxT("background_colour"), backColourHex);
671 expr->GetAttributeValue(wxT("label_colour"), labelColourHex);
672 expr->GetAttributeValue(wxT("button_colour"), buttonColourHex);
673
674 int useDialogUnits = 0;
675 expr->GetAttributeValue(wxT("use_dialog_units"), useDialogUnits);
676 if (useDialogUnits != 0)
677 dialogItem->SetResourceStyle(dialogItem->GetResourceStyle() | wxRESOURCE_DIALOG_UNITS);
678
679 int useDefaults = 0;
680 expr->GetAttributeValue(wxT("use_system_defaults"), useDefaults);
681 if (useDefaults != 0)
682 dialogItem->SetResourceStyle(dialogItem->GetResourceStyle() | wxRESOURCE_USE_DEFAULTS);
683
684 int id = 0;
685 expr->GetAttributeValue(wxT("id"), id);
686 dialogItem->SetId(id);
687
688 if (style != wxT(""))
689 {
690 windowStyle = wxParseWindowStyle(style);
691 }
692 dialogItem->SetStyle(windowStyle);
693 dialogItem->SetValue1(isModal);
694 if (windowStyle & wxDIALOG_MODAL) // Uses style in wxWin 2
695 dialogItem->SetValue1(TRUE);
696
697 dialogItem->SetName(name);
698 dialogItem->SetTitle(title);
699 dialogItem->SetSize(x, y, width, height);
700
701 // Check for wxWin 1.68-style specifications
702 if (style.Find(wxT("VERTICAL_LABEL")) != -1)
703 dialogItem->SetResourceStyle(dialogItem->GetResourceStyle() | wxRESOURCE_VERTICAL_LABEL);
704 else if (style.Find(wxT("HORIZONTAL_LABEL")) != -1)
705 dialogItem->SetResourceStyle(dialogItem->GetResourceStyle() | wxRESOURCE_HORIZONTAL_LABEL);
706
707 if (backColourHex != wxT(""))
708 {
709 int r = 0;
710 int g = 0;
711 int b = 0;
712 r = wxHexToDec(backColourHex.Mid(0, 2));
713 g = wxHexToDec(backColourHex.Mid(2, 2));
714 b = wxHexToDec(backColourHex.Mid(4, 2));
715 dialogItem->SetBackgroundColour(wxColour((unsigned char)r,(unsigned char)g,(unsigned char)b));
716 }
717 if (labelColourHex != wxT(""))
718 {
719 int r = 0;
720 int g = 0;
721 int b = 0;
722 r = wxHexToDec(labelColourHex.Mid(0, 2));
723 g = wxHexToDec(labelColourHex.Mid(2, 2));
724 b = wxHexToDec(labelColourHex.Mid(4, 2));
725 dialogItem->SetLabelColour(wxColour((unsigned char)r,(unsigned char)g,(unsigned char)b));
726 }
727 if (buttonColourHex != wxT(""))
728 {
729 int r = 0;
730 int g = 0;
731 int b = 0;
732 r = wxHexToDec(buttonColourHex.Mid(0, 2));
733 g = wxHexToDec(buttonColourHex.Mid(2, 2));
734 b = wxHexToDec(buttonColourHex.Mid(4, 2));
735 dialogItem->SetButtonColour(wxColour((unsigned char)r,(unsigned char)g,(unsigned char)b));
736 }
737
738 if (fontExpr)
739 dialogItem->SetFont(wxResourceInterpretFontSpec(fontExpr));
740 else if (buttonFontExpr)
741 dialogItem->SetFont(wxResourceInterpretFontSpec(buttonFontExpr));
742 else if (labelFontExpr)
743 dialogItem->SetFont(wxResourceInterpretFontSpec(labelFontExpr));
744
745 // Now parse all controls
746 wxExpr *controlExpr = expr->GetFirst();
747 while (controlExpr)
748 {
749 if (controlExpr->Number() == 3)
750 {
751 wxString controlKeyword(controlExpr->Nth(1)->StringValue());
752 if (controlKeyword != wxT("") && controlKeyword == wxT("control"))
753 {
754 // The value part: always a list.
755 wxExpr *listExpr = controlExpr->Nth(2);
756 if (listExpr->Type() == PrologList)
757 {
758 wxItemResource *controlItem = wxResourceInterpretControl(table, listExpr);
759 if (controlItem)
760 {
761 dialogItem->GetChildren().Append(controlItem);
762 }
763 }
764 }
765 }
766 controlExpr = controlExpr->GetNext();
767 }
768 return dialogItem;
769 }
770
771 wxItemResource *wxResourceInterpretControl(wxResourceTable& table, wxExpr *expr)
772 {
773 wxItemResource *controlItem = new wxItemResource;
774
775 // First, find the standard features of a control definition:
776 // [optional integer/string id], control name, title, style, name, x, y, width, height
777
778 wxString controlType;
779 wxString style;
780 wxString title;
781 wxString name;
782 int id = 0;
783 long windowStyle = 0;
784 int x = 0; int y = 0; int width = -1; int height = -1;
785 int count = 0;
786
787 wxExpr *expr1 = expr->Nth(0);
788
789 if ( expr1->Type() == PrologString || expr1->Type() == PrologWord )
790 {
791 if ( wxIsValidControlClass(expr1->StringValue()) )
792 {
793 count = 1;
794 controlType = expr1->StringValue();
795 }
796 else
797 {
798 wxString str(expr1->StringValue());
799 id = wxResourceGetIdentifier(str, &table);
800 if (id == 0)
801 {
802 wxLogWarning(_("Could not resolve control class or id '%s'. Use (non-zero) integer instead\n or provide #define (see manual for caveats)"),
803 (const wxChar*) expr1->StringValue());
804 delete controlItem;
805 return (wxItemResource *) NULL;
806 }
807 else
808 {
809 // Success - we have an id, so the 2nd element must be the control class.
810 controlType = expr->Nth(1)->StringValue();
811 count = 2;
812 }
813 }
814 }
815 else if (expr1->Type() == PrologInteger)
816 {
817 id = (int)expr1->IntegerValue();
818 // Success - we have an id, so the 2nd element must be the control class.
819 controlType = expr->Nth(1)->StringValue();
820 count = 2;
821 }
822
823 expr1 = expr->Nth(count);
824 count ++;
825 if ( expr1 )
826 title = expr1->StringValue();
827
828 expr1 = expr->Nth(count);
829 count ++;
830 if (expr1)
831 {
832 style = expr1->StringValue();
833 windowStyle = wxParseWindowStyle(style);
834 }
835
836 expr1 = expr->Nth(count);
837 count ++;
838 if (expr1)
839 name = expr1->StringValue();
840
841 expr1 = expr->Nth(count);
842 count ++;
843 if (expr1)
844 x = (int)expr1->IntegerValue();
845
846 expr1 = expr->Nth(count);
847 count ++;
848 if (expr1)
849 y = (int)expr1->IntegerValue();
850
851 expr1 = expr->Nth(count);
852 count ++;
853 if (expr1)
854 width = (int)expr1->IntegerValue();
855
856 expr1 = expr->Nth(count);
857 count ++;
858 if (expr1)
859 height = (int)expr1->IntegerValue();
860
861 controlItem->SetStyle(windowStyle);
862 controlItem->SetName(name);
863 controlItem->SetTitle(title);
864 controlItem->SetSize(x, y, width, height);
865 controlItem->SetType(controlType);
866 controlItem->SetId(id);
867
868 // Check for wxWin 1.68-style specifications
869 if (style.Find(wxT("VERTICAL_LABEL")) != -1)
870 controlItem->SetResourceStyle(controlItem->GetResourceStyle() | wxRESOURCE_VERTICAL_LABEL);
871 else if (style.Find(wxT("HORIZONTAL_LABEL")) != -1)
872 controlItem->SetResourceStyle(controlItem->GetResourceStyle() | wxRESOURCE_HORIZONTAL_LABEL);
873
874 if (controlType == wxT("wxButton"))
875 {
876 // Check for bitmap resource name (in case loading old-style resource file)
877 if (expr->Nth(count) && ((expr->Nth(count)->Type() == PrologString) || (expr->Nth(count)->Type() == PrologWord)))
878 {
879 wxString str(expr->Nth(count)->StringValue());
880 count ++;
881
882 if (str != wxT(""))
883 {
884 controlItem->SetValue4(str);
885 controlItem->SetType(wxT("wxBitmapButton"));
886 }
887 }
888 if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
889 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
890 }
891 else if (controlType == wxT("wxBitmapButton"))
892 {
893 // Check for bitmap resource name
894 if (expr->Nth(count) && ((expr->Nth(count)->Type() == PrologString) || (expr->Nth(count)->Type() == PrologWord)))
895 {
896 wxString str(expr->Nth(count)->StringValue());
897 controlItem->SetValue4(str);
898 count ++;
899 if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
900 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
901 }
902 }
903 else if (controlType == wxT("wxCheckBox"))
904 {
905 // Check for default value
906 if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
907 {
908 controlItem->SetValue1(expr->Nth(count)->IntegerValue());
909 count ++;
910 if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
911 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
912 }
913 }
914 #if wxUSE_RADIOBTN
915 else if (controlType == wxT("wxRadioButton"))
916 {
917 // Check for default value
918 if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
919 {
920 controlItem->SetValue1(expr->Nth(count)->IntegerValue());
921 count ++;
922 if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
923 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
924 }
925 }
926 #endif
927 else if (controlType == wxT("wxText") || controlType == wxT("wxTextCtrl") || controlType == wxT("wxMultiText"))
928 {
929 // Check for default value
930 if (expr->Nth(count) && ((expr->Nth(count)->Type() == PrologString) || (expr->Nth(count)->Type() == PrologWord)))
931 {
932 wxString str(expr->Nth(count)->StringValue());
933 controlItem->SetValue4(str);
934 count ++;
935
936 if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
937 {
938 // controlItem->SetLabelFont(wxResourceInterpretFontSpec(expr->Nth(count)));
939 // Skip past the obsolete label font spec if there are two consecutive specs
940 if (expr->Nth(count+1) && expr->Nth(count+1)->Type() == PrologList)
941 count ++;
942 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
943 }
944 }
945 }
946 else if (controlType == wxT("wxMessage") || controlType == wxT("wxStaticText"))
947 {
948 // Check for bitmap resource name (in case it's an old-style .wxr file)
949 if (expr->Nth(count) && ((expr->Nth(count)->Type() == PrologString) || (expr->Nth(count)->Type() == PrologWord)))
950 {
951 wxString str(expr->Nth(count)->StringValue());
952 controlItem->SetValue4(str);
953 count ++;
954 controlItem->SetType(wxT("wxStaticText"));
955 }
956 if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
957 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
958 }
959 else if (controlType == wxT("wxStaticBitmap"))
960 {
961 // Check for bitmap resource name
962 if (expr->Nth(count) && ((expr->Nth(count)->Type() == PrologString) || (expr->Nth(count)->Type() == PrologWord)))
963 {
964 wxString str(expr->Nth(count)->StringValue());
965 controlItem->SetValue4(str);
966 count ++;
967 }
968 if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
969 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
970 }
971 else if (controlType == wxT("wxGroupBox") || controlType == wxT("wxStaticBox"))
972 {
973 if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
974 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
975 }
976 else if (controlType == wxT("wxGauge"))
977 {
978 // Check for default value
979 if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
980 {
981 controlItem->SetValue1(expr->Nth(count)->IntegerValue());
982 count ++;
983
984 // Check for range
985 if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
986 {
987 controlItem->SetValue2(expr->Nth(count)->IntegerValue());
988 count ++;
989
990 if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
991 {
992 // Skip past the obsolete label font spec if there are two consecutive specs
993 if (expr->Nth(count+1) && expr->Nth(count+1)->Type() == PrologList)
994 count ++;
995 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
996 }
997 }
998 }
999 }
1000 else if (controlType == wxT("wxSlider"))
1001 {
1002 // Check for default value
1003 if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
1004 {
1005 controlItem->SetValue1(expr->Nth(count)->IntegerValue());
1006 count ++;
1007
1008 // Check for min
1009 if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
1010 {
1011 controlItem->SetValue2(expr->Nth(count)->IntegerValue());
1012 count ++;
1013
1014 // Check for max
1015 if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
1016 {
1017 controlItem->SetValue3(expr->Nth(count)->IntegerValue());
1018 count ++;
1019
1020 if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
1021 {
1022 // controlItem->SetLabelFont(wxResourceInterpretFontSpec(expr->Nth(count)));
1023 // do nothing
1024 count ++;
1025
1026 if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
1027 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
1028 }
1029 }
1030 }
1031 }
1032 }
1033 else if (controlType == wxT("wxScrollBar"))
1034 {
1035 // DEFAULT VALUE
1036 if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
1037 {
1038 controlItem->SetValue1(expr->Nth(count)->IntegerValue());
1039 count ++;
1040
1041 // PAGE LENGTH
1042 if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
1043 {
1044 controlItem->SetValue2(expr->Nth(count)->IntegerValue());
1045 count ++;
1046
1047 // OBJECT LENGTH
1048 if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
1049 {
1050 controlItem->SetValue3(expr->Nth(count)->IntegerValue());
1051 count ++;
1052
1053 // VIEW LENGTH
1054 if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
1055 controlItem->SetValue5(expr->Nth(count)->IntegerValue());
1056 }
1057 }
1058 }
1059 }
1060 else if (controlType == wxT("wxListBox"))
1061 {
1062 wxExpr *valueList = (wxExpr *) NULL;
1063
1064 if (((valueList = expr->Nth(count)) != 0) && (valueList->Type() == PrologList))
1065 {
1066 wxStringList stringList;
1067 wxExpr *stringExpr = valueList->GetFirst();
1068 while (stringExpr)
1069 {
1070 stringList.Add(stringExpr->StringValue());
1071 stringExpr = stringExpr->GetNext();
1072 }
1073 controlItem->SetStringValues(stringList);
1074 count ++;
1075 // This is now obsolete: it's in the window style.
1076 // Check for wxSINGLE/wxMULTIPLE
1077 wxExpr *mult = (wxExpr *) NULL;
1078 /*
1079 controlItem->SetValue1(wxLB_SINGLE);
1080 */
1081 if (((mult = expr->Nth(count)) != 0) && ((mult->Type() == PrologString)||(mult->Type() == PrologWord)))
1082 {
1083 /*
1084 wxString m(mult->StringValue());
1085 if (m == "wxLB_MULTIPLE")
1086 controlItem->SetValue1(wxLB_MULTIPLE);
1087 else if (m == "wxLB_EXTENDED")
1088 controlItem->SetValue1(wxLB_EXTENDED);
1089 */
1090 // Ignore the value
1091 count ++;
1092 }
1093 if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
1094 {
1095 // Skip past the obsolete label font spec if there are two consecutive specs
1096 if (expr->Nth(count+1) && expr->Nth(count+1)->Type() == PrologList)
1097 count ++;
1098 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
1099 }
1100 }
1101 }
1102 else if (controlType == wxT("wxChoice"))
1103 {
1104 wxExpr *valueList = (wxExpr *) NULL;
1105 // Check for default value list
1106 if (((valueList = expr->Nth(count)) != 0) && (valueList->Type() == PrologList))
1107 {
1108 wxStringList stringList;
1109 wxExpr *stringExpr = valueList->GetFirst();
1110 while (stringExpr)
1111 {
1112 stringList.Add(stringExpr->StringValue());
1113 stringExpr = stringExpr->GetNext();
1114 }
1115 controlItem->SetStringValues(stringList);
1116
1117 count ++;
1118
1119 if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
1120 {
1121 // Skip past the obsolete label font spec if there are two consecutive specs
1122 if (expr->Nth(count+1) && expr->Nth(count+1)->Type() == PrologList)
1123 count ++;
1124 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
1125 }
1126 }
1127 }
1128 #if wxUSE_COMBOBOX
1129 else if (controlType == wxT("wxComboBox"))
1130 {
1131 wxExpr *textValue = expr->Nth(count);
1132 if (textValue && (textValue->Type() == PrologString || textValue->Type() == PrologWord))
1133 {
1134 wxString str(textValue->StringValue());
1135 controlItem->SetValue4(str);
1136
1137 count ++;
1138
1139 wxExpr *valueList = (wxExpr *) NULL;
1140 // Check for default value list
1141 if (((valueList = expr->Nth(count)) != 0) && (valueList->Type() == PrologList))
1142 {
1143 wxStringList stringList;
1144 wxExpr *stringExpr = valueList->GetFirst();
1145 while (stringExpr)
1146 {
1147 stringList.Add(stringExpr->StringValue());
1148 stringExpr = stringExpr->GetNext();
1149 }
1150 controlItem->SetStringValues(stringList);
1151
1152 count ++;
1153
1154 if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
1155 {
1156 // Skip past the obsolete label font spec if there are two consecutive specs
1157 if (expr->Nth(count+1) && expr->Nth(count+1)->Type() == PrologList)
1158 count ++;
1159 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
1160 }
1161 }
1162 }
1163 }
1164 #endif
1165 #if 1
1166 else if (controlType == wxT("wxRadioBox"))
1167 {
1168 wxExpr *valueList = (wxExpr *) NULL;
1169 // Check for default value list
1170 if (((valueList = expr->Nth(count)) != 0) && (valueList->Type() == PrologList))
1171 {
1172 wxStringList stringList;
1173 wxExpr *stringExpr = valueList->GetFirst();
1174 while (stringExpr)
1175 {
1176 stringList.Add(stringExpr->StringValue());
1177 stringExpr = stringExpr->GetNext();
1178 }
1179 controlItem->SetStringValues(stringList);
1180 count ++;
1181
1182 // majorDim (number of rows or cols)
1183 if (expr->Nth(count) && (expr->Nth(count)->Type() == PrologInteger))
1184 {
1185 controlItem->SetValue1(expr->Nth(count)->IntegerValue());
1186 count ++;
1187 }
1188 else
1189 controlItem->SetValue1(0);
1190
1191 if (expr->Nth(count) && expr->Nth(count)->Type() == PrologList)
1192 {
1193 // Skip past the obsolete label font spec if there are two consecutive specs
1194 if (expr->Nth(count+1) && expr->Nth(count+1)->Type() == PrologList)
1195 count ++;
1196 controlItem->SetFont(wxResourceInterpretFontSpec(expr->Nth(count)));
1197 }
1198 }
1199 }
1200 #endif
1201 else
1202 {
1203 delete controlItem;
1204 return (wxItemResource *) NULL;
1205 }
1206 return controlItem;
1207 }
1208
1209 // Forward declaration
1210 wxItemResource *wxResourceInterpretMenu1(wxResourceTable& table, wxExpr *expr);
1211
1212 /*
1213 * Interpet a menu item
1214 */
1215
1216 wxItemResource *wxResourceInterpretMenuItem(wxResourceTable& table, wxExpr *expr)
1217 {
1218 wxItemResource *item = new wxItemResource;
1219
1220 wxExpr *labelExpr = expr->Nth(0);
1221 wxExpr *idExpr = expr->Nth(1);
1222 wxExpr *helpExpr = expr->Nth(2);
1223 wxExpr *checkableExpr = expr->Nth(3);
1224
1225 // Further keywords/attributes to follow sometime...
1226 if (expr->Number() == 0)
1227 {
1228 // item->SetType(wxRESOURCE_TYPE_SEPARATOR);
1229 item->SetType(wxT("wxMenuSeparator"));
1230 return item;
1231 }
1232 else
1233 {
1234 // item->SetType(wxTYPE_MENU); // Well, menu item, but doesn't matter.
1235 item->SetType(wxT("wxMenu")); // Well, menu item, but doesn't matter.
1236 if (labelExpr)
1237 {
1238 wxString str(labelExpr->StringValue());
1239 item->SetTitle(str);
1240 }
1241 if (idExpr)
1242 {
1243 int id = 0;
1244 // If a string or word, must look up in identifier table.
1245 if ((idExpr->Type() == PrologString) || (idExpr->Type() == PrologWord))
1246 {
1247 wxString str(idExpr->StringValue());
1248 id = wxResourceGetIdentifier(str, &table);
1249 if (id == 0)
1250 {
1251 wxLogWarning(_("Could not resolve menu id '%s'. Use (non-zero) integer instead\nor provide #define (see manual for caveats)"),
1252 (const wxChar*) idExpr->StringValue());
1253 }
1254 }
1255 else if (idExpr->Type() == PrologInteger)
1256 id = (int)idExpr->IntegerValue();
1257 item->SetValue1(id);
1258 }
1259 if (helpExpr)
1260 {
1261 wxString str(helpExpr->StringValue());
1262 item->SetValue4(str);
1263 }
1264 if (checkableExpr)
1265 item->SetValue2(checkableExpr->IntegerValue());
1266
1267 // Find the first expression that's a list, for submenu
1268 wxExpr *subMenuExpr = expr->GetFirst();
1269 while (subMenuExpr && (subMenuExpr->Type() != PrologList))
1270 subMenuExpr = subMenuExpr->GetNext();
1271
1272 while (subMenuExpr)
1273 {
1274 wxItemResource *child = wxResourceInterpretMenuItem(table, subMenuExpr);
1275 item->GetChildren().Append(child);
1276 subMenuExpr = subMenuExpr->GetNext();
1277 }
1278 }
1279 return item;
1280 }
1281
1282 /*
1283 * Interpret a nested list as a menu
1284 */
1285 /*
1286 wxItemResource *wxResourceInterpretMenu1(wxResourceTable& table, wxExpr *expr)
1287 {
1288 wxItemResource *menu = new wxItemResource;
1289 // menu->SetType(wxTYPE_MENU);
1290 menu->SetType("wxMenu");
1291 wxExpr *element = expr->GetFirst();
1292 while (element)
1293 {
1294 wxItemResource *item = wxResourceInterpretMenuItem(table, element);
1295 if (item)
1296 menu->GetChildren().Append(item);
1297 element = element->GetNext();
1298 }
1299 return menu;
1300 }
1301 */
1302
1303 wxItemResource *wxResourceInterpretMenu(wxResourceTable& table, wxExpr *expr)
1304 {
1305 wxExpr *listExpr = (wxExpr *) NULL;
1306 expr->GetAttributeValue(wxT("menu"), &listExpr);
1307 if (!listExpr)
1308 return (wxItemResource *) NULL;
1309
1310 wxItemResource *menuResource = wxResourceInterpretMenuItem(table, listExpr);
1311
1312 if (!menuResource)
1313 return (wxItemResource *) NULL;
1314
1315 wxString name;
1316 if (expr->GetAttributeValue(wxT("name"), name))
1317 {
1318 menuResource->SetName(name);
1319 }
1320
1321 return menuResource;
1322 }
1323
1324 wxItemResource *wxResourceInterpretMenuBar(wxResourceTable& table, wxExpr *expr)
1325 {
1326 wxExpr *listExpr = (wxExpr *) NULL;
1327 expr->GetAttributeValue(wxT("menu"), &listExpr);
1328 if (!listExpr)
1329 return (wxItemResource *) NULL;
1330
1331 wxItemResource *resource = new wxItemResource;
1332 resource->SetType(wxT("wxMenu"));
1333 // resource->SetType(wxTYPE_MENU);
1334
1335 wxExpr *element = listExpr->GetFirst();
1336 while (element)
1337 {
1338 wxItemResource *menuResource = wxResourceInterpretMenuItem(table, listExpr);
1339 resource->GetChildren().Append(menuResource);
1340 element = element->GetNext();
1341 }
1342
1343 wxString name;
1344 if (expr->GetAttributeValue(wxT("name"), name))
1345 {
1346 resource->SetName(name);
1347 }
1348
1349 return resource;
1350 }
1351
1352 wxItemResource *wxResourceInterpretString(wxResourceTable& WXUNUSED(table), wxExpr *WXUNUSED(expr))
1353 {
1354 return (wxItemResource *) NULL;
1355 }
1356
1357 wxItemResource *wxResourceInterpretBitmap(wxResourceTable& WXUNUSED(table), wxExpr *expr)
1358 {
1359 wxItemResource *bitmapItem = new wxItemResource;
1360 // bitmapItem->SetType(wxTYPE_BITMAP);
1361 bitmapItem->SetType(wxT("wxBitmap"));
1362 wxString name;
1363 if (expr->GetAttributeValue(wxT("name"), name))
1364 {
1365 bitmapItem->SetName(name);
1366 }
1367 // Now parse all bitmap specifications
1368 wxExpr *bitmapExpr = expr->GetFirst();
1369 while (bitmapExpr)
1370 {
1371 if (bitmapExpr->Number() == 3)
1372 {
1373 wxString bitmapKeyword(bitmapExpr->Nth(1)->StringValue());
1374 if (bitmapKeyword == wxT("bitmap") || bitmapKeyword == wxT("icon"))
1375 {
1376 // The value part: always a list.
1377 wxExpr *listExpr = bitmapExpr->Nth(2);
1378 if (listExpr->Type() == PrologList)
1379 {
1380 wxItemResource *bitmapSpec = new wxItemResource;
1381 // bitmapSpec->SetType(wxTYPE_BITMAP);
1382 bitmapSpec->SetType(wxT("wxBitmap"));
1383
1384 // List is of form: [filename, bitmaptype, platform, colours, xresolution, yresolution]
1385 // where everything after 'filename' is optional.
1386 wxExpr *nameExpr = listExpr->Nth(0);
1387 wxExpr *typeExpr = listExpr->Nth(1);
1388 wxExpr *platformExpr = listExpr->Nth(2);
1389 wxExpr *coloursExpr = listExpr->Nth(3);
1390 wxExpr *xresExpr = listExpr->Nth(4);
1391 wxExpr *yresExpr = listExpr->Nth(5);
1392 if (nameExpr && nameExpr->StringValue() != wxT(""))
1393 {
1394 bitmapSpec->SetName(nameExpr->StringValue());
1395 }
1396 if (typeExpr && typeExpr->StringValue() != wxT(""))
1397 {
1398 bitmapSpec->SetValue1(wxParseWindowStyle(typeExpr->StringValue()));
1399 }
1400 else
1401 bitmapSpec->SetValue1(0);
1402
1403 if (platformExpr && platformExpr->StringValue() != wxT(""))
1404 {
1405 wxString plat(platformExpr->StringValue());
1406 if (plat == wxT("windows") || plat == wxT("WINDOWS"))
1407 bitmapSpec->SetValue2(RESOURCE_PLATFORM_WINDOWS);
1408 else if (plat == wxT("x") || plat == wxT("X"))
1409 bitmapSpec->SetValue2(RESOURCE_PLATFORM_X);
1410 else if (plat == wxT("mac") || plat == wxT("MAC"))
1411 bitmapSpec->SetValue2(RESOURCE_PLATFORM_MAC);
1412 else
1413 bitmapSpec->SetValue2(RESOURCE_PLATFORM_ANY);
1414 }
1415 else
1416 bitmapSpec->SetValue2(RESOURCE_PLATFORM_ANY);
1417
1418 if (coloursExpr)
1419 bitmapSpec->SetValue3(coloursExpr->IntegerValue());
1420 int xres = 0;
1421 int yres = 0;
1422 if (xresExpr)
1423 xres = (int)xresExpr->IntegerValue();
1424 if (yresExpr)
1425 yres = (int)yresExpr->IntegerValue();
1426 bitmapSpec->SetSize(0, 0, xres, yres);
1427
1428 bitmapItem->GetChildren().Append(bitmapSpec);
1429 }
1430 }
1431 }
1432 bitmapExpr = bitmapExpr->GetNext();
1433 }
1434
1435 return bitmapItem;
1436 }
1437
1438 wxItemResource *wxResourceInterpretIcon(wxResourceTable& table, wxExpr *expr)
1439 {
1440 wxItemResource *item = wxResourceInterpretBitmap(table, expr);
1441 if (item)
1442 {
1443 // item->SetType(wxTYPE_ICON);
1444 item->SetType(wxT("wxIcon"));
1445 return item;
1446 }
1447 else
1448 return (wxItemResource *) NULL;
1449 }
1450
1451 // Interpret list expression as a font
1452 wxFont wxResourceInterpretFontSpec(wxExpr *expr)
1453 {
1454 if (expr->Type() != PrologList)
1455 return wxNullFont;
1456
1457 int point = 10;
1458 int family = wxSWISS;
1459 int style = wxNORMAL;
1460 int weight = wxNORMAL;
1461 int underline = 0;
1462 wxString faceName(wxT(""));
1463
1464 wxExpr *pointExpr = expr->Nth(0);
1465 wxExpr *familyExpr = expr->Nth(1);
1466 wxExpr *styleExpr = expr->Nth(2);
1467 wxExpr *weightExpr = expr->Nth(3);
1468 wxExpr *underlineExpr = expr->Nth(4);
1469 wxExpr *faceNameExpr = expr->Nth(5);
1470 if (pointExpr)
1471 point = (int)pointExpr->IntegerValue();
1472
1473 wxString str;
1474 if (familyExpr)
1475 {
1476 str = familyExpr->StringValue();
1477 family = (int)wxParseWindowStyle(str);
1478 }
1479 if (styleExpr)
1480 {
1481 str = styleExpr->StringValue();
1482 style = (int)wxParseWindowStyle(str);
1483 }
1484 if (weightExpr)
1485 {
1486 str = weightExpr->StringValue();
1487 weight = (int)wxParseWindowStyle(str);
1488 }
1489 if (underlineExpr)
1490 underline = (int)underlineExpr->IntegerValue();
1491 if (faceNameExpr)
1492 faceName = faceNameExpr->StringValue();
1493
1494 return *wxTheFontList->FindOrCreateFont(point, family, style, weight,
1495 (underline != 0), faceName);
1496 }
1497
1498 // Separate file for the remainder of this, for BC++/Win16
1499
1500 #if !((defined(__BORLANDC__) || defined(__SC__)) && defined(__WIN16__))
1501 /*
1502 * (Re)allocate buffer for reading in from resource file
1503 */
1504
1505 bool wxReallocateResourceBuffer()
1506 {
1507 if (!wxResourceBuffer)
1508 {
1509 wxResourceBufferSize = 1000;
1510 wxResourceBuffer = new char[wxResourceBufferSize];
1511 return TRUE;
1512 }
1513 if (wxResourceBuffer)
1514 {
1515 long newSize = wxResourceBufferSize + 1000;
1516 char *tmp = new char[(int)newSize];
1517 strncpy(tmp, wxResourceBuffer, (int)wxResourceBufferCount);
1518 delete[] wxResourceBuffer;
1519 wxResourceBuffer = tmp;
1520 wxResourceBufferSize = newSize;
1521 }
1522 return TRUE;
1523 }
1524
1525 static bool wxEatWhiteSpace(FILE *fd)
1526 {
1527 int ch = 0;
1528
1529 while ((ch = getc(fd)) != EOF)
1530 {
1531 switch (ch)
1532 {
1533 case ' ':
1534 case 0x0a:
1535 case 0x0d:
1536 case 0x09:
1537 break;
1538 case '/':
1539 {
1540 int prev_ch = ch;
1541 ch = getc(fd);
1542 if (ch == EOF)
1543 {
1544 ungetc(prev_ch, fd);
1545 return TRUE;
1546 }
1547
1548 if (ch == '*')
1549 {
1550 // Eat C comment
1551 prev_ch = 0;
1552 while ((ch = getc(fd)) != EOF)
1553 {
1554 if (ch == '/' && prev_ch == '*')
1555 break;
1556 prev_ch = ch;
1557 }
1558 }
1559 else if (ch == '/')
1560 {
1561 // Eat C++ comment
1562 static char buffer[255];
1563 fgets(buffer, 255, fd);
1564 }
1565 else
1566 {
1567 ungetc(prev_ch, fd);
1568 ungetc(ch, fd);
1569 return TRUE;
1570 }
1571 }
1572 break;
1573 default:
1574 ungetc(ch, fd);
1575 return TRUE;
1576
1577 }
1578 }
1579 return FALSE;
1580 }
1581 static bool wxEatWhiteSpace(wxInputStream *is)
1582 {
1583 int ch = is->GetC() ;
1584 if ((ch != ' ') && (ch != '/') && (ch != ' ') && (ch != 10) && (ch != 13) && (ch != 9))
1585 {
1586 is->Ungetch(ch);
1587 return TRUE;
1588 }
1589
1590 // Eat whitespace
1591 while (ch == ' ' || ch == 10 || ch == 13 || ch == 9)
1592 ch = is->GetC();
1593 // Check for comment
1594 if (ch == '/')
1595 {
1596 ch = is->GetC();
1597 if (ch == '*')
1598 {
1599 bool finished = FALSE;
1600 while (!finished)
1601 {
1602 ch = is->GetC();
1603 if (ch == EOF)
1604 return FALSE;
1605 if (ch == '*')
1606 {
1607 int newCh = is->GetC();
1608 if (newCh == '/')
1609 finished = TRUE;
1610 else
1611 {
1612 is->Ungetch(ch);
1613 }
1614 }
1615 }
1616 }
1617 else // False alarm
1618 return FALSE;
1619 }
1620 else
1621 is->Ungetch(ch);
1622 return wxEatWhiteSpace(is);
1623 }
1624
1625 bool wxGetResourceToken(FILE *fd)
1626 {
1627 if (!wxResourceBuffer)
1628 wxReallocateResourceBuffer();
1629 wxResourceBuffer[0] = 0;
1630 wxEatWhiteSpace(fd);
1631
1632 int ch = getc(fd);
1633 if (ch == '"')
1634 {
1635 // Get string
1636 wxResourceBufferCount = 0;
1637 ch = getc(fd);
1638 while (ch != '"')
1639 {
1640 int actualCh = ch;
1641 if (ch == EOF)
1642 {
1643 wxResourceBuffer[wxResourceBufferCount] = 0;
1644 return FALSE;
1645 }
1646 // Escaped characters
1647 else if (ch == '\\')
1648 {
1649 int newCh = getc(fd);
1650 if (newCh == '"')
1651 actualCh = '"';
1652 else if (newCh == 10)
1653 actualCh = 10;
1654 else
1655 {
1656 ungetc(newCh, fd);
1657 }
1658 }
1659
1660 if (wxResourceBufferCount >= wxResourceBufferSize-1)
1661 wxReallocateResourceBuffer();
1662 wxResourceBuffer[wxResourceBufferCount] = (char)actualCh;
1663 wxResourceBufferCount ++;
1664 ch = getc(fd);
1665 }
1666 wxResourceBuffer[wxResourceBufferCount] = 0;
1667 }
1668 else
1669 {
1670 wxResourceBufferCount = 0;
1671 // Any other token
1672 while (ch != ' ' && ch != EOF && ch != ' ' && ch != 13 && ch != 9 && ch != 10)
1673 {
1674 if (wxResourceBufferCount >= wxResourceBufferSize-1)
1675 wxReallocateResourceBuffer();
1676 wxResourceBuffer[wxResourceBufferCount] = (char)ch;
1677 wxResourceBufferCount ++;
1678
1679 ch = getc(fd);
1680 }
1681 wxResourceBuffer[wxResourceBufferCount] = 0;
1682 if (ch == EOF)
1683 return FALSE;
1684 }
1685 return TRUE;
1686 }
1687
1688 bool wxGetResourceToken(wxInputStream *is)
1689 {
1690 if (!wxResourceBuffer)
1691 wxReallocateResourceBuffer();
1692 wxResourceBuffer[0] = 0;
1693 wxEatWhiteSpace(is);
1694
1695 int ch = is->GetC() ;
1696 if (ch == '"')
1697 {
1698 // Get string
1699 wxResourceBufferCount = 0;
1700 ch = is->GetC();
1701 while (ch != '"')
1702 {
1703 int actualCh = ch;
1704 if (ch == EOF)
1705 {
1706 wxResourceBuffer[wxResourceBufferCount] = 0;
1707 return FALSE;
1708 }
1709 // Escaped characters
1710 else if (ch == '\\')
1711 {
1712 int newCh = is->GetC();
1713 if (newCh == '"')
1714 actualCh = '"';
1715 else if (newCh == 10)
1716 actualCh = 10;
1717 else if (newCh == 13) // mac
1718 actualCh = 10;
1719 else
1720 {
1721 is->Ungetch(newCh);
1722 }
1723 }
1724
1725 if (wxResourceBufferCount >= wxResourceBufferSize-1)
1726 wxReallocateResourceBuffer();
1727 wxResourceBuffer[wxResourceBufferCount] = (char)actualCh;
1728 wxResourceBufferCount ++;
1729 ch = is->GetC();
1730 }
1731 wxResourceBuffer[wxResourceBufferCount] = 0;
1732 }
1733 else
1734 {
1735 wxResourceBufferCount = 0;
1736 // Any other token
1737 while (ch != ' ' && ch != EOF && ch != ' ' && ch != 13 && ch != 9 && ch != 10)
1738 {
1739 if (wxResourceBufferCount >= wxResourceBufferSize-1)
1740 wxReallocateResourceBuffer();
1741 wxResourceBuffer[wxResourceBufferCount] = (char)ch;
1742 wxResourceBufferCount ++;
1743
1744 ch = is->GetC();
1745 }
1746 wxResourceBuffer[wxResourceBufferCount] = 0;
1747 if (ch == EOF)
1748 return FALSE;
1749 }
1750 return TRUE;
1751 }
1752
1753 /*
1754 * Files are in form:
1755 static char *name = "....";
1756 with possible comments.
1757 */
1758
1759 bool wxResourceReadOneResource(FILE *fd, wxExprDatabase& db, bool *eof, wxResourceTable *table)
1760 {
1761 if (!table)
1762 table = wxDefaultResourceTable;
1763
1764 // static or #define
1765 if (!wxGetResourceToken(fd))
1766 {
1767 *eof = TRUE;
1768 return FALSE;
1769 }
1770
1771 if (strcmp(wxResourceBuffer, "#define") == 0)
1772 {
1773 wxGetResourceToken(fd);
1774 wxChar *name = copystring(wxConvCurrent->cMB2WX(wxResourceBuffer));
1775 wxGetResourceToken(fd);
1776 wxChar *value = copystring(wxConvCurrent->cMB2WX(wxResourceBuffer));
1777 if (wxIsdigit(value[0]))
1778 {
1779 int val = (int)wxAtol(value);
1780 wxResourceAddIdentifier(name, val, table);
1781 }
1782 else
1783 {
1784 wxLogWarning(_("#define %s must be an integer."), name);
1785 delete[] name;
1786 delete[] value;
1787 return FALSE;
1788 }
1789 delete[] name;
1790 delete[] value;
1791
1792 return TRUE;
1793 }
1794 else if (strcmp(wxResourceBuffer, "#include") == 0)
1795 {
1796 wxGetResourceToken(fd);
1797 wxChar *name = copystring(wxConvCurrent->cMB2WX(wxResourceBuffer));
1798 wxChar *actualName = name;
1799 if (name[0] == wxT('"'))
1800 actualName = name + 1;
1801 int len = wxStrlen(name);
1802 if ((len > 0) && (name[len-1] == wxT('"')))
1803 name[len-1] = 0;
1804 if (!wxResourceParseIncludeFile(actualName, table))
1805 {
1806 wxLogWarning(_("Could not find resource include file %s."), actualName);
1807 }
1808 delete[] name;
1809 return TRUE;
1810 }
1811 else if (strcmp(wxResourceBuffer, "static") != 0)
1812 {
1813 wxChar buf[300];
1814 wxStrcpy(buf, _("Found "));
1815 wxStrncat(buf, wxConvCurrent->cMB2WX(wxResourceBuffer), 30);
1816 wxStrcat(buf, _(", expected static, #include or #define\nwhilst parsing resource."));
1817 wxLogWarning(buf);
1818 return FALSE;
1819 }
1820
1821 // char
1822 if (!wxGetResourceToken(fd))
1823 {
1824 wxLogWarning(_("Unexpected end of file whilst parsing resource."));
1825 *eof = TRUE;
1826 return FALSE;
1827 }
1828
1829 if (strcmp(wxResourceBuffer, "char") != 0)
1830 {
1831 wxLogWarning(_("Expected 'char' whilst parsing resource."));
1832 return FALSE;
1833 }
1834
1835 // *name
1836 if (!wxGetResourceToken(fd))
1837 {
1838 wxLogWarning(_("Unexpected end of file whilst parsing resource."));
1839 *eof = TRUE;
1840 return FALSE;
1841 }
1842
1843 if (wxResourceBuffer[0] != '*')
1844 {
1845 wxLogWarning(_("Expected '*' whilst parsing resource."));
1846 return FALSE;
1847 }
1848 wxChar nameBuf[100];
1849 wxMB2WX(nameBuf, wxResourceBuffer+1, 99);
1850 nameBuf[99] = 0;
1851
1852 // =
1853 if (!wxGetResourceToken(fd))
1854 {
1855 wxLogWarning(_("Unexpected end of file whilst parsing resource."));
1856 *eof = TRUE;
1857 return FALSE;
1858 }
1859
1860 if (strcmp(wxResourceBuffer, "=") != 0)
1861 {
1862 wxLogWarning(_("Expected '=' whilst parsing resource."));
1863 return FALSE;
1864 }
1865
1866 // String
1867 if (!wxGetResourceToken(fd))
1868 {
1869 wxLogWarning(_("Unexpected end of file whilst parsing resource."));
1870 *eof = TRUE;
1871 return FALSE;
1872 }
1873 else
1874 {
1875 if (!db.ReadPrologFromString(wxResourceBuffer))
1876 {
1877 wxLogWarning(_("%s: ill-formed resource file syntax."), nameBuf);
1878 return FALSE;
1879 }
1880 }
1881 // Semicolon
1882 if (!wxGetResourceToken(fd))
1883 {
1884 *eof = TRUE;
1885 }
1886 return TRUE;
1887 }
1888
1889 bool wxResourceReadOneResource(wxInputStream *fd, wxExprDatabase& db, bool *eof, wxResourceTable *table)
1890 {
1891 if (!table)
1892 table = wxDefaultResourceTable;
1893
1894 // static or #define
1895 if (!wxGetResourceToken(fd))
1896 {
1897 *eof = TRUE;
1898 return FALSE;
1899 }
1900
1901 if (strcmp(wxResourceBuffer, "#define") == 0)
1902 {
1903 wxGetResourceToken(fd);
1904 wxChar *name = copystring(wxConvLibc.cMB2WX(wxResourceBuffer));
1905 wxGetResourceToken(fd);
1906 wxChar *value = copystring(wxConvLibc.cMB2WX(wxResourceBuffer));
1907 if (wxIsalpha(value[0]))
1908 {
1909 int val = (int)wxAtol(value);
1910 wxResourceAddIdentifier(name, val, table);
1911 }
1912 else
1913 {
1914 wxLogWarning(_("#define %s must be an integer."), name);
1915 delete[] name;
1916 delete[] value;
1917 return FALSE;
1918 }
1919 delete[] name;
1920 delete[] value;
1921
1922 return TRUE;
1923 }
1924 else if (strcmp(wxResourceBuffer, "#include") == 0)
1925 {
1926 wxGetResourceToken(fd);
1927 wxChar *name = copystring(wxConvLibc.cMB2WX(wxResourceBuffer));
1928 wxChar *actualName = name;
1929 if (name[0] == wxT('"'))
1930 actualName = name + 1;
1931 int len = wxStrlen(name);
1932 if ((len > 0) && (name[len-1] == wxT('"')))
1933 name[len-1] = 0;
1934 if (!wxResourceParseIncludeFile(actualName, table))
1935 {
1936 wxLogWarning(_("Could not find resource include file %s."), actualName);
1937 }
1938 delete[] name;
1939 return TRUE;
1940 }
1941 else if (strcmp(wxResourceBuffer, "static") != 0)
1942 {
1943 wxChar buf[300];
1944 wxStrcpy(buf, _("Found "));
1945 wxStrncat(buf, wxConvLibc.cMB2WX(wxResourceBuffer), 30);
1946 wxStrcat(buf, _(", expected static, #include or #define\nwhilst parsing resource."));
1947 wxLogWarning(buf);
1948 return FALSE;
1949 }
1950
1951 // char
1952 if (!wxGetResourceToken(fd))
1953 {
1954 wxLogWarning(_("Unexpected end of file whilst parsing resource."));
1955 *eof = TRUE;
1956 return FALSE;
1957 }
1958
1959 if (strcmp(wxResourceBuffer, "char") != 0)
1960 {
1961 wxLogWarning(_("Expected 'char' whilst parsing resource."));
1962 return FALSE;
1963 }
1964
1965 // *name
1966 if (!wxGetResourceToken(fd))
1967 {
1968 wxLogWarning(_("Unexpected end of file whilst parsing resource."));
1969 *eof = TRUE;
1970 return FALSE;
1971 }
1972
1973 if (wxResourceBuffer[0] != '*')
1974 {
1975 wxLogWarning(_("Expected '*' whilst parsing resource."));
1976 return FALSE;
1977 }
1978 char nameBuf[100];
1979 strncpy(nameBuf, wxResourceBuffer+1, 99);
1980
1981 // =
1982 if (!wxGetResourceToken(fd))
1983 {
1984 wxLogWarning(_("Unexpected end of file whilst parsing resource."));
1985 *eof = TRUE;
1986 return FALSE;
1987 }
1988
1989 if (strcmp(wxResourceBuffer, "=") != 0)
1990 {
1991 wxLogWarning(_("Expected '=' whilst parsing resource."));
1992 return FALSE;
1993 }
1994
1995 // String
1996 if (!wxGetResourceToken(fd))
1997 {
1998 wxLogWarning(_("Unexpected end of file whilst parsing resource."));
1999 *eof = TRUE;
2000 return FALSE;
2001 }
2002 else
2003 {
2004 if (!db.ReadPrologFromString(wxResourceBuffer))
2005 {
2006 wxLogWarning(_("%s: ill-formed resource file syntax."), nameBuf);
2007 return FALSE;
2008 }
2009 }
2010 // Semicolon
2011 if (!wxGetResourceToken(fd))
2012 {
2013 *eof = TRUE;
2014 }
2015 return TRUE;
2016 }
2017
2018 /*
2019 * Parses string window style into integer window style
2020 */
2021
2022 /*
2023 * Style flag parsing, e.g.
2024 * "wxSYSTEM_MENU | wxBORDER" -> integer
2025 */
2026
2027 wxChar* wxResourceParseWord(wxChar*s, int *i)
2028 {
2029 if (!s)
2030 return (wxChar*) NULL;
2031
2032 static wxChar buf[150];
2033 int len = wxStrlen(s);
2034 int j = 0;
2035 int ii = *i;
2036 while ((ii < len) && (wxIsalpha(s[ii]) || (s[ii] == wxT('_'))))
2037 {
2038 buf[j] = s[ii];
2039 j ++;
2040 ii ++;
2041 }
2042 buf[j] = 0;
2043
2044 // Eat whitespace and conjunction characters
2045 while ((ii < len) &&
2046 ((s[ii] == wxT(' ')) || (s[ii] == wxT('|')) || (s[ii] == wxT(','))))
2047 {
2048 ii ++;
2049 }
2050 *i = ii;
2051 if (j == 0)
2052 return (wxChar*) NULL;
2053 else
2054 return buf;
2055 }
2056
2057 struct wxResourceBitListStruct
2058 {
2059 const wxChar *word;
2060 long bits;
2061 };
2062
2063 static wxResourceBitListStruct wxResourceBitListTable[] =
2064 {
2065 /* wxListBox */
2066 { wxT("wxSINGLE"), wxLB_SINGLE },
2067 { wxT("wxMULTIPLE"), wxLB_MULTIPLE },
2068 { wxT("wxEXTENDED"), wxLB_EXTENDED },
2069 { wxT("wxLB_SINGLE"), wxLB_SINGLE },
2070 { wxT("wxLB_MULTIPLE"), wxLB_MULTIPLE },
2071 { wxT("wxLB_EXTENDED"), wxLB_EXTENDED },
2072 { wxT("wxLB_NEEDED_SB"), wxLB_NEEDED_SB },
2073 { wxT("wxLB_ALWAYS_SB"), wxLB_ALWAYS_SB },
2074 { wxT("wxLB_SORT"), wxLB_SORT },
2075 { wxT("wxLB_OWNERDRAW"), wxLB_OWNERDRAW },
2076 { wxT("wxLB_HSCROLL"), wxLB_HSCROLL },
2077
2078 /* wxComboxBox */
2079 { wxT("wxCB_SIMPLE"), wxCB_SIMPLE },
2080 { wxT("wxCB_DROPDOWN"), wxCB_DROPDOWN },
2081 { wxT("wxCB_READONLY"), wxCB_READONLY },
2082 { wxT("wxCB_SORT"), wxCB_SORT },
2083
2084 /* wxGauge */
2085 { wxT("wxGA_PROGRESSBAR"), wxGA_PROGRESSBAR },
2086 { wxT("wxGA_HORIZONTAL"), wxGA_HORIZONTAL },
2087 { wxT("wxGA_VERTICAL"), wxGA_VERTICAL },
2088
2089 /* wxTextCtrl */
2090 { wxT("wxPASSWORD"), wxPASSWORD},
2091 { wxT("wxPROCESS_ENTER"), wxPROCESS_ENTER},
2092 { wxT("wxTE_PASSWORD"), wxTE_PASSWORD},
2093 { wxT("wxTE_READONLY"), wxTE_READONLY},
2094 { wxT("wxTE_PROCESS_ENTER"), wxTE_PROCESS_ENTER},
2095 { wxT("wxTE_MULTILINE"), wxTE_MULTILINE},
2096 { wxT("wxTE_NO_VSCROLL"), wxTE_NO_VSCROLL},
2097
2098 /* wxRadioBox/wxRadioButton */
2099 { wxT("wxRB_GROUP"), wxRB_GROUP },
2100 { wxT("wxRA_SPECIFY_COLS"), wxRA_SPECIFY_COLS },
2101 { wxT("wxRA_SPECIFY_ROWS"), wxRA_SPECIFY_ROWS },
2102 { wxT("wxRA_HORIZONTAL"), wxRA_HORIZONTAL },
2103 { wxT("wxRA_VERTICAL"), wxRA_VERTICAL },
2104
2105 /* wxSlider */
2106 { wxT("wxSL_HORIZONTAL"), wxSL_HORIZONTAL },
2107 { wxT("wxSL_VERTICAL"), wxSL_VERTICAL },
2108 { wxT("wxSL_AUTOTICKS"), wxSL_AUTOTICKS },
2109 { wxT("wxSL_LABELS"), wxSL_LABELS },
2110 { wxT("wxSL_LEFT"), wxSL_LEFT },
2111 { wxT("wxSL_TOP"), wxSL_TOP },
2112 { wxT("wxSL_RIGHT"), wxSL_RIGHT },
2113 { wxT("wxSL_BOTTOM"), wxSL_BOTTOM },
2114 { wxT("wxSL_BOTH"), wxSL_BOTH },
2115 { wxT("wxSL_SELRANGE"), wxSL_SELRANGE },
2116
2117 /* wxScrollBar */
2118 { wxT("wxSB_HORIZONTAL"), wxSB_HORIZONTAL },
2119 { wxT("wxSB_VERTICAL"), wxSB_VERTICAL },
2120
2121 /* wxButton */
2122 { wxT("wxBU_AUTODRAW"), wxBU_AUTODRAW },
2123 { wxT("wxBU_NOAUTODRAW"), wxBU_NOAUTODRAW },
2124
2125 /* wxTreeCtrl */
2126 { wxT("wxTR_HAS_BUTTONS"), wxTR_HAS_BUTTONS },
2127 { wxT("wxTR_EDIT_LABELS"), wxTR_EDIT_LABELS },
2128 { wxT("wxTR_LINES_AT_ROOT"), wxTR_LINES_AT_ROOT },
2129
2130 /* wxListCtrl */
2131 { wxT("wxLC_ICON"), wxLC_ICON },
2132 { wxT("wxLC_SMALL_ICON"), wxLC_SMALL_ICON },
2133 { wxT("wxLC_LIST"), wxLC_LIST },
2134 { wxT("wxLC_REPORT"), wxLC_REPORT },
2135 { wxT("wxLC_ALIGN_TOP"), wxLC_ALIGN_TOP },
2136 { wxT("wxLC_ALIGN_LEFT"), wxLC_ALIGN_LEFT },
2137 { wxT("wxLC_AUTOARRANGE"), wxLC_AUTOARRANGE },
2138 { wxT("wxLC_USER_TEXT"), wxLC_USER_TEXT },
2139 { wxT("wxLC_EDIT_LABELS"), wxLC_EDIT_LABELS },
2140 { wxT("wxLC_NO_HEADER"), wxLC_NO_HEADER },
2141 { wxT("wxLC_NO_SORT_HEADER"), wxLC_NO_SORT_HEADER },
2142 { wxT("wxLC_SINGLE_SEL"), wxLC_SINGLE_SEL },
2143 { wxT("wxLC_SORT_ASCENDING"), wxLC_SORT_ASCENDING },
2144 { wxT("wxLC_SORT_DESCENDING"), wxLC_SORT_DESCENDING },
2145
2146 /* wxSpinButton */
2147 { wxT("wxSP_VERTICAL"), wxSP_VERTICAL},
2148 { wxT("wxSP_HORIZONTAL"), wxSP_HORIZONTAL},
2149 { wxT("wxSP_ARROW_KEYS"), wxSP_ARROW_KEYS},
2150 { wxT("wxSP_WRAP"), wxSP_WRAP},
2151
2152 /* wxSplitterWnd */
2153 { wxT("wxSP_NOBORDER"), wxSP_NOBORDER},
2154 { wxT("wxSP_3D"), wxSP_3D},
2155 { wxT("wxSP_BORDER"), wxSP_BORDER},
2156
2157 /* wxTabCtrl */
2158 { wxT("wxTC_MULTILINE"), wxTC_MULTILINE},
2159 { wxT("wxTC_RIGHTJUSTIFY"), wxTC_RIGHTJUSTIFY},
2160 { wxT("wxTC_FIXEDWIDTH"), wxTC_FIXEDWIDTH},
2161 { wxT("wxTC_OWNERDRAW"), wxTC_OWNERDRAW},
2162
2163 /* wxStatusBar95 */
2164 { wxT("wxST_SIZEGRIP"), wxST_SIZEGRIP},
2165
2166 /* wxControl */
2167 { wxT("wxFIXED_LENGTH"), wxFIXED_LENGTH},
2168 { wxT("wxALIGN_LEFT"), wxALIGN_LEFT},
2169 { wxT("wxALIGN_CENTER"), wxALIGN_CENTER},
2170 { wxT("wxALIGN_CENTRE"), wxALIGN_CENTRE},
2171 { wxT("wxALIGN_RIGHT"), wxALIGN_RIGHT},
2172 { wxT("wxCOLOURED"), wxCOLOURED},
2173
2174 /* wxToolBar */
2175 { wxT("wxTB_3DBUTTONS"), wxTB_3DBUTTONS},
2176 { wxT("wxTB_HORIZONTAL"), wxTB_HORIZONTAL},
2177 { wxT("wxTB_VERTICAL"), wxTB_VERTICAL},
2178 { wxT("wxTB_FLAT"), wxTB_FLAT},
2179
2180 /* wxDialog */
2181 { wxT("wxDIALOG_MODAL"), wxDIALOG_MODAL },
2182
2183 /* Generic */
2184 { wxT("wxVSCROLL"), wxVSCROLL },
2185 { wxT("wxHSCROLL"), wxHSCROLL },
2186 { wxT("wxCAPTION"), wxCAPTION },
2187 { wxT("wxSTAY_ON_TOP"), wxSTAY_ON_TOP},
2188 { wxT("wxICONIZE"), wxICONIZE},
2189 { wxT("wxMINIMIZE"), wxICONIZE},
2190 { wxT("wxMAXIMIZE"), wxMAXIMIZE},
2191 { wxT("wxSDI"), 0},
2192 { wxT("wxMDI_PARENT"), 0},
2193 { wxT("wxMDI_CHILD"), 0},
2194 { wxT("wxTHICK_FRAME"), wxTHICK_FRAME},
2195 { wxT("wxRESIZE_BORDER"), wxRESIZE_BORDER},
2196 { wxT("wxSYSTEM_MENU"), wxSYSTEM_MENU},
2197 { wxT("wxMINIMIZE_BOX"), wxMINIMIZE_BOX},
2198 { wxT("wxMAXIMIZE_BOX"), wxMAXIMIZE_BOX},
2199 { wxT("wxRESIZE_BOX"), wxRESIZE_BOX},
2200 { wxT("wxDEFAULT_FRAME_STYLE"), wxDEFAULT_FRAME_STYLE},
2201 { wxT("wxDEFAULT_FRAME"), wxDEFAULT_FRAME_STYLE},
2202 { wxT("wxDEFAULT_DIALOG_STYLE"), wxDEFAULT_DIALOG_STYLE},
2203 { wxT("wxBORDER"), wxBORDER},
2204 { wxT("wxRETAINED"), wxRETAINED},
2205 { wxT("wxNATIVE_IMPL"), 0},
2206 { wxT("wxEXTENDED_IMPL"), 0},
2207 { wxT("wxBACKINGSTORE"), wxBACKINGSTORE},
2208 // { wxT("wxFLAT"), wxFLAT},
2209 // { wxT("wxMOTIF_RESIZE"), wxMOTIF_RESIZE},
2210 { wxT("wxFIXED_LENGTH"), 0},
2211 { wxT("wxDOUBLE_BORDER"), wxDOUBLE_BORDER},
2212 { wxT("wxSUNKEN_BORDER"), wxSUNKEN_BORDER},
2213 { wxT("wxRAISED_BORDER"), wxRAISED_BORDER},
2214 { wxT("wxSIMPLE_BORDER"), wxSIMPLE_BORDER},
2215 { wxT("wxSTATIC_BORDER"), wxSTATIC_BORDER},
2216 { wxT("wxTRANSPARENT_WINDOW"), wxTRANSPARENT_WINDOW},
2217 { wxT("wxNO_BORDER"), wxNO_BORDER},
2218 { wxT("wxCLIP_CHILDREN"), wxCLIP_CHILDREN},
2219 { wxT("wxCLIP_SIBLINGS"), wxCLIP_SIBLINGS},
2220 { wxT("wxTAB_TRAVERSAL"), 0}, // Compatibility only
2221
2222 { wxT("wxTINY_CAPTION_HORIZ"), wxTINY_CAPTION_HORIZ},
2223 { wxT("wxTINY_CAPTION_VERT"), wxTINY_CAPTION_VERT},
2224
2225 // Text font families
2226 { wxT("wxDEFAULT"), wxDEFAULT},
2227 { wxT("wxDECORATIVE"), wxDECORATIVE},
2228 { wxT("wxROMAN"), wxROMAN},
2229 { wxT("wxSCRIPT"), wxSCRIPT},
2230 { wxT("wxSWISS"), wxSWISS},
2231 { wxT("wxMODERN"), wxMODERN},
2232 { wxT("wxTELETYPE"), wxTELETYPE},
2233 { wxT("wxVARIABLE"), wxVARIABLE},
2234 { wxT("wxFIXED"), wxFIXED},
2235 { wxT("wxNORMAL"), wxNORMAL},
2236 { wxT("wxLIGHT"), wxLIGHT},
2237 { wxT("wxBOLD"), wxBOLD},
2238 { wxT("wxITALIC"), wxITALIC},
2239 { wxT("wxSLANT"), wxSLANT},
2240 { wxT("wxSOLID"), wxSOLID},
2241 { wxT("wxDOT"), wxDOT},
2242 { wxT("wxLONG_DASH"), wxLONG_DASH},
2243 { wxT("wxSHORT_DASH"), wxSHORT_DASH},
2244 { wxT("wxDOT_DASH"), wxDOT_DASH},
2245 { wxT("wxUSER_DASH"), wxUSER_DASH},
2246 { wxT("wxTRANSPARENT"), wxTRANSPARENT},
2247 { wxT("wxSTIPPLE"), wxSTIPPLE},
2248 { wxT("wxBDIAGONAL_HATCH"), wxBDIAGONAL_HATCH},
2249 { wxT("wxCROSSDIAG_HATCH"), wxCROSSDIAG_HATCH},
2250 { wxT("wxFDIAGONAL_HATCH"), wxFDIAGONAL_HATCH},
2251 { wxT("wxCROSS_HATCH"), wxCROSS_HATCH},
2252 { wxT("wxHORIZONTAL_HATCH"), wxHORIZONTAL_HATCH},
2253 { wxT("wxVERTICAL_HATCH"), wxVERTICAL_HATCH},
2254 { wxT("wxJOIN_BEVEL"), wxJOIN_BEVEL},
2255 { wxT("wxJOIN_MITER"), wxJOIN_MITER},
2256 { wxT("wxJOIN_ROUND"), wxJOIN_ROUND},
2257 { wxT("wxCAP_ROUND"), wxCAP_ROUND},
2258 { wxT("wxCAP_PROJECTING"), wxCAP_PROJECTING},
2259 { wxT("wxCAP_BUTT"), wxCAP_BUTT},
2260
2261 // Logical ops
2262 { wxT("wxCLEAR"), wxCLEAR},
2263 { wxT("wxXOR"), wxXOR},
2264 { wxT("wxINVERT"), wxINVERT},
2265 { wxT("wxOR_REVERSE"), wxOR_REVERSE},
2266 { wxT("wxAND_REVERSE"), wxAND_REVERSE},
2267 { wxT("wxCOPY"), wxCOPY},
2268 { wxT("wxAND"), wxAND},
2269 { wxT("wxAND_INVERT"), wxAND_INVERT},
2270 { wxT("wxNO_OP"), wxNO_OP},
2271 { wxT("wxNOR"), wxNOR},
2272 { wxT("wxEQUIV"), wxEQUIV},
2273 { wxT("wxSRC_INVERT"), wxSRC_INVERT},
2274 { wxT("wxOR_INVERT"), wxOR_INVERT},
2275 { wxT("wxNAND"), wxNAND},
2276 { wxT("wxOR"), wxOR},
2277 { wxT("wxSET"), wxSET},
2278
2279 { wxT("wxFLOOD_SURFACE"), wxFLOOD_SURFACE},
2280 { wxT("wxFLOOD_BORDER"), wxFLOOD_BORDER},
2281 { wxT("wxODDEVEN_RULE"), wxODDEVEN_RULE},
2282 { wxT("wxWINDING_RULE"), wxWINDING_RULE},
2283 { wxT("wxHORIZONTAL"), wxHORIZONTAL},
2284 { wxT("wxVERTICAL"), wxVERTICAL},
2285 { wxT("wxBOTH"), wxBOTH},
2286 { wxT("wxCENTER_FRAME"), wxCENTER_FRAME},
2287 { wxT("wxOK"), wxOK},
2288 { wxT("wxYES_NO"), wxYES_NO},
2289 { wxT("wxCANCEL"), wxCANCEL},
2290 { wxT("wxYES"), wxYES},
2291 { wxT("wxNO"), wxNO},
2292 { wxT("wxICON_EXCLAMATION"), wxICON_EXCLAMATION},
2293 { wxT("wxICON_HAND"), wxICON_HAND},
2294 { wxT("wxICON_QUESTION"), wxICON_QUESTION},
2295 { wxT("wxICON_INFORMATION"), wxICON_INFORMATION},
2296 { wxT("wxICON_STOP"), wxICON_STOP},
2297 { wxT("wxICON_ASTERISK"), wxICON_ASTERISK},
2298 { wxT("wxICON_MASK"), wxICON_MASK},
2299 { wxT("wxCENTRE"), wxCENTRE},
2300 { wxT("wxCENTER"), wxCENTRE},
2301 { wxT("wxUSER_COLOURS"), wxUSER_COLOURS},
2302 { wxT("wxVERTICAL_LABEL"), 0},
2303 { wxT("wxHORIZONTAL_LABEL"), 0},
2304
2305 // Bitmap types (not strictly styles)
2306 { wxT("wxBITMAP_TYPE_XPM"), wxBITMAP_TYPE_XPM},
2307 { wxT("wxBITMAP_TYPE_XBM"), wxBITMAP_TYPE_XBM},
2308 { wxT("wxBITMAP_TYPE_BMP"), wxBITMAP_TYPE_BMP},
2309 { wxT("wxBITMAP_TYPE_RESOURCE"), wxBITMAP_TYPE_BMP_RESOURCE},
2310 { wxT("wxBITMAP_TYPE_BMP_RESOURCE"), wxBITMAP_TYPE_BMP_RESOURCE},
2311 { wxT("wxBITMAP_TYPE_GIF"), wxBITMAP_TYPE_GIF},
2312 { wxT("wxBITMAP_TYPE_TIF"), wxBITMAP_TYPE_TIF},
2313 { wxT("wxBITMAP_TYPE_ICO"), wxBITMAP_TYPE_ICO},
2314 { wxT("wxBITMAP_TYPE_ICO_RESOURCE"), wxBITMAP_TYPE_ICO_RESOURCE},
2315 { wxT("wxBITMAP_TYPE_CUR"), wxBITMAP_TYPE_CUR},
2316 { wxT("wxBITMAP_TYPE_CUR_RESOURCE"), wxBITMAP_TYPE_CUR_RESOURCE},
2317 { wxT("wxBITMAP_TYPE_XBM_DATA"), wxBITMAP_TYPE_XBM_DATA},
2318 { wxT("wxBITMAP_TYPE_XPM_DATA"), wxBITMAP_TYPE_XPM_DATA},
2319 { wxT("wxBITMAP_TYPE_ANY"), wxBITMAP_TYPE_ANY}
2320 };
2321
2322 static int wxResourceBitListCount = (sizeof(wxResourceBitListTable)/sizeof(wxResourceBitListStruct));
2323
2324 long wxParseWindowStyle(const wxString& bitListString)
2325 {
2326 int i = 0;
2327 wxChar *word;
2328 long bitList = 0;
2329 word = wxResourceParseWord(WXSTRINGCAST bitListString, &i);
2330 while (word != NULL)
2331 {
2332 bool found = FALSE;
2333 int j;
2334 for (j = 0; j < wxResourceBitListCount; j++)
2335 if (wxStrcmp(wxResourceBitListTable[j].word, word) == 0)
2336 {
2337 bitList |= wxResourceBitListTable[j].bits;
2338 found = TRUE;
2339 break;
2340 }
2341 if (!found)
2342 {
2343 wxLogWarning(_("Unrecognized style %s whilst parsing resource."), word);
2344 return 0;
2345 }
2346 word = wxResourceParseWord(WXSTRINGCAST bitListString, &i);
2347 }
2348 return bitList;
2349 }
2350
2351 /*
2352 * Load a bitmap from a wxWindows resource, choosing an optimum
2353 * depth and appropriate type.
2354 */
2355
2356 wxBitmap wxResourceCreateBitmap(const wxString& resource, wxResourceTable *table)
2357 {
2358 if (!table)
2359 table = wxDefaultResourceTable;
2360
2361 wxItemResource *item = table->FindResource(resource);
2362 if (item)
2363 {
2364 if ((item->GetType() == wxT("")) || (item->GetType() != wxT("wxBitmap")))
2365 {
2366 wxLogWarning(_("%s not a bitmap resource specification."), (const wxChar*) resource);
2367 return wxNullBitmap;
2368 }
2369 int thisDepth = wxDisplayDepth();
2370 long thisNoColours = (long)pow(2.0, (double)thisDepth);
2371
2372 wxItemResource *optResource = (wxItemResource *) NULL;
2373
2374 // Try to find optimum bitmap for this platform/colour depth
2375 wxNode *node = item->GetChildren().First();
2376 while (node)
2377 {
2378 wxItemResource *child = (wxItemResource *)node->Data();
2379 int platform = (int)child->GetValue2();
2380 int noColours = (int)child->GetValue3();
2381 /*
2382 char *name = child->GetName();
2383 int bitmapType = (int)child->GetValue1();
2384 int xRes = child->GetWidth();
2385 int yRes = child->GetHeight();
2386 */
2387
2388 switch (platform)
2389 {
2390 case RESOURCE_PLATFORM_ANY:
2391 {
2392 if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
2393 optResource = child;
2394 else
2395 {
2396 // Maximise the number of colours.
2397 // If noColours is zero (unspecified), then assume this
2398 // is the right one.
2399 if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
2400 optResource = child;
2401 }
2402 break;
2403 }
2404 #ifdef __WXMSW__
2405 case RESOURCE_PLATFORM_WINDOWS:
2406 {
2407 if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
2408 optResource = child;
2409 else
2410 {
2411 // Maximise the number of colours
2412 if ((noColours > 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
2413 optResource = child;
2414 }
2415 break;
2416 }
2417 #endif
2418 #ifdef __WXGTK__
2419 case RESOURCE_PLATFORM_X:
2420 {
2421 if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
2422 optResource = child;
2423 else
2424 {
2425 // Maximise the number of colours
2426 if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
2427 optResource = child;
2428 }
2429 break;
2430 }
2431 #endif
2432 #ifdef wx_max
2433 case RESOURCE_PLATFORM_MAC:
2434 {
2435 if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
2436 optResource = child;
2437 else
2438 {
2439 // Maximise the number of colours
2440 if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
2441 optResource = child;
2442 }
2443 break;
2444 }
2445 #endif
2446 default:
2447 break;
2448 }
2449 node = node->Next();
2450 }
2451 // If no matching resource, fail.
2452 if (!optResource)
2453 return wxNullBitmap;
2454
2455 wxString name = optResource->GetName();
2456 int bitmapType = (int)optResource->GetValue1();
2457 switch (bitmapType)
2458 {
2459 case wxBITMAP_TYPE_XBM_DATA:
2460 {
2461 #ifdef __WXGTK__
2462 wxItemResource *item = table->FindResource(name);
2463 if (!item)
2464 {
2465 wxLogWarning(_("Failed to find XBM resource %s.\n"
2466 "Forgot to use wxResourceLoadBitmapData?"), (const wxChar*) name);
2467 return wxNullBitmap;
2468 }
2469 return wxBitmap(item->GetValue1(), (int)item->GetValue2(), (int)item->GetValue3()) ;
2470 #else
2471 wxLogWarning(_("No XBM facility available!"));
2472 break;
2473 #endif
2474 }
2475 case wxBITMAP_TYPE_XPM_DATA:
2476 {
2477 wxItemResource *item = table->FindResource(name);
2478 if (!item)
2479 {
2480 wxLogWarning(_("Failed to find XPM resource %s.\nForgot to use wxResourceLoadBitmapData?"), (const wxChar*) name);
2481 return wxNullBitmap;
2482 }
2483 return wxBitmap((char **)item->GetValue1());
2484 }
2485 default:
2486 {
2487 #if defined(__WXPM__)
2488 return wxNullBitmap;
2489 #else
2490 return wxBitmap(name, (wxBitmapType)bitmapType);
2491 #endif
2492 }
2493 }
2494 #ifndef __WXGTK__
2495 return wxNullBitmap;
2496 #endif
2497 }
2498 else
2499 {
2500 wxLogWarning(_("Bitmap resource specification %s not found."), (const wxChar*) resource);
2501 return wxNullBitmap;
2502 }
2503 }
2504
2505 /*
2506 * Load an icon from a wxWindows resource, choosing an optimum
2507 * depth and appropriate type.
2508 */
2509
2510 wxIcon wxResourceCreateIcon(const wxString& resource, wxResourceTable *table)
2511 {
2512 if (!table)
2513 table = wxDefaultResourceTable;
2514
2515 wxItemResource *item = table->FindResource(resource);
2516 if (item)
2517 {
2518 if ((item->GetType() == wxT("")) || wxStrcmp(item->GetType(), wxT("wxIcon")) != 0)
2519 {
2520 wxLogWarning(_("%s not an icon resource specification."), (const wxChar*) resource);
2521 return wxNullIcon;
2522 }
2523 int thisDepth = wxDisplayDepth();
2524 long thisNoColours = (long)pow(2.0, (double)thisDepth);
2525
2526 wxItemResource *optResource = (wxItemResource *) NULL;
2527
2528 // Try to find optimum icon for this platform/colour depth
2529 wxNode *node = item->GetChildren().First();
2530 while (node)
2531 {
2532 wxItemResource *child = (wxItemResource *)node->Data();
2533 int platform = (int)child->GetValue2();
2534 int noColours = (int)child->GetValue3();
2535 /*
2536 char *name = child->GetName();
2537 int bitmapType = (int)child->GetValue1();
2538 int xRes = child->GetWidth();
2539 int yRes = child->GetHeight();
2540 */
2541
2542 switch (platform)
2543 {
2544 case RESOURCE_PLATFORM_ANY:
2545 {
2546 if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
2547 optResource = child;
2548 else
2549 {
2550 // Maximise the number of colours.
2551 // If noColours is zero (unspecified), then assume this
2552 // is the right one.
2553 if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
2554 optResource = child;
2555 }
2556 break;
2557 }
2558 #ifdef __WXMSW__
2559 case RESOURCE_PLATFORM_WINDOWS:
2560 {
2561 if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
2562 optResource = child;
2563 else
2564 {
2565 // Maximise the number of colours
2566 if ((noColours > 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
2567 optResource = child;
2568 }
2569 break;
2570 }
2571 #endif
2572 #ifdef __WXGTK__
2573 case RESOURCE_PLATFORM_X:
2574 {
2575 if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
2576 optResource = child;
2577 else
2578 {
2579 // Maximise the number of colours
2580 if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
2581 optResource = child;
2582 }
2583 break;
2584 }
2585 #endif
2586 #ifdef wx_max
2587 case RESOURCE_PLATFORM_MAC:
2588 {
2589 if (!optResource && ((noColours == 0) || (noColours <= thisNoColours)))
2590 optResource = child;
2591 else
2592 {
2593 // Maximise the number of colours
2594 if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3())))
2595 optResource = child;
2596 }
2597 break;
2598 }
2599 #endif
2600 default:
2601 break;
2602 }
2603 node = node->Next();
2604 }
2605 // If no matching resource, fail.
2606 if (!optResource)
2607 return wxNullIcon;
2608
2609 wxString name = optResource->GetName();
2610 int bitmapType = (int)optResource->GetValue1();
2611 switch (bitmapType)
2612 {
2613 case wxBITMAP_TYPE_XBM_DATA:
2614 {
2615 #ifdef __WXGTK__
2616 wxItemResource *item = table->FindResource(name);
2617 if (!item)
2618 {
2619 wxLogWarning(_("Failed to find XBM resource %s.\n"
2620 "Forgot to use wxResourceLoadIconData?"), (const wxChar*) name);
2621 return wxNullIcon;
2622 }
2623 return wxIcon((const char **)item->GetValue1(), (int)item->GetValue2(), (int)item->GetValue3());
2624 #else
2625 wxLogWarning(_("No XBM facility available!"));
2626 break;
2627 #endif
2628 }
2629 case wxBITMAP_TYPE_XPM_DATA:
2630 {
2631 // *** XPM ICON NOT YET IMPLEMENTED IN WXWINDOWS ***
2632 /*
2633 wxItemResource *item = table->FindResource(name);
2634 if (!item)
2635 {
2636 char buf[400];
2637 sprintf(buf, _("Failed to find XPM resource %s.\nForgot to use wxResourceLoadIconData?"), name);
2638 wxLogWarning(buf);
2639 return NULL;
2640 }
2641 return wxIcon((char **)item->GetValue1());
2642 */
2643 wxLogWarning(_("No XPM icon facility available!"));
2644 break;
2645 }
2646 default:
2647 {
2648 #ifdef __WXGTK__
2649 wxLogWarning(_("Icon resource specification %s not found."), (const wxChar*) resource);
2650 break;
2651 #else
2652 return wxIcon(name, bitmapType);
2653 #endif
2654 }
2655 }
2656 return wxNullIcon;
2657 }
2658 else
2659 {
2660 wxLogWarning(_("Icon resource specification %s not found."), (const wxChar*) resource);
2661 return wxNullIcon;
2662 }
2663 }
2664
2665 #if wxUSE_MENUS
2666
2667 wxMenu *wxResourceCreateMenu(wxItemResource *item)
2668 {
2669 wxMenu *menu = new wxMenu;
2670 wxNode *node = item->GetChildren().First();
2671 while (node)
2672 {
2673 wxItemResource *child = (wxItemResource *)node->Data();
2674 if ((child->GetType() != wxT("")) && (child->GetType() == wxT("wxMenuSeparator")))
2675 menu->AppendSeparator();
2676 else if (child->GetChildren().Number() > 0)
2677 {
2678 wxMenu *subMenu = wxResourceCreateMenu(child);
2679 if (subMenu)
2680 menu->Append((int)child->GetValue1(), child->GetTitle(), subMenu, child->GetValue4());
2681 }
2682 else
2683 {
2684 menu->Append((int)child->GetValue1(), child->GetTitle(), child->GetValue4(), (child->GetValue2() != 0));
2685 }
2686 node = node->Next();
2687 }
2688 return menu;
2689 }
2690
2691 wxMenuBar *wxResourceCreateMenuBar(const wxString& resource, wxResourceTable *table, wxMenuBar *menuBar)
2692 {
2693 if (!table)
2694 table = wxDefaultResourceTable;
2695
2696 wxItemResource *menuResource = table->FindResource(resource);
2697 if (menuResource && (menuResource->GetType() != wxT("")) && (menuResource->GetType() == wxT("wxMenu")))
2698 {
2699 if (!menuBar)
2700 menuBar = new wxMenuBar;
2701 wxNode *node = menuResource->GetChildren().First();
2702 while (node)
2703 {
2704 wxItemResource *child = (wxItemResource *)node->Data();
2705 wxMenu *menu = wxResourceCreateMenu(child);
2706 if (menu)
2707 menuBar->Append(menu, child->GetTitle());
2708 node = node->Next();
2709 }
2710 return menuBar;
2711 }
2712 return (wxMenuBar *) NULL;
2713 }
2714
2715 wxMenu *wxResourceCreateMenu(const wxString& resource, wxResourceTable *table)
2716 {
2717 if (!table)
2718 table = wxDefaultResourceTable;
2719
2720 wxItemResource *menuResource = table->FindResource(resource);
2721 if (menuResource && (menuResource->GetType() != wxT("")) && (menuResource->GetType() == wxT("wxMenu")))
2722 // if (menuResource && (menuResource->GetType() == wxTYPE_MENU))
2723 return wxResourceCreateMenu(menuResource);
2724 return (wxMenu *) NULL;
2725 }
2726
2727 #endif // wxUSE_MENUS
2728
2729 // Global equivalents (so don't have to refer to default table explicitly)
2730 bool wxResourceParseData(const wxString& resource, wxResourceTable *table)
2731 {
2732 if (!table)
2733 table = wxDefaultResourceTable;
2734
2735 return table->ParseResourceData(resource);
2736 }
2737
2738 bool wxResourceParseFile(const wxString& filename, wxResourceTable *table)
2739 {
2740 if (!table)
2741 table = wxDefaultResourceTable;
2742
2743 return table->ParseResourceFile(filename);
2744 }
2745
2746 // Register XBM/XPM data
2747 bool wxResourceRegisterBitmapData(const wxString& name, char bits[], int width, int height, wxResourceTable *table)
2748 {
2749 if (!table)
2750 table = wxDefaultResourceTable;
2751
2752 return table->RegisterResourceBitmapData(name, bits, width, height);
2753 }
2754
2755 bool wxResourceRegisterBitmapData(const wxString& name, char **data, wxResourceTable *table)
2756 {
2757 if (!table)
2758 table = wxDefaultResourceTable;
2759
2760 return table->RegisterResourceBitmapData(name, data);
2761 }
2762
2763 void wxResourceClear(wxResourceTable *table)
2764 {
2765 if (!table)
2766 table = wxDefaultResourceTable;
2767
2768 table->ClearTable();
2769 }
2770
2771 /*
2772 * Identifiers
2773 */
2774
2775 bool wxResourceAddIdentifier(const wxString& name, int value, wxResourceTable *table)
2776 {
2777 if (!table)
2778 table = wxDefaultResourceTable;
2779
2780 table->identifiers.Put(name, (wxObject *)(long)value);
2781 return TRUE;
2782 }
2783
2784 int wxResourceGetIdentifier(const wxString& name, wxResourceTable *table)
2785 {
2786 if (!table)
2787 table = wxDefaultResourceTable;
2788
2789 return (int)(long)table->identifiers.Get(name);
2790 }
2791
2792 /*
2793 * Parse #include file for #defines (only)
2794 */
2795
2796 bool wxResourceParseIncludeFile(const wxString& f, wxResourceTable *table)
2797 {
2798 if (!table)
2799 table = wxDefaultResourceTable;
2800
2801 FILE *fd = wxFopen(f, _T("r"));
2802 if (!fd)
2803 {
2804 return FALSE;
2805 }
2806 while (wxGetResourceToken(fd))
2807 {
2808 if (strcmp(wxResourceBuffer, "#define") == 0)
2809 {
2810 wxGetResourceToken(fd);
2811 wxChar *name = copystring(wxConvCurrent->cMB2WX(wxResourceBuffer));
2812 wxGetResourceToken(fd);
2813 wxChar *value = copystring(wxConvCurrent->cMB2WX(wxResourceBuffer));
2814 if (wxIsdigit(value[0]))
2815 {
2816 int val = (int)wxAtol(value);
2817 wxResourceAddIdentifier(name, val, table);
2818 }
2819 delete[] name;
2820 delete[] value;
2821 }
2822 }
2823 fclose(fd);
2824 return TRUE;
2825 }
2826
2827 /*
2828 * Reading strings as if they were .wxr files
2829 */
2830
2831 static int getc_string(char *s)
2832 {
2833 int ch = s[wxResourceStringPtr];
2834 if (ch == 0)
2835 return EOF;
2836 else
2837 {
2838 wxResourceStringPtr ++;
2839 return ch;
2840 }
2841 }
2842
2843 static int ungetc_string()
2844 {
2845 wxResourceStringPtr --;
2846 return 0;
2847 }
2848
2849 bool wxEatWhiteSpaceString(char *s)
2850 {
2851 int ch = 0;
2852
2853 while ((ch = getc_string(s)) != EOF)
2854 {
2855 switch (ch)
2856 {
2857 case ' ':
2858 case 0x0a:
2859 case 0x0d:
2860 case 0x09:
2861 break;
2862 case '/':
2863 {
2864 int prev_ch = ch;
2865 ch = getc_string(s);
2866 if (ch == EOF)
2867 {
2868 ungetc_string();
2869 return TRUE;
2870 }
2871
2872 if (ch == '*')
2873 {
2874 // Eat C comment
2875 prev_ch = 0;
2876 while ((ch = getc_string(s)) != EOF)
2877 {
2878 if (ch == '/' && prev_ch == '*')
2879 break;
2880 prev_ch = ch;
2881 }
2882 }
2883 else
2884 {
2885 ungetc_string();
2886 ungetc_string();
2887 return TRUE;
2888 }
2889 }
2890 break;
2891 default:
2892 ungetc_string();
2893 return TRUE;
2894
2895 }
2896 }
2897 return FALSE;
2898 }
2899
2900 bool wxGetResourceTokenString(char *s)
2901 {
2902 if (!wxResourceBuffer)
2903 wxReallocateResourceBuffer();
2904 wxResourceBuffer[0] = 0;
2905 wxEatWhiteSpaceString(s);
2906
2907 int ch = getc_string(s);
2908 if (ch == '"')
2909 {
2910 // Get string
2911 wxResourceBufferCount = 0;
2912 ch = getc_string(s);
2913 while (ch != '"')
2914 {
2915 int actualCh = ch;
2916 if (ch == EOF)
2917 {
2918 wxResourceBuffer[wxResourceBufferCount] = 0;
2919 return FALSE;
2920 }
2921 // Escaped characters
2922 else if (ch == '\\')
2923 {
2924 int newCh = getc_string(s);
2925 if (newCh == '"')
2926 actualCh = '"';
2927 else if (newCh == 10)
2928 actualCh = 10;
2929 else
2930 {
2931 ungetc_string();
2932 }
2933 }
2934
2935 if (wxResourceBufferCount >= wxResourceBufferSize-1)
2936 wxReallocateResourceBuffer();
2937 wxResourceBuffer[wxResourceBufferCount] = (char)actualCh;
2938 wxResourceBufferCount ++;
2939 ch = getc_string(s);
2940 }
2941 wxResourceBuffer[wxResourceBufferCount] = 0;
2942 }
2943 else
2944 {
2945 wxResourceBufferCount = 0;
2946 // Any other token
2947 while (ch != ' ' && ch != EOF && ch != ' ' && ch != 13 && ch != 9 && ch != 10)
2948 {
2949 if (wxResourceBufferCount >= wxResourceBufferSize-1)
2950 wxReallocateResourceBuffer();
2951 wxResourceBuffer[wxResourceBufferCount] = (char)ch;
2952 wxResourceBufferCount ++;
2953
2954 ch = getc_string(s);
2955 }
2956 wxResourceBuffer[wxResourceBufferCount] = 0;
2957 if (ch == EOF)
2958 return FALSE;
2959 }
2960 return TRUE;
2961 }
2962
2963 /*
2964 * Files are in form:
2965 static char *name = "....";
2966 with possible comments.
2967 */
2968
2969 bool wxResourceReadOneResourceString(char *s, wxExprDatabase& db, bool *eof, wxResourceTable *table)
2970 {
2971 if (!table)
2972 table = wxDefaultResourceTable;
2973
2974 // static or #define
2975 if (!wxGetResourceTokenString(s))
2976 {
2977 *eof = TRUE;
2978 return FALSE;
2979 }
2980
2981 if (strcmp(wxResourceBuffer, "#define") == 0)
2982 {
2983 wxGetResourceTokenString(s);
2984 wxChar *name = copystring(wxConvCurrent->cMB2WX(wxResourceBuffer));
2985 wxGetResourceTokenString(s);
2986 wxChar *value = copystring(wxConvCurrent->cMB2WX(wxResourceBuffer));
2987 if (wxIsdigit(value[0]))
2988 {
2989 int val = (int)wxAtol(value);
2990 wxResourceAddIdentifier(name, val, table);
2991 }
2992 else
2993 {
2994 wxLogWarning(_("#define %s must be an integer."), name);
2995 delete[] name;
2996 delete[] value;
2997 return FALSE;
2998 }
2999 delete[] name;
3000 delete[] value;
3001
3002 return TRUE;
3003 }
3004 /*
3005 else if (strcmp(wxResourceBuffer, "#include") == 0)
3006 {
3007 wxGetResourceTokenString(s);
3008 char *name = copystring(wxResourceBuffer);
3009 char *actualName = name;
3010 if (name[0] == '"')
3011 actualName = name + 1;
3012 int len = strlen(name);
3013 if ((len > 0) && (name[len-1] == '"'))
3014 name[len-1] = 0;
3015 if (!wxResourceParseIncludeFile(actualName, table))
3016 {
3017 char buf[400];
3018 sprintf(buf, _("Could not find resource include file %s."), actualName);
3019 wxLogWarning(buf);
3020 }
3021 delete[] name;
3022 return TRUE;
3023 }
3024 */
3025 else if (strcmp(wxResourceBuffer, "static") != 0)
3026 {
3027 wxChar buf[300];
3028 wxStrcpy(buf, _("Found "));
3029 wxStrncat(buf, wxConvCurrent->cMB2WX(wxResourceBuffer), 30);
3030 wxStrcat(buf, _(", expected static, #include or #define\nwhilst parsing resource."));
3031 wxLogWarning(buf);
3032 return FALSE;
3033 }
3034
3035 // char
3036 if (!wxGetResourceTokenString(s))
3037 {
3038 wxLogWarning(_("Unexpected end of file whilst parsing resource."));
3039 *eof = TRUE;
3040 return FALSE;
3041 }
3042
3043 if (strcmp(wxResourceBuffer, "char") != 0)
3044 {
3045 wxLogWarning(_("Expected 'char' whilst parsing resource."));
3046 return FALSE;
3047 }
3048
3049 // *name
3050 if (!wxGetResourceTokenString(s))
3051 {
3052 wxLogWarning(_("Unexpected end of file whilst parsing resource."));
3053 *eof = TRUE;
3054 return FALSE;
3055 }
3056
3057 if (wxResourceBuffer[0] != '*')
3058 {
3059 wxLogWarning(_("Expected '*' whilst parsing resource."));
3060 return FALSE;
3061 }
3062 wxChar nameBuf[100];
3063 wxMB2WX(nameBuf, wxResourceBuffer+1, 99);
3064 nameBuf[99] = 0;
3065
3066 // =
3067 if (!wxGetResourceTokenString(s))
3068 {
3069 wxLogWarning(_("Unexpected end of file whilst parsing resource."));
3070 *eof = TRUE;
3071 return FALSE;
3072 }
3073
3074 if (strcmp(wxResourceBuffer, "=") != 0)
3075 {
3076 wxLogWarning(_("Expected '=' whilst parsing resource."));
3077 return FALSE;
3078 }
3079
3080 // String
3081 if (!wxGetResourceTokenString(s))
3082 {
3083 wxLogWarning(_("Unexpected end of file whilst parsing resource."));
3084 *eof = TRUE;
3085 return FALSE;
3086 }
3087 else
3088 {
3089 if (!db.ReadPrologFromString(wxResourceBuffer))
3090 {
3091 wxLogWarning(_("%s: ill-formed resource file syntax."), nameBuf);
3092 return FALSE;
3093 }
3094 }
3095 // Semicolon
3096 if (!wxGetResourceTokenString(s))
3097 {
3098 *eof = TRUE;
3099 }
3100 return TRUE;
3101 }
3102
3103 bool wxResourceParseString(char *s, wxResourceTable *table)
3104 {
3105 if (!table)
3106 table = wxDefaultResourceTable;
3107
3108 if (!s)
3109 return FALSE;
3110
3111 // Turn backslashes into spaces
3112 if (s)
3113 {
3114 int len = strlen(s);
3115 int i;
3116 for (i = 0; i < len; i++)
3117 if (s[i] == 92 && s[i+1] == 13)
3118 {
3119 s[i] = ' ';
3120 s[i+1] = ' ';
3121 }
3122 }
3123
3124 wxExprDatabase db;
3125 wxResourceStringPtr = 0;
3126
3127 bool eof = FALSE;
3128 while (wxResourceReadOneResourceString(s, db, &eof, table) && !eof)
3129 {
3130 // Loop
3131 }
3132 return wxResourceInterpretResources(*table, db);
3133 }
3134
3135 /*
3136 * resource loading facility
3137 */
3138
3139 bool wxWindowBase::LoadFromResource(wxWindow *parent, const wxString& resourceName, const wxResourceTable *table)
3140 {
3141 if (!table)
3142 table = wxDefaultResourceTable;
3143
3144 wxItemResource *resource = table->FindResource((const wxChar *)resourceName);
3145 // if (!resource || (resource->GetType() != wxTYPE_DIALOG_BOX))
3146 if (!resource || (resource->GetType() == wxT("")) ||
3147 ! ((resource->GetType() == wxT("wxDialog")) || (resource->GetType() == wxT("wxPanel"))))
3148 return FALSE;
3149
3150 wxString title(resource->GetTitle());
3151 long theWindowStyle = resource->GetStyle();
3152 bool isModal = (resource->GetValue1() != 0) ;
3153 int x = resource->GetX();
3154 int y = resource->GetY();
3155 int width = resource->GetWidth();
3156 int height = resource->GetHeight();
3157 wxString name = resource->GetName();
3158
3159 // this is used for loading wxWizard pages from WXR
3160 if ( parent != this )
3161 {
3162 if (IsKindOf(CLASSINFO(wxDialog)))
3163 {
3164 wxDialog *dialogBox = (wxDialog *)this;
3165 long modalStyle = isModal ? wxDIALOG_MODAL : 0;
3166 if (!dialogBox->Create(parent, -1, title, wxPoint(x, y), wxSize(width, height), theWindowStyle|modalStyle, name))
3167 return FALSE;
3168
3169 // Only reset the client size if we know we're not going to do it again below.
3170 if ((resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS) == 0)
3171 dialogBox->SetClientSize(width, height);
3172 }
3173 else if (IsKindOf(CLASSINFO(wxPanel)))
3174 {
3175 wxPanel* panel = (wxPanel *)this;
3176 if (!panel->Create(parent, -1, wxPoint(x, y), wxSize(width, height), theWindowStyle | wxTAB_TRAVERSAL, name))
3177 return FALSE;
3178 }
3179 else
3180 {
3181 if (!((wxWindow *)this)->Create(parent, -1, wxPoint(x, y), wxSize(width, height), theWindowStyle, name))
3182 return FALSE;
3183 }
3184 }
3185
3186 if ((resource->GetResourceStyle() & wxRESOURCE_USE_DEFAULTS) != 0)
3187 {
3188 // No need to do this since it's done in wxPanel or wxDialog constructor.
3189 // SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
3190 }
3191 else
3192 {
3193 if (resource->GetFont().Ok())
3194 SetFont(resource->GetFont());
3195 if (resource->GetBackgroundColour().Ok())
3196 SetBackgroundColour(resource->GetBackgroundColour());
3197 }
3198
3199 // Should have some kind of font at this point
3200 if (!GetFont().Ok())
3201 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
3202 if (!GetBackgroundColour().Ok())
3203 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
3204
3205 // Only when we've created the window and set the font can we set the correct size,
3206 // if based on dialog units.
3207 if ((resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS) != 0)
3208 {
3209 wxSize sz = ConvertDialogToPixels(wxSize(width, height));
3210 SetClientSize(sz.x, sz.y);
3211
3212 wxPoint pt = ConvertDialogToPixels(wxPoint(x, y));
3213 Move(pt.x, pt.y);
3214 }
3215
3216 // Now create children
3217 wxNode *node = resource->GetChildren().First();
3218 while (node)
3219 {
3220 wxItemResource *childResource = (wxItemResource *)node->Data();
3221
3222 (void) CreateItem(childResource, resource, table);
3223
3224 node = node->Next();
3225 }
3226 return TRUE;
3227 }
3228
3229 wxControl *wxWindowBase::CreateItem(const wxItemResource *resource, const wxItemResource* parentResource, const wxResourceTable *table)
3230 {
3231 if (!table)
3232 table = wxDefaultResourceTable;
3233 return table->CreateItem((wxWindow *)this, resource, parentResource);
3234 }
3235
3236 #ifdef __VISUALC__
3237 #pragma warning(default:4706) // assignment within conditional expression
3238 #endif // VC++
3239
3240 #endif
3241 // BC++/Win16
3242
3243 #endif // wxUSE_WX_RESOURCES
wxWidgets (Impactor)