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