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