]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: resourc2.cpp | |
3 | // Purpose: Resource system (2nd file). Only required for 16-bit BC++. | |
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 licence | |
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 _MSC_VER | |
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/statbox.h" | |
48 | #if wxUSE_GAUGE | |
49 | #include "wx/gauge.h" | |
50 | #endif | |
51 | #include "wx/textctrl.h" | |
52 | #include "wx/msgdlg.h" | |
53 | #include "wx/intl.h" | |
54 | #endif | |
55 | ||
56 | #if wxUSE_SCROLLBAR | |
57 | #include "wx/scrolbar.h" | |
58 | #endif | |
59 | ||
60 | #if wxUSE_COMBOBOX | |
61 | #include "wx/combobox.h" | |
62 | #endif | |
63 | ||
64 | #include "wx/validate.h" | |
65 | ||
66 | #include "wx/log.h" | |
67 | ||
68 | #include <ctype.h> | |
69 | #include <math.h> | |
70 | #include <stdlib.h> | |
71 | #include <string.h> | |
72 | ||
73 | #include "wx/resource.h" | |
74 | #include "wx/string.h" | |
75 | #include "wx/wxexpr.h" | |
76 | ||
77 | #include "wx/settings.h" | |
78 | ||
79 | #if ((defined(__BORLANDC__) || defined(__SC__)) && defined(__WIN16__)) | |
80 | ||
81 | // Forward (private) declarations | |
82 | bool wxResourceInterpretResources(wxResourceTable& table, wxExprDatabase& db); | |
83 | wxItemResource *wxResourceInterpretDialog(wxResourceTable& table, wxExpr *expr, bool isPanel = FALSE); | |
84 | wxItemResource *wxResourceInterpretControl(wxResourceTable& table, wxExpr *expr); | |
85 | wxItemResource *wxResourceInterpretMenu(wxResourceTable& table, wxExpr *expr); | |
86 | wxItemResource *wxResourceInterpretMenuBar(wxResourceTable& table, wxExpr *expr); | |
87 | wxItemResource *wxResourceInterpretString(wxResourceTable& table, wxExpr *expr); | |
88 | wxItemResource *wxResourceInterpretBitmap(wxResourceTable& table, wxExpr *expr); | |
89 | wxItemResource *wxResourceInterpretIcon(wxResourceTable& table, wxExpr *expr); | |
90 | // Interpret list expression | |
91 | wxFont wxResourceInterpretFontSpec(wxExpr *expr); | |
92 | ||
93 | bool wxResourceReadOneResource(FILE *fd, wxExprDatabase& db, bool *eof, wxResourceTable *table = (wxResourceTable *) NULL); | |
94 | bool wxResourceParseIncludeFile(const wxString& f, wxResourceTable *table = (wxResourceTable *) NULL); | |
95 | ||
96 | extern wxResourceTable *wxDefaultResourceTable; | |
97 | ||
98 | extern char *wxResourceBuffer; | |
99 | extern long wxResourceBufferSize; | |
100 | extern long wxResourceBufferCount; | |
101 | extern int wxResourceStringPtr; | |
102 | ||
103 | /* | |
104 | * (Re)allocate buffer for reading in from resource file | |
105 | */ | |
106 | ||
107 | bool wxReallocateResourceBuffer() | |
108 | { | |
109 | if (!wxResourceBuffer) | |
110 | { | |
111 | wxResourceBufferSize = 1000; | |
112 | wxResourceBuffer = new char[wxResourceBufferSize]; | |
113 | return TRUE; | |
114 | } | |
115 | if (wxResourceBuffer) | |
116 | { | |
117 | long newSize = wxResourceBufferSize + 1000; | |
118 | char *tmp = new char[(int)newSize]; | |
119 | strncpy(tmp, wxResourceBuffer, (int)wxResourceBufferCount); | |
120 | delete[] wxResourceBuffer; | |
121 | wxResourceBuffer = tmp; | |
122 | wxResourceBufferSize = newSize; | |
123 | } | |
124 | return TRUE; | |
125 | } | |
126 | ||
127 | static bool wxEatWhiteSpace(FILE *fd) | |
128 | { | |
129 | int ch = getc(fd); | |
130 | if ((ch != ' ') && (ch != '/') && (ch != ' ') && (ch != 10) && (ch != 13) && (ch != 9)) | |
131 | { | |
132 | ungetc(ch, fd); | |
133 | return TRUE; | |
134 | } | |
135 | ||
136 | // Eat whitespace | |
137 | while (ch == ' ' || ch == 10 || ch == 13 || ch == 9) | |
138 | ch = getc(fd); | |
139 | // Check for comment | |
140 | if (ch == '/') | |
141 | { | |
142 | ch = getc(fd); | |
143 | if (ch == '*') | |
144 | { | |
145 | bool finished = FALSE; | |
146 | while (!finished) | |
147 | { | |
148 | ch = getc(fd); | |
149 | if (ch == EOF) | |
150 | return FALSE; | |
151 | if (ch == '*') | |
152 | { | |
153 | int newCh = getc(fd); | |
154 | if (newCh == '/') | |
155 | finished = TRUE; | |
156 | else | |
157 | { | |
158 | ungetc(newCh, fd); | |
159 | } | |
160 | } | |
161 | } | |
162 | } | |
163 | else // False alarm | |
164 | return FALSE; | |
165 | } | |
166 | else | |
167 | ungetc(ch, fd); | |
168 | return wxEatWhiteSpace(fd); | |
169 | } | |
170 | ||
171 | bool wxGetResourceToken(FILE *fd) | |
172 | { | |
173 | if (!wxResourceBuffer) | |
174 | wxReallocateResourceBuffer(); | |
175 | wxResourceBuffer[0] = 0; | |
176 | wxEatWhiteSpace(fd); | |
177 | ||
178 | int ch = getc(fd); | |
179 | if (ch == '"') | |
180 | { | |
181 | // Get string | |
182 | wxResourceBufferCount = 0; | |
183 | ch = getc(fd); | |
184 | while (ch != '"') | |
185 | { | |
186 | int actualCh = ch; | |
187 | if (ch == EOF) | |
188 | { | |
189 | wxResourceBuffer[wxResourceBufferCount] = 0; | |
190 | return FALSE; | |
191 | } | |
192 | // Escaped characters | |
193 | else if (ch == '\\') | |
194 | { | |
195 | int newCh = getc(fd); | |
196 | if (newCh == '"') | |
197 | actualCh = '"'; | |
198 | else if (newCh == 10) | |
199 | actualCh = 10; | |
200 | else | |
201 | { | |
202 | ungetc(newCh, fd); | |
203 | } | |
204 | } | |
205 | ||
206 | if (wxResourceBufferCount >= wxResourceBufferSize-1) | |
207 | wxReallocateResourceBuffer(); | |
208 | wxResourceBuffer[wxResourceBufferCount] = (char)actualCh; | |
209 | wxResourceBufferCount ++; | |
210 | ch = getc(fd); | |
211 | } | |
212 | wxResourceBuffer[wxResourceBufferCount] = 0; | |
213 | } | |
214 | else | |
215 | { | |
216 | wxResourceBufferCount = 0; | |
217 | // Any other token | |
218 | while (ch != ' ' && ch != EOF && ch != ' ' && ch != 13 && ch != 9 && ch != 10) | |
219 | { | |
220 | if (wxResourceBufferCount >= wxResourceBufferSize-1) | |
221 | wxReallocateResourceBuffer(); | |
222 | wxResourceBuffer[wxResourceBufferCount] = (char)ch; | |
223 | wxResourceBufferCount ++; | |
224 | ||
225 | ch = getc(fd); | |
226 | } | |
227 | wxResourceBuffer[wxResourceBufferCount] = 0; | |
228 | if (ch == EOF) | |
229 | return FALSE; | |
230 | } | |
231 | return TRUE; | |
232 | } | |
233 | ||
234 | /* | |
235 | * Files are in form: | |
236 | static char *name = "...."; | |
237 | with possible comments. | |
238 | */ | |
239 | ||
240 | bool wxResourceReadOneResource(FILE *fd, wxExprDatabase& db, bool *eof, wxResourceTable *table) | |
241 | { | |
242 | if (!table) | |
243 | table = wxDefaultResourceTable; | |
244 | ||
245 | // static or #define | |
246 | if (!wxGetResourceToken(fd)) | |
247 | { | |
248 | *eof = TRUE; | |
249 | return FALSE; | |
250 | } | |
251 | ||
252 | if (strcmp(wxResourceBuffer, "#define") == 0) | |
253 | { | |
254 | wxGetResourceToken(fd); | |
255 | char *name = copystring(wxResourceBuffer); | |
256 | wxGetResourceToken(fd); | |
257 | char *value = copystring(wxResourceBuffer); | |
258 | if (isalpha(value[0])) | |
259 | { | |
260 | int val = (int)atol(value); | |
261 | wxResourceAddIdentifier(name, val, table); | |
262 | } | |
263 | else | |
264 | { | |
265 | wxLogWarning(_("#define %s must be an integer."), name); | |
266 | delete[] name; | |
267 | delete[] value; | |
268 | return FALSE; | |
269 | } | |
270 | delete[] name; | |
271 | delete[] value; | |
272 | ||
273 | return TRUE; | |
274 | } | |
275 | else if (strcmp(wxResourceBuffer, "#include") == 0) | |
276 | { | |
277 | wxGetResourceToken(fd); | |
278 | char *name = copystring(wxResourceBuffer); | |
279 | char *actualName = name; | |
280 | if (name[0] == '"') | |
281 | actualName = name + 1; | |
282 | int len = strlen(name); | |
283 | if ((len > 0) && (name[len-1] == '"')) | |
284 | name[len-1] = 0; | |
285 | if (!wxResourceParseIncludeFile(actualName, table)) | |
286 | { | |
287 | wxLogWarning(_("Could not find resource include file %s."), actualName); | |
288 | } | |
289 | delete[] name; | |
290 | return TRUE; | |
291 | } | |
292 | else if (strcmp(wxResourceBuffer, "static") != 0) | |
293 | { | |
294 | char buf[300]; | |
295 | strcpy(buf, _("Found ")); | |
296 | strncat(buf, wxResourceBuffer, 30); | |
297 | strcat(buf, _(", expected static, #include or #define\nwhilst parsing resource.")); | |
298 | wxLogWarning(buf); | |
299 | return FALSE; | |
300 | } | |
301 | ||
302 | // char | |
303 | if (!wxGetResourceToken(fd)) | |
304 | { | |
305 | wxLogWarning(_("Unexpected end of file whilst parsing resource.")); | |
306 | *eof = TRUE; | |
307 | return FALSE; | |
308 | } | |
309 | ||
310 | if (strcmp(wxResourceBuffer, "char") != 0) | |
311 | { | |
312 | wxLogWarning(_("Expected 'char' whilst parsing resource.")); | |
313 | return FALSE; | |
314 | } | |
315 | ||
316 | // *name | |
317 | if (!wxGetResourceToken(fd)) | |
318 | { | |
319 | wxLogWarning(_("Unexpected end of file whilst parsing resource.")); | |
320 | *eof = TRUE; | |
321 | return FALSE; | |
322 | } | |
323 | ||
324 | if (wxResourceBuffer[0] != '*') | |
325 | { | |
326 | wxLogWarning(_("Expected '*' whilst parsing resource.")); | |
327 | return FALSE; | |
328 | } | |
329 | char nameBuf[100]; | |
330 | strncpy(nameBuf, wxResourceBuffer+1, 99); | |
331 | ||
332 | // = | |
333 | if (!wxGetResourceToken(fd)) | |
334 | { | |
335 | wxLogWarning(_("Unexpected end of file whilst parsing resource.")); | |
336 | *eof = TRUE; | |
337 | return FALSE; | |
338 | } | |
339 | ||
340 | if (strcmp(wxResourceBuffer, "=") != 0) | |
341 | { | |
342 | wxLogWarning(_("Expected '=' whilst parsing resource.")); | |
343 | return FALSE; | |
344 | } | |
345 | ||
346 | // String | |
347 | if (!wxGetResourceToken(fd)) | |
348 | { | |
349 | wxLogWarning(_("Unexpected end of file whilst parsing resource.")); | |
350 | *eof = TRUE; | |
351 | return FALSE; | |
352 | } | |
353 | else | |
354 | { | |
355 | if (!db.ReadPrologFromString(wxResourceBuffer)) | |
356 | { | |
357 | wxLogWarning(_("%s: ill-formed resource file syntax."), nameBuf); | |
358 | return FALSE; | |
359 | } | |
360 | } | |
361 | // Semicolon | |
362 | if (!wxGetResourceToken(fd)) | |
363 | { | |
364 | *eof = TRUE; | |
365 | } | |
366 | return TRUE; | |
367 | } | |
368 | ||
369 | /* | |
370 | * Parses string window style into integer window style | |
371 | */ | |
372 | ||
373 | /* | |
374 | * Style flag parsing, e.g. | |
375 | * "wxSYSTEM_MENU | wxBORDER" -> integer | |
376 | */ | |
377 | ||
378 | char* wxResourceParseWord(char*s, int *i) | |
379 | { | |
380 | if (!s) | |
381 | return (char*) NULL; | |
382 | ||
383 | static char buf[150]; | |
384 | int len = strlen(s); | |
385 | int j = 0; | |
386 | int ii = *i; | |
387 | while ((ii < len) && (isalpha(s[ii]) || (s[ii] == '_'))) | |
388 | { | |
389 | buf[j] = s[ii]; | |
390 | j ++; | |
391 | ii ++; | |
392 | } | |
393 | buf[j] = 0; | |
394 | ||
395 | // Eat whitespace and conjunction characters | |
396 | while ((ii < len) && | |
397 | ((s[ii] == ' ') || (s[ii] == '|') || (s[ii] == ','))) | |
398 | { | |
399 | ii ++; | |
400 | } | |
401 | *i = ii; | |
402 | if (j == 0) | |
403 | return (char*) NULL; | |
404 | else | |
405 | return buf; | |
406 | } | |
407 | ||
408 | struct wxResourceBitListStruct | |
409 | { | |
410 | char *word; | |
411 | long bits; | |
412 | }; | |
413 | ||
414 | static wxResourceBitListStruct wxResourceBitListTable[] = | |
415 | { | |
416 | /* wxListBox */ | |
417 | { "wxSINGLE", wxLB_SINGLE }, | |
418 | { "wxMULTIPLE", wxLB_MULTIPLE }, | |
419 | { "wxEXTENDED", wxLB_EXTENDED }, | |
420 | { "wxLB_SINGLE", wxLB_SINGLE }, | |
421 | { "wxLB_MULTIPLE", wxLB_MULTIPLE }, | |
422 | { "wxLB_EXTENDED", wxLB_EXTENDED }, | |
423 | { "wxLB_NEEDED_SB", wxLB_NEEDED_SB }, | |
424 | { "wxLB_ALWAYS_SB", wxLB_ALWAYS_SB }, | |
425 | { "wxLB_SORT", wxLB_SORT }, | |
426 | { "wxLB_OWNERDRAW", wxLB_OWNERDRAW }, | |
427 | { "wxLB_HSCROLL", wxLB_HSCROLL }, | |
428 | ||
429 | /* wxComboxBox */ | |
430 | { "wxCB_SIMPLE", wxCB_SIMPLE }, | |
431 | { "wxCB_DROPDOWN", wxCB_DROPDOWN }, | |
432 | { "wxCB_READONLY", wxCB_READONLY }, | |
433 | { "wxCB_SORT", wxCB_SORT }, | |
434 | ||
435 | /* wxGauge */ | |
436 | { "wxGA_PROGRESSBAR", wxGA_PROGRESSBAR }, | |
437 | { "wxGA_HORIZONTAL", wxGA_HORIZONTAL }, | |
438 | { "wxGA_VERTICAL", wxGA_VERTICAL }, | |
439 | ||
440 | /* wxTextCtrl */ | |
441 | { "wxPASSWORD", wxPASSWORD}, | |
442 | { "wxPROCESS_ENTER", wxPROCESS_ENTER}, | |
443 | { "wxTE_PASSWORD", wxTE_PASSWORD}, | |
444 | { "wxTE_READONLY", wxTE_READONLY}, | |
445 | { "wxTE_PROCESS_ENTER", wxTE_PROCESS_ENTER}, | |
446 | { "wxTE_MULTILINE", wxTE_MULTILINE}, | |
447 | ||
448 | /* wxRadioBox/wxRadioButton */ | |
449 | { "wxRB_GROUP", wxRB_GROUP }, | |
450 | { "wxRA_SPECIFY_COLS", wxRA_SPECIFY_COLS }, | |
451 | { "wxRA_SPECIFY_ROWS", wxRA_SPECIFY_ROWS }, | |
452 | { "wxRA_HORIZONTAL", wxRA_HORIZONTAL }, | |
453 | { "wxRA_VERTICAL", wxRA_VERTICAL }, | |
454 | ||
455 | /* wxSlider */ | |
456 | { "wxSL_HORIZONTAL", wxSL_HORIZONTAL }, | |
457 | { "wxSL_VERTICAL", wxSL_VERTICAL }, | |
458 | { "wxSL_AUTOTICKS", wxSL_AUTOTICKS }, | |
459 | { "wxSL_LABELS", wxSL_LABELS }, | |
460 | { "wxSL_LEFT", wxSL_LEFT }, | |
461 | { "wxSL_TOP", wxSL_TOP }, | |
462 | { "wxSL_RIGHT", wxSL_RIGHT }, | |
463 | { "wxSL_BOTTOM", wxSL_BOTTOM }, | |
464 | { "wxSL_BOTH", wxSL_BOTH }, | |
465 | { "wxSL_SELRANGE", wxSL_SELRANGE }, | |
466 | ||
467 | /* wxScrollBar */ | |
468 | { "wxSB_HORIZONTAL", wxSB_HORIZONTAL }, | |
469 | { "wxSB_VERTICAL", wxSB_VERTICAL }, | |
470 | ||
471 | /* wxButton */ | |
472 | { "wxBU_AUTODRAW", wxBU_AUTODRAW }, | |
473 | { "wxBU_NOAUTODRAW", wxBU_NOAUTODRAW }, | |
474 | ||
475 | /* wxTreeCtrl */ | |
476 | { "wxTR_HAS_BUTTONS", wxTR_HAS_BUTTONS }, | |
477 | { "wxTR_EDIT_LABELS", wxTR_EDIT_LABELS }, | |
478 | { "wxTR_LINES_AT_ROOT", wxTR_LINES_AT_ROOT }, | |
479 | ||
480 | /* wxListCtrl */ | |
481 | { "wxLC_ICON", wxLC_ICON }, | |
482 | { "wxLC_SMALL_ICON", wxLC_SMALL_ICON }, | |
483 | { "wxLC_LIST", wxLC_LIST }, | |
484 | { "wxLC_REPORT", wxLC_REPORT }, | |
485 | { "wxLC_ALIGN_TOP", wxLC_ALIGN_TOP }, | |
486 | { "wxLC_ALIGN_LEFT", wxLC_ALIGN_LEFT }, | |
487 | { "wxLC_AUTOARRANGE", wxLC_AUTOARRANGE }, | |
488 | { "wxLC_USER_TEXT", wxLC_USER_TEXT }, | |
489 | { "wxLC_EDIT_LABELS", wxLC_EDIT_LABELS }, | |
490 | { "wxLC_NO_HEADER", wxLC_NO_HEADER }, | |
491 | { "wxLC_NO_SORT_HEADER", wxLC_NO_SORT_HEADER }, | |
492 | { "wxLC_SINGLE_SEL", wxLC_SINGLE_SEL }, | |
493 | { "wxLC_SORT_ASCENDING", wxLC_SORT_ASCENDING }, | |
494 | { "wxLC_SORT_DESCENDING", wxLC_SORT_DESCENDING }, | |
495 | ||
496 | /* wxSpinButton */ | |
497 | { "wxSP_VERTICAL", wxSP_VERTICAL}, | |
498 | { "wxSP_HORIZONTAL", wxSP_HORIZONTAL}, | |
499 | { "wxSP_ARROW_KEYS", wxSP_ARROW_KEYS}, | |
500 | { "wxSP_WRAP", wxSP_WRAP}, | |
501 | ||
502 | /* wxSplitterWnd */ | |
503 | { "wxSP_NOBORDER", wxSP_NOBORDER}, | |
504 | { "wxSP_3D", wxSP_3D}, | |
505 | { "wxSP_BORDER", wxSP_BORDER}, | |
506 | ||
507 | /* wxTabCtrl */ | |
508 | { "wxTC_MULTILINE", wxTC_MULTILINE}, | |
509 | { "wxTC_RIGHTJUSTIFY", wxTC_RIGHTJUSTIFY}, | |
510 | { "wxTC_FIXEDWIDTH", wxTC_FIXEDWIDTH}, | |
511 | { "wxTC_OWNERDRAW", wxTC_OWNERDRAW}, | |
512 | ||
513 | /* wxStatusBar95 */ | |
514 | { "wxST_SIZEGRIP", wxST_SIZEGRIP}, | |
515 | ||
516 | /* wxControl */ | |
517 | { "wxFIXED_LENGTH", wxFIXED_LENGTH}, | |
518 | { "wxALIGN_LEFT", wxALIGN_LEFT}, | |
519 | { "wxALIGN_CENTER", wxALIGN_CENTER}, | |
520 | { "wxALIGN_CENTRE", wxALIGN_CENTRE}, | |
521 | { "wxALIGN_RIGHT", wxALIGN_RIGHT}, | |
522 | { "wxCOLOURED", wxCOLOURED}, | |
523 | ||
524 | /* wxToolBar */ | |
525 | { "wxTB_3DBUTTONS", wxTB_3DBUTTONS}, | |
526 | { "wxTB_HORIZONTAL", wxTB_HORIZONTAL}, | |
527 | { "wxTB_VERTICAL", wxTB_VERTICAL}, | |
528 | { "wxTB_FLAT", wxTB_FLAT}, | |
529 | ||
530 | /* Generic */ | |
531 | { "wxVSCROLL", wxVSCROLL }, | |
532 | { "wxHSCROLL", wxHSCROLL }, | |
533 | { "wxCAPTION", wxCAPTION }, | |
534 | { "wxSTAY_ON_TOP", wxSTAY_ON_TOP}, | |
535 | { "wxICONIZE", wxICONIZE}, | |
536 | { "wxMINIMIZE", wxICONIZE}, | |
537 | { "wxMAXIMIZE", wxMAXIMIZE}, | |
538 | { "wxSDI", 0}, | |
539 | { "wxMDI_PARENT", 0}, | |
540 | { "wxMDI_CHILD", 0}, | |
541 | { "wxTHICK_FRAME", wxTHICK_FRAME}, | |
542 | { "wxRESIZE_BORDER", wxRESIZE_BORDER}, | |
543 | { "wxSYSTEM_MENU", wxSYSTEM_MENU}, | |
544 | { "wxMINIMIZE_BOX", wxMINIMIZE_BOX}, | |
545 | { "wxMAXIMIZE_BOX", wxMAXIMIZE_BOX}, | |
546 | { "wxRESIZE_BOX", wxRESIZE_BOX}, | |
547 | { "wxDEFAULT_FRAME_STYLE", wxDEFAULT_FRAME_STYLE}, | |
548 | { "wxDEFAULT_FRAME", wxDEFAULT_FRAME_STYLE}, | |
549 | { "wxDEFAULT_DIALOG_STYLE", wxDEFAULT_DIALOG_STYLE}, | |
550 | { "wxBORDER", wxBORDER}, | |
551 | { "wxRETAINED", wxRETAINED}, | |
552 | { "wxNATIVE_IMPL", 0}, | |
553 | { "wxEXTENDED_IMPL", 0}, | |
554 | { "wxBACKINGSTORE", wxBACKINGSTORE}, | |
555 | // { "wxFLAT", wxFLAT}, | |
556 | // { "wxMOTIF_RESIZE", wxMOTIF_RESIZE}, | |
557 | { "wxFIXED_LENGTH", 0}, | |
558 | { "wxDOUBLE_BORDER", wxDOUBLE_BORDER}, | |
559 | { "wxSUNKEN_BORDER", wxSUNKEN_BORDER}, | |
560 | { "wxRAISED_BORDER", wxRAISED_BORDER}, | |
561 | { "wxSIMPLE_BORDER", wxSIMPLE_BORDER}, | |
562 | { "wxSTATIC_BORDER", wxSTATIC_BORDER}, | |
563 | { "wxTRANSPARENT_WINDOW", wxTRANSPARENT_WINDOW}, | |
564 | { "wxNO_BORDER", wxNO_BORDER}, | |
565 | { "wxCLIP_CHILDREN", wxCLIP_CHILDREN}, | |
566 | ||
567 | { "wxTINY_CAPTION_HORIZ", wxTINY_CAPTION_HORIZ}, | |
568 | { "wxTINY_CAPTION_VERT", wxTINY_CAPTION_VERT}, | |
569 | ||
570 | // Text font families | |
571 | { "wxDEFAULT", wxDEFAULT}, | |
572 | { "wxDECORATIVE", wxDECORATIVE}, | |
573 | { "wxROMAN", wxROMAN}, | |
574 | { "wxSCRIPT", wxSCRIPT}, | |
575 | { "wxSWISS", wxSWISS}, | |
576 | { "wxMODERN", wxMODERN}, | |
577 | { "wxTELETYPE", wxTELETYPE}, | |
578 | { "wxVARIABLE", wxVARIABLE}, | |
579 | { "wxFIXED", wxFIXED}, | |
580 | { "wxNORMAL", wxNORMAL}, | |
581 | { "wxLIGHT", wxLIGHT}, | |
582 | { "wxBOLD", wxBOLD}, | |
583 | { "wxITALIC", wxITALIC}, | |
584 | { "wxSLANT", wxSLANT}, | |
585 | { "wxSOLID", wxSOLID}, | |
586 | { "wxDOT", wxDOT}, | |
587 | { "wxLONG_DASH", wxLONG_DASH}, | |
588 | { "wxSHORT_DASH", wxSHORT_DASH}, | |
589 | { "wxDOT_DASH", wxDOT_DASH}, | |
590 | { "wxUSER_DASH", wxUSER_DASH}, | |
591 | { "wxTRANSPARENT", wxTRANSPARENT}, | |
592 | { "wxSTIPPLE", wxSTIPPLE}, | |
593 | { "wxBDIAGONAL_HATCH", wxBDIAGONAL_HATCH}, | |
594 | { "wxCROSSDIAG_HATCH", wxCROSSDIAG_HATCH}, | |
595 | { "wxFDIAGONAL_HATCH", wxFDIAGONAL_HATCH}, | |
596 | { "wxCROSS_HATCH", wxCROSS_HATCH}, | |
597 | { "wxHORIZONTAL_HATCH", wxHORIZONTAL_HATCH}, | |
598 | { "wxVERTICAL_HATCH", wxVERTICAL_HATCH}, | |
599 | { "wxJOIN_BEVEL", wxJOIN_BEVEL}, | |
600 | { "wxJOIN_MITER", wxJOIN_MITER}, | |
601 | { "wxJOIN_ROUND", wxJOIN_ROUND}, | |
602 | { "wxCAP_ROUND", wxCAP_ROUND}, | |
603 | { "wxCAP_PROJECTING", wxCAP_PROJECTING}, | |
604 | { "wxCAP_BUTT", wxCAP_BUTT}, | |
605 | ||
606 | // Logical ops | |
607 | { "wxCLEAR", wxCLEAR}, | |
608 | { "wxXOR", wxXOR}, | |
609 | { "wxINVERT", wxINVERT}, | |
610 | { "wxOR_REVERSE", wxOR_REVERSE}, | |
611 | { "wxAND_REVERSE", wxAND_REVERSE}, | |
612 | { "wxCOPY", wxCOPY}, | |
613 | { "wxAND", wxAND}, | |
614 | { "wxAND_INVERT", wxAND_INVERT}, | |
615 | { "wxNO_OP", wxNO_OP}, | |
616 | { "wxNOR", wxNOR}, | |
617 | { "wxEQUIV", wxEQUIV}, | |
618 | { "wxSRC_INVERT", wxSRC_INVERT}, | |
619 | { "wxOR_INVERT", wxOR_INVERT}, | |
620 | { "wxNAND", wxNAND}, | |
621 | { "wxOR", wxOR}, | |
622 | { "wxSET", wxSET}, | |
623 | ||
624 | { "wxFLOOD_SURFACE", wxFLOOD_SURFACE}, | |
625 | { "wxFLOOD_BORDER", wxFLOOD_BORDER}, | |
626 | { "wxODDEVEN_RULE", wxODDEVEN_RULE}, | |
627 | { "wxWINDING_RULE", wxWINDING_RULE}, | |
628 | { "wxHORIZONTAL", wxHORIZONTAL}, | |
629 | { "wxVERTICAL", wxVERTICAL}, | |
630 | { "wxBOTH", wxBOTH}, | |
631 | { "wxCENTER_FRAME", wxCENTER_FRAME}, | |
632 | { "wxOK", wxOK}, | |
633 | { "wxYES_NO", wxYES_NO}, | |
634 | { "wxCANCEL", wxCANCEL}, | |
635 | { "wxYES", wxYES}, | |
636 | { "wxNO", wxNO}, | |
637 | { "wxICON_EXCLAMATION", wxICON_EXCLAMATION}, | |
638 | { "wxICON_HAND", wxICON_HAND}, | |
639 | { "wxICON_QUESTION", wxICON_QUESTION}, | |
640 | { "wxICON_INFORMATION", wxICON_INFORMATION}, | |
641 | { "wxICON_STOP", wxICON_STOP}, | |
642 | { "wxICON_ASTERISK", wxICON_ASTERISK}, | |
643 | { "wxICON_MASK", wxICON_MASK}, | |
644 | { "wxCENTRE", wxCENTRE}, | |
645 | { "wxCENTER", wxCENTRE}, | |
646 | { "wxUSER_COLOURS", wxUSER_COLOURS}, | |
647 | { "wxVERTICAL_LABEL", 0}, | |
648 | { "wxHORIZONTAL_LABEL", 0}, | |
649 | ||
650 | // Bitmap types (not strictly styles) | |
651 | { "wxBITMAP_TYPE_XPM", wxBITMAP_TYPE_XPM}, | |
652 | { "wxBITMAP_TYPE_XBM", wxBITMAP_TYPE_XBM}, | |
653 | { "wxBITMAP_TYPE_BMP", wxBITMAP_TYPE_BMP}, | |
654 | { "wxBITMAP_TYPE_RESOURCE", wxBITMAP_TYPE_BMP_RESOURCE}, | |
655 | { "wxBITMAP_TYPE_BMP_RESOURCE", wxBITMAP_TYPE_BMP_RESOURCE}, | |
656 | { "wxBITMAP_TYPE_GIF", wxBITMAP_TYPE_GIF}, | |
657 | { "wxBITMAP_TYPE_TIF", wxBITMAP_TYPE_TIF}, | |
658 | { "wxBITMAP_TYPE_ICO", wxBITMAP_TYPE_ICO}, | |
659 | { "wxBITMAP_TYPE_ICO_RESOURCE", wxBITMAP_TYPE_ICO_RESOURCE}, | |
660 | { "wxBITMAP_TYPE_CUR", wxBITMAP_TYPE_CUR}, | |
661 | { "wxBITMAP_TYPE_CUR_RESOURCE", wxBITMAP_TYPE_CUR_RESOURCE}, | |
662 | { "wxBITMAP_TYPE_XBM_DATA", wxBITMAP_TYPE_XBM_DATA}, | |
663 | { "wxBITMAP_TYPE_XPM_DATA", wxBITMAP_TYPE_XPM_DATA}, | |
664 | { "wxBITMAP_TYPE_ANY", wxBITMAP_TYPE_ANY} | |
665 | }; | |
666 | ||
667 | static int wxResourceBitListCount = (sizeof(wxResourceBitListTable)/sizeof(wxResourceBitListStruct)); | |
668 | ||
669 | long wxParseWindowStyle(const wxString& bitListString) | |
670 | { | |
671 | int i = 0; | |
672 | char *word; | |
673 | long bitList = 0; | |
674 | while ((word = wxResourceParseWord((char*) (const char*) bitListString, &i))) | |
675 | { | |
676 | bool found = FALSE; | |
677 | int j; | |
678 | for (j = 0; j < wxResourceBitListCount; j++) | |
679 | if (strcmp(wxResourceBitListTable[j].word, word) == 0) | |
680 | { | |
681 | bitList |= wxResourceBitListTable[j].bits; | |
682 | found = TRUE; | |
683 | break; | |
684 | } | |
685 | if (!found) | |
686 | { | |
687 | wxLogWarning(_("Unrecognized style %s whilst parsing resource."), word); | |
688 | return 0; | |
689 | } | |
690 | } | |
691 | return bitList; | |
692 | } | |
693 | ||
694 | /* | |
695 | * Load a bitmap from a wxWindows resource, choosing an optimum | |
696 | * depth and appropriate type. | |
697 | */ | |
698 | ||
699 | wxBitmap wxResourceCreateBitmap(const wxString& resource, wxResourceTable *table) | |
700 | { | |
701 | if (!table) | |
702 | table = wxDefaultResourceTable; | |
703 | ||
704 | wxItemResource *item = table->FindResource(resource); | |
705 | if (item) | |
706 | { | |
707 | if ((item->GetType() == "") || (item->GetType() != "wxBitmap")) | |
708 | { | |
709 | wxLogWarning(_("%s not a bitmap resource specification."), (const char*) resource); | |
710 | return wxNullBitmap; | |
711 | } | |
712 | int thisDepth = wxDisplayDepth(); | |
713 | long thisNoColours = (long)pow(2.0, (double)thisDepth); | |
714 | ||
715 | wxItemResource *optResource = (wxItemResource *) NULL; | |
716 | ||
717 | // Try to find optimum bitmap for this platform/colour depth | |
718 | wxNode *node = item->GetChildren().First(); | |
719 | while (node) | |
720 | { | |
721 | wxItemResource *child = (wxItemResource *)node->Data(); | |
722 | int platform = (int)child->GetValue2(); | |
723 | int noColours = (int)child->GetValue3(); | |
724 | /* | |
725 | char *name = child->GetName(); | |
726 | int bitmapType = (int)child->GetValue1(); | |
727 | int xRes = child->GetWidth(); | |
728 | int yRes = child->GetHeight(); | |
729 | */ | |
730 | ||
731 | switch (platform) | |
732 | { | |
733 | case RESOURCE_PLATFORM_ANY: | |
734 | { | |
735 | if (!optResource && ((noColours == 0) || (noColours <= thisNoColours))) | |
736 | optResource = child; | |
737 | else | |
738 | { | |
739 | // Maximise the number of colours. | |
740 | // If noColours is zero (unspecified), then assume this | |
741 | // is the right one. | |
742 | if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3()))) | |
743 | optResource = child; | |
744 | } | |
745 | break; | |
746 | } | |
747 | #ifdef __WXMSW__ | |
748 | case RESOURCE_PLATFORM_WINDOWS: | |
749 | { | |
750 | if (!optResource && ((noColours == 0) || (noColours <= thisNoColours))) | |
751 | optResource = child; | |
752 | else | |
753 | { | |
754 | // Maximise the number of colours | |
755 | if ((noColours > 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3()))) | |
756 | optResource = child; | |
757 | } | |
758 | break; | |
759 | } | |
760 | #endif | |
761 | #ifdef __WXGTK__ | |
762 | case RESOURCE_PLATFORM_X: | |
763 | { | |
764 | if (!optResource && ((noColours == 0) || (noColours <= thisNoColours))) | |
765 | optResource = child; | |
766 | else | |
767 | { | |
768 | // Maximise the number of colours | |
769 | if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3()))) | |
770 | optResource = child; | |
771 | } | |
772 | break; | |
773 | } | |
774 | #endif | |
775 | #ifdef wx_max | |
776 | case RESOURCE_PLATFORM_MAC: | |
777 | { | |
778 | if (!optResource && ((noColours == 0) || (noColours <= thisNoColours))) | |
779 | optResource = child; | |
780 | else | |
781 | { | |
782 | // Maximise the number of colours | |
783 | if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3()))) | |
784 | optResource = child; | |
785 | } | |
786 | break; | |
787 | } | |
788 | #endif | |
789 | default: | |
790 | break; | |
791 | } | |
792 | node = node->Next(); | |
793 | } | |
794 | // If no matching resource, fail. | |
795 | if (!optResource) | |
796 | return wxNullBitmap; | |
797 | ||
798 | wxString name = optResource->GetName(); | |
799 | int bitmapType = (int)optResource->GetValue1(); | |
800 | switch (bitmapType) | |
801 | { | |
802 | case wxBITMAP_TYPE_XBM_DATA: | |
803 | { | |
804 | #ifdef __WXGTK__ | |
805 | wxItemResource *item = table->FindResource(name); | |
806 | if (!item) | |
807 | { | |
808 | wxLogWarning(_("Failed to find XBM resource %s.\n" | |
809 | "Forgot to use wxResourceLoadBitmapData?"), (const char*) name); | |
810 | return wxNullBitmap; | |
811 | } | |
812 | return wxBitmap(item->GetValue1(), (int)item->GetValue2(), (int)item->GetValue3()) ; | |
813 | #else | |
814 | wxLogWarning(_("No XBM facility available!")); | |
815 | #endif | |
816 | break; | |
817 | } | |
818 | case wxBITMAP_TYPE_XPM_DATA: | |
819 | { | |
820 | #if (defined(__WXGTK__)) || (defined(__WXMSW__) && wxUSE_XPM_IN_MSW) | |
821 | wxItemResource *item = table->FindResource(name); | |
822 | if (!item) | |
823 | { | |
824 | wxLogWarning(_("Failed to find XPM resource %s.\n" | |
825 | "Forgot to use wxResourceLoadBitmapData?"), (const char*) name); | |
826 | return wxNullBitmap; | |
827 | } | |
828 | return wxBitmap(item->GetValue1()); | |
829 | #else | |
830 | wxLogWarning(_("No XPM facility available!")); | |
831 | #endif | |
832 | break; | |
833 | } | |
834 | default: | |
835 | { | |
836 | return wxBitmap(name, bitmapType); | |
837 | break; | |
838 | } | |
839 | } | |
840 | return wxNullBitmap; | |
841 | } | |
842 | else | |
843 | { | |
844 | wxLogWarning(_("Bitmap resource specification %s not found."), (const char*) resource); | |
845 | return wxNullBitmap; | |
846 | } | |
847 | } | |
848 | ||
849 | /* | |
850 | * Load an icon from a wxWindows resource, choosing an optimum | |
851 | * depth and appropriate type. | |
852 | */ | |
853 | ||
854 | wxIcon wxResourceCreateIcon(const wxString& resource, wxResourceTable *table) | |
855 | { | |
856 | if (!table) | |
857 | table = wxDefaultResourceTable; | |
858 | ||
859 | wxItemResource *item = table->FindResource(resource); | |
860 | if (item) | |
861 | { | |
862 | if ((item->GetType() == "") || (item->GetType() != "wxIcon")) | |
863 | { | |
864 | wxLogWarning(_("%s not an icon resource specification."), (const char*) resource); | |
865 | return wxNullIcon; | |
866 | } | |
867 | int thisDepth = wxDisplayDepth(); | |
868 | long thisNoColours = (long)pow(2.0, (double)thisDepth); | |
869 | ||
870 | wxItemResource *optResource = (wxItemResource *) NULL; | |
871 | ||
872 | // Try to find optimum icon for this platform/colour depth | |
873 | wxNode *node = item->GetChildren().First(); | |
874 | while (node) | |
875 | { | |
876 | wxItemResource *child = (wxItemResource *)node->Data(); | |
877 | int platform = (int)child->GetValue2(); | |
878 | int noColours = (int)child->GetValue3(); | |
879 | /* | |
880 | char *name = child->GetName(); | |
881 | int bitmapType = (int)child->GetValue1(); | |
882 | int xRes = child->GetWidth(); | |
883 | int yRes = child->GetHeight(); | |
884 | */ | |
885 | ||
886 | switch (platform) | |
887 | { | |
888 | case RESOURCE_PLATFORM_ANY: | |
889 | { | |
890 | if (!optResource && ((noColours == 0) || (noColours <= thisNoColours))) | |
891 | optResource = child; | |
892 | else | |
893 | { | |
894 | // Maximise the number of colours. | |
895 | // If noColours is zero (unspecified), then assume this | |
896 | // is the right one. | |
897 | if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3()))) | |
898 | optResource = child; | |
899 | } | |
900 | break; | |
901 | } | |
902 | #ifdef __WXMSW__ | |
903 | case RESOURCE_PLATFORM_WINDOWS: | |
904 | { | |
905 | if (!optResource && ((noColours == 0) || (noColours <= thisNoColours))) | |
906 | optResource = child; | |
907 | else | |
908 | { | |
909 | // Maximise the number of colours | |
910 | if ((noColours > 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3()))) | |
911 | optResource = child; | |
912 | } | |
913 | break; | |
914 | } | |
915 | #endif | |
916 | #ifdef __WXGTK__ | |
917 | case RESOURCE_PLATFORM_X: | |
918 | { | |
919 | if (!optResource && ((noColours == 0) || (noColours <= thisNoColours))) | |
920 | optResource = child; | |
921 | else | |
922 | { | |
923 | // Maximise the number of colours | |
924 | if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3()))) | |
925 | optResource = child; | |
926 | } | |
927 | break; | |
928 | } | |
929 | #endif | |
930 | #ifdef wx_max | |
931 | case RESOURCE_PLATFORM_MAC: | |
932 | { | |
933 | if (!optResource && ((noColours == 0) || (noColours <= thisNoColours))) | |
934 | optResource = child; | |
935 | else | |
936 | { | |
937 | // Maximise the number of colours | |
938 | if ((noColours == 0) || ((noColours <= thisNoColours) && (noColours > optResource->GetValue3()))) | |
939 | optResource = child; | |
940 | } | |
941 | break; | |
942 | } | |
943 | #endif | |
944 | default: | |
945 | break; | |
946 | } | |
947 | node = node->Next(); | |
948 | } | |
949 | // If no matching resource, fail. | |
950 | if (!optResource) | |
951 | return wxNullIcon; | |
952 | ||
953 | wxString name = optResource->GetName(); | |
954 | int bitmapType = (int)optResource->GetValue1(); | |
955 | switch (bitmapType) | |
956 | { | |
957 | case wxBITMAP_TYPE_XBM_DATA: | |
958 | { | |
959 | #ifdef __WXGTK__ | |
960 | wxItemResource *item = table->FindResource(name); | |
961 | if (!item) | |
962 | { | |
963 | wxLogWarning(_("Failed to find XBM resource %s.\n" | |
964 | "Forgot to use wxResourceLoadIconData?"), (const char*) name); | |
965 | return wxNullIcon; | |
966 | } | |
967 | return wxIcon((const char **)item->GetValue1(), (int)item->GetValue2(), (int)item->GetValue3()); | |
968 | #else | |
969 | wxLogWarning(_("No XBM facility available!")); | |
970 | #endif | |
971 | break; | |
972 | } | |
973 | case wxBITMAP_TYPE_XPM_DATA: | |
974 | { | |
975 | // *** XPM ICON NOT YET IMPLEMENTED IN WXWINDOWS *** | |
976 | /* | |
977 | #if (defined(__WXGTK__)) || (defined(__WXMSW__) && wxUSE_XPM_IN_MSW) | |
978 | wxItemResource *item = table->FindResource(name); | |
979 | if (!item) | |
980 | { | |
981 | char buf[400]; | |
982 | sprintf(buf, _("Failed to find XPM resource %s.\nForgot to use wxResourceLoadIconData?"), name); | |
983 | wxLogWarning(buf); | |
984 | return NULL; | |
985 | } | |
986 | return wxIcon((char **)item->GetValue1()); | |
987 | #else | |
988 | wxLogWarning(_("No XPM facility available!")); | |
989 | #endif | |
990 | */ | |
991 | wxLogWarning(_("No XPM icon facility available!")); | |
992 | break; | |
993 | } | |
994 | default: | |
995 | { | |
996 | #ifdef __WXGTK__ | |
997 | wxLogWarning(_("Icon resource specification %s not found."), (const char*) resource); | |
998 | #else | |
999 | return wxIcon(name, bitmapType); | |
1000 | #endif | |
1001 | break; | |
1002 | } | |
1003 | } | |
1004 | return wxNullIcon; | |
1005 | } | |
1006 | else | |
1007 | { | |
1008 | wxLogWarning(_("Icon resource specification %s not found."), (const char*) resource); | |
1009 | return wxNullIcon; | |
1010 | } | |
1011 | } | |
1012 | ||
1013 | wxMenu *wxResourceCreateMenu(wxItemResource *item) | |
1014 | { | |
1015 | wxMenu *menu = new wxMenu; | |
1016 | wxNode *node = item->GetChildren().First(); | |
1017 | while (node) | |
1018 | { | |
1019 | wxItemResource *child = (wxItemResource *)node->Data(); | |
1020 | if ((child->GetType() != "") && (child->GetType() == "wxMenuSeparator")) | |
1021 | menu->AppendSeparator(); | |
1022 | else if (child->GetChildren().Number() > 0) | |
1023 | { | |
1024 | wxMenu *subMenu = wxResourceCreateMenu(child); | |
1025 | if (subMenu) | |
1026 | menu->Append((int)child->GetValue1(), child->GetTitle(), subMenu, child->GetValue4()); | |
1027 | } | |
1028 | else | |
1029 | { | |
1030 | menu->Append((int)child->GetValue1(), child->GetTitle(), child->GetValue4(), (child->GetValue2() != 0)); | |
1031 | } | |
1032 | node = node->Next(); | |
1033 | } | |
1034 | return menu; | |
1035 | } | |
1036 | ||
1037 | wxMenuBar *wxResourceCreateMenuBar(const wxString& resource, wxResourceTable *table, wxMenuBar *menuBar) | |
1038 | { | |
1039 | if (!table) | |
1040 | table = wxDefaultResourceTable; | |
1041 | ||
1042 | wxItemResource *menuResource = table->FindResource(resource); | |
1043 | if (menuResource && (menuResource->GetType() != "") && (menuResource->GetType() == "wxMenu")) | |
1044 | { | |
1045 | if (!menuBar) | |
1046 | menuBar = new wxMenuBar; | |
1047 | wxNode *node = menuResource->GetChildren().First(); | |
1048 | while (node) | |
1049 | { | |
1050 | wxItemResource *child = (wxItemResource *)node->Data(); | |
1051 | wxMenu *menu = wxResourceCreateMenu(child); | |
1052 | if (menu) | |
1053 | menuBar->Append(menu, child->GetTitle()); | |
1054 | node = node->Next(); | |
1055 | } | |
1056 | return menuBar; | |
1057 | } | |
1058 | return (wxMenuBar *) NULL; | |
1059 | } | |
1060 | ||
1061 | wxMenu *wxResourceCreateMenu(const wxString& resource, wxResourceTable *table) | |
1062 | { | |
1063 | if (!table) | |
1064 | table = wxDefaultResourceTable; | |
1065 | ||
1066 | wxItemResource *menuResource = table->FindResource(resource); | |
1067 | if (menuResource && (menuResource->GetType() != "") && (menuResource->GetType() == "wxMenu")) | |
1068 | // if (menuResource && (menuResource->GetType() == wxTYPE_MENU)) | |
1069 | return wxResourceCreateMenu(menuResource); | |
1070 | return (wxMenu *) NULL; | |
1071 | } | |
1072 | ||
1073 | // Global equivalents (so don't have to refer to default table explicitly) | |
1074 | bool wxResourceParseData(const wxString& resource, wxResourceTable *table) | |
1075 | { | |
1076 | if (!table) | |
1077 | table = wxDefaultResourceTable; | |
1078 | ||
1079 | return table->ParseResourceData(resource); | |
1080 | } | |
1081 | ||
1082 | bool wxResourceParseFile(const wxString& filename, wxResourceTable *table) | |
1083 | { | |
1084 | if (!table) | |
1085 | table = wxDefaultResourceTable; | |
1086 | ||
1087 | return table->ParseResourceFile(filename); | |
1088 | } | |
1089 | ||
1090 | // Register XBM/XPM data | |
1091 | bool wxResourceRegisterBitmapData(const wxString& name, char bits[], int width, int height, wxResourceTable *table) | |
1092 | { | |
1093 | if (!table) | |
1094 | table = wxDefaultResourceTable; | |
1095 | ||
1096 | return table->RegisterResourceBitmapData(name, bits, width, height); | |
1097 | } | |
1098 | ||
1099 | bool wxResourceRegisterBitmapData(const wxString& name, char **data, wxResourceTable *table) | |
1100 | { | |
1101 | if (!table) | |
1102 | table = wxDefaultResourceTable; | |
1103 | ||
1104 | return table->RegisterResourceBitmapData(name, data); | |
1105 | } | |
1106 | ||
1107 | void wxResourceClear(wxResourceTable *table) | |
1108 | { | |
1109 | if (!table) | |
1110 | table = wxDefaultResourceTable; | |
1111 | ||
1112 | table->ClearTable(); | |
1113 | } | |
1114 | ||
1115 | /* | |
1116 | * Identifiers | |
1117 | */ | |
1118 | ||
1119 | bool wxResourceAddIdentifier(const wxString& name, int value, wxResourceTable *table) | |
1120 | { | |
1121 | if (!table) | |
1122 | table = wxDefaultResourceTable; | |
1123 | ||
1124 | table->identifiers.Put(name, (wxObject *)value); | |
1125 | return TRUE; | |
1126 | } | |
1127 | ||
1128 | int wxResourceGetIdentifier(const wxString& name, wxResourceTable *table) | |
1129 | { | |
1130 | if (!table) | |
1131 | table = wxDefaultResourceTable; | |
1132 | ||
1133 | return (int)table->identifiers.Get(name); | |
1134 | } | |
1135 | ||
1136 | /* | |
1137 | * Parse #include file for #defines (only) | |
1138 | */ | |
1139 | ||
1140 | bool wxResourceParseIncludeFile(const wxString& f, wxResourceTable *table) | |
1141 | { | |
1142 | if (!table) | |
1143 | table = wxDefaultResourceTable; | |
1144 | ||
1145 | FILE *fd = fopen(f, "r"); | |
1146 | if (!fd) | |
1147 | { | |
1148 | return FALSE; | |
1149 | } | |
1150 | while (wxGetResourceToken(fd)) | |
1151 | { | |
1152 | if (strcmp(wxResourceBuffer, "#define") == 0) | |
1153 | { | |
1154 | wxGetResourceToken(fd); | |
1155 | char *name = copystring(wxResourceBuffer); | |
1156 | wxGetResourceToken(fd); | |
1157 | char *value = copystring(wxResourceBuffer); | |
1158 | if (isdigit(value[0])) | |
1159 | { | |
1160 | int val = (int)atol(value); | |
1161 | wxResourceAddIdentifier(name, val, table); | |
1162 | } | |
1163 | delete[] name; | |
1164 | delete[] value; | |
1165 | } | |
1166 | } | |
1167 | fclose(fd); | |
1168 | return TRUE; | |
1169 | } | |
1170 | ||
1171 | /* | |
1172 | * Reading strings as if they were .wxr files | |
1173 | */ | |
1174 | ||
1175 | static int getc_string(char *s) | |
1176 | { | |
1177 | int ch = s[wxResourceStringPtr]; | |
1178 | if (ch == 0) | |
1179 | return EOF; | |
1180 | else | |
1181 | { | |
1182 | wxResourceStringPtr ++; | |
1183 | return ch; | |
1184 | } | |
1185 | } | |
1186 | ||
1187 | static int ungetc_string() | |
1188 | { | |
1189 | wxResourceStringPtr --; | |
1190 | return 0; | |
1191 | } | |
1192 | ||
1193 | bool wxEatWhiteSpaceString(char *s) | |
1194 | { | |
1195 | int ch = getc_string(s); | |
1196 | if (ch == EOF) | |
1197 | return TRUE; | |
1198 | ||
1199 | if ((ch != ' ') && (ch != '/') && (ch != ' ') && (ch != 10) && (ch != 13) && (ch != 9)) | |
1200 | { | |
1201 | ungetc_string(); | |
1202 | return TRUE; | |
1203 | } | |
1204 | ||
1205 | // Eat whitespace | |
1206 | while (ch == ' ' || ch == 10 || ch == 13 || ch == 9) | |
1207 | ch = getc_string(s); | |
1208 | // Check for comment | |
1209 | if (ch == '/') | |
1210 | { | |
1211 | ch = getc_string(s); | |
1212 | if (ch == '*') | |
1213 | { | |
1214 | bool finished = FALSE; | |
1215 | while (!finished) | |
1216 | { | |
1217 | ch = getc_string(s); | |
1218 | if (ch == EOF) | |
1219 | return FALSE; | |
1220 | if (ch == '*') | |
1221 | { | |
1222 | int newCh = getc_string(s); | |
1223 | if (newCh == '/') | |
1224 | finished = TRUE; | |
1225 | else | |
1226 | { | |
1227 | ungetc_string(); | |
1228 | } | |
1229 | } | |
1230 | } | |
1231 | } | |
1232 | else // False alarm | |
1233 | return FALSE; | |
1234 | } | |
1235 | else if (ch != EOF) | |
1236 | ungetc_string(); | |
1237 | return wxEatWhiteSpaceString(s); | |
1238 | } | |
1239 | ||
1240 | bool wxGetResourceTokenString(char *s) | |
1241 | { | |
1242 | if (!wxResourceBuffer) | |
1243 | wxReallocateResourceBuffer(); | |
1244 | wxResourceBuffer[0] = 0; | |
1245 | wxEatWhiteSpaceString(s); | |
1246 | ||
1247 | int ch = getc_string(s); | |
1248 | if (ch == '"') | |
1249 | { | |
1250 | // Get string | |
1251 | wxResourceBufferCount = 0; | |
1252 | ch = getc_string(s); | |
1253 | while (ch != '"') | |
1254 | { | |
1255 | int actualCh = ch; | |
1256 | if (ch == EOF) | |
1257 | { | |
1258 | wxResourceBuffer[wxResourceBufferCount] = 0; | |
1259 | return FALSE; | |
1260 | } | |
1261 | // Escaped characters | |
1262 | else if (ch == '\\') | |
1263 | { | |
1264 | int newCh = getc_string(s); | |
1265 | if (newCh == '"') | |
1266 | actualCh = '"'; | |
1267 | else if (newCh == 10) | |
1268 | actualCh = 10; | |
1269 | else | |
1270 | { | |
1271 | ungetc_string(); | |
1272 | } | |
1273 | } | |
1274 | ||
1275 | if (wxResourceBufferCount >= wxResourceBufferSize-1) | |
1276 | wxReallocateResourceBuffer(); | |
1277 | wxResourceBuffer[wxResourceBufferCount] = (char)actualCh; | |
1278 | wxResourceBufferCount ++; | |
1279 | ch = getc_string(s); | |
1280 | } | |
1281 | wxResourceBuffer[wxResourceBufferCount] = 0; | |
1282 | } | |
1283 | else | |
1284 | { | |
1285 | wxResourceBufferCount = 0; | |
1286 | // Any other token | |
1287 | while (ch != ' ' && ch != EOF && ch != ' ' && ch != 13 && ch != 9 && ch != 10) | |
1288 | { | |
1289 | if (wxResourceBufferCount >= wxResourceBufferSize-1) | |
1290 | wxReallocateResourceBuffer(); | |
1291 | wxResourceBuffer[wxResourceBufferCount] = (char)ch; | |
1292 | wxResourceBufferCount ++; | |
1293 | ||
1294 | ch = getc_string(s); | |
1295 | } | |
1296 | wxResourceBuffer[wxResourceBufferCount] = 0; | |
1297 | if (ch == EOF) | |
1298 | return FALSE; | |
1299 | } | |
1300 | return TRUE; | |
1301 | } | |
1302 | ||
1303 | /* | |
1304 | * Files are in form: | |
1305 | static char *name = "...."; | |
1306 | with possible comments. | |
1307 | */ | |
1308 | ||
1309 | bool wxResourceReadOneResourceString(char *s, wxExprDatabase& db, bool *eof, wxResourceTable *table) | |
1310 | { | |
1311 | if (!table) | |
1312 | table = wxDefaultResourceTable; | |
1313 | ||
1314 | // static or #define | |
1315 | if (!wxGetResourceTokenString(s)) | |
1316 | { | |
1317 | *eof = TRUE; | |
1318 | return FALSE; | |
1319 | } | |
1320 | ||
1321 | if (strcmp(wxResourceBuffer, "#define") == 0) | |
1322 | { | |
1323 | wxGetResourceTokenString(s); | |
1324 | char *name = copystring(wxResourceBuffer); | |
1325 | wxGetResourceTokenString(s); | |
1326 | char *value = copystring(wxResourceBuffer); | |
1327 | if (isalpha(value[0])) | |
1328 | { | |
1329 | int val = (int)atol(value); | |
1330 | wxResourceAddIdentifier(name, val, table); | |
1331 | } | |
1332 | else | |
1333 | { | |
1334 | wxLogWarning(_("#define %s must be an integer."), name); | |
1335 | delete[] name; | |
1336 | delete[] value; | |
1337 | return FALSE; | |
1338 | } | |
1339 | delete[] name; | |
1340 | delete[] value; | |
1341 | ||
1342 | return TRUE; | |
1343 | } | |
1344 | /* | |
1345 | else if (strcmp(wxResourceBuffer, "#include") == 0) | |
1346 | { | |
1347 | wxGetResourceTokenString(s); | |
1348 | char *name = copystring(wxResourceBuffer); | |
1349 | char *actualName = name; | |
1350 | if (name[0] == '"') | |
1351 | actualName = name + 1; | |
1352 | int len = strlen(name); | |
1353 | if ((len > 0) && (name[len-1] == '"')) | |
1354 | name[len-1] = 0; | |
1355 | if (!wxResourceParseIncludeFile(actualName, table)) | |
1356 | { | |
1357 | char buf[400]; | |
1358 | sprintf(buf, _("Could not find resource include file %s."), actualName); | |
1359 | wxLogWarning(buf); | |
1360 | } | |
1361 | delete[] name; | |
1362 | return TRUE; | |
1363 | } | |
1364 | */ | |
1365 | else if (strcmp(wxResourceBuffer, "static") != 0) | |
1366 | { | |
1367 | char buf[300]; | |
1368 | strcpy(buf, _("Found ")); | |
1369 | strncat(buf, wxResourceBuffer, 30); | |
1370 | strcat(buf, _(", expected static, #include or #define\nwhilst parsing resource.")); | |
1371 | wxLogWarning(buf); | |
1372 | return FALSE; | |
1373 | } | |
1374 | ||
1375 | // char | |
1376 | if (!wxGetResourceTokenString(s)) | |
1377 | { | |
1378 | wxLogWarning(_("Unexpected end of file whilst parsing resource.")); | |
1379 | *eof = TRUE; | |
1380 | return FALSE; | |
1381 | } | |
1382 | ||
1383 | if (strcmp(wxResourceBuffer, "char") != 0) | |
1384 | { | |
1385 | wxLogWarning(_("Expected 'char' whilst parsing resource.")); | |
1386 | return FALSE; | |
1387 | } | |
1388 | ||
1389 | // *name | |
1390 | if (!wxGetResourceTokenString(s)) | |
1391 | { | |
1392 | wxLogWarning(_("Unexpected end of file whilst parsing resource.")); | |
1393 | *eof = TRUE; | |
1394 | return FALSE; | |
1395 | } | |
1396 | ||
1397 | if (wxResourceBuffer[0] != '*') | |
1398 | { | |
1399 | wxLogWarning(_("Expected '*' whilst parsing resource.")); | |
1400 | return FALSE; | |
1401 | } | |
1402 | char nameBuf[100]; | |
1403 | strncpy(nameBuf, wxResourceBuffer+1, 99); | |
1404 | ||
1405 | // = | |
1406 | if (!wxGetResourceTokenString(s)) | |
1407 | { | |
1408 | wxLogWarning(_("Unexpected end of file whilst parsing resource.")); | |
1409 | *eof = TRUE; | |
1410 | return FALSE; | |
1411 | } | |
1412 | ||
1413 | if (strcmp(wxResourceBuffer, "=") != 0) | |
1414 | { | |
1415 | wxLogWarning(_("Expected '=' whilst parsing resource.")); | |
1416 | return FALSE; | |
1417 | } | |
1418 | ||
1419 | // String | |
1420 | if (!wxGetResourceTokenString(s)) | |
1421 | { | |
1422 | wxLogWarning(_("Unexpected end of file whilst parsing resource.")); | |
1423 | *eof = TRUE; | |
1424 | return FALSE; | |
1425 | } | |
1426 | else | |
1427 | { | |
1428 | if (!db.ReadPrologFromString(wxResourceBuffer)) | |
1429 | { | |
1430 | wxLogWarning(_("%s: ill-formed resource file syntax."), nameBuf); | |
1431 | return FALSE; | |
1432 | } | |
1433 | } | |
1434 | // Semicolon | |
1435 | if (!wxGetResourceTokenString(s)) | |
1436 | { | |
1437 | *eof = TRUE; | |
1438 | } | |
1439 | return TRUE; | |
1440 | } | |
1441 | ||
1442 | bool wxResourceParseString(char *s, wxResourceTable *table) | |
1443 | { | |
1444 | if (!table) | |
1445 | table = wxDefaultResourceTable; | |
1446 | ||
1447 | if (!s) | |
1448 | return FALSE; | |
1449 | ||
1450 | // Turn backslashes into spaces | |
1451 | if (s) | |
1452 | { | |
1453 | int len = strlen(s); | |
1454 | int i; | |
1455 | for (i = 0; i < len; i++) | |
1456 | if (s[i] == 92 && s[i+1] == 13) | |
1457 | { | |
1458 | s[i] = ' '; | |
1459 | s[i+1] = ' '; | |
1460 | } | |
1461 | } | |
1462 | ||
1463 | wxExprDatabase db; | |
1464 | wxResourceStringPtr = 0; | |
1465 | ||
1466 | bool eof = FALSE; | |
1467 | while (wxResourceReadOneResourceString(s, db, &eof, table) && !eof) | |
1468 | { | |
1469 | // Loop | |
1470 | } | |
1471 | return wxResourceInterpretResources(*table, db); | |
1472 | } | |
1473 | ||
1474 | /* | |
1475 | * resource loading facility | |
1476 | */ | |
1477 | ||
1478 | bool wxWindow::LoadFromResource(wxWindow *parent, const wxString& resourceName, const wxResourceTable *table) | |
1479 | { | |
1480 | if (!table) | |
1481 | table = wxDefaultResourceTable; | |
1482 | ||
1483 | wxItemResource *resource = table->FindResource((const char *)resourceName); | |
1484 | // if (!resource || (resource->GetType() != wxTYPE_DIALOG_BOX)) | |
1485 | if (!resource || (resource->GetType() == "") || | |
1486 | ! ((strcmp(resource->GetType(), "wxDialog") == 0) || (strcmp(resource->GetType(), "wxPanel") == 0))) | |
1487 | return FALSE; | |
1488 | ||
1489 | wxString title(resource->GetTitle()); | |
1490 | long theWindowStyle = resource->GetStyle(); | |
1491 | bool isModal = (resource->GetValue1() != 0); | |
1492 | int x = resource->GetX(); | |
1493 | int y = resource->GetY(); | |
1494 | int width = resource->GetWidth(); | |
1495 | int height = resource->GetHeight(); | |
1496 | wxString name = resource->GetName(); | |
1497 | ||
1498 | if (IsKindOf(CLASSINFO(wxDialog))) | |
1499 | { | |
1500 | wxDialog *dialogBox = (wxDialog *)this; | |
1501 | long modalStyle = isModal ? wxDIALOG_MODAL : 0; | |
1502 | if (!dialogBox->Create(parent, -1, title, wxPoint(x, y), wxSize(width, height), theWindowStyle|modalStyle, name)) | |
1503 | return FALSE; | |
1504 | ||
1505 | // Only reset the client size if we know we're not going to do it again below. | |
1506 | if ((resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS) == 0) | |
1507 | dialogBox->SetClientSize(width, height); | |
1508 | } | |
1509 | else if (IsKindOf(CLASSINFO(wxPanel))) | |
1510 | { | |
1511 | wxPanel* panel = (wxPanel *)this; | |
1512 | if (!panel->Create(parent, -1, wxPoint(x, y), wxSize(width, height), theWindowStyle, name)) | |
1513 | return FALSE; | |
1514 | } | |
1515 | else | |
1516 | { | |
1517 | if (!this->Create(parent, -1, wxPoint(x, y), wxSize(width, height), theWindowStyle, name)) | |
1518 | return FALSE; | |
1519 | } | |
1520 | ||
1521 | if ((resource->GetResourceStyle() & wxRESOURCE_USE_DEFAULTS) != 0) | |
1522 | { | |
1523 | // No need to do this since it's done in wxPanel or wxDialog constructor. | |
1524 | // SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT)); | |
1525 | } | |
1526 | else | |
1527 | { | |
1528 | if (resource->GetFont().Ok()) | |
1529 | SetFont(resource->GetFont()); | |
1530 | if (resource->GetBackgroundColour().Ok()) | |
1531 | SetBackgroundColour(resource->GetBackgroundColour()); | |
1532 | } | |
1533 | ||
1534 | // Should have some kind of font at this point | |
1535 | if (!GetFont().Ok()) | |
1536 | SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT)); | |
1537 | if (!GetBackgroundColour().Ok()) | |
1538 | SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE)); | |
1539 | ||
1540 | // Only when we've created the window and set the font can we set the correct size, | |
1541 | // if based on dialog units. | |
1542 | if ((resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS) != 0) | |
1543 | { | |
1544 | wxSize sz = ConvertDialogToPixels(wxSize(width, height)); | |
1545 | SetClientSize(sz.x, sz.y); | |
1546 | ||
1547 | wxPoint pt = ConvertDialogToPixels(wxPoint(x, y)); | |
1548 | Move(pt.x, pt.y); | |
1549 | } | |
1550 | ||
1551 | // Now create children | |
1552 | wxNode *node = resource->GetChildren().First(); | |
1553 | while (node) | |
1554 | { | |
1555 | wxItemResource *childResource = (wxItemResource *)node->Data(); | |
1556 | ||
1557 | (void) CreateItem(childResource, resource, table); | |
1558 | ||
1559 | node = node->Next(); | |
1560 | } | |
1561 | return TRUE; | |
1562 | } | |
1563 | ||
1564 | wxControl *wxWindow::CreateItem(const wxItemResource *resource, const wxItemResource* parentResource, const wxResourceTable *table) | |
1565 | { | |
1566 | if (!table) | |
1567 | table = wxDefaultResourceTable; | |
1568 | return table->CreateItem((wxWindow *)this, resource, parentResource); | |
1569 | } | |
1570 | ||
1571 | #ifdef _MSC_VER | |
1572 | #pragma warning(default:4706) // assignment within conditional expression | |
1573 | #endif // VC++ | |
1574 | ||
1575 | #endif | |
1576 | // BC++/Win16 only | |
1577 | #endif // wxUSE_WX_RESOURCES |