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