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