]> git.saurik.com Git - wxWidgets.git/blob - src/common/resource.cpp
projects / wxWidgets.git / blob
? search:


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