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