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


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