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