]> git.saurik.com Git - wxWidgets.git/blob - utils/dialoged/src/winprop.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fixed nasty bug wxFont
[wxWidgets.git] / utils / dialoged / src / winprop.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: winprop.cpp
3 // Purpose: Window properties
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 04/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "winprop.h"
14 #endif
15
16 // For compilers that support precompilation, includes "wx/wx.h".
17 #include "wx/wxprec.h"
18
19 #ifdef __BORLANDC__
20 #pragma hdrstop
21 #endif
22
23 #ifndef WX_PRECOMP
24 #include "wx/wx.h"
25 #endif
26
27 #include <ctype.h>
28 #include <stdlib.h>
29 #include <math.h>
30 #include <string.h>
31
32 #if wxUSE_IOSTREAMH
33 #if defined(__WXMSW__) && !defined(__GNUWIN32__)
34 #include <strstrea.h>
35 #else
36 #include <strstream.h>
37 #endif
38 #else
39 #include <strstream>
40 #endif
41
42 #ifdef __WXMSW__
43 #include <windows.h>
44 #endif
45
46 #include "reseditr.h"
47 #include "winprop.h"
48
49 // Causes immediate feedback.
50 void wxResourcePropertyListView::OnPropertyChanged(wxProperty *property)
51 {
52 // Sets the value of the property back into the actual object,
53 // IF the property value was modified.
54 if (property->GetValue().GetModified())
55 {
56 m_propertyInfo->SetProperty(property->GetName(), property);
57 property->GetValue().SetModified(FALSE);
58 wxResourceManager::GetCurrentResourceManager()->Modify(TRUE);
59 }
60 }
61
62 bool wxResourcePropertyListView::OnClose(void)
63 {
64 int w, h, x, y;
65 GetManagedWindow()->GetSize(& w, & h);
66 GetManagedWindow()->GetPosition(& x, & y);
67
68 wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().width = w;
69 wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().height = h;
70 wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().x = x;
71 wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().y = y;
72
73 return wxPropertyListView::OnClose();
74 }
75
76 wxWindow *wxPropertyInfo::sm_propertyWindow;
77
78 /*
79 * wxDialogEditorPropertyListDialog
80 */
81
82 /*
83 wxDialogEditorPropertyListDialog::wxDialogEditorPropertyListDialog(wxPropertyListView *v, wxWindow *parent, const wxString& title,
84 const wxPoint& pos, const wxSize& size,
85 long style, const wxString& name):
86 wxPropertyListDialog(v, parent, title, pos, size, style, name)
87 {
88 m_propSheet = NULL;
89 m_propInfo = NULL;
90 }
91
92 wxDialogEditorPropertyListDialog::~wxDialogEditorPropertyListDialog()
93 {
94 delete m_propSheet;
95 delete m_propInfo;
96 wxPropertyInfo::sm_propertyWindow = NULL;
97 }
98 */
99
100 wxDialogEditorPropertyListFrame::wxDialogEditorPropertyListFrame(wxPropertyListView *v, wxFrame *parent, const wxString& title,
101 const wxPoint& pos, const wxSize& size,
102 long style, const wxString& name):
103 wxPropertyListFrame(v, parent, title, pos, size, style, name)
104 {
105 m_propSheet = NULL;
106 m_propInfo = NULL;
107 }
108
109 wxDialogEditorPropertyListFrame::~wxDialogEditorPropertyListFrame()
110 {
111 delete m_propSheet;
112 delete m_propInfo;
113 wxPropertyInfo::sm_propertyWindow = NULL;
114 }
115
116 /*
117 * wxPropertyInfo
118 */
119
120 // Edit the information represented by this object, whatever that
121 // might be.
122 bool wxPropertyInfo::Edit(wxWindow *WXUNUSED(parent), const wxString& title)
123 {
124 if (sm_propertyWindow)
125 {
126 sm_propertyWindow->Raise();
127 return TRUE;
128 }
129
130 int width = wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().width;
131 int height = wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().height;
132 int x = wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().x;
133 int y = wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().y;
134
135 wxPropertySheet *propSheet = new wxPropertySheet;
136
137 wxStringList propNames;
138 GetPropertyNames(propNames);
139
140 wxNode *node = propNames.First();
141 while (node)
142 {
143 wxString name((char *)node->Data());
144 wxProperty *prop = GetProperty(name);
145 if (prop)
146 {
147 propSheet->AddProperty(prop);
148 }
149 node = node->Next();
150 }
151
152 // Reset 'modified' flags for all property values
153 propSheet->SetAllModified(FALSE);
154
155 wxResourcePropertyListView *view = new wxResourcePropertyListView(this, NULL,
156 wxPROP_BUTTON_OK | wxPROP_BUTTON_CANCEL |
157 wxPROP_BUTTON_CHECK_CROSS|wxPROP_DYNAMIC_VALUE_FIELD|wxPROP_PULLDOWN|wxPROP_SHOWVALUES);
158
159 wxDialogEditorPropertyListFrame *propWin = new wxDialogEditorPropertyListFrame(view,
160 wxResourceManager::GetCurrentResourceManager()->GetEditorFrame(), title, wxPoint(x, y),
161 wxSize(width, height), wxDEFAULT_FRAME_STYLE);
162 sm_propertyWindow = propWin;
163
164 propWin->m_registry.RegisterValidator(wxString("real"), new wxRealListValidator);
165 propWin->m_registry.RegisterValidator(wxString("string"), new wxStringListValidator);
166 propWin->m_registry.RegisterValidator(wxString("integer"), new wxIntegerListValidator);
167 propWin->m_registry.RegisterValidator(wxString("bool"), new wxBoolListValidator);
168 propWin->m_registry.RegisterValidator(wxString("filename"), new wxFilenameListValidator);
169 propWin->m_registry.RegisterValidator(wxString("stringlist"), new wxListOfStringsListValidator);
170 propWin->m_registry.RegisterValidator(wxString("window_id"), new wxResourceSymbolValidator);
171
172 propWin->m_propInfo = this;
173 propWin->m_propSheet = propSheet;
174
175 // view->m_propertyWindow = propWin;
176 view->AddRegistry(&(propWin->m_registry));
177
178 propWin->Initialize();
179 view->ShowView(propSheet, propWin->GetPropertyPanel());
180
181 propWin->Show(TRUE);
182 return TRUE;
183 }
184
185 /*
186 * wxWindowPropertyInfo
187 */
188
189 wxWindowPropertyInfo::wxWindowPropertyInfo(wxWindow *win, wxItemResource *res)
190 {
191 m_propertyWindow = win;
192 m_propertyResource = res;
193 }
194
195 wxWindowPropertyInfo::~wxWindowPropertyInfo(void)
196 {
197 }
198
199 wxProperty *wxWindowPropertyInfo::GetFontProperty(wxString& name, wxFont *font)
200 {
201 if (!font)
202 return NULL;
203
204 if (name.Contains("Points"))
205 return new wxProperty(name, (long)font->GetPointSize(), "integer", new wxIntegerListValidator(1, 100));
206 else if (name.Contains("Family"))
207 return new wxProperty(name, font->GetFamilyString(), "string",
208 new wxStringListValidator(new wxStringList("wxDECORATIVE", "wxROMAN", "wxSCRIPT", "wxSWISS", "wxMODERN",
209 NULL)));
210 else if (name.Contains("Style"))
211 return new wxProperty(name, font->GetStyleString(), "string",
212 new wxStringListValidator(new wxStringList("wxNORMAL", "wxITALIC", "wxSLANT", NULL)));
213 else if (name.Contains("Weight"))
214 return new wxProperty(name, font->GetWeightString(), "string",
215 new wxStringListValidator(new wxStringList("wxNORMAL", "wxBOLD", "wxLIGHT", NULL)));
216 else if (name.Contains("Underlined"))
217 return new wxProperty(name, (bool)font->GetUnderlined(), "bool");
218 else
219 return NULL;
220 }
221
222 wxFont *wxWindowPropertyInfo::SetFontProperty(wxString& name, wxProperty *property, wxFont *font)
223 {
224 int pointSize = 12;
225 int fontFamily = wxMODERN;
226 int fontStyle = wxNORMAL;
227 int fontWeight = wxNORMAL;
228 bool fontUnderlined = FALSE;
229
230 if (name.Contains("Points"))
231 {
232 pointSize = (int)property->GetValue().IntegerValue();
233 if (font && (pointSize == font->GetPointSize()))
234 return NULL; // No change
235 }
236 else if (font) pointSize = font->GetPointSize();
237
238 if (name.Contains("Family"))
239 {
240 wxString val = property->GetValue().StringValue();
241 fontFamily = wxStringToFontFamily(val);
242
243 if (font && (fontFamily == font->GetFamily()))
244 return NULL; // No change
245 }
246 else if (font) fontFamily = font->GetFamily();
247
248 if (name.Contains("Style"))
249 {
250 wxString val = property->GetValue().StringValue();
251 fontStyle = wxStringToFontStyle(val);
252
253 if (font && (fontStyle == font->GetStyle()))
254 return NULL; // No change
255 }
256 else if (font) fontStyle = font->GetStyle();
257 if (name.Contains("Weight"))
258 {
259 wxString val = property->GetValue().StringValue();
260 fontWeight = wxStringToFontWeight(val);
261
262 if (font && (fontWeight == font->GetWeight()))
263 return NULL; // No change
264 }
265 else if (font) fontWeight = font->GetWeight();
266
267 if (name.Contains("Underlined"))
268 {
269 fontUnderlined = property->GetValue().BoolValue();
270
271 if (font && (fontUnderlined == font->GetUnderlined()))
272 return NULL; // No change
273 }
274 else if (font) fontUnderlined = font->GetUnderlined();
275
276 wxFont *newFont = wxTheFontList->FindOrCreateFont(pointSize, fontFamily, fontStyle, fontWeight, fontUnderlined);
277 if (newFont)
278 {
279 return newFont;
280 }
281 else
282 return NULL;
283 }
284
285 wxProperty *wxWindowPropertyInfo::GetProperty(wxString& name)
286 {
287 wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
288
289 wxFont *font = & m_propertyWindow->GetFont();
290 if (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" ||
291 name == "fontUnderlined")
292 return GetFontProperty(name, font);
293 else if (name == "name")
294 return new wxProperty("name", m_propertyWindow->GetName(), "string");
295 else if (name == "title")
296 return new wxProperty("title", m_propertyWindow->GetTitle(), "string");
297 else if (name == "x")
298 {
299 return new wxProperty("x", (long)resource->GetX(), "integer");
300 }
301 else if (name == "y")
302 {
303 return new wxProperty("y", (long)resource->GetY(), "integer");
304 }
305 else if (name == "width")
306 {
307 return new wxProperty("width", (long)resource->GetWidth(), "integer");
308 }
309 else if (name == "height")
310 {
311 return new wxProperty("height", (long)resource->GetHeight(), "integer");
312 }
313 else if (name == "id")
314 {
315 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
316 if (resource)
317 {
318 int id = resource->GetId();
319 wxString idStr;
320 idStr.Printf("%d", id);
321 wxString symbolName = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetSymbolForId(id);
322 symbolName += "=";
323 symbolName += idStr;
324 // symbolName is now e.g. "ID_PANEL21=105"
325 return new wxProperty("id", symbolName, "window_id");
326 }
327 else
328 return NULL;
329 }
330 else if (name == "border")
331 {
332 wxString border("");
333 if (m_propertyWindow->GetWindowStyleFlag() & wxSIMPLE_BORDER)
334 border = "wxSIMPLE_BORDER";
335 else if (m_propertyWindow->GetWindowStyleFlag() & wxRAISED_BORDER)
336 border = "wxRAISED_BORDER";
337 else if (m_propertyWindow->GetWindowStyleFlag() & wxSUNKEN_BORDER)
338 border = "wxSUNKEN_BORDER";
339 else if (m_propertyWindow->GetWindowStyleFlag() & wxDOUBLE_BORDER)
340 border = "wxDOUBLE_BORDER";
341 else if (m_propertyWindow->GetWindowStyleFlag() & wxSTATIC_BORDER)
342 border = "wxSTATIC_BORDER";
343 else
344 border = "wxNO_BORDER";
345
346 return new wxProperty("border", border, "string",
347 new wxStringListValidator(new wxStringList("wxSIMPLE_BORDER", "wxRAISED_BORDER",
348 "wxSUNKEN_BORDER", "wxDOUBLE_BORDER", "wxSTATIC_BORDER", "wxNO_BORDER", NULL)));
349 }
350 else
351 return NULL;
352 }
353
354 bool wxWindowPropertyInfo::SetProperty(wxString& name, wxProperty *property)
355 {
356 wxFont *font = & m_propertyWindow->GetFont();
357 if (font && (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" || name == "fontUnderlined" ))
358 {
359 wxFont *newFont = SetFontProperty(name, property, font);
360 if (newFont)
361 m_propertyWindow->SetFont(* newFont);
362 return TRUE;
363 }
364 else if (name == "name")
365 {
366 // Remove old name from resource table, if it's there.
367 wxItemResource *oldResource = (wxItemResource *)wxResourceManager::GetCurrentResourceManager()->GetResourceTable().Delete(m_propertyWindow->GetName());
368 if (oldResource)
369 {
370 // It's a top-level resource
371 m_propertyWindow->SetName(property->GetValue().StringValue());
372 oldResource->SetName(property->GetValue().StringValue());
373 wxResourceManager::GetCurrentResourceManager()->GetResourceTable().Put(m_propertyWindow->GetName(), oldResource);
374 }
375 else
376 {
377 // It's a child of something; just set the name of the resource and the window.
378 m_propertyWindow->SetName(property->GetValue().StringValue());
379 m_propertyResource->SetName(property->GetValue().StringValue());
380 }
381 // Refresh the resource manager list, because the name changed.
382 wxResourceManager::GetCurrentResourceManager()->UpdateResourceList();
383 return TRUE;
384 }
385 else if (name == "title")
386 {
387 m_propertyWindow->SetTitle(property->GetValue().StringValue());
388 return TRUE;
389 }
390 else if (name == "x")
391 {
392 int x, y;
393 m_propertyWindow->GetPosition(&x, &y);
394 int newX = (int)property->GetValue().IntegerValue();
395
396 // We need to convert to pixels if this is not a dialog or panel, but
397 // the parent resource specifies dialog units.
398 if (m_propertyWindow->GetParent() && m_propertyWindow->IsKindOf(CLASSINFO(wxControl)))
399 {
400 wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow->GetParent());
401 if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
402 {
403 wxPoint pt = m_propertyWindow->GetParent()->ConvertDialogToPixels(wxPoint(newX, y));
404 newX = pt.x;
405 }
406 }
407 else if (m_propertyWindow->IsKindOf(CLASSINFO(wxPanel)))
408 {
409 wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
410 if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
411 {
412 wxPoint pt = m_propertyWindow->ConvertDialogToPixels(wxPoint(newX, y));
413 newX = pt.x;
414 }
415 }
416
417 if (x != newX)
418 m_propertyWindow->Move(newX, y);
419 return TRUE;
420 }
421 else if (name == "y")
422 {
423 int x, y;
424 m_propertyWindow->GetPosition(&x, &y);
425 int newY = (int)property->GetValue().IntegerValue();
426
427 // We need to convert to pixels if this is not a dialog or panel, but
428 // the parent resource specifies dialog units.
429 if (m_propertyWindow->GetParent() && m_propertyWindow->IsKindOf(CLASSINFO(wxControl)))
430 {
431 wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow->GetParent());
432 if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
433 {
434 wxPoint pt = m_propertyWindow->GetParent()->ConvertDialogToPixels(wxPoint(x, newY));
435 newY = pt.y;
436 }
437 }
438 else if (m_propertyWindow->IsKindOf(CLASSINFO(wxPanel)))
439 {
440 wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
441 if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
442 {
443 wxPoint pt = m_propertyWindow->ConvertDialogToPixels(wxPoint(x, newY));
444 newY = pt.y;
445 }
446 }
447
448 if (y != newY)
449 m_propertyWindow->Move(x, newY);
450 return TRUE;
451 }
452 else if (name == "width")
453 {
454 int width, height;
455 m_propertyWindow->GetSize(&width, &height);
456 int newWidth = (int)property->GetValue().IntegerValue();
457
458 // We need to convert to pixels if this is not a dialog or panel, but
459 // the parent resource specifies dialog units.
460 if (m_propertyWindow->GetParent() && m_propertyWindow->IsKindOf(CLASSINFO(wxControl)))
461 {
462 wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow->GetParent());
463 if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
464 {
465 wxSize sz = m_propertyWindow->GetParent()->ConvertDialogToPixels(wxSize(newWidth, height));
466 newWidth = sz.x;
467 }
468 }
469 else if (m_propertyWindow->IsKindOf(CLASSINFO(wxPanel)))
470 {
471 wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
472 if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
473 {
474 wxSize sz = m_propertyWindow->ConvertDialogToPixels(wxSize(newWidth, height));
475 newWidth = sz.x;
476 }
477 }
478
479 if (width != newWidth)
480 {
481 m_propertyWindow->SetSize(newWidth, height);
482 }
483 return TRUE;
484 }
485 else if (name == "height")
486 {
487 int width, height;
488 m_propertyWindow->GetSize(&width, &height);
489 int newHeight = (int)property->GetValue().IntegerValue();
490
491 // We need to convert to pixels if this is not a dialog or panel, but
492 // the parent resource specifies dialog units.
493 if (m_propertyWindow->GetParent() && m_propertyWindow->IsKindOf(CLASSINFO(wxControl)))
494 {
495 wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow->GetParent());
496 if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
497 {
498 wxSize sz = m_propertyWindow->GetParent()->ConvertDialogToPixels(wxSize(width, newHeight));
499 newHeight = sz.y;
500 }
501 }
502 else if (m_propertyWindow->IsKindOf(CLASSINFO(wxPanel)))
503 {
504 wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
505 if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
506 {
507 wxSize sz = m_propertyWindow->ConvertDialogToPixels(wxSize(width, newHeight));
508 newHeight = sz.y;
509 }
510 }
511
512 if (height != newHeight)
513 {
514 m_propertyWindow->SetSize(width, newHeight);
515 }
516 return TRUE;
517 }
518 else if (name == "id")
519 {
520 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
521 if (resource)
522 {
523 wxString value = property->GetValue().StringValue();
524
525 wxString strName = value.Before('=');
526 wxString strId = value.After('=');
527 int id = atoi(strId);
528
529 wxString oldSymbolName = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetSymbolForId(resource->GetId());
530 int oldSymbolId = resource->GetId();
531
532 if (strName != "")
533 {
534 // If we change the id for an existing symbol, we need to:
535 // 1) Check if there are any other resources currently using the original id.
536 // If so, will need to change their id to the new id.
537 // 2) Remove the old symbol, add the new symbol.
538 // In this check, we don't have to do this, but we need to do it in SetProperty.
539
540 if (strName == oldSymbolName && id != oldSymbolId)
541 {
542 wxASSERT( (!wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(oldSymbolName)) );
543
544 // It's OK to change just the id. But we'll need to change all matching ids in all resources,
545 // because ids are unique and changing one resource's id must change all identical ones.
546 wxResourceManager::GetCurrentResourceManager()->ChangeIds(oldSymbolId, id);
547
548 wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().RemoveSymbol(oldSymbolName);
549 wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().AddSymbol(strName, id);
550 }
551
552 // If we change the name but not the id, we'll just need to remove and
553 // re-add the symbol/id pair.
554 if (strName != oldSymbolName && id == oldSymbolId)
555 {
556 wxASSERT( (!wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(oldSymbolName)) );
557
558 wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().RemoveSymbol(oldSymbolName);
559
560 if (!wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().SymbolExists(strName))
561 {
562 wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().AddSymbol(strName, id);
563 }
564 }
565
566 // What if we're changing both the name and the id?
567 // - if there's no symbol of that name, just remove the old, add the new (in SetProperty)
568 // - if there is a symbol of that name, if id matches, do nothing. If not, veto.
569
570 if (strName != oldSymbolName && id != oldSymbolId)
571 {
572 // Remove old symbol if it's not being used
573 if (!wxResourceManager::GetCurrentResourceManager()->IsSymbolUsed(resource, oldSymbolId) &&
574 !wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(oldSymbolName))
575 {
576 wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().RemoveSymbol(oldSymbolName);
577 }
578
579 if (!wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().SymbolExists(strName))
580 {
581 wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().AddSymbol(strName, id);
582 }
583 }
584 resource->SetId(id);
585 }
586
587 return TRUE;
588 }
589 else
590 return FALSE;
591 }
592 else if (name == "border")
593 {
594 long borderStyle = wxNO_BORDER;
595 wxString val = property->GetValue().StringValue();
596
597 if (val == "wxSIMPLE_BORDER")
598 borderStyle = wxSIMPLE_BORDER;
599 else if (val == "wxRAISED_BORDER")
600 borderStyle = wxRAISED_BORDER;
601 else if (val == "wxSUNKEN_BORDER")
602 borderStyle = wxSUNKEN_BORDER;
603 else if (val == "wxDOUBLE_BORDER")
604 borderStyle = wxDOUBLE_BORDER;
605 else if (val == "wxSTATIC_BORDER")
606 borderStyle = wxSTATIC_BORDER;
607 else
608 borderStyle = wxNO_BORDER;
609
610 SetWindowStyle(m_propertyWindow, wxSIMPLE_BORDER, FALSE);
611 SetWindowStyle(m_propertyWindow, wxRAISED_BORDER, FALSE);
612 SetWindowStyle(m_propertyWindow, wxSUNKEN_BORDER, FALSE);
613 SetWindowStyle(m_propertyWindow, wxDOUBLE_BORDER, FALSE);
614 SetWindowStyle(m_propertyWindow, wxSTATIC_BORDER, FALSE);
615 SetWindowStyle(m_propertyWindow, wxNO_BORDER, FALSE);
616
617 SetWindowStyle(m_propertyWindow, borderStyle, TRUE);
618
619 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
620 resource->SetStyle(m_propertyWindow->GetWindowStyleFlag());
621 return TRUE;
622 }
623 else
624 return FALSE;
625 }
626
627 void wxWindowPropertyInfo::GetPropertyNames(wxStringList& names)
628 {
629 names.Add("id");
630 names.Add("name");
631 names.Add("x");
632 names.Add("y");
633 names.Add("width");
634 names.Add("height");
635 names.Add("border");
636 if (!m_propertyWindow->IsKindOf(CLASSINFO(wxControl)))
637 {
638 names.Add("fontPoints");
639 names.Add("fontFamily");
640 names.Add("fontStyle");
641 names.Add("fontWeight");
642 names.Add("fontUnderlined");
643 }
644 }
645
646 // Fill in the wxItemResource members to mirror the current window settings
647 bool wxWindowPropertyInfo::InstantiateResource(wxItemResource *resource)
648 {
649 // resource->SetType(m_propertyWindow->GetClassInfo()->GetClassName());
650
651 // resource->SetStyle(m_propertyWindow->GetWindowStyleFlag());
652 wxString str(m_propertyWindow->GetName());
653 resource->SetName(str);
654
655 #if 0
656 int x, y, w, h;
657
658 if (m_propertyWindow->IsKindOf(CLASSINFO(wxPanel)))
659 m_propertyWindow->GetClientSize(&w, &h);
660 else
661 m_propertyWindow->GetSize(&w, &h);
662
663 m_propertyWindow->GetPosition(&x, &y);
664
665 // We need to convert to dialog units if this is not a dialog or panel, but
666 // the parent resource specifies dialog units.
667 if (m_propertyWindow->GetParent() && m_propertyWindow->IsKindOf(CLASSINFO(wxControl)))
668 {
669 wxItemResource* parentResource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow->GetParent());
670 if (parentResource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
671 {
672 wxPoint pt = m_propertyWindow->GetParent()->ConvertPixelsToDialog(wxPoint(x, y));
673 x = pt.x; y = pt.y;
674 wxSize sz = m_propertyWindow->GetParent()->ConvertPixelsToDialog(wxSize(w, h));
675 w = sz.x; h = sz.y;
676 }
677 }
678 else if (m_propertyWindow->IsKindOf(CLASSINFO(wxPanel)))
679 {
680 if (resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS)
681 {
682 wxPoint pt = m_propertyWindow->ConvertPixelsToDialog(wxPoint(x, y));
683 x = pt.x; y = pt.y;
684 wxSize sz = m_propertyWindow->ConvertPixelsToDialog(wxSize(w, h));
685 w = sz.x; h = sz.y;
686 }
687 }
688
689 resource->SetSize(x, y, w, h);
690 #endif
691
692 return TRUE;
693 }
694
695 // Set the window style
696 void wxWindowPropertyInfo::SetWindowStyle(wxWindow* win, long style, bool set)
697 {
698 if (style == 0)
699 return;
700
701 if ((win->GetWindowStyleFlag() & style) == style)
702 {
703 if (!set)
704 {
705 win->SetWindowStyleFlag(win->GetWindowStyleFlag() - style);
706 }
707 }
708 else
709 {
710 if (set)
711 {
712 win->SetWindowStyleFlag(win->GetWindowStyleFlag() | style);
713 }
714 }
715 }
716
717 /*
718 * Controls
719 */
720
721 wxProperty *wxItemPropertyInfo::GetProperty(wxString& name)
722 {
723 wxControl *itemWindow = (wxControl *)m_propertyWindow;
724 wxFont *font = & itemWindow->GetFont();
725
726 if (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" ||
727 name == "fontUnderlined")
728 return GetFontProperty(name, font);
729 else if (name == "label" && itemWindow->GetLabel())
730 return new wxProperty("label", m_propertyWindow->GetLabel(), "string");
731 else
732 return wxWindowPropertyInfo::GetProperty(name);
733 }
734
735 bool wxItemPropertyInfo::SetProperty(wxString& name, wxProperty *property)
736 {
737 wxControl *itemWindow = (wxControl *)m_propertyWindow;
738 wxFont *font = & itemWindow->GetFont();
739
740 if (font && (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" || name == "fontUnderlined" ))
741 {
742 wxFont *newFont = SetFontProperty(name, property, font);
743 if (newFont)
744 itemWindow->SetLabelFont(* newFont);
745 return TRUE;
746 }
747 else if (name == "label")
748 {
749 itemWindow->SetLabel(property->GetValue().StringValue());
750 return TRUE;
751 }
752 else
753 return wxWindowPropertyInfo::SetProperty(name, property);
754 }
755
756 void wxItemPropertyInfo::GetPropertyNames(wxStringList& names)
757 {
758 wxWindowPropertyInfo::GetPropertyNames(names);
759
760 names.Add("fontPoints");
761 names.Add("fontFamily");
762 names.Add("fontStyle");
763 names.Add("fontWeight");
764 names.Add("fontUnderlined");
765 }
766
767 bool wxItemPropertyInfo::InstantiateResource(wxItemResource *resource)
768 {
769 wxWindowPropertyInfo::InstantiateResource(resource);
770
771 wxControl *item = (wxControl *)m_propertyWindow;
772 wxString str(item->GetLabel());
773 resource->SetTitle(str);
774 if (item->GetFont().Ok())
775 resource->SetFont(* wxTheFontList->FindOrCreateFont(item->GetFont().GetPointSize(),
776 item->GetFont().GetFamily(), item->GetFont().GetStyle(), item->GetFont().GetWeight(),
777 item->GetFont().GetUnderlined(), item->GetFont().GetFaceName()));
778 return TRUE;
779 }
780
781 /*
782 * Button
783 */
784
785 wxProperty *wxButtonPropertyInfo::GetProperty(wxString& name)
786 {
787 return wxItemPropertyInfo::GetProperty(name);
788 }
789
790 bool wxButtonPropertyInfo::SetProperty(wxString& name, wxProperty *property)
791 {
792 return wxItemPropertyInfo::SetProperty(name, property);
793 }
794
795 void wxButtonPropertyInfo::GetPropertyNames(wxStringList& names)
796 {
797 wxItemPropertyInfo::GetPropertyNames(names);
798 names.Add("label");
799 }
800
801 bool wxButtonPropertyInfo::InstantiateResource(wxItemResource *resource)
802 {
803 return wxItemPropertyInfo::InstantiateResource(resource);
804 }
805
806 /*
807 * wxBitmapButton
808 */
809
810 wxProperty *wxBitmapButtonPropertyInfo::GetProperty(wxString& name)
811 {
812 wxBitmapButton *button = (wxBitmapButton *)m_propertyWindow;
813 if (name == "bitmapFilename")
814 {
815 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(button);
816 wxString str("none.bmp");
817
818 if (resource)
819 {
820 str = wxResourceManager::GetCurrentResourceManager()->FindBitmapFilenameForResource(resource);
821 }
822 return new wxProperty("bitmapFilename", str.GetData(), "string", new wxFilenameListValidator("Select a bitmap file", "*.bmp"));
823 }
824 else
825 return wxButtonPropertyInfo::GetProperty(name);
826 }
827
828 bool wxBitmapButtonPropertyInfo::SetProperty(wxString& name, wxProperty *property)
829 {
830 wxBitmapButton *button = (wxBitmapButton *)m_propertyWindow;
831 if (name == "bitmapFilename")
832 {
833 char *s = property->GetValue().StringValue();
834 if (s && wxFileExists(s))
835 {
836 s = copystring(s);
837 wxBitmap *bitmap = new wxBitmap(s, wxBITMAP_TYPE_BMP);
838 if (!bitmap->Ok())
839 {
840 delete bitmap;
841 delete[] s;
842 return FALSE;
843 }
844 else
845 {
846 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(button);
847 if (resource)
848 {
849 wxString oldResource(resource->GetValue4());
850 wxString resName = wxResourceManager::GetCurrentResourceManager()->AddBitmapResource(s);
851 resource->SetValue4(resName);
852
853 if (!oldResource.IsNull())
854 wxResourceManager::GetCurrentResourceManager()->PossiblyDeleteBitmapResource(oldResource);
855 }
856
857 button->SetLabel(* bitmap);
858 delete[] s;
859 return TRUE;
860 }
861 }
862 return FALSE;
863 }
864 else
865 return wxButtonPropertyInfo::SetProperty(name, property);
866 }
867
868 void wxBitmapButtonPropertyInfo::GetPropertyNames(wxStringList& names)
869 {
870 wxButtonPropertyInfo::GetPropertyNames(names);
871 names.Delete("label");
872 names.Add("bitmapFilename");
873 }
874
875 bool wxBitmapButtonPropertyInfo::InstantiateResource(wxItemResource *resource)
876 {
877 return wxItemPropertyInfo::InstantiateResource(resource);
878 }
879
880 /*
881 * wxStaticText
882 */
883
884 wxProperty *wxStaticTextPropertyInfo::GetProperty(wxString& name)
885 {
886 return wxItemPropertyInfo::GetProperty(name);
887 }
888
889 bool wxStaticTextPropertyInfo::SetProperty(wxString& name, wxProperty *property)
890 {
891 return wxItemPropertyInfo::SetProperty(name, property);
892 }
893
894 void wxStaticTextPropertyInfo::GetPropertyNames(wxStringList& names)
895 {
896 wxItemPropertyInfo::GetPropertyNames(names);
897 names.Add("label");
898 }
899
900 bool wxStaticTextPropertyInfo::InstantiateResource(wxItemResource *resource)
901 {
902 return wxItemPropertyInfo::InstantiateResource(resource);
903 }
904
905 /*
906 * wxStaticBitmap
907 */
908
909 wxProperty *wxStaticBitmapPropertyInfo::GetProperty(wxString& name)
910 {
911 wxStaticBitmap *message = (wxStaticBitmap *)m_propertyWindow;
912 if (name == "bitmapFilename")
913 {
914 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(message);
915 wxString str("none.bmp");
916
917 if (resource)
918 {
919 str = wxResourceManager::GetCurrentResourceManager()->FindBitmapFilenameForResource(resource);
920 }
921 return new wxProperty("bitmapFilename", str.GetData(), "string", new wxFilenameListValidator("Select a bitmap file", "*.bmp"));
922 }
923 else
924 return wxItemPropertyInfo::GetProperty(name);
925 }
926
927 bool wxStaticBitmapPropertyInfo::SetProperty(wxString& name, wxProperty *property)
928 {
929 wxStaticBitmap *message = (wxStaticBitmap *)m_propertyWindow;
930 if (name == "bitmapFilename")
931 {
932 char *s = property->GetValue().StringValue();
933 if (s && wxFileExists(s))
934 {
935 s = copystring(s);
936
937 wxBitmap *bitmap = new wxBitmap(s, wxBITMAP_TYPE_BMP);
938 if (!bitmap->Ok())
939 {
940 delete bitmap;
941 delete[] s;
942 return FALSE;
943 }
944 else
945 {
946 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(message);
947 if (resource)
948 {
949 wxString oldResource(resource->GetValue4());
950 wxString resName = wxResourceManager::GetCurrentResourceManager()->AddBitmapResource(s);
951 resource->SetValue4(resName);
952
953 if (!oldResource.IsNull())
954 wxResourceManager::GetCurrentResourceManager()->PossiblyDeleteBitmapResource(oldResource);
955 }
956
957 message->SetBitmap(* bitmap);
958 delete[] s;
959 return TRUE;
960 }
961 }
962 return FALSE;
963 }
964 else
965 return wxItemPropertyInfo::SetProperty(name, property);
966 }
967
968 void wxStaticBitmapPropertyInfo::GetPropertyNames(wxStringList& names)
969 {
970 wxItemPropertyInfo::GetPropertyNames(names);
971 names.Add("bitmapFilename");
972 }
973
974 bool wxStaticBitmapPropertyInfo::InstantiateResource(wxItemResource *resource)
975 {
976 return wxItemPropertyInfo::InstantiateResource(resource);
977 }
978
979 /*
980 * Text item
981 */
982
983 wxProperty *wxTextPropertyInfo::GetProperty(wxString& name)
984 {
985 wxTextCtrl *text = (wxTextCtrl *)m_propertyWindow;
986 if (name == "value")
987 return new wxProperty("value", text->GetValue(), "string");
988 else if (name == "password")
989 {
990 bool isPassword = ((text->GetWindowStyleFlag() & wxTE_PASSWORD) == wxTE_PASSWORD);
991 return new wxProperty("password", isPassword, "bool");
992 }
993 else if (name == "readonly")
994 {
995 bool isReadOnly = ((text->GetWindowStyleFlag() & wxTE_READONLY) == wxTE_READONLY);
996 return new wxProperty("readonly", isReadOnly, "bool");
997 }
998 else
999 return wxItemPropertyInfo::GetProperty(name);
1000 }
1001
1002 bool wxTextPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1003 {
1004 wxTextCtrl *text = (wxTextCtrl *)m_propertyWindow;
1005 if (name == "value")
1006 {
1007 text->SetValue(property->GetValue().StringValue());
1008 return TRUE;
1009 }
1010 else if (name == "password")
1011 {
1012 long flag = text->GetWindowStyleFlag();
1013 if (property->GetValue().BoolValue())
1014 {
1015 if ((flag & wxTE_PASSWORD) != wxTE_PASSWORD)
1016 flag |= wxTE_PASSWORD;
1017 }
1018 else
1019 {
1020 if ((flag & wxTE_PASSWORD) == wxTE_PASSWORD)
1021 flag -= wxTE_PASSWORD;
1022 }
1023 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(text);
1024 resource->SetStyle(flag);
1025
1026 wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(text, this);
1027 return TRUE;
1028 }
1029 else if (name == "readonly")
1030 {
1031 long flag = text->GetWindowStyleFlag();
1032 if (property->GetValue().BoolValue())
1033 {
1034 if ((flag & wxTE_READONLY) != wxTE_READONLY)
1035 flag |= wxTE_READONLY;
1036 }
1037 else
1038 {
1039 if ((flag & wxTE_READONLY) == wxTE_READONLY)
1040 flag -= wxTE_READONLY;
1041 }
1042 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(text);
1043 resource->SetStyle(flag);
1044
1045 wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(text, this);
1046 return TRUE;
1047 }
1048 else
1049 return wxItemPropertyInfo::SetProperty(name, property);
1050 }
1051
1052 void wxTextPropertyInfo::GetPropertyNames(wxStringList& names)
1053 {
1054 wxItemPropertyInfo::GetPropertyNames(names);
1055 names.Add("value");
1056 names.Add("readonly");
1057 names.Add("password");
1058 }
1059
1060 bool wxTextPropertyInfo::InstantiateResource(wxItemResource *resource)
1061 {
1062 wxTextCtrl *text = (wxTextCtrl *)m_propertyWindow;
1063 wxString str(text->GetValue());
1064 resource->SetValue4(str);
1065
1066 return wxItemPropertyInfo::InstantiateResource(resource);
1067 }
1068
1069 /*
1070 * Listbox item
1071 */
1072
1073 wxProperty *wxListBoxPropertyInfo::GetProperty(wxString& name)
1074 {
1075 wxListBox *listBox = (wxListBox *)m_propertyWindow;
1076 if (name == "values")
1077 {
1078 wxStringList *stringList = new wxStringList;
1079 int i;
1080 for (i = 0; i < listBox->Number(); i++)
1081 stringList->Add(listBox->GetString(i));
1082
1083 return new wxProperty(name, stringList, "stringlist");
1084 }
1085 else if (name == "multiple")
1086 {
1087 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(listBox);
1088 if (!resource)
1089 return NULL;
1090
1091 char *mult = "wxLB_SINGLE";
1092
1093 if ((listBox->GetWindowStyleFlag() & wxLB_MULTIPLE) != 0)
1094 mult = "wxLB_MULTIPLE";
1095 else if ((listBox->GetWindowStyleFlag() & wxLB_EXTENDED) != 0)
1096 mult = "wxLB_EXTENDED";
1097 else
1098 mult = "wxLB_SINGLE";
1099
1100 return new wxProperty("multiple", mult, "string",
1101 new wxStringListValidator(new wxStringList("wxLB_SINGLE", "wxLB_MULTIPLE", "wxLB_EXTENDED",
1102 NULL)));
1103 }
1104 else
1105 return wxItemPropertyInfo::GetProperty(name);
1106 }
1107
1108 bool wxListBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1109 {
1110 wxListBox *listBox = (wxListBox *)m_propertyWindow;
1111 if (name == "values")
1112 {
1113 listBox->Clear();
1114 wxPropertyValue *expr = property->GetValue().GetFirst();
1115 while (expr)
1116 {
1117 char *s = expr->StringValue();
1118 if (s)
1119 listBox->Append(s);
1120 expr = expr->GetNext();
1121 }
1122 return TRUE;
1123 }
1124 else if (name == "multiple")
1125 {
1126 SetWindowStyle(m_propertyWindow, wxLB_SINGLE, FALSE);
1127 SetWindowStyle(m_propertyWindow, wxLB_MULTIPLE, FALSE);
1128 SetWindowStyle(m_propertyWindow, wxLB_EXTENDED, FALSE);
1129
1130 wxString str(property->GetValue().StringValue());
1131 if (str == "wxLB_MULTIPLE")
1132 SetWindowStyle(m_propertyWindow, wxLB_MULTIPLE, TRUE);
1133 else if (str == "wxLB_EXTENDED")
1134 SetWindowStyle(m_propertyWindow, wxLB_EXTENDED, TRUE);
1135 else
1136 SetWindowStyle(m_propertyWindow, wxLB_SINGLE, TRUE);
1137
1138 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(listBox);
1139 if (resource)
1140 resource->SetStyle(m_propertyWindow->GetWindowStyleFlag());
1141 wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(listBox, this);
1142 return TRUE;
1143 }
1144 else
1145 return wxItemPropertyInfo::SetProperty(name, property);
1146 }
1147
1148 void wxListBoxPropertyInfo::GetPropertyNames(wxStringList& names)
1149 {
1150 wxItemPropertyInfo::GetPropertyNames(names);
1151 names.Add("values");
1152 names.Add("multiple");
1153 }
1154
1155 bool wxListBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
1156 {
1157 wxListBox *lbox = (wxListBox *)m_propertyWindow;
1158 // This will be set for the wxItemResource on reading or in SetProperty
1159 // resource->SetValue1(lbox->GetSelectionMode());
1160 int i;
1161 if (lbox->Number() == 0)
1162 resource->SetStringValues(NULL);
1163 else
1164 {
1165 wxStringList slist;
1166
1167 for (i = 0; i < lbox->Number(); i++)
1168 slist.Add(lbox->GetString(i));
1169
1170 resource->SetStringValues(slist);
1171 }
1172 return wxItemPropertyInfo::InstantiateResource(resource);
1173 }
1174
1175 /*
1176 * Choice item
1177 */
1178
1179 wxProperty *wxChoicePropertyInfo::GetProperty(wxString& name)
1180 {
1181 wxChoice *choice = (wxChoice *)m_propertyWindow;
1182 if (name == "values")
1183 {
1184 wxStringList* stringList = new wxStringList;
1185 int i;
1186 for (i = 0; i < choice->Number(); i++)
1187 stringList->Add(choice->GetString(i));
1188
1189 return new wxProperty(name, stringList, "stringlist");
1190 }
1191 else
1192 return wxItemPropertyInfo::GetProperty(name);
1193 }
1194
1195 bool wxChoicePropertyInfo::SetProperty(wxString& name, wxProperty *property)
1196 {
1197 wxChoice *choice = (wxChoice *)m_propertyWindow;
1198 if (name == "values")
1199 {
1200 choice->Clear();
1201 wxPropertyValue *expr = property->GetValue().GetFirst();
1202 while (expr)
1203 {
1204 char *s = expr->StringValue();
1205 if (s)
1206 choice->Append(s);
1207 expr = expr->GetNext();
1208 }
1209 if (choice->Number() > 0)
1210 choice->SetSelection(0);
1211 return TRUE;
1212 }
1213 else
1214 return wxItemPropertyInfo::SetProperty(name, property);
1215 }
1216
1217 void wxChoicePropertyInfo::GetPropertyNames(wxStringList& names)
1218 {
1219 wxItemPropertyInfo::GetPropertyNames(names);
1220 names.Add("values");
1221 }
1222
1223 bool wxChoicePropertyInfo::InstantiateResource(wxItemResource *resource)
1224 {
1225 wxChoice *choice = (wxChoice *)m_propertyWindow;
1226 int i;
1227 if (choice->Number() == 0)
1228 resource->SetStringValues(NULL);
1229 else
1230 {
1231 wxStringList slist;
1232
1233 for (i = 0; i < choice->Number(); i++)
1234 slist.Add(choice->GetString(i));
1235
1236 resource->SetStringValues(slist);
1237 }
1238 return wxItemPropertyInfo::InstantiateResource(resource);
1239 }
1240
1241 /*
1242 * Choice item
1243 */
1244
1245 wxProperty *wxComboBoxPropertyInfo::GetProperty(wxString& name)
1246 {
1247 wxComboBox *choice = (wxComboBox *)m_propertyWindow;
1248 if (name == "values")
1249 {
1250 wxStringList *stringList = new wxStringList;
1251 int i;
1252 for (i = 0; i < choice->Number(); i++)
1253 stringList->Add(choice->GetString(i));
1254
1255 return new wxProperty(name, stringList, "stringlist");
1256 }
1257 else if (name == "sort")
1258 {
1259 bool sort = ((m_propertyWindow->GetWindowStyleFlag() & wxCB_SORT) == wxCB_SORT);
1260 return new wxProperty(name, sort, "bool");
1261 }
1262 else if (name == "style")
1263 {
1264 wxString styleStr("dropdown");
1265 if (m_propertyWindow->GetWindowStyleFlag() & wxCB_SIMPLE)
1266 styleStr = "simple";
1267 else if (m_propertyWindow->GetWindowStyleFlag() & wxCB_READONLY)
1268 styleStr = "readonly";
1269 else
1270 styleStr = "dropdown";
1271
1272 return new wxProperty(name, styleStr, "string",
1273 new wxStringListValidator(new wxStringList("simple", "dropdown", "readonly",
1274 NULL)));
1275 }
1276 else
1277 return wxItemPropertyInfo::GetProperty(name);
1278 }
1279
1280 bool wxComboBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1281 {
1282 wxComboBox *choice = (wxComboBox *)m_propertyWindow;
1283 if (name == "values")
1284 {
1285 choice->Clear();
1286 wxPropertyValue *expr = property->GetValue().GetFirst();
1287 while (expr)
1288 {
1289 char *s = expr->StringValue();
1290 if (s)
1291 choice->Append(s);
1292 expr = expr->GetNext();
1293 }
1294 if (choice->Number() > 0)
1295 choice->SetSelection(0);
1296 return TRUE;
1297 }
1298 else if (name == "sort")
1299 {
1300 SetWindowStyle(m_propertyWindow, wxCB_SORT, property->GetValue().BoolValue());
1301
1302 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
1303 resource->SetStyle(m_propertyWindow->GetWindowStyleFlag());
1304
1305 wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(m_propertyWindow, this);
1306 return TRUE;
1307 }
1308 else if (name == "style")
1309 {
1310 SetWindowStyle(m_propertyWindow, wxCB_SIMPLE, FALSE);
1311 SetWindowStyle(m_propertyWindow, wxCB_DROPDOWN, FALSE);
1312 SetWindowStyle(m_propertyWindow, wxCB_READONLY, FALSE);
1313
1314 wxString styleStr(property->GetValue().StringValue());
1315 if (styleStr == "simple")
1316 SetWindowStyle(m_propertyWindow, wxCB_SIMPLE, TRUE);
1317 else if (styleStr == "dropdown")
1318 SetWindowStyle(m_propertyWindow, wxCB_DROPDOWN, TRUE);
1319 else if (styleStr == "readonly")
1320 SetWindowStyle(m_propertyWindow, wxCB_READONLY, TRUE);
1321
1322 // Necesary?
1323 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
1324 resource->SetStyle(m_propertyWindow->GetWindowStyleFlag());
1325
1326 wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(m_propertyWindow, this);
1327
1328 return TRUE;
1329 }
1330 else
1331 return wxItemPropertyInfo::SetProperty(name, property);
1332 }
1333
1334 void wxComboBoxPropertyInfo::GetPropertyNames(wxStringList& names)
1335 {
1336 wxItemPropertyInfo::GetPropertyNames(names);
1337 names.Add("values");
1338 names.Add("style");
1339 names.Add("sort");
1340 }
1341
1342 bool wxComboBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
1343 {
1344 wxComboBox *choice = (wxComboBox *)m_propertyWindow;
1345 int i;
1346 if (choice->Number() == 0)
1347 resource->SetStringValues(NULL);
1348 else
1349 {
1350 wxStringList slist;
1351
1352 for (i = 0; i < choice->Number(); i++)
1353 slist.Add(choice->GetString(i));
1354
1355 resource->SetStringValues(slist);
1356 }
1357 return wxItemPropertyInfo::InstantiateResource(resource);
1358 }
1359
1360 /*
1361 * Radiobox item
1362 */
1363
1364 wxProperty *wxRadioBoxPropertyInfo::GetProperty(wxString& name)
1365 {
1366 wxRadioBox *radioBox = (wxRadioBox *)m_propertyWindow;
1367 if (name == "numberRowsOrCols")
1368 {
1369 return new wxProperty("numberRowsOrCols", (long)radioBox->GetNumberOfRowsOrCols(), "integer");
1370 }
1371 if (name == "orientation")
1372 {
1373 wxString orient;
1374 if (m_propertyWindow->GetWindowStyleFlag() & wxRA_HORIZONTAL)
1375 orient = "wxRA_HORIZONTAL";
1376 else
1377 orient = "wxRA_VERTICAL";
1378
1379 return new wxProperty("orientation", orient, "string",
1380 new wxStringListValidator(new wxStringList("wxRA_HORIZONTAL", "wxRA_VERTICAL",
1381 NULL)));
1382 }
1383 else if (name == "values")
1384 {
1385 wxStringList *stringList = new wxStringList;
1386 int i;
1387 for (i = 0; i < radioBox->Number(); i++)
1388 stringList->Add(radioBox->GetString(i));
1389
1390 return new wxProperty(name, stringList, "stringlist");
1391 }
1392 return wxItemPropertyInfo::GetProperty(name);
1393 }
1394
1395 bool wxRadioBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1396 {
1397 wxRadioBox *radioBox = (wxRadioBox *)m_propertyWindow;
1398 if (name == "numberRowsOrCols")
1399 {
1400 radioBox->SetNumberOfRowsOrCols((int)property->GetValue().IntegerValue());
1401 wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(radioBox, this);
1402 return TRUE;
1403 }
1404 else if (name == "orientation")
1405 {
1406 long windowStyle = radioBox->GetWindowStyleFlag();
1407 wxString val(property->GetValue().StringValue());
1408 if (val == "wxRA_HORIZONTAL")
1409 {
1410 if (windowStyle & wxRA_VERTICAL)
1411 windowStyle -= wxRA_VERTICAL;
1412 windowStyle |= wxRA_HORIZONTAL;
1413 }
1414 else
1415 {
1416 if (windowStyle & wxRA_HORIZONTAL)
1417 windowStyle -= wxRA_HORIZONTAL;
1418 windowStyle |= wxRA_VERTICAL;
1419 }
1420 radioBox->SetWindowStyleFlag(windowStyle);
1421 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(radioBox);
1422 resource->SetStyle(windowStyle);
1423
1424 wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(radioBox, this);
1425 return TRUE;
1426 }
1427 else if (name == "values")
1428 {
1429 // Set property into *resource*, not wxRadioBox, and then recreate
1430 // the wxRadioBox. This is because we can't dynamically set the strings
1431 // of a wxRadioBox.
1432 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
1433 if (!resource)
1434 return FALSE;
1435
1436 wxStringList stringList;
1437 wxPropertyValue *expr = property->GetValue().GetFirst();
1438 while (expr)
1439 {
1440 char *s = expr->StringValue();
1441 if (s)
1442 stringList.Add(s);
1443 expr = expr->GetNext();
1444 }
1445 resource->SetStringValues(stringList);
1446 wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(radioBox, this);
1447 return TRUE;
1448 }
1449 return wxItemPropertyInfo::SetProperty(name, property);
1450 }
1451
1452 void wxRadioBoxPropertyInfo::GetPropertyNames(wxStringList& names)
1453 {
1454 wxItemPropertyInfo::GetPropertyNames(names);
1455 names.Add("label");
1456 names.Add("values");
1457 names.Add("orientation");
1458 names.Add("numberRowsOrCols");
1459 }
1460
1461 bool wxRadioBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
1462 {
1463 wxRadioBox *rbox = (wxRadioBox *)m_propertyWindow;
1464 // Take strings from resource instead
1465 /*
1466 int i;
1467 if (rbox->Number() == 0)
1468 resource->SetStringValues(NULL);
1469 else
1470 {
1471 wxStringList *slist = new wxStringList;
1472
1473 for (i = 0; i < rbox->Number(); i++)
1474 slist->Add(rbox->GetString(i));
1475
1476 resource->SetStringValues(slist);
1477 }
1478 */
1479 resource->SetValue1(rbox->GetNumberOfRowsOrCols());
1480 return wxItemPropertyInfo::InstantiateResource(resource);
1481 }
1482
1483 /*
1484 * Groupbox item
1485 */
1486
1487 wxProperty *wxGroupBoxPropertyInfo::GetProperty(wxString& name)
1488 {
1489 return wxItemPropertyInfo::GetProperty(name);
1490 }
1491
1492 bool wxGroupBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1493 {
1494 return wxItemPropertyInfo::SetProperty(name, property);
1495 }
1496
1497 void wxGroupBoxPropertyInfo::GetPropertyNames(wxStringList& names)
1498 {
1499 wxItemPropertyInfo::GetPropertyNames(names);
1500 names.Add("label");
1501 }
1502
1503 bool wxGroupBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
1504 {
1505 return wxItemPropertyInfo::InstantiateResource(resource);
1506 }
1507
1508 /*
1509 * Checkbox item
1510 */
1511
1512 wxProperty *wxCheckBoxPropertyInfo::GetProperty(wxString& name)
1513 {
1514 wxCheckBox *checkBox = (wxCheckBox *)m_propertyWindow;
1515 if (name == "value")
1516 return new wxProperty("value", checkBox->GetValue(), "bool");
1517 else
1518 return wxItemPropertyInfo::GetProperty(name);
1519 }
1520
1521 bool wxCheckBoxPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1522 {
1523 wxCheckBox *checkBox = (wxCheckBox *)m_propertyWindow;
1524 if (name == "value")
1525 {
1526 checkBox->SetValue((bool)property->GetValue().BoolValue());
1527 return TRUE;
1528 }
1529 else
1530 return wxItemPropertyInfo::SetProperty(name, property);
1531 }
1532
1533 void wxCheckBoxPropertyInfo::GetPropertyNames(wxStringList& names)
1534 {
1535 wxItemPropertyInfo::GetPropertyNames(names);
1536 names.Add("label");
1537 names.Add("value");
1538 }
1539
1540 bool wxCheckBoxPropertyInfo::InstantiateResource(wxItemResource *resource)
1541 {
1542 wxCheckBox *cbox = (wxCheckBox *)m_propertyWindow;
1543 resource->SetValue1(cbox->GetValue());
1544 return wxItemPropertyInfo::InstantiateResource(resource);
1545 }
1546
1547 /*
1548 * Radiobutton item
1549 */
1550
1551 wxProperty *wxRadioButtonPropertyInfo::GetProperty(wxString& name)
1552 {
1553 wxRadioButton *checkBox = (wxRadioButton *)m_propertyWindow;
1554 if (name == "value")
1555 return new wxProperty("value", checkBox->GetValue(), "bool");
1556 else
1557 return wxItemPropertyInfo::GetProperty(name);
1558 }
1559
1560 bool wxRadioButtonPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1561 {
1562 wxRadioButton *checkBox = (wxRadioButton *)m_propertyWindow;
1563 if (name == "value")
1564 {
1565 checkBox->SetValue((bool)property->GetValue().BoolValue());
1566 return TRUE;
1567 }
1568 else
1569 return wxItemPropertyInfo::SetProperty(name, property);
1570 }
1571
1572 void wxRadioButtonPropertyInfo::GetPropertyNames(wxStringList& names)
1573 {
1574 wxItemPropertyInfo::GetPropertyNames(names);
1575 names.Add("label");
1576 names.Add("value");
1577 }
1578
1579 bool wxRadioButtonPropertyInfo::InstantiateResource(wxItemResource *resource)
1580 {
1581 wxRadioButton *cbox = (wxRadioButton *)m_propertyWindow;
1582 resource->SetValue1(cbox->GetValue());
1583 return wxItemPropertyInfo::InstantiateResource(resource);
1584 }
1585
1586 /*
1587 * Slider item
1588 */
1589
1590 wxProperty *wxSliderPropertyInfo::GetProperty(wxString& name)
1591 {
1592 wxSlider *slider = (wxSlider *)m_propertyWindow;
1593 if (name == "value")
1594 return new wxProperty("value", (long)slider->GetValue(), "integer");
1595 else if (name == "orientation")
1596 {
1597 char *pos = NULL;
1598 if (m_propertyWindow->GetWindowStyleFlag() & wxHORIZONTAL)
1599 pos = "wxHORIZONTAL";
1600 else
1601 pos = "wxVERTICAL";
1602
1603 return new wxProperty("orientation", pos, "string",
1604 new wxStringListValidator(new wxStringList("wxHORIZONTAL", "wxVERTICAL",
1605 NULL)));
1606 }
1607 else if (name == "minValue")
1608 return new wxProperty("minValue", (long)slider->GetMin(), "integer");
1609 else if (name == "maxValue")
1610 return new wxProperty("maxValue", (long)slider->GetMax(), "integer");
1611 else
1612 return wxItemPropertyInfo::GetProperty(name);
1613 }
1614
1615 bool wxSliderPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1616 {
1617 wxSlider *slider = (wxSlider *)m_propertyWindow;
1618 if (name == "value")
1619 {
1620 slider->SetValue((int)property->GetValue().IntegerValue());
1621 return TRUE;
1622 }
1623 else if (name == "orientation")
1624 {
1625 long windowStyle = slider->GetWindowStyleFlag();
1626 long oldWindowStyle = windowStyle;
1627 wxString val(property->GetValue().StringValue());
1628 if (val == "wxHORIZONTAL")
1629 {
1630 if (windowStyle & wxVERTICAL)
1631 windowStyle -= wxVERTICAL;
1632 windowStyle |= wxHORIZONTAL;
1633 }
1634 else
1635 {
1636 if (windowStyle & wxHORIZONTAL)
1637 windowStyle -= wxHORIZONTAL;
1638 windowStyle |= wxVERTICAL;
1639 }
1640
1641 if (oldWindowStyle == windowStyle)
1642 return TRUE;
1643
1644 slider->SetWindowStyleFlag(windowStyle);
1645
1646 // If the window style has changed, we swap the width and height parameters.
1647 int w, h;
1648 slider->GetSize(&w, &h);
1649
1650 slider = (wxSlider *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(slider, this);
1651 slider->SetSize(-1, -1, h, w);
1652
1653 return TRUE;
1654 }
1655 else if (name == "minValue")
1656 {
1657 slider->SetRange((int)property->GetValue().IntegerValue(), slider->GetMax());
1658 return TRUE;
1659 }
1660 else if (name == "maxValue")
1661 {
1662 slider->SetRange(slider->GetMin(), (int)property->GetValue().IntegerValue());
1663 return TRUE;
1664 }
1665 else
1666 return wxItemPropertyInfo::SetProperty(name, property);
1667 }
1668
1669 void wxSliderPropertyInfo::GetPropertyNames(wxStringList& names)
1670 {
1671 wxItemPropertyInfo::GetPropertyNames(names);
1672 names.Add("value");
1673 names.Add("orientation");
1674 names.Add("minValue");
1675 names.Add("maxValue");
1676 }
1677
1678 bool wxSliderPropertyInfo::InstantiateResource(wxItemResource *resource)
1679 {
1680 wxSlider *slider = (wxSlider *)m_propertyWindow;
1681 resource->SetValue1(slider->GetValue());
1682 resource->SetValue2(slider->GetMin());
1683 resource->SetValue3(slider->GetMax());
1684 return wxItemPropertyInfo::InstantiateResource(resource);
1685 }
1686
1687 /*
1688 * Gauge item
1689 */
1690
1691 wxProperty *wxGaugePropertyInfo::GetProperty(wxString& name)
1692 {
1693 wxGauge *gauge = (wxGauge *)m_propertyWindow;
1694 if (name == "value")
1695 return new wxProperty("value", (long)gauge->GetValue(), "integer");
1696 else if (name == "maxValue")
1697 return new wxProperty("maxValue", (long)gauge->GetRange(), "integer");
1698 else
1699 return wxItemPropertyInfo::GetProperty(name);
1700 }
1701
1702 bool wxGaugePropertyInfo::SetProperty(wxString& name, wxProperty *property)
1703 {
1704 wxGauge *gauge = (wxGauge *)m_propertyWindow;
1705 if (name == "value")
1706 {
1707 gauge->SetValue((int)property->GetValue().IntegerValue());
1708 return TRUE;
1709 }
1710 else if (name == "maxValue")
1711 {
1712 gauge->SetRange((int)property->GetValue().IntegerValue());
1713 return TRUE;
1714 }
1715 else
1716 return wxItemPropertyInfo::SetProperty(name, property);
1717 }
1718
1719 void wxGaugePropertyInfo::GetPropertyNames(wxStringList& names)
1720 {
1721 wxItemPropertyInfo::GetPropertyNames(names);
1722 names.Add("value");
1723 names.Add("maxValue");
1724 }
1725
1726 bool wxGaugePropertyInfo::InstantiateResource(wxItemResource *resource)
1727 {
1728 wxGauge *gauge = (wxGauge *)m_propertyWindow;
1729 resource->SetValue1(gauge->GetValue());
1730 resource->SetValue2(gauge->GetRange());
1731 return wxItemPropertyInfo::InstantiateResource(resource);
1732 }
1733
1734 /*
1735 * Scrollbar item
1736 */
1737
1738 wxProperty *wxScrollBarPropertyInfo::GetProperty(wxString& name)
1739 {
1740 wxScrollBar *scrollBar = (wxScrollBar *)m_propertyWindow;
1741 if (name == "value")
1742 return new wxProperty("value", (long)scrollBar->GetValue(), "integer");
1743 else if (name == "orientation")
1744 {
1745 char *pos = NULL;
1746 if (m_propertyWindow->GetWindowStyleFlag() & wxHORIZONTAL)
1747 pos = "wxHORIZONTAL";
1748 else
1749 pos = "wxVERTICAL";
1750
1751 return new wxProperty("orientation", pos, "string",
1752 new wxStringListValidator(new wxStringList("wxHORIZONTAL", "wxVERTICAL",
1753 NULL)));
1754 }
1755 else if (name == "pageSize")
1756 {
1757 int viewStart, pageLength, objectLength, viewLength;
1758 scrollBar->GetValues(&viewStart, &viewLength, &objectLength, &pageLength);
1759
1760 return new wxProperty("pageSize", (long)pageLength, "integer");
1761 }
1762 else if (name == "viewLength")
1763 {
1764 int viewStart, pageLength, objectLength, viewLength;
1765 scrollBar->GetValues(&viewStart, &viewLength, &objectLength, &pageLength);
1766
1767 return new wxProperty("viewLength", (long)viewLength, "integer");
1768 }
1769 else if (name == "objectLength")
1770 {
1771 int viewStart, pageLength, objectLength, viewLength;
1772 scrollBar->GetValues(&viewStart, &viewLength, &objectLength, &pageLength);
1773
1774 return new wxProperty("objectLength", (long)objectLength, "integer");
1775 }
1776 else
1777 return wxItemPropertyInfo::GetProperty(name);
1778 }
1779
1780 bool wxScrollBarPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1781 {
1782 wxScrollBar *scrollBar = (wxScrollBar *)m_propertyWindow;
1783 if (name == "value")
1784 {
1785 scrollBar->SetValue((int)property->GetValue().IntegerValue());
1786 return TRUE;
1787 }
1788 else if (name == "orientation")
1789 {
1790 long windowStyle = scrollBar->GetWindowStyleFlag();
1791 long oldWindowStyle = windowStyle;
1792 wxString val(property->GetValue().StringValue());
1793 if (val == "wxHORIZONTAL")
1794 {
1795 if (windowStyle & wxVERTICAL)
1796 windowStyle -= wxVERTICAL;
1797 windowStyle |= wxHORIZONTAL;
1798 }
1799 else
1800 {
1801 if (windowStyle & wxHORIZONTAL)
1802 windowStyle -= wxHORIZONTAL;
1803 windowStyle |= wxVERTICAL;
1804 }
1805
1806 if (oldWindowStyle == windowStyle)
1807 return TRUE;
1808
1809 scrollBar->SetWindowStyleFlag(windowStyle);
1810
1811 // If the window style has changed, we swap the width and height parameters.
1812 int w, h;
1813 scrollBar->GetSize(&w, &h);
1814
1815 scrollBar = (wxScrollBar *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(scrollBar, this);
1816 scrollBar->SetSize(-1, -1, h, w);
1817
1818 return TRUE;
1819 }
1820 else if (name == "pageSize")
1821 {
1822 scrollBar->SetPageSize((int)property->GetValue().IntegerValue());
1823 return TRUE;
1824 }
1825 else if (name == "viewLength")
1826 {
1827 scrollBar->SetViewLength((int)property->GetValue().IntegerValue());
1828 return TRUE;
1829 }
1830 else if (name == "objectLength")
1831 {
1832 scrollBar->SetObjectLength((int)property->GetValue().IntegerValue());
1833 return TRUE;
1834 }
1835 else
1836 return wxItemPropertyInfo::SetProperty(name, property);
1837 }
1838
1839 void wxScrollBarPropertyInfo::GetPropertyNames(wxStringList& names)
1840 {
1841 wxItemPropertyInfo::GetPropertyNames(names);
1842 names.Add("orientation");
1843 names.Add("value");
1844 names.Add("pageSize");
1845 names.Add("viewLength");
1846 names.Add("objectLength");
1847
1848 // Remove some properties we don't inherit
1849 names.Delete("fontPoints");
1850 names.Delete("fontFamily");
1851 names.Delete("fontStyle");
1852 names.Delete("fontWeight");
1853 names.Delete("fontUnderlined");
1854 }
1855
1856 bool wxScrollBarPropertyInfo::InstantiateResource(wxItemResource *resource)
1857 {
1858 wxScrollBar *sbar = (wxScrollBar *)m_propertyWindow;
1859
1860 resource->SetValue1(sbar->GetValue());
1861
1862 int viewStart, pageLength, objectLength, viewLength;
1863 sbar->GetValues(&viewStart, &viewLength, &objectLength, &pageLength);
1864
1865 resource->SetValue2(pageLength);
1866 resource->SetValue3(objectLength);
1867 resource->SetValue5(viewLength);
1868
1869 return wxItemPropertyInfo::InstantiateResource(resource);
1870 }
1871
1872 /*
1873 * Panels
1874 */
1875
1876 wxProperty *wxPanelPropertyInfo::GetProperty(wxString& name)
1877 {
1878 wxPanel *panelWindow = (wxPanel *)m_propertyWindow;
1879
1880 /*
1881 wxFont *labelFont = panelWindow->GetLabelFont();
1882 wxFont *buttonFont = panelWindow->GetButtonFont();
1883
1884 if (name == "labelFontPoints" || name == "labelFontFamily" || name == "labelFontStyle" || name == "labelFontWeight" ||
1885 name == "labelFontUnderlined")
1886 return GetFontProperty(name, labelFont);
1887 else if (name == "buttonFontPoints" || name == "buttonFontFamily" || name == "buttonFontStyle" || name == "buttonFontWeight" ||
1888 name == "buttonFontUnderlined")
1889 return GetFontProperty(name, buttonFont);
1890 */
1891
1892 if (name == "no3D")
1893 {
1894 bool userColours;
1895 if (panelWindow->GetWindowStyleFlag() & wxNO_3D)
1896 userColours = TRUE;
1897 else
1898 userColours = FALSE;
1899
1900 return new wxProperty(name, (bool)userColours, "bool");
1901 }
1902 else if (name == "backgroundColour")
1903 {
1904 wxColour col(panelWindow->GetBackgroundColour());
1905 char buf[7];
1906 wxDecToHex(col.Red(), buf);
1907 wxDecToHex(col.Green(), buf+2);
1908 wxDecToHex(col.Blue(), buf+4);
1909
1910 return new wxProperty(name, buf, "string", new wxColourListValidator);
1911 }
1912 else if (name == "title")
1913 {
1914 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
1915 if (resource)
1916 return new wxProperty(name, resource->GetTitle(), "string");
1917 else
1918 return new wxProperty(name, "Could not get title", "string");
1919 }
1920 else if (name == "caption")
1921 {
1922 return new wxProperty(name, ((panelWindow->GetWindowStyleFlag() & wxCAPTION) == wxCAPTION),
1923 "bool");
1924 }
1925 else if (name == "systemMenu")
1926 {
1927 return new wxProperty(name, ((panelWindow->GetWindowStyleFlag() & wxSYSTEM_MENU) == wxSYSTEM_MENU),
1928 "bool");
1929 }
1930 else if (name == "thickFrame")
1931 {
1932 return new wxProperty(name, ((panelWindow->GetWindowStyleFlag() & wxTHICK_FRAME) == wxTHICK_FRAME),
1933 "bool");
1934 }
1935 else if (name == "useSystemDefaults")
1936 {
1937 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
1938 return new wxProperty(name, ((resource->GetResourceStyle() & wxRESOURCE_USE_DEFAULTS) == wxRESOURCE_USE_DEFAULTS),
1939 "bool");
1940 }
1941 else if (name == "useDialogUnits")
1942 {
1943 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
1944 return new wxProperty(name, ((resource->GetResourceStyle() & wxRESOURCE_DIALOG_UNITS) == wxRESOURCE_DIALOG_UNITS),
1945 "bool");
1946 }
1947 else
1948 return wxWindowPropertyInfo::GetProperty(name);
1949 }
1950
1951 bool wxPanelPropertyInfo::SetProperty(wxString& name, wxProperty *property)
1952 {
1953 wxPanel *panelWindow = (wxPanel *)m_propertyWindow;
1954 /*
1955 wxFont *labelFont = panelWindow->GetLabelFont();
1956 wxFont *buttonFont = panelWindow->GetButtonFont();
1957
1958 if (labelFont && (name == "labelFontPoints" || name == "labelFontFamily" || name == "labelFontStyle" || name == "labelFontWeight" || name == "labelFontUnderlined" ))
1959 {
1960 wxFont *newFont = SetFontProperty(name, property, labelFont);
1961 if (newFont)
1962 panelWindow->SetLabelFont(* newFont);
1963 return TRUE;
1964 }
1965 else if (buttonFont && (name == "buttonFontPoints" || name == "buttonFontFamily" || name == "buttonFontStyle" || name == "buttonFontWeight" || name == "buttonFontUnderlined" ))
1966 {
1967 wxFont *newFont = SetFontProperty(name, property, buttonFont);
1968 if (newFont)
1969 panelWindow->SetButtonFont(* newFont);
1970 return TRUE;
1971 }
1972 */
1973
1974 if (name == "no3D")
1975 {
1976 bool userColours = property->GetValue().BoolValue();
1977
1978 if (userColours)
1979 {
1980 if ((panelWindow->GetWindowStyleFlag() & wxNO_3D) != wxNO_3D)
1981 panelWindow->SetWindowStyleFlag(panelWindow->GetWindowStyleFlag() | wxNO_3D);
1982 }
1983 else
1984 {
1985 if ((panelWindow->GetWindowStyleFlag() & wxNO_3D) == wxNO_3D)
1986 panelWindow->SetWindowStyleFlag(panelWindow->GetWindowStyleFlag() - wxNO_3D);
1987 }
1988 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
1989 resource->SetStyle(panelWindow->GetWindowStyleFlag());
1990
1991 panelWindow = (wxPanel *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(panelWindow, this);
1992 return TRUE;
1993 }
1994 else if (name == "backgroundColour")
1995 {
1996 char *hex = property->GetValue().StringValue();
1997 int r = wxHexToDec(hex);
1998 int g = wxHexToDec(hex+2);
1999 int b = wxHexToDec(hex+4);
2000
2001 wxColour col(r,g,b);
2002 panelWindow->SetBackgroundColour(col);
2003 panelWindow = (wxPanel *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(panelWindow, this);
2004 return TRUE;
2005 }
2006 else if (name == "title")
2007 {
2008 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2009 if (resource)
2010 {
2011 resource->SetTitle(property->GetValue().StringValue());
2012 return TRUE;
2013 }
2014 else
2015 return FALSE;
2016 }
2017 else if (name == "caption")
2018 {
2019 SetWindowStyle(panelWindow, wxCAPTION, property->GetValue().BoolValue());
2020
2021 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2022 resource->SetStyle(panelWindow->GetWindowStyleFlag());
2023 return TRUE;
2024 }
2025 else if (name == "thickFrame")
2026 {
2027 SetWindowStyle(panelWindow, wxTHICK_FRAME, property->GetValue().BoolValue());
2028
2029 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2030 resource->SetStyle(panelWindow->GetWindowStyleFlag());
2031 return TRUE;
2032 }
2033 else if (name == "systemMenu")
2034 {
2035 SetWindowStyle(panelWindow, wxSYSTEM_MENU, property->GetValue().BoolValue());
2036
2037 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2038 resource->SetStyle(panelWindow->GetWindowStyleFlag());
2039 return TRUE;
2040 }
2041 else if (name == "useSystemDefaults")
2042 {
2043 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2044 bool useDefaults = property->GetValue().BoolValue();
2045 long style = resource->GetResourceStyle();
2046 if (useDefaults)
2047 {
2048 if ((style & wxRESOURCE_USE_DEFAULTS) == 0)
2049 style |= wxRESOURCE_USE_DEFAULTS;
2050 }
2051 else
2052 {
2053 if ((style & wxRESOURCE_USE_DEFAULTS) != 0)
2054 style -= wxRESOURCE_USE_DEFAULTS;
2055 }
2056 resource->SetResourceStyle(style);
2057 panelWindow = (wxPanel *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(panelWindow, this);
2058 return TRUE;
2059 }
2060 else if (name == "useDialogUnits")
2061 {
2062 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
2063 bool useDialogUnits = property->GetValue().BoolValue();
2064 long style = resource->GetResourceStyle();
2065 if (useDialogUnits)
2066 {
2067 if ((style & wxRESOURCE_DIALOG_UNITS) == 0)
2068 {
2069 style |= wxRESOURCE_DIALOG_UNITS;
2070 ConvertDialogUnits(TRUE); // Convert all resources
2071 }
2072 }
2073 else
2074 {
2075 if ((style & wxRESOURCE_DIALOG_UNITS) != 0)
2076 {
2077 style -= wxRESOURCE_DIALOG_UNITS;
2078 ConvertDialogUnits(FALSE); // Convert all resources
2079 }
2080 }
2081 resource->SetResourceStyle(style);
2082 panelWindow = (wxPanel *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(panelWindow, this);
2083 // TODO: need to regenerate the width and height properties else they'll be inconsistent.
2084 return TRUE;
2085 }
2086 else
2087 return wxWindowPropertyInfo::SetProperty(name, property);
2088 }
2089
2090 void wxPanelPropertyInfo::GetPropertyNames(wxStringList& names)
2091 {
2092 wxWindowPropertyInfo::GetPropertyNames(names);
2093
2094 names.Add("title");
2095 names.Add("no3D");
2096 names.Add("backgroundColour");
2097 names.Add("caption");
2098 names.Add("systemMenu");
2099 names.Add("thickFrame");
2100 names.Add("useSystemDefaults");
2101 names.Add("useDialogUnits");
2102 }
2103
2104 bool wxPanelPropertyInfo::InstantiateResource(wxItemResource *resource)
2105 {
2106 wxPanel *panel = (wxPanel *)m_propertyWindow;
2107 if (panel->GetFont().Ok())
2108 resource->SetFont(* wxTheFontList->FindOrCreateFont(panel->GetFont().GetPointSize(),
2109 panel->GetFont().GetFamily(), panel->GetFont().GetStyle(), panel->GetFont().GetWeight(),
2110 panel->GetFont().GetUnderlined(), panel->GetFont().GetFaceName()));
2111
2112 resource->SetBackgroundColour(wxColour(panel->GetBackgroundColour()));
2113
2114 return wxWindowPropertyInfo::InstantiateResource(resource);
2115 }
2116
2117 // Convert this dialog, and its children, to or from dialog units
2118 void wxPanelPropertyInfo::ConvertDialogUnits(bool toDialogUnits)
2119 {
2120 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
2121
2122 wxPoint pt;
2123 wxSize sz;
2124 if (toDialogUnits)
2125 {
2126 sz = m_propertyWindow->ConvertPixelsToDialog(wxSize(resource->GetWidth(), resource->GetHeight()));
2127 pt = m_propertyWindow->ConvertPixelsToDialog(wxPoint(resource->GetX(), resource->GetY()));
2128 }
2129 else
2130 {
2131 sz = m_propertyWindow->ConvertDialogToPixels(wxSize(resource->GetWidth(), resource->GetHeight()));
2132 pt = m_propertyWindow->ConvertDialogToPixels(wxPoint(resource->GetX(), resource->GetY()));
2133 }
2134 resource->SetSize(pt.x, pt.y, sz.x, sz.y);
2135
2136 wxNode* node = m_propertyWindow->GetChildren().First();
2137 while (node)
2138 {
2139 wxWindow* child = (wxWindow*) node->Data();
2140 if (child->IsKindOf(CLASSINFO(wxControl)))
2141 {
2142 resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(child);
2143 if (toDialogUnits)
2144 {
2145 sz = m_propertyWindow->ConvertPixelsToDialog(wxSize(resource->GetWidth(), resource->GetHeight()));
2146 pt = m_propertyWindow->ConvertPixelsToDialog(wxPoint(resource->GetX(), resource->GetY()));
2147 }
2148 else
2149 {
2150 sz = m_propertyWindow->ConvertDialogToPixels(wxSize(resource->GetWidth(), resource->GetHeight()));
2151 pt = m_propertyWindow->ConvertDialogToPixels(wxPoint(resource->GetX(), resource->GetY()));
2152 }
2153 resource->SetSize(pt.x, pt.y, sz.x, sz.y);
2154 }
2155 node = node->Next();
2156 }
2157 }
2158
2159 #if 0
2160 /*
2161 * Dialog boxes
2162 */
2163
2164 wxProperty *wxDialogPropertyInfo::GetProperty(wxString& name)
2165 {
2166 wxDialog *dialogWindow = (wxDialog *)m_propertyWindow;
2167 if (name == "modal")
2168 {
2169 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(dialogWindow);
2170 if (!resource)
2171 return NULL;
2172
2173 bool modal = (resource->GetValue1() != 0);
2174 return new wxProperty(name, modal, "bool");
2175 }
2176 else
2177 return wxPanelPropertyInfo::GetProperty(name);
2178 }
2179
2180 bool wxDialogPropertyInfo::SetProperty(wxString& name, wxProperty *property)
2181 {
2182 wxDialog *dialogWindow = (wxDialog *)m_propertyWindow;
2183
2184 if (name == "modal")
2185 {
2186 wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(dialogWindow);
2187 if (!resource)
2188 return FALSE;
2189
2190 resource->SetValue1(property->GetValue().BoolValue());
2191 return TRUE;
2192 }
2193 else
2194 return wxPanelPropertyInfo::SetProperty(name, property);
2195 }
2196
2197 void wxDialogPropertyInfo::GetPropertyNames(wxStringList& names)
2198 {
2199 wxPanelPropertyInfo::GetPropertyNames(names);
2200 names.Add("title");
2201 names.Add("modal");
2202 }
2203
2204 bool wxDialogPropertyInfo::InstantiateResource(wxItemResource *resource)
2205 {
2206 wxDialog *dialog = (wxDialog *)m_propertyWindow;
2207 wxString str(dialog->GetTitle());
2208 resource->SetTitle(str);
2209
2210 return wxPanelPropertyInfo::InstantiateResource(resource);
2211 }
2212 #endif
2213
2214 /*
2215 * Utilities
2216 */
2217
2218 int wxStringToFontWeight(wxString& val)
2219 {
2220 if (val == "wxBOLD") return wxBOLD;
2221 else if (val == "wxLIGHT") return wxLIGHT;
2222 else return wxNORMAL;
2223 }
2224
2225 int wxStringToFontStyle(wxString& val)
2226 {
2227 if (val == "wxITALIC") return wxITALIC;
2228 else if (val == "wxSLANT") return wxSLANT;
2229 else return wxNORMAL;
2230 }
2231
2232 int wxStringToFontFamily(wxString& val)
2233 {
2234 if (val == "wxDECORATIVE") return wxDECORATIVE;
2235 else if (val == "wxROMAN") return wxROMAN;
2236 else if (val == "wxSCRIPT") return wxSCRIPT;
2237 else if (val == "wxMODERN") return wxMODERN;
2238 else if (val == "wxTELETYPE") return wxTELETYPE;
2239 else return wxSWISS;
2240 }
2241
2242 ///
2243 /// Resource symbol validator
2244 ///
2245 IMPLEMENT_DYNAMIC_CLASS(wxResourceSymbolValidator, wxPropertyListValidator)
2246
2247 wxResourceSymbolValidator::wxResourceSymbolValidator(long flags):
2248 wxPropertyListValidator(flags)
2249 {
2250 }
2251
2252 wxResourceSymbolValidator::~wxResourceSymbolValidator(void)
2253 {
2254 }
2255
2256 bool wxResourceSymbolValidator::OnCheckValue(wxProperty *WXUNUSED(property), wxPropertyListView *WXUNUSED(view), wxWindow *WXUNUSED(parentWindow))
2257 {
2258 return TRUE;
2259 }
2260
2261 // Called when TICK is pressed or focus is lost or view wants to update
2262 // the property list.
2263 // Does the transferance from the property editing area to the property itself
2264 bool wxResourceSymbolValidator::OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
2265 {
2266 if (!view->GetValueText())
2267 return FALSE;
2268 wxString value(view->GetValueText()->GetValue());
2269 property->GetValue() = value ;
2270 return TRUE;
2271 }
2272
2273 // Called when TICK is pressed or focus is lost or view wants to update
2274 // the property list.
2275 // Does the transferance from the property editing area to the property itself
2276 bool wxResourceSymbolValidator::OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
2277 {
2278 if (!view->GetValueText())
2279 return FALSE;
2280 wxString str(property->GetValue().GetStringRepresentation());
2281 view->GetValueText()->SetValue(str);
2282 return TRUE;
2283 }
2284
2285 // Called when the property is double clicked. Extra functionality can be provided,
2286 // cycling through possible values.
2287 bool wxResourceSymbolValidator::OnDoubleClick(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
2288 {
2289 if (!view->GetValueText())
2290 return FALSE;
2291 OnEdit(property, view, parentWindow);
2292 return TRUE;
2293 }
2294
2295 bool wxResourceSymbolValidator::OnPrepareControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
2296 {
2297 if (view->GetConfirmButton())
2298 view->GetConfirmButton()->Enable(TRUE);
2299 if (view->GetCancelButton())
2300 view->GetCancelButton()->Enable(TRUE);
2301 if (view->GetEditButton())
2302 view->GetEditButton()->Enable(TRUE);
2303 if (view->GetValueText())
2304 view->GetValueText()->Enable((GetFlags() & wxPROP_ALLOW_TEXT_EDITING) == wxPROP_ALLOW_TEXT_EDITING);
2305 return TRUE;
2306 }
2307
2308 void wxResourceSymbolValidator::OnEdit(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
2309 {
2310 if (!view->GetValueText())
2311 return;
2312
2313 wxResourceSymbolDialog* dialog = new wxResourceSymbolDialog(parentWindow, -1, "Edit Symbol");
2314
2315 // Split name/id pair e.g. "IDC_TEXT=123"
2316 wxString value(property->GetValue().StringValue());
2317
2318 wxString strName = value.Before('=');
2319 wxString strId = value.After('=');
2320
2321 dialog->SetSymbol(strName);
2322 dialog->SetId(atoi(strId));
2323
2324 dialog->Init();
2325
2326 if (dialog->ShowModal() == wxID_OK)
2327 {
2328 wxString symbolName(dialog->GetSymbol());
2329 long id = dialog->GetId();
2330 dialog->Destroy();
2331
2332 wxString str;
2333 str.Printf("%d", id);
2334 property->GetValue() = symbolName + wxString("=") + str;
2335
2336 view->DisplayProperty(property);
2337 view->UpdatePropertyDisplayInList(property);
2338 view->OnPropertyChanged(property);
2339 }
2340 }
2341
2342 BEGIN_EVENT_TABLE(wxResourceSymbolDialog, wxDialog)
2343 EVT_BUTTON(wxID_OK, wxResourceSymbolDialog::OnOK)
2344 EVT_COMBOBOX(ID_SYMBOLNAME_COMBOBOX, wxResourceSymbolDialog::OnComboBoxSelect)
2345 EVT_TEXT(ID_SYMBOLNAME_COMBOBOX, wxResourceSymbolDialog::OnSymbolNameUpdate)
2346 END_EVENT_TABLE()
2347
2348 wxResourceSymbolDialog::wxResourceSymbolDialog(wxWindow* parent, const wxWindowID id, const wxString& title, const wxPoint& pos,
2349 const wxSize& size, long style):
2350 wxDialog(parent, id, title, pos, size, style)
2351 {
2352 int x = 5;
2353 int y = 5;
2354
2355 (void) new wxStaticText(this, -1, "Name: ", wxPoint(x, y));
2356
2357 x += 80;
2358
2359 m_nameCtrl = new wxComboBox(this, ID_SYMBOLNAME_COMBOBOX, "",
2360 wxPoint(x, y), wxSize(200, -1), 0, NULL, wxCB_DROPDOWN|wxCB_SORT);
2361
2362 y += 30;
2363 x = 5;
2364
2365 (void) new wxStaticText(this, -1, "Id: ", wxPoint(x, y));
2366
2367 x += 80;
2368
2369 m_idCtrl = new wxTextCtrl(this, ID_SYMBOLID_TEXTCTRL, "",
2370 wxPoint(x, y), wxSize(200, -1));
2371
2372 y += 30;
2373 x = 5;
2374 (void) new wxButton(this, wxID_OK, "OK", wxPoint(x, y), wxSize(80, -1));
2375
2376 x += 100;
2377 (void) new wxButton(this, wxID_CANCEL, "Cancel", wxPoint(x, y), wxSize(80, -1));
2378
2379 Fit();
2380 Centre();
2381 }
2382
2383 void wxResourceSymbolDialog::Init()
2384 {
2385 wxString defaultId;
2386 defaultId.Printf("%ld", m_symbolId);
2387
2388 m_nameCtrl->SetValue(m_symbolName);
2389 m_idCtrl->SetValue(defaultId);
2390
2391 wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().FillComboBox(m_nameCtrl);
2392 }
2393
2394 void wxResourceSymbolDialog::OnOK(wxCommandEvent& event)
2395 {
2396 if (CheckValues())
2397 {
2398 wxDialog::OnOK(event);
2399 }
2400 }
2401
2402 bool wxResourceSymbolDialog::CheckValues()
2403 {
2404 wxString nameStr(m_nameCtrl->GetValue());
2405 wxString idStr(m_idCtrl->GetValue());
2406 int id = atoi(idStr);
2407
2408 if (id <= 0 )
2409 {
2410 wxMessageBox("Identifier cannot be missing or zero", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
2411 return FALSE;
2412 }
2413 if (nameStr == "")
2414 {
2415 wxMessageBox("Please enter a symbol name", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
2416 return FALSE;
2417 }
2418 if (nameStr.Contains(" "))
2419 {
2420 wxMessageBox("Symbol name cannot contain spaces.", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
2421 return FALSE;
2422 }
2423 if (nameStr.Contains("="))
2424 {
2425 wxMessageBox("Symbol name cannot contain =.", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
2426 return FALSE;
2427 }
2428 if (nameStr.IsNumber())
2429 {
2430 wxMessageBox("Symbol name cannot be a number.", "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
2431 return FALSE;
2432 }
2433 // TODO: other checks on the name syntax.
2434
2435 if (!wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(nameStr))
2436 {
2437 // If we change the id for an existing symbol, we need to:
2438 // 1) Check if there are any other resources currently using the original id.
2439 // If so, will need to change their id to the new id, in SetProperty.
2440 // 2) Remove the old symbol, add the new symbol.
2441 // In this check, we don't have to do this, but we need to do it in SetProperty.
2442
2443 if (nameStr == GetSymbol() && id != GetId())
2444 {
2445 // It's OK to change the id. But we'll need to change all matching ids in all resources,
2446 // in SetProperty.
2447 }
2448
2449 // If we change the name but not the id... we'll just need to remove and
2450 // re-add the symbol/id pair, in SetProperty.
2451 if (nameStr != GetSymbol() && id == GetId())
2452 {
2453 }
2454
2455 // What if we're changing both the name and the id?
2456 // - if there's no symbol of that name, just remove the old, add the new (in SetProperty)
2457 // - if there is a symbol of that name, if id matches, do nothing. If not, veto.
2458
2459 if (nameStr != GetSymbol() && id != GetId())
2460 {
2461 if (!wxResourceManager::GetCurrentResourceManager()->IsIdentifierOK(nameStr, id))
2462 {
2463 wxMessageBox("This integer id is already being used under a different name.\nPlease choose another.",
2464 "Dialog Editor", wxOK|wxICON_EXCLAMATION, this);
2465 return FALSE;
2466 }
2467 }
2468
2469 }
2470
2471 SetSymbol(nameStr);
2472 SetId(id);
2473
2474 return TRUE;
2475 }
2476
2477 void wxResourceSymbolDialog::OnComboBoxSelect(wxCommandEvent& WXUNUSED(event))
2478 {
2479 wxString str(m_nameCtrl->GetStringSelection());
2480 if (wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(str))
2481 {
2482 int id = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetIdForSymbol(str);
2483 wxString str2;
2484 str2.Printf("%d", id);
2485 m_idCtrl->SetValue(str2);
2486 m_idCtrl->Enable(FALSE);
2487 }
2488 else
2489 {
2490 if (wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().SymbolExists(str))
2491 {
2492 int id = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetIdForSymbol(str);
2493 wxString str2;
2494 str2.Printf("%d", id);
2495 m_idCtrl->SetValue(str2);
2496 }
2497 m_idCtrl->Enable(TRUE);
2498 }
2499 }
2500
2501 void wxResourceSymbolDialog::OnSymbolNameUpdate(wxCommandEvent& WXUNUSED(event))
2502 {
2503 wxString str(m_nameCtrl->GetValue());
2504 if (wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().IsStandardSymbol(str))
2505 {
2506 int id = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetIdForSymbol(str);
2507 wxString str2;
2508 str2.Printf("%d", id);
2509 m_idCtrl->SetValue(str2);
2510 m_idCtrl->Enable(FALSE);
2511 }
2512 else
2513 {
2514 if (wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().SymbolExists(str))
2515 {
2516 int id = wxResourceManager::GetCurrentResourceManager()->GetSymbolTable().GetIdForSymbol(str);
2517 wxString str2;
2518 str2.Printf("%d", id);
2519 m_idCtrl->SetValue(str2);
2520 }
2521 m_idCtrl->Enable(TRUE);
2522 }
2523 }
2524
wxWidgets (Impactor)