src/generic/proplist.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        proplist.cpp
   3 // Purpose:     Property list classes
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "proplist.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx/wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #if wxUSE_PROPSHEET
  32
  33 #ifndef WX_PRECOMP
  34     #include "wx/window.h"
  35     #include "wx/font.h"
  36     #include "wx/button.h"
  37     #include "wx/bmpbuttn.h"
  38     #include "wx/textctrl.h"
  39     #include "wx/listbox.h"
  40     #include "wx/settings.h"
  41     #include "wx/msgdlg.h"
  42     #include "wx/filedlg.h"
  43 #endif
  44
  45 #include "wx/sizer.h"
  46 #include "wx/module.h"
  47 #include "wx/intl.h"
  48
  49 #include "wx/colordlg.h"
  50 #include "wx/proplist.h"
  51
  52 #include <ctype.h>
  53 #include <stdlib.h>
  54 #include <math.h>
  55 #include <string.h>
  56
  57 // ----------------------------------------------------------------------------
  58 // XPMs
  59 // ----------------------------------------------------------------------------
  60
  61 #ifndef __WXMSW__
  62     #include "wx/generic/cross.xpm"
  63     #include "wx/generic/tick.xpm"
  64 #endif
  65
  66 // ----------------------------------------------------------------------------
  67 // accessor functions for the bitmaps (may return NULL, check for it!)
  68 // ----------------------------------------------------------------------------
  69
  70 static wxBitmap *GetTickBitmap();
  71 static wxBitmap *GetCrossBitmap();
  72
  73 // ----------------------------------------------------------------------------
  74 // Property text edit control
  75 // ----------------------------------------------------------------------------
  76
  77 IMPLEMENT_DYNAMIC_CLASS(wxPropertyTextEdit, wxTextCtrl)
  78
  79 wxPropertyTextEdit::wxPropertyTextEdit(wxPropertyListView *v, wxWindow *parent,
  80     const wxWindowID id, const wxString& value,
  81     const wxPoint& pos, const wxSize& size,
  82     long style, const wxString& name):
  83  wxTextCtrl(parent, id, value, pos, size, style, wxDefaultValidator, name)
  84 {
  85   m_view = v;
  86 }
  87
  88 void wxPropertyTextEdit::OnSetFocus()
  89 {
  90 }
  91
  92 void wxPropertyTextEdit::OnKillFocus()
  93 {
  94 }
  95
  96 // ----------------------------------------------------------------------------
  97 // Property list view
  98 // ----------------------------------------------------------------------------
  99
 100 bool wxPropertyListView::sm_dialogCancelled = FALSE;
 101
 102 IMPLEMENT_DYNAMIC_CLASS(wxPropertyListView, wxPropertyView)
 103
 104 BEGIN_EVENT_TABLE(wxPropertyListView, wxPropertyView)
 105     EVT_BUTTON(wxID_OK,                 wxPropertyListView::OnOk)
 106     EVT_BUTTON(wxID_CANCEL,             wxPropertyListView::OnCancel)
 107     EVT_BUTTON(wxID_HELP,               wxPropertyListView::OnHelp)
 108     EVT_BUTTON(wxID_PROP_CROSS,         wxPropertyListView::OnCross)
 109     EVT_BUTTON(wxID_PROP_CHECK,         wxPropertyListView::OnCheck)
 110     EVT_BUTTON(wxID_PROP_EDIT,          wxPropertyListView::OnEdit)
 111     EVT_TEXT_ENTER(wxID_PROP_TEXT,      wxPropertyListView::OnText)
 112     EVT_LISTBOX(wxID_PROP_SELECT,       wxPropertyListView::OnPropertySelect)
 113     EVT_COMMAND(wxID_PROP_SELECT, wxEVT_COMMAND_LISTBOX_DOUBLECLICKED,
 114                                         wxPropertyListView::OnPropertyDoubleClick)
 115     EVT_LISTBOX(wxID_PROP_VALUE_SELECT, wxPropertyListView::OnValueListSelect)
 116 END_EVENT_TABLE()
 117
 118 wxPropertyListView::wxPropertyListView(wxPanel *propPanel, long flags):wxPropertyView(flags)
 119 {
 120   m_propertyScrollingList = NULL;
 121   m_valueList = NULL;
 122   m_valueText = NULL;
 123   m_editButton = NULL;
 124   m_confirmButton = NULL;
 125   m_cancelButton = NULL;
 126   m_propertyWindow = propPanel;
 127   m_managedWindow = NULL;
 128
 129   m_windowCloseButton = NULL;
 130   m_windowCancelButton = NULL;
 131   m_windowHelpButton = NULL;
 132
 133   m_detailedEditing = FALSE;
 134 }
 135
 136 wxPropertyListView::~wxPropertyListView()
 137 {
 138 }
 139
 140 void wxPropertyListView::ShowView(wxPropertySheet *ps, wxPanel *panel)
 141 {
 142   m_propertySheet = ps;
 143
 144   AssociatePanel(panel);
 145   CreateControls();
 146
 147   UpdatePropertyList();
 148   panel->Layout();
 149 }
 150
 151 // Update this view of the viewed object, called e.g. by
 152 // the object itself.
 153 bool wxPropertyListView::OnUpdateView()
 154 {
 155   return TRUE;
 156 }
 157
 158 bool wxPropertyListView::UpdatePropertyList(bool clearEditArea)
 159 {
 160   if (!m_propertyScrollingList || !m_propertySheet)
 161     return FALSE;
 162
 163   m_propertyScrollingList->Clear();
 164   if (clearEditArea)
 165   {
 166     m_valueList->Clear();
 167     m_valueText->SetValue("");
 168   }
 169   wxNode *node = m_propertySheet->GetProperties().First();
 170
 171   // Should sort them... later...
 172   while (node)
 173   {
 174     wxProperty *property = (wxProperty *)node->Data();
 175     wxString stringValueRepr(property->GetValue().GetStringRepresentation());
 176     wxString paddedString(MakeNameValueString(property->GetName(), stringValueRepr));
 177     m_propertyScrollingList->Append(paddedString.GetData(), (void *)property);
 178     node = node->Next();
 179   }
 180   return TRUE;
 181 }
 182
 183 bool wxPropertyListView::UpdatePropertyDisplayInList(wxProperty *property)
 184 {
 185   if (!m_propertyScrollingList || !m_propertySheet)
 186     return FALSE;
 187
 188 #ifdef __WXMSW__
 189   int currentlySelected = m_propertyScrollingList->GetSelection();
 190 #endif
 191 // #ifdef __WXMSW__
 192   wxString stringValueRepr(property->GetValue().GetStringRepresentation());
 193   wxString paddedString(MakeNameValueString(property->GetName(), stringValueRepr));
 194   int sel = FindListIndexForProperty(property);
 195
 196   if (sel > -1)
 197   {
 198     // Don't update the listbox unnecessarily because it can cause
 199     // ugly flashing.
 200
 201     if (paddedString != m_propertyScrollingList->GetString(sel))
 202       m_propertyScrollingList->SetString(sel, paddedString.GetData());
 203   }
 204 //#else
 205 //  UpdatePropertyList(FALSE);
 206 //#endif
 207
 208   // TODO: why is this necessary?
 209 #ifdef __WXMSW__
 210   if (currentlySelected > -1)
 211     m_propertyScrollingList->SetSelection(currentlySelected);
 212 #endif
 213
 214   return TRUE;
 215 }
 216
 217 // Find the wxListBox index corresponding to this property
 218 int wxPropertyListView::FindListIndexForProperty(wxProperty *property)
 219 {
 220   int n = m_propertyScrollingList->GetCount();
 221   for (int i = 0; i < n; i++)
 222   {
 223     if (property == (wxProperty *)m_propertyScrollingList->wxListBox::GetClientData(i))
 224       return i;
 225   }
 226   return -1;
 227 }
 228
 229 wxString wxPropertyListView::MakeNameValueString(wxString name, wxString value)
 230 {
 231   wxString theString(name);
 232
 233   int nameWidth = 25;
 234   int padWith = nameWidth - theString.Length();
 235   if (padWith < 0)
 236     padWith = 0;
 237
 238   if (GetFlags() & wxPROP_SHOWVALUES)
 239   {
 240     // Want to pad with spaces
 241     theString.Append(' ', padWith);
 242     theString += value;
 243   }
 244
 245   return theString;
 246 }
 247
 248 // Select and show string representation in validator the given
 249 // property. NULL resets to show no property.
 250 bool wxPropertyListView::ShowProperty(wxProperty *property, bool select)
 251 {
 252   if (m_currentProperty)
 253   {
 254     EndShowingProperty(m_currentProperty);
 255     m_currentProperty = NULL;
 256   }
 257
 258   m_valueList->Clear();
 259   m_valueText->SetValue("");
 260
 261   if (property)
 262   {
 263     m_currentProperty = property;
 264     BeginShowingProperty(property);
 265   }
 266   if (select)
 267   {
 268     int sel = FindListIndexForProperty(property);
 269     if (sel > -1)
 270       m_propertyScrollingList->SetSelection(sel);
 271   }
 272   return TRUE;
 273 }
 274
 275 // Find appropriate validator and load property into value controls
 276 bool wxPropertyListView::BeginShowingProperty(wxProperty *property)
 277 {
 278   m_currentValidator = FindPropertyValidator(property);
 279   if (!m_currentValidator)
 280     return FALSE;
 281
 282   if (!m_currentValidator->IsKindOf(CLASSINFO(wxPropertyListValidator)))
 283     return FALSE;
 284
 285   wxPropertyListValidator *listValidator = (wxPropertyListValidator *)m_currentValidator;
 286
 287   listValidator->OnPrepareControls(property, this, m_propertyWindow);
 288   DisplayProperty(property);
 289   return TRUE;
 290 }
 291
 292 // Find appropriate validator and unload property from value controls
 293 bool wxPropertyListView::EndShowingProperty(wxProperty *property)
 294 {
 295   if (!m_currentValidator)
 296     return FALSE;
 297
 298   RetrieveProperty(property);
 299
 300   if (!m_currentValidator->IsKindOf(CLASSINFO(wxPropertyListValidator)))
 301     return FALSE;
 302
 303   wxPropertyListValidator *listValidator = (wxPropertyListValidator *)m_currentValidator;
 304
 305   listValidator->OnClearControls(property, this, m_propertyWindow);
 306   if (m_detailedEditing)
 307   {
 308     listValidator->OnClearDetailControls(property, this, m_propertyWindow);
 309     m_detailedEditing = FALSE;
 310   }
 311   return TRUE;
 312 }
 313
 314 void wxPropertyListView::BeginDetailedEditing()
 315 {
 316   if (!m_currentValidator)
 317     return;
 318   if (!m_currentProperty)
 319     return;
 320   if (m_detailedEditing)
 321     return;
 322   if (!m_currentValidator->IsKindOf(CLASSINFO(wxPropertyListValidator)))
 323     return;
 324   if (!m_currentProperty->IsEnabled())
 325     return;
 326
 327   wxPropertyListValidator *listValidator = (wxPropertyListValidator *)m_currentValidator;
 328
 329   if (listValidator->OnPrepareDetailControls(m_currentProperty, this, m_propertyWindow))
 330     m_detailedEditing = TRUE;
 331 }
 332
 333 void wxPropertyListView::EndDetailedEditing()
 334 {
 335   if (!m_currentValidator)
 336     return;
 337   if (!m_currentProperty)
 338     return;
 339
 340   RetrieveProperty(m_currentProperty);
 341
 342   if (!m_currentValidator->IsKindOf(CLASSINFO(wxPropertyListValidator)))
 343     return;
 344
 345   wxPropertyListValidator *listValidator = (wxPropertyListValidator *)m_currentValidator;
 346
 347   if (m_detailedEditing)
 348   {
 349     listValidator->OnClearDetailControls(m_currentProperty, this, m_propertyWindow);
 350     m_detailedEditing = FALSE;
 351   }
 352 }
 353
 354 bool wxPropertyListView::DisplayProperty(wxProperty *property)
 355 {
 356   if (!m_currentValidator)
 357     return FALSE;
 358
 359   if (((m_currentValidator->GetFlags() & wxPROP_ALLOW_TEXT_EDITING) == 0) || !property->IsEnabled())
 360     m_valueText->SetEditable(FALSE);
 361   else
 362     m_valueText->SetEditable(TRUE);
 363
 364   if (!m_currentValidator->IsKindOf(CLASSINFO(wxPropertyListValidator)))
 365     return FALSE;
 366
 367   wxPropertyListValidator *listValidator = (wxPropertyListValidator *)m_currentValidator;
 368
 369   listValidator->OnDisplayValue(property, this, m_propertyWindow);
 370   return TRUE;
 371 }
 372
 373 bool wxPropertyListView::RetrieveProperty(wxProperty *property)
 374 {
 375   if (!m_currentValidator)
 376     return FALSE;
 377   if (!property->IsEnabled())
 378     return FALSE;
 379
 380   if (!m_currentValidator->IsKindOf(CLASSINFO(wxPropertyListValidator)))
 381     return FALSE;
 382
 383   wxPropertyListValidator *listValidator = (wxPropertyListValidator *)m_currentValidator;
 384
 385   if (listValidator->OnCheckValue(property, this, m_propertyWindow))
 386   {
 387     if (listValidator->OnRetrieveValue(property, this, m_propertyWindow))
 388     {
 389       UpdatePropertyDisplayInList(property);
 390       OnPropertyChanged(property);
 391     }
 392   }
 393   else
 394   {
 395     // Revert to old value
 396     listValidator->OnDisplayValue(property, this, m_propertyWindow);
 397   }
 398   return TRUE;
 399 }
 400
 401
 402 bool wxPropertyListView::EditProperty(wxProperty *WXUNUSED(property))
 403 {
 404   return TRUE;
 405 }
 406
 407 // Called by the listbox callback
 408 void wxPropertyListView::OnPropertySelect(wxCommandEvent& WXUNUSED(event))
 409 {
 410   int sel = m_propertyScrollingList->GetSelection();
 411   if (sel > -1)
 412   {
 413     wxProperty *newSel = (wxProperty *)m_propertyScrollingList->wxListBox::GetClientData(sel);
 414     if (newSel && newSel != m_currentProperty)
 415     {
 416       ShowProperty(newSel, FALSE);
 417     }
 418   }
 419 }
 420
 421 bool wxPropertyListView::CreateControls()
 422 {
 423     wxPanel *panel = (wxPanel *)m_propertyWindow;
 424
 425     wxSize largeButtonSize( 70, 25 );
 426     wxSize smallButtonSize( 23, 23 );
 427
 428     if (m_valueText)
 429         return TRUE;
 430
 431     if (!panel)
 432         return FALSE;
 433
 434     wxSystemSettings settings;
 435     wxFont guiFont = settings.GetSystemFont(wxSYS_DEFAULT_GUI_FONT);
 436
 437 #ifdef __WXMSW__
 438     wxFont *boringFont = wxTheFontList->FindOrCreateFont(guiFont.GetPointSize(), wxMODERN, wxNORMAL, wxNORMAL, FALSE, "Courier New");
 439 #else
 440     wxFont *boringFont = wxTheFontList->FindOrCreateFont(guiFont.GetPointSize(), wxTELETYPE, wxNORMAL, wxNORMAL);
 441 #endif
 442
 443     // May need to be changed in future to eliminate clashes with app.
 444     // WHAT WAS THIS FOR?
 445 //  panel->SetClientData((char *)this);
 446
 447     wxBoxSizer *mainsizer = new wxBoxSizer( wxVERTICAL );
 448
 449     // top row with optional buttons and input line
 450
 451     wxBoxSizer *topsizer = new wxBoxSizer( wxHORIZONTAL );
 452     int buttonborder = 3;
 453
 454     if (m_buttonFlags & wxPROP_BUTTON_CHECK_CROSS)
 455     {
 456         wxBitmap *tickBitmap = GetTickBitmap();
 457         wxBitmap *crossBitmap = GetCrossBitmap();
 458
 459         if ( tickBitmap && crossBitmap )
 460         {
 461             m_confirmButton = new wxBitmapButton(panel, wxID_PROP_CHECK, *tickBitmap, wxPoint(-1, -1), smallButtonSize );
 462             m_cancelButton = new wxBitmapButton(panel, wxID_PROP_CROSS, *crossBitmap, wxPoint(-1, -1), smallButtonSize );
 463         }
 464         else
 465         {
 466             m_confirmButton = new wxButton(panel, wxID_PROP_CHECK, ":-)", wxPoint(-1, -1), smallButtonSize );
 467             m_cancelButton = new wxButton(panel, wxID_PROP_CROSS, "X", wxPoint(-1, -1), smallButtonSize );
 468         }
 469
 470         topsizer->Add( m_confirmButton, 0, wxLEFT|wxTOP|wxBOTTOM | wxEXPAND, buttonborder );
 471         topsizer->Add( m_cancelButton, 0, wxLEFT|wxTOP|wxBOTTOM | wxEXPAND, buttonborder );
 472     }
 473
 474     m_valueText = new wxPropertyTextEdit(this, panel, wxID_PROP_TEXT, "",
 475        wxPoint(-1, -1), wxSize(-1, smallButtonSize.y), wxPROCESS_ENTER);
 476     m_valueText->Enable(FALSE);
 477     topsizer->Add( m_valueText, 1, wxALL | wxEXPAND, buttonborder );
 478
 479     if (m_buttonFlags & wxPROP_PULLDOWN)
 480     {
 481         m_editButton = new wxButton(panel, wxID_PROP_EDIT, "...",  wxPoint(-1, -1), smallButtonSize);
 482         m_editButton->Enable(FALSE);
 483         topsizer->Add( m_editButton, 0, wxRIGHT|wxTOP|wxBOTTOM | wxEXPAND, buttonborder );
 484     }
 485
 486     mainsizer->Add( topsizer, 0, wxEXPAND );
 487
 488     // middle section with two list boxes
 489
 490     m_middleSizer = new wxBoxSizer( wxVERTICAL );
 491
 492     m_valueList = new wxListBox(panel, wxID_PROP_VALUE_SELECT, wxPoint(-1, -1), wxSize(-1, 60));
 493     m_valueList->Show(FALSE);
 494
 495     m_propertyScrollingList = new wxListBox(panel, wxID_PROP_SELECT, wxPoint(-1, -1), wxSize(100, 100));
 496     m_propertyScrollingList->SetFont(* boringFont);
 497     m_middleSizer->Add( m_propertyScrollingList, 1, wxALL|wxEXPAND, buttonborder );
 498
 499     mainsizer->Add( m_middleSizer, 1, wxEXPAND );
 500
 501     // bottom row with buttons
 502
 503     if ((m_buttonFlags & wxPROP_BUTTON_OK) ||
 504         (m_buttonFlags & wxPROP_BUTTON_CLOSE) ||
 505         (m_buttonFlags & wxPROP_BUTTON_CANCEL) ||
 506         (m_buttonFlags & wxPROP_BUTTON_HELP))
 507     {
 508         wxBoxSizer *bottomsizer = new wxBoxSizer( wxHORIZONTAL );
 509         buttonborder = 5;
 510
 511         if (m_buttonFlags & wxPROP_BUTTON_OK)
 512         {
 513             m_windowCloseButton = new wxButton(panel, wxID_OK, _("OK"), wxPoint(-1, -1), largeButtonSize );
 514             m_windowCloseButton->SetDefault();
 515             m_windowCloseButton->SetFocus();
 516             bottomsizer->Add( m_windowCloseButton, 0, wxALL, buttonborder );
 517         }
 518         else if (m_buttonFlags & wxPROP_BUTTON_CLOSE)
 519         {
 520             m_windowCloseButton = new wxButton(panel, wxID_OK, _("Close"), wxPoint(-1, -1), largeButtonSize );
 521             bottomsizer->Add( m_windowCloseButton, 0, wxALL, buttonborder );
 522         }
 523         if (m_buttonFlags & wxPROP_BUTTON_CANCEL)
 524         {
 525             m_windowCancelButton = new wxButton(panel, wxID_CANCEL, _("Cancel"), wxPoint(-1, -1), largeButtonSize );
 526             bottomsizer->Add( m_windowCancelButton, 0, wxALL, buttonborder );
 527         }
 528         if (m_buttonFlags & wxPROP_BUTTON_HELP)
 529         {
 530             m_windowHelpButton = new wxButton(panel, wxID_HELP, _("Help"), wxPoint(-1, -1), largeButtonSize );
 531             bottomsizer->Add( m_windowHelpButton, 0, wxALL, buttonborder );
 532         }
 533
 534         mainsizer->Add( bottomsizer, 0, wxALIGN_RIGHT | wxEXPAND );
 535     }
 536
 537     panel->SetSizer( mainsizer );
 538
 539     return TRUE;
 540 }
 541
 542 void wxPropertyListView::ShowTextControl(bool show)
 543 {
 544   if (m_valueText)
 545     m_valueText->Show(show);
 546 }
 547
 548 void wxPropertyListView::ShowListBoxControl(bool show)
 549 {
 550     if (!m_valueList) return;
 551
 552     m_valueList->Show(show);
 553
 554     if (m_buttonFlags & wxPROP_DYNAMIC_VALUE_FIELD)
 555     {
 556         if (show)
 557             m_middleSizer->Prepend( m_valueList, 0, wxTOP|wxLEFT|wxRIGHT | wxEXPAND, 3 );
 558         else
 559             m_middleSizer->Remove( 0 );
 560
 561         m_propertyWindow->Layout();
 562     }
 563 }
 564
 565 void wxPropertyListView::EnableCheck(bool show)
 566 {
 567   if (m_confirmButton)
 568     m_confirmButton->Enable(show);
 569 }
 570
 571 void wxPropertyListView::EnableCross(bool show)
 572 {
 573   if (m_cancelButton)
 574     m_cancelButton->Enable(show);
 575 }
 576
 577 bool wxPropertyListView::OnClose()
 578 {
 579   // Retrieve the value if any
 580   wxCommandEvent event;
 581   OnCheck(event);
 582
 583   delete this;
 584   return TRUE;
 585 }
 586
 587 void wxPropertyListView::OnValueListSelect(wxCommandEvent& WXUNUSED(event))
 588 {
 589   if (m_currentProperty && m_currentValidator)
 590   {
 591     if (!m_currentValidator->IsKindOf(CLASSINFO(wxPropertyListValidator)))
 592       return;
 593
 594     wxPropertyListValidator *listValidator = (wxPropertyListValidator *)m_currentValidator;
 595
 596     listValidator->OnValueListSelect(m_currentProperty, this, m_propertyWindow);
 597   }
 598 }
 599
 600 void wxPropertyListView::OnOk(wxCommandEvent& event)
 601 {
 602   // Retrieve the value if any
 603   OnCheck(event);
 604
 605   m_managedWindow->Close(TRUE);
 606 }
 607
 608 void wxPropertyListView::OnCancel(wxCommandEvent& WXUNUSED(event))
 609 {
 610 //  SetReturnCode(wxID_CANCEL);
 611   m_managedWindow->Close(TRUE);
 612   sm_dialogCancelled = TRUE;
 613 }
 614
 615 void wxPropertyListView::OnHelp(wxCommandEvent& WXUNUSED(event))
 616 {
 617 }
 618
 619 void wxPropertyListView::OnCheck(wxCommandEvent& WXUNUSED(event))
 620 {
 621   if (m_currentProperty)
 622   {
 623     RetrieveProperty(m_currentProperty);
 624   }
 625 }
 626
 627 void wxPropertyListView::OnCross(wxCommandEvent& WXUNUSED(event))
 628 {
 629   if (m_currentProperty && m_currentValidator)
 630   {
 631     if (!m_currentValidator->IsKindOf(CLASSINFO(wxPropertyListValidator)))
 632       return;
 633
 634     wxPropertyListValidator *listValidator = (wxPropertyListValidator *)m_currentValidator;
 635
 636     // Revert to old value
 637     listValidator->OnDisplayValue(m_currentProperty, this, m_propertyWindow);
 638   }
 639 }
 640
 641 void wxPropertyListView::OnPropertyDoubleClick(wxCommandEvent& WXUNUSED(event))
 642 {
 643   if (m_currentProperty && m_currentValidator)
 644   {
 645     if (!m_currentValidator->IsKindOf(CLASSINFO(wxPropertyListValidator)))
 646       return;
 647
 648     wxPropertyListValidator *listValidator = (wxPropertyListValidator *)m_currentValidator;
 649
 650     // Revert to old value
 651     listValidator->OnDoubleClick(m_currentProperty, this, m_propertyWindow);
 652   }
 653 }
 654
 655 void wxPropertyListView::OnEdit(wxCommandEvent& WXUNUSED(event))
 656 {
 657   if (m_currentProperty && m_currentValidator)
 658   {
 659     if (!m_currentValidator->IsKindOf(CLASSINFO(wxPropertyListValidator)))
 660       return;
 661
 662     wxPropertyListValidator *listValidator = (wxPropertyListValidator *)m_currentValidator;
 663
 664     listValidator->OnEdit(m_currentProperty, this, m_propertyWindow);
 665   }
 666 }
 667
 668 void wxPropertyListView::OnText(wxCommandEvent& event)
 669 {
 670   if (event.GetEventType() == wxEVT_COMMAND_TEXT_ENTER)
 671   {
 672     OnCheck(event);
 673   }
 674 }
 675
 676 // ----------------------------------------------------------------------------
 677 // Property dialog box
 678 // ----------------------------------------------------------------------------
 679
 680 IMPLEMENT_DYNAMIC_CLASS(wxPropertyListDialog, wxDialog)
 681
 682 BEGIN_EVENT_TABLE(wxPropertyListDialog, wxDialog)
 683     EVT_BUTTON(wxID_CANCEL,                wxPropertyListDialog::OnCancel)
 684     EVT_CLOSE(wxPropertyListDialog::OnCloseWindow)
 685 END_EVENT_TABLE()
 686
 687 wxPropertyListDialog::wxPropertyListDialog(wxPropertyListView *v, wxWindow *parent,
 688     const wxString& title, const wxPoint& pos,
 689     const wxSize& size, long style, const wxString& name):
 690      wxDialog(parent, -1, title, pos, size, style, name)
 691 {
 692   m_view = v;
 693   m_view->AssociatePanel( ((wxPanel*)this) );
 694   m_view->SetManagedWindow(this);
 695   SetAutoLayout(TRUE);
 696 }
 697
 698 void wxPropertyListDialog::OnCloseWindow(wxCloseEvent& event)
 699 {
 700   if (m_view)
 701   {
 702     SetReturnCode(wxID_CANCEL);
 703     m_view->OnClose();
 704     m_view = NULL;
 705     this->Destroy();
 706   }
 707   else
 708   {
 709     event.Veto();
 710   }
 711 }
 712
 713 void wxPropertyListDialog::OnCancel(wxCommandEvent& WXUNUSED(event))
 714 {
 715     SetReturnCode(wxID_CANCEL);
 716     this->Close();
 717 }
 718
 719 void wxPropertyListDialog::OnDefaultAction(wxControl *WXUNUSED(item))
 720 {
 721 /*
 722   if (item == m_view->GetPropertyScrollingList())
 723     view->OnDoubleClick();
 724 */
 725 }
 726
 727 // Extend event processing to search the view's event table
 728 bool wxPropertyListDialog::ProcessEvent(wxEvent& event)
 729 {
 730     if ( !m_view || ! m_view->ProcessEvent(event) )
 731         return wxEvtHandler::ProcessEvent(event);
 732     else
 733         return TRUE;
 734 }
 735
 736 // ----------------------------------------------------------------------------
 737 // Property panel
 738 // ----------------------------------------------------------------------------
 739
 740 IMPLEMENT_DYNAMIC_CLASS(wxPropertyListPanel, wxPanel)
 741
 742 BEGIN_EVENT_TABLE(wxPropertyListPanel, wxPanel)
 743     EVT_SIZE(wxPropertyListPanel::OnSize)
 744 END_EVENT_TABLE()
 745
 746 wxPropertyListPanel::~wxPropertyListPanel()
 747 {
 748 }
 749
 750 void wxPropertyListPanel::OnDefaultAction(wxControl *WXUNUSED(item))
 751 {
 752 /*
 753   if (item == view->GetPropertyScrollingList())
 754     view->OnDoubleClick();
 755 */
 756 }
 757
 758 // Extend event processing to search the view's event table
 759 bool wxPropertyListPanel::ProcessEvent(wxEvent& event)
 760 {
 761     if ( !m_view || ! m_view->ProcessEvent(event) )
 762         return wxEvtHandler::ProcessEvent(event);
 763     else
 764         return TRUE;
 765 }
 766
 767 void wxPropertyListPanel::OnSize(wxSizeEvent& WXUNUSED(event))
 768 {
 769     Layout();
 770 }
 771
 772 // ----------------------------------------------------------------------------
 773 // Property frame
 774 // ----------------------------------------------------------------------------
 775
 776 IMPLEMENT_DYNAMIC_CLASS(wxPropertyListFrame, wxFrame)
 777
 778 BEGIN_EVENT_TABLE(wxPropertyListFrame, wxFrame)
 779     EVT_CLOSE(wxPropertyListFrame::OnCloseWindow)
 780 END_EVENT_TABLE()
 781
 782 void wxPropertyListFrame::OnCloseWindow(wxCloseEvent& event)
 783 {
 784   if (m_view)
 785   {
 786     if (m_propertyPanel)
 787         m_propertyPanel->SetView(NULL);
 788     m_view->OnClose();
 789     m_view = NULL;
 790     this->Destroy();
 791   }
 792   else
 793   {
 794     event.Veto();
 795   }
 796 }
 797
 798 wxPropertyListPanel *wxPropertyListFrame::OnCreatePanel(wxFrame *parent, wxPropertyListView *v)
 799 {
 800   return new wxPropertyListPanel(v, parent);
 801 }
 802
 803 bool wxPropertyListFrame::Initialize()
 804 {
 805   m_propertyPanel = OnCreatePanel(this, m_view);
 806   if (m_propertyPanel)
 807   {
 808     m_view->AssociatePanel(m_propertyPanel);
 809     m_view->SetManagedWindow(this);
 810     m_propertyPanel->SetAutoLayout(TRUE);
 811     return TRUE;
 812   }
 813   else
 814     return FALSE;
 815 }
 816
 817 // ----------------------------------------------------------------------------
 818 // Property list specific validator
 819 // ----------------------------------------------------------------------------
 820
 821 IMPLEMENT_ABSTRACT_CLASS(wxPropertyListValidator, wxPropertyValidator)
 822
 823 bool wxPropertyListValidator::OnSelect(bool select, wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
 824 {
 825 //  view->GetValueText()->Show(TRUE);
 826   if (select)
 827     OnDisplayValue(property, view, parentWindow);
 828
 829   return TRUE;
 830 }
 831
 832 bool wxPropertyListValidator::OnValueListSelect(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
 833 {
 834   wxString s(view->GetValueList()->GetStringSelection());
 835   if (s != wxT(""))
 836   {
 837     view->GetValueText()->SetValue(s);
 838     view->RetrieveProperty(property);
 839   }
 840   return TRUE;
 841 }
 842
 843 bool wxPropertyListValidator::OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
 844 {
 845 //  view->GetValueText()->Show(TRUE);
 846   wxString str(property->GetValue().GetStringRepresentation());
 847
 848   view->GetValueText()->SetValue(str);
 849   return TRUE;
 850 }
 851
 852 // Called when TICK is pressed or focus is lost or view wants to update
 853 // the property list.
 854 // Does the transferance from the property editing area to the property itself
 855 bool wxPropertyListValidator::OnRetrieveValue(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
 856 {
 857   if (!view->GetValueText())
 858     return FALSE;
 859   return FALSE;
 860 }
 861
 862 void wxPropertyListValidator::OnEdit(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
 863 {
 864   if (view->GetDetailedEditing())
 865     view->EndDetailedEditing();
 866   else
 867     view->BeginDetailedEditing();
 868 }
 869
 870 bool wxPropertyListValidator::OnClearControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
 871 {
 872   if (view->GetConfirmButton())
 873     view->GetConfirmButton()->Enable(FALSE);
 874   if (view->GetCancelButton())
 875     view->GetCancelButton()->Enable(FALSE);
 876   if (view->GetEditButton())
 877     view->GetEditButton()->Enable(FALSE);
 878   return TRUE;
 879 }
 880
 881 // ----------------------------------------------------------------------------
 882 // Default validators
 883 // ----------------------------------------------------------------------------
 884
 885 IMPLEMENT_DYNAMIC_CLASS(wxRealListValidator, wxPropertyListValidator)
 886
 887 ///
 888 /// Real number validator
 889 ///
 890 bool wxRealListValidator::OnCheckValue(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *parentWindow)
 891 {
 892   if (m_realMin == 0.0 && m_realMax == 0.0)
 893     return TRUE;
 894
 895   if (!view->GetValueText())
 896     return FALSE;
 897   wxString value(view->GetValueText()->GetValue());
 898
 899   float val = 0.0;
 900   if (!StringToFloat(WXSTRINGCAST value, &val))
 901   {
 902     wxChar buf[200];
 903     wxSprintf(buf, wxT("Value %s is not a valid real number!"), value.GetData());
 904     wxMessageBox(buf, wxT("Property value error"), wxOK | wxICON_EXCLAMATION, parentWindow);
 905     return FALSE;
 906   }
 907
 908   if (val < m_realMin || val > m_realMax)
 909   {
 910     char buf[200];
 911     sprintf(buf, "Value must be a real number between %.2f and %.2f!", m_realMin, m_realMax);
 912     wxMessageBox(buf, "Property value error", wxOK | wxICON_EXCLAMATION, parentWindow);
 913     return FALSE;
 914   }
 915   return TRUE;
 916 }
 917
 918 // Called when TICK is pressed or focus is lost or view wants to update
 919 // the property list.
 920 // Does the transferance from the property editing area to the property itself
 921 bool wxRealListValidator::OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
 922 {
 923   if (!view->GetValueText())
 924     return FALSE;
 925
 926   if (wxStrlen(view->GetValueText()->GetValue()) == 0)
 927     return FALSE;
 928
 929   wxString value(view->GetValueText()->GetValue());
 930   float f = (float)wxAtof(value.GetData());
 931   property->GetValue() = f;
 932   return TRUE;
 933 }
 934
 935 bool wxRealListValidator::OnPrepareControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
 936 {
 937   if (view->GetConfirmButton())
 938     view->GetConfirmButton()->Enable(TRUE);
 939   if (view->GetCancelButton())
 940     view->GetCancelButton()->Enable(TRUE);
 941   if (view->GetEditButton())
 942     view->GetEditButton()->Enable(FALSE);
 943   if (view->GetValueText())
 944     view->GetValueText()->Enable(TRUE);
 945   return TRUE;
 946 }
 947
 948 ///
 949 /// Integer validator
 950 ///
 951 IMPLEMENT_DYNAMIC_CLASS(wxIntegerListValidator, wxPropertyListValidator)
 952
 953 bool wxIntegerListValidator::OnCheckValue(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *parentWindow)
 954 {
 955   if (m_integerMin == 0 && m_integerMax == 0)
 956     return TRUE;
 957
 958   if (!view->GetValueText())
 959     return FALSE;
 960   wxString value(view->GetValueText()->GetValue());
 961
 962   long val = 0;
 963   if (!StringToLong(WXSTRINGCAST value, &val))
 964   {
 965     wxChar buf[200];
 966     wxSprintf(buf, wxT("Value %s is not a valid integer!"), value.GetData());
 967     wxMessageBox(buf, wxT("Property value error"), wxOK | wxICON_EXCLAMATION, parentWindow);
 968     return FALSE;
 969   }
 970   if (val < m_integerMin || val > m_integerMax)
 971   {
 972     wxChar buf[200];
 973     wxSprintf(buf, wxT("Value must be an integer between %ld and %ld!"), m_integerMin, m_integerMax);
 974     wxMessageBox(buf, wxT("Property value error"), wxOK | wxICON_EXCLAMATION, parentWindow);
 975     return FALSE;
 976   }
 977   return TRUE;
 978 }
 979
 980 // Called when TICK is pressed or focus is lost or view wants to update
 981 // the property list.
 982 // Does the transferance from the property editing area to the property itself
 983 bool wxIntegerListValidator::OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
 984 {
 985   if (!view->GetValueText())
 986     return FALSE;
 987
 988   if (wxStrlen(view->GetValueText()->GetValue()) == 0)
 989     return FALSE;
 990
 991   wxString value(view->GetValueText()->GetValue());
 992   long val = (long)wxAtoi(value.GetData());
 993   property->GetValue() = (long)val;
 994   return TRUE;
 995 }
 996
 997 bool wxIntegerListValidator::OnPrepareControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
 998 {
 999   if (view->GetConfirmButton())
1000     view->GetConfirmButton()->Enable(TRUE);
1001   if (view->GetCancelButton())
1002     view->GetCancelButton()->Enable(TRUE);
1003   if (view->GetEditButton())
1004     view->GetEditButton()->Enable(FALSE);
1005   if (view->GetValueText())
1006     view->GetValueText()->Enable(TRUE);
1007   return TRUE;
1008 }
1009
1010 ///
1011 /// boolean validator
1012 ///
1013 IMPLEMENT_DYNAMIC_CLASS(wxBoolListValidator, wxPropertyListValidator)
1014
1015 bool wxBoolListValidator::OnCheckValue(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *parentWindow)
1016 {
1017   if (!view->GetValueText())
1018     return FALSE;
1019   wxString value(view->GetValueText()->GetValue());
1020   if (value != wxT("True") && value != wxT("False"))
1021   {
1022     wxMessageBox(wxT("Value must be True or False!"), wxT("Property value error"), wxOK | wxICON_EXCLAMATION, parentWindow);
1023     return FALSE;
1024   }
1025   return TRUE;
1026 }
1027
1028 // Called when TICK is pressed or focus is lost or view wants to update
1029 // the property list.
1030 // Does the transferance from the property editing area to the property itself
1031 bool wxBoolListValidator::OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1032 {
1033   if (!view->GetValueText())
1034     return FALSE;
1035
1036   if (wxStrlen(view->GetValueText()->GetValue()) == 0)
1037     return FALSE;
1038
1039   wxString value(view->GetValueText()->GetValue());
1040   bool boolValue = FALSE;
1041   if (value == wxT("True"))
1042     boolValue = TRUE;
1043   else
1044     boolValue = FALSE;
1045   property->GetValue() = (bool)boolValue;
1046   return TRUE;
1047 }
1048
1049 bool wxBoolListValidator::OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1050 {
1051   if (!view->GetValueText())
1052     return FALSE;
1053   wxString str(property->GetValue().GetStringRepresentation());
1054
1055   view->GetValueText()->SetValue(str);
1056
1057   if (view->GetValueList()->IsShown())
1058   {
1059     view->GetValueList()->SetStringSelection(str);
1060   }
1061   return TRUE;
1062 }
1063
1064 bool wxBoolListValidator::OnPrepareControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1065 {
1066   if (view->GetConfirmButton())
1067     view->GetConfirmButton()->Enable(FALSE);
1068   if (view->GetCancelButton())
1069     view->GetCancelButton()->Enable(FALSE);
1070   if (view->GetEditButton())
1071     view->GetEditButton()->Enable(TRUE);
1072   if (view->GetValueText())
1073     view->GetValueText()->Enable(FALSE);
1074   return TRUE;
1075 }
1076
1077 bool wxBoolListValidator::OnPrepareDetailControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1078 {
1079   if (view->GetValueList())
1080   {
1081     view->ShowListBoxControl(TRUE);
1082     view->GetValueList()->Enable(TRUE);
1083
1084     view->GetValueList()->Append(wxT("True"));
1085     view->GetValueList()->Append(wxT("False"));
1086     wxChar *currentString = copystring(view->GetValueText()->GetValue());
1087     view->GetValueList()->SetStringSelection(currentString);
1088     delete[] currentString;
1089   }
1090   return TRUE;
1091 }
1092
1093 bool wxBoolListValidator::OnClearDetailControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1094 {
1095   if (view->GetValueList())
1096   {
1097     view->GetValueList()->Clear();
1098     view->ShowListBoxControl(FALSE);
1099     view->GetValueList()->Enable(FALSE);
1100   }
1101   return TRUE;
1102 }
1103
1104 // Called when the property is double clicked. Extra functionality can be provided,
1105 // cycling through possible values.
1106 bool wxBoolListValidator::OnDoubleClick(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1107 {
1108   if (!view->GetValueText())
1109     return FALSE;
1110   if (property->GetValue().BoolValue())
1111     property->GetValue() = (bool)FALSE;
1112   else
1113     property->GetValue() = (bool)TRUE;
1114   view->DisplayProperty(property);
1115   view->UpdatePropertyDisplayInList(property);
1116   view->OnPropertyChanged(property);
1117   return TRUE;
1118 }
1119
1120 ///
1121 /// String validator
1122 ///
1123 IMPLEMENT_DYNAMIC_CLASS(wxStringListValidator, wxPropertyListValidator)
1124
1125 wxStringListValidator::wxStringListValidator(wxStringList *list, long flags):
1126   wxPropertyListValidator(flags)
1127 {
1128   m_strings = list;
1129   // If no constraint, we just allow the string to be edited.
1130   if (!m_strings && ((m_validatorFlags & wxPROP_ALLOW_TEXT_EDITING) == 0))
1131     m_validatorFlags |= wxPROP_ALLOW_TEXT_EDITING;
1132 }
1133
1134 bool wxStringListValidator::OnCheckValue(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *parentWindow)
1135 {
1136   if (!m_strings)
1137     return TRUE;
1138
1139   if (!view->GetValueText())
1140     return FALSE;
1141   wxString value(view->GetValueText()->GetValue());
1142
1143   if (!m_strings->Member(value.GetData()))
1144   {
1145     wxString s("Value ");
1146     s += value.GetData();
1147     s += " is not valid.";
1148     wxMessageBox(s.GetData(), "Property value error", wxOK | wxICON_EXCLAMATION, parentWindow);
1149     return FALSE;
1150   }
1151   return TRUE;
1152 }
1153
1154 // Called when TICK is pressed or focus is lost or view wants to update
1155 // the property list.
1156 // Does the transferance from the property editing area to the property itself
1157 bool wxStringListValidator::OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1158 {
1159   if (!view->GetValueText())
1160     return FALSE;
1161   wxString value(view->GetValueText()->GetValue());
1162   property->GetValue() = value ;
1163   return TRUE;
1164 }
1165
1166 // Called when TICK is pressed or focus is lost or view wants to update
1167 // the property list.
1168 // Does the transferance from the property editing area to the property itself
1169 bool wxStringListValidator::OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1170 {
1171   if (!view->GetValueText())
1172     return FALSE;
1173   wxString str(property->GetValue().GetStringRepresentation());
1174   view->GetValueText()->SetValue(str);
1175   if (m_strings && view->GetValueList() && view->GetValueList()->IsShown() && view->GetValueList()->GetCount() > 0)
1176   {
1177     view->GetValueList()->SetStringSelection(str);
1178   }
1179   return TRUE;
1180 }
1181
1182 bool wxStringListValidator::OnPrepareControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1183 {
1184   // Unconstrained
1185   if (!m_strings)
1186   {
1187     if (view->GetEditButton())
1188       view->GetEditButton()->Enable(FALSE);
1189     if (view->GetConfirmButton())
1190       view->GetConfirmButton()->Enable(TRUE);
1191     if (view->GetCancelButton())
1192       view->GetCancelButton()->Enable(TRUE);
1193     if (view->GetValueText())
1194       view->GetValueText()->Enable(TRUE);
1195     return TRUE;
1196   }
1197
1198   // Constrained
1199   if (view->GetValueText())
1200     view->GetValueText()->Enable(FALSE);
1201
1202   if (view->GetEditButton())
1203     view->GetEditButton()->Enable(TRUE);
1204
1205   if (view->GetConfirmButton())
1206     view->GetConfirmButton()->Enable(FALSE);
1207   if (view->GetCancelButton())
1208     view->GetCancelButton()->Enable(FALSE);
1209   return TRUE;
1210 }
1211
1212 bool wxStringListValidator::OnPrepareDetailControls(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1213 {
1214   if (view->GetValueList())
1215   {
1216     view->ShowListBoxControl(TRUE);
1217     view->GetValueList()->Enable(TRUE);
1218     wxNode *node = m_strings->First();
1219     while (node)
1220     {
1221       wxChar *s = (wxChar *)node->Data();
1222       view->GetValueList()->Append(s);
1223       node = node->Next();
1224     }
1225     wxChar *currentString = property->GetValue().StringValue();
1226     view->GetValueList()->SetStringSelection(currentString);
1227   }
1228   return TRUE;
1229 }
1230
1231 bool wxStringListValidator::OnClearDetailControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1232 {
1233   if (!m_strings)
1234   {
1235     return TRUE;
1236   }
1237
1238   if (view->GetValueList())
1239   {
1240     view->GetValueList()->Clear();
1241     view->ShowListBoxControl(FALSE);
1242     view->GetValueList()->Enable(FALSE);
1243   }
1244   return TRUE;
1245 }
1246
1247 // Called when the property is double clicked. Extra functionality can be provided,
1248 // cycling through possible values.
1249 bool wxStringListValidator::OnDoubleClick(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1250 {
1251   if (!view->GetValueText())
1252     return FALSE;
1253   if (!m_strings)
1254     return FALSE;
1255
1256   wxNode *node = m_strings->First();
1257   wxChar *currentString = property->GetValue().StringValue();
1258   while (node)
1259   {
1260     wxChar *s = (wxChar *)node->Data();
1261     if (wxStrcmp(s, currentString) == 0)
1262     {
1263       wxChar *nextString = NULL;
1264       if (node->Next())
1265         nextString = (wxChar *)node->Next()->Data();
1266       else
1267         nextString = (wxChar *)m_strings->First()->Data();
1268       property->GetValue() = wxString(nextString);
1269       view->DisplayProperty(property);
1270       view->UpdatePropertyDisplayInList(property);
1271       view->OnPropertyChanged(property);
1272       return TRUE;
1273     }
1274     else node = node->Next();
1275   }
1276   return TRUE;
1277 }
1278
1279 ///
1280 /// Filename validator
1281 ///
1282 IMPLEMENT_DYNAMIC_CLASS(wxFilenameListValidator, wxPropertyListValidator)
1283
1284 wxFilenameListValidator::wxFilenameListValidator(wxString message , wxString wildcard, long flags):
1285   wxPropertyListValidator(flags), m_filenameWildCard(wildcard), m_filenameMessage(message)
1286 {
1287 }
1288
1289 wxFilenameListValidator::~wxFilenameListValidator()
1290 {
1291 }
1292
1293 bool wxFilenameListValidator::OnCheckValue(wxProperty *WXUNUSED(property), wxPropertyListView *WXUNUSED(view), wxWindow *WXUNUSED(parentWindow))
1294 {
1295   return TRUE;
1296 }
1297
1298 // Called when TICK is pressed or focus is lost or view wants to update
1299 // the property list.
1300 // Does the transferance from the property editing area to the property itself
1301 bool wxFilenameListValidator::OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1302 {
1303   if (!view->GetValueText())
1304     return FALSE;
1305   wxString value(view->GetValueText()->GetValue());
1306   property->GetValue() = value ;
1307   return TRUE;
1308 }
1309
1310 // Called when TICK is pressed or focus is lost or view wants to update
1311 // the property list.
1312 // Does the transferance from the property editing area to the property itself
1313 bool wxFilenameListValidator::OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1314 {
1315   if (!view->GetValueText())
1316     return FALSE;
1317   wxString str(property->GetValue().GetStringRepresentation());
1318   view->GetValueText()->SetValue(str);
1319   return TRUE;
1320 }
1321
1322 // Called when the property is double clicked. Extra functionality can be provided,
1323 // cycling through possible values.
1324 bool wxFilenameListValidator::OnDoubleClick(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
1325 {
1326   if (!view->GetValueText())
1327     return FALSE;
1328   OnEdit(property, view, parentWindow);
1329   return TRUE;
1330 }
1331
1332 bool wxFilenameListValidator::OnPrepareControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1333 {
1334   if (view->GetConfirmButton())
1335     view->GetConfirmButton()->Enable(TRUE);
1336   if (view->GetCancelButton())
1337     view->GetCancelButton()->Enable(TRUE);
1338   if (view->GetEditButton())
1339     view->GetEditButton()->Enable(TRUE);
1340   if (view->GetValueText())
1341     view->GetValueText()->Enable((GetFlags() & wxPROP_ALLOW_TEXT_EDITING) == wxPROP_ALLOW_TEXT_EDITING);
1342   return TRUE;
1343 }
1344
1345 void wxFilenameListValidator::OnEdit(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
1346 {
1347   if (!view->GetValueText())
1348     return;
1349
1350   wxString s = wxFileSelector(
1351      m_filenameMessage.GetData(),
1352      wxPathOnly(property->GetValue().StringValue()),
1353      wxFileNameFromPath(property->GetValue().StringValue()),
1354      NULL,
1355      m_filenameWildCard.GetData(),
1356      0,
1357      parentWindow);
1358   if (s != wxT(""))
1359   {
1360     property->GetValue() = s;
1361     view->DisplayProperty(property);
1362     view->UpdatePropertyDisplayInList(property);
1363     view->OnPropertyChanged(property);
1364   }
1365 }
1366
1367 ///
1368 /// Colour validator
1369 ///
1370 IMPLEMENT_DYNAMIC_CLASS(wxColourListValidator, wxPropertyListValidator)
1371
1372 wxColourListValidator::wxColourListValidator(long flags):
1373   wxPropertyListValidator(flags)
1374 {
1375 }
1376
1377 wxColourListValidator::~wxColourListValidator()
1378 {
1379 }
1380
1381 bool wxColourListValidator::OnCheckValue(wxProperty *WXUNUSED(property), wxPropertyListView *WXUNUSED(view), wxWindow *WXUNUSED(parentWindow))
1382 {
1383   return TRUE;
1384 }
1385
1386 // Called when TICK is pressed or focus is lost or view wants to update
1387 // the property list.
1388 // Does the transferance from the property editing area to the property itself
1389 bool wxColourListValidator::OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1390 {
1391   if (!view->GetValueText())
1392     return FALSE;
1393   wxString value(view->GetValueText()->GetValue());
1394
1395   property->GetValue() = value ;
1396   return TRUE;
1397 }
1398
1399 // Called when TICK is pressed or focus is lost or view wants to update
1400 // the property list.
1401 // Does the transferance from the property editing area to the property itself
1402 bool wxColourListValidator::OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1403 {
1404   if (!view->GetValueText())
1405     return FALSE;
1406   wxString str(property->GetValue().GetStringRepresentation());
1407   view->GetValueText()->SetValue(str);
1408   return TRUE;
1409 }
1410
1411 // Called when the property is double clicked. Extra functionality can be provided,
1412 // cycling through possible values.
1413 bool wxColourListValidator::OnDoubleClick(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
1414 {
1415   if (!view->GetValueText())
1416     return FALSE;
1417   OnEdit(property, view, parentWindow);
1418   return TRUE;
1419 }
1420
1421 bool wxColourListValidator::OnPrepareControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1422 {
1423   if (view->GetConfirmButton())
1424     view->GetConfirmButton()->Enable(TRUE);
1425   if (view->GetCancelButton())
1426     view->GetCancelButton()->Enable(TRUE);
1427   if (view->GetEditButton())
1428     view->GetEditButton()->Enable(TRUE);
1429   if (view->GetValueText())
1430     view->GetValueText()->Enable((GetFlags() & wxPROP_ALLOW_TEXT_EDITING) == wxPROP_ALLOW_TEXT_EDITING);
1431   return TRUE;
1432 }
1433
1434 void wxColourListValidator::OnEdit(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
1435 {
1436   if (!view->GetValueText())
1437     return;
1438
1439   wxChar *s = property->GetValue().StringValue();
1440   int r = 0;
1441   int g = 0;
1442   int b = 0;
1443   if (s)
1444   {
1445     r = wxHexToDec(s);
1446     g = wxHexToDec(s+2);
1447     b = wxHexToDec(s+4);
1448   }
1449
1450   wxColour col(r,g,b);
1451
1452   wxColourData data;
1453   data.SetChooseFull(TRUE);
1454   data.SetColour(col);
1455
1456   for (int i = 0; i < 16; i++)
1457   {
1458     wxColour colour(i*16, i*16, i*16);
1459     data.SetCustomColour(i, colour);
1460   }
1461
1462   wxColourDialog dialog(parentWindow, &data);
1463   if (dialog.ShowModal() != wxID_CANCEL)
1464   {
1465     wxColourData retData = dialog.GetColourData();
1466     col = retData.GetColour();
1467
1468     wxChar buf[7];
1469     wxDecToHex(col.Red(), buf);
1470     wxDecToHex(col.Green(), buf+2);
1471     wxDecToHex(col.Blue(), buf+4);
1472
1473     property->GetValue() = wxString(buf);
1474     view->DisplayProperty(property);
1475     view->UpdatePropertyDisplayInList(property);
1476     view->OnPropertyChanged(property);
1477   }
1478 }
1479
1480 ///
1481 /// List of strings validator. For this we need more user interface than
1482 /// we get with a property list; so create a new dialog for editing the list.
1483 ///
1484 IMPLEMENT_DYNAMIC_CLASS(wxListOfStringsListValidator, wxPropertyListValidator)
1485
1486 wxListOfStringsListValidator::wxListOfStringsListValidator(long flags):
1487   wxPropertyListValidator(flags)
1488 {
1489 }
1490
1491 bool wxListOfStringsListValidator::OnCheckValue(wxProperty *WXUNUSED(property), wxPropertyListView *WXUNUSED(view), wxWindow *WXUNUSED(parentWindow))
1492 {
1493   // No constraints for an arbitrary, user-editable list of strings.
1494   return TRUE;
1495 }
1496
1497 // Called when TICK is pressed or focus is lost or view wants to update
1498 // the property list.
1499 // Does the transferance from the property editing area to the property itself.
1500 // In this case, the user cannot directly edit the string list.
1501 bool wxListOfStringsListValidator::OnRetrieveValue(wxProperty *WXUNUSED(property), wxPropertyListView *WXUNUSED(view), wxWindow *WXUNUSED(parentWindow))
1502 {
1503   return TRUE;
1504 }
1505
1506 bool wxListOfStringsListValidator::OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1507 {
1508   if (!view->GetValueText())
1509     return FALSE;
1510   wxString str(property->GetValue().GetStringRepresentation());
1511   view->GetValueText()->SetValue(str);
1512   return TRUE;
1513 }
1514
1515 bool wxListOfStringsListValidator::OnPrepareControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1516 {
1517   if (view->GetEditButton())
1518     view->GetEditButton()->Enable(TRUE);
1519   if (view->GetValueText())
1520     view->GetValueText()->Enable(FALSE);
1521
1522   if (view->GetConfirmButton())
1523     view->GetConfirmButton()->Enable(FALSE);
1524   if (view->GetCancelButton())
1525     view->GetCancelButton()->Enable(FALSE);
1526   return TRUE;
1527 }
1528
1529 // Called when the property is double clicked. Extra functionality can be provided,
1530 // cycling through possible values.
1531 bool wxListOfStringsListValidator::OnDoubleClick(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
1532 {
1533   OnEdit(property, view, parentWindow);
1534   return TRUE;
1535 }
1536
1537 void wxListOfStringsListValidator::OnEdit(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
1538 {
1539   // Convert property value to a list of strings for editing
1540   wxStringList *stringList = new wxStringList;
1541
1542   wxPropertyValue *expr = property->GetValue().GetFirst();
1543   while (expr)
1544   {
1545     wxChar *s = expr->StringValue();
1546     if (s)
1547       stringList->Add(s);
1548     expr = expr->GetNext();
1549   }
1550
1551   wxString title(wxT("Editing "));
1552   title += property->GetName();
1553
1554   if (EditStringList(parentWindow, stringList, title.GetData()))
1555   {
1556     wxPropertyValue& oldValue = property->GetValue();
1557     oldValue.ClearList();
1558     wxNode *node = stringList->First();
1559     while (node)
1560     {
1561       wxChar *s = (wxChar *)node->Data();
1562       oldValue.Append(new wxPropertyValue(s));
1563
1564       node = node->Next();
1565     }
1566
1567     view->DisplayProperty(property);
1568     view->UpdatePropertyDisplayInList(property);
1569     view->OnPropertyChanged(property);
1570   }
1571   delete stringList;
1572 }
1573
1574 class wxPropertyStringListEditorDialog: public wxDialog
1575 {
1576   public:
1577     wxPropertyStringListEditorDialog(wxWindow *parent, const wxString& title,
1578         const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
1579           long windowStyle = wxDEFAULT_DIALOG_STYLE, const wxString& name = "stringEditorDialogBox"):
1580                wxDialog(parent, -1, title, pos, size, windowStyle, name)
1581     {
1582       m_stringList = NULL;
1583       m_stringText = NULL;
1584       m_listBox = NULL;
1585       sm_dialogCancelled = FALSE;
1586       m_currentSelection = -1;
1587     }
1588     ~wxPropertyStringListEditorDialog(void) {}
1589     void OnCloseWindow(wxCloseEvent& event);
1590     void SaveCurrentSelection(void);
1591     void ShowCurrentSelection(void);
1592
1593     void OnOK(wxCommandEvent& event);
1594     void OnCancel(wxCommandEvent& event);
1595     void OnAdd(wxCommandEvent& event);
1596     void OnDelete(wxCommandEvent& event);
1597     void OnStrings(wxCommandEvent& event);
1598     void OnText(wxCommandEvent& event);
1599
1600 public:
1601     wxStringList*       m_stringList;
1602     wxListBox*          m_listBox;
1603     wxTextCtrl*         m_stringText;
1604     static bool         sm_dialogCancelled;
1605     int                 m_currentSelection;
1606 DECLARE_EVENT_TABLE()
1607 };
1608
1609 #define    wxID_PROP_SL_ADD            3000
1610 #define    wxID_PROP_SL_DELETE            3001
1611 #define    wxID_PROP_SL_STRINGS        3002
1612 #define    wxID_PROP_SL_TEXT            3003
1613
1614 BEGIN_EVENT_TABLE(wxPropertyStringListEditorDialog, wxDialog)
1615     EVT_BUTTON(wxID_OK,                 wxPropertyStringListEditorDialog::OnOK)
1616     EVT_BUTTON(wxID_CANCEL,                wxPropertyStringListEditorDialog::OnCancel)
1617     EVT_BUTTON(wxID_PROP_SL_ADD,        wxPropertyStringListEditorDialog::OnAdd)
1618     EVT_BUTTON(wxID_PROP_SL_DELETE,        wxPropertyStringListEditorDialog::OnDelete)
1619     EVT_LISTBOX(wxID_PROP_SL_STRINGS,    wxPropertyStringListEditorDialog::OnStrings)
1620     EVT_TEXT_ENTER(wxID_PROP_SL_TEXT,            wxPropertyStringListEditorDialog::OnText)
1621     EVT_CLOSE(wxPropertyStringListEditorDialog::OnCloseWindow)
1622 END_EVENT_TABLE()
1623
1624 class wxPropertyStringListEditorText: public wxTextCtrl
1625 {
1626  public:
1627   wxPropertyStringListEditorText(wxWindow *parent, wxWindowID id, const wxString& val,
1628       const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
1629     long windowStyle = 0, const wxString& name = "text"):
1630      wxTextCtrl(parent, id, val, pos, size, windowStyle, wxDefaultValidator, name)
1631   {
1632   }
1633   void OnKillFocus()
1634   {
1635     wxPropertyStringListEditorDialog *dialog = (wxPropertyStringListEditorDialog *)GetParent();
1636     dialog->SaveCurrentSelection();
1637   }
1638 };
1639
1640 bool wxPropertyStringListEditorDialog::sm_dialogCancelled = FALSE;
1641
1642 // Edit the string list.
1643 bool wxListOfStringsListValidator::EditStringList(wxWindow *parent, wxStringList *stringList, const wxChar *title)
1644 {
1645   int largeButtonWidth = 60;
1646   int largeButtonHeight = 25;
1647
1648   wxBeginBusyCursor();
1649   wxPropertyStringListEditorDialog *dialog = new wxPropertyStringListEditorDialog(parent,
1650       title, wxPoint(10, 10), wxSize(400, 400), wxDEFAULT_DIALOG_STYLE|wxDIALOG_MODAL);
1651
1652   dialog->m_stringList = stringList;
1653
1654   dialog->m_listBox = new wxListBox(dialog, wxID_PROP_SL_STRINGS,
1655     wxPoint(-1, -1), wxSize(-1, -1), 0, NULL, wxLB_SINGLE);
1656
1657   dialog->m_stringText = new wxPropertyStringListEditorText(dialog,
1658   wxID_PROP_SL_TEXT, "", wxPoint(5, 240),
1659        wxSize(300, -1), wxPROCESS_ENTER);
1660   dialog->m_stringText->Enable(FALSE);
1661
1662   wxButton *addButton = new wxButton(dialog, wxID_PROP_SL_ADD, "Add", wxPoint(-1, -1), wxSize(largeButtonWidth, largeButtonHeight));
1663   wxButton *deleteButton = new wxButton(dialog, wxID_PROP_SL_DELETE, "Delete", wxPoint(-1, -1), wxSize(largeButtonWidth, largeButtonHeight));
1664   wxButton *cancelButton = new wxButton(dialog, wxID_CANCEL, "Cancel", wxPoint(-1, -1), wxSize(largeButtonWidth, largeButtonHeight));
1665   wxButton *okButton = new wxButton(dialog, wxID_OK, "OK", wxPoint(-1, -1), wxSize(largeButtonWidth, largeButtonHeight));
1666
1667 #ifndef __WXGTK__
1668   okButton->SetDefault();
1669 #endif
1670
1671   wxLayoutConstraints *c = new wxLayoutConstraints;
1672
1673   c->top.SameAs     (dialog, wxTop, 2);
1674   c->left.SameAs    (dialog, wxLeft, 2);
1675   c->right.SameAs   (dialog, wxRight, 2);
1676   c->bottom.SameAs  (dialog->m_stringText, wxTop, 2);
1677   dialog->m_listBox->SetConstraints(c);
1678
1679   c = new wxLayoutConstraints;
1680   c->left.SameAs    (dialog, wxLeft, 2);
1681   c->right.SameAs   (dialog, wxRight, 2);
1682   c->bottom.SameAs  (addButton, wxTop, 2);
1683   c->height.AsIs();
1684   dialog->m_stringText->SetConstraints(c);
1685
1686   c = new wxLayoutConstraints;
1687   c->bottom.SameAs  (dialog, wxBottom, 2);
1688   c->left.SameAs    (dialog, wxLeft, 2);
1689   c->width.AsIs();
1690   c->height.AsIs();
1691   addButton->SetConstraints(c);
1692
1693   c = new wxLayoutConstraints;
1694   c->bottom.SameAs  (dialog, wxBottom, 2);
1695   c->left.SameAs    (addButton, wxRight, 2);
1696   c->width.AsIs();
1697   c->height.AsIs();
1698   deleteButton->SetConstraints(c);
1699
1700   c = new wxLayoutConstraints;
1701   c->bottom.SameAs  (dialog, wxBottom, 2);
1702   c->right.SameAs   (dialog, wxRight, 2);
1703   c->width.AsIs();
1704   c->height.AsIs();
1705   cancelButton->SetConstraints(c);
1706
1707   c = new wxLayoutConstraints;
1708   c->bottom.SameAs  (dialog, wxBottom, 2);
1709   c->right.SameAs   (cancelButton, wxLeft, 2);
1710   c->width.AsIs();
1711   c->height.AsIs();
1712   okButton->SetConstraints(c);
1713
1714   wxNode *node = stringList->First();
1715   while (node)
1716   {
1717     char *str = (char *)node->Data();
1718     // Save node as client data for each listbox item
1719     dialog->m_listBox->Append(str, (char *)node);
1720     node = node->Next();
1721   }
1722
1723   dialog->SetClientSize(310, 305);
1724   dialog->Layout();
1725
1726   dialog->Centre(wxBOTH);
1727   wxEndBusyCursor();
1728   if (dialog->ShowModal() == wxID_CANCEL)
1729     return FALSE;
1730   else
1731     return TRUE;
1732 }
1733
1734 /*
1735  * String list editor callbacks
1736  *
1737  */
1738
1739 void wxPropertyStringListEditorDialog::OnStrings(wxCommandEvent& WXUNUSED(event))
1740 {
1741   int sel = m_listBox->GetSelection();
1742   if (sel > -1)
1743   {
1744     m_currentSelection = sel;
1745
1746     ShowCurrentSelection();
1747   }
1748 }
1749
1750 void wxPropertyStringListEditorDialog::OnDelete(wxCommandEvent& WXUNUSED(event))
1751 {
1752   int sel = m_listBox->GetSelection();
1753   if (sel == -1)
1754     return;
1755
1756   wxNode *node = (wxNode *)m_listBox->wxListBox::GetClientData(sel);
1757   if (!node)
1758     return;
1759
1760   m_listBox->Delete(sel);
1761   delete[] (wxChar *)node->Data();
1762   delete node;
1763   m_currentSelection = -1;
1764   m_stringText->SetValue("");
1765 }
1766
1767 void wxPropertyStringListEditorDialog::OnAdd(wxCommandEvent& WXUNUSED(event))
1768 {
1769   SaveCurrentSelection();
1770
1771   wxChar *initialText = wxT("");
1772   wxNode *node = m_stringList->Add(initialText);
1773   m_listBox->Append(initialText, (void *)node);
1774   m_currentSelection = m_stringList->Number() - 1;
1775   m_listBox->SetSelection(m_currentSelection);
1776   ShowCurrentSelection();
1777   m_stringText->SetFocus();
1778 }
1779
1780 void wxPropertyStringListEditorDialog::OnOK(wxCommandEvent& WXUNUSED(event))
1781 {
1782   SaveCurrentSelection();
1783   EndModal(wxID_OK);
1784   // Close(TRUE);
1785   this->Destroy();
1786 }
1787
1788 void wxPropertyStringListEditorDialog::OnCancel(wxCommandEvent& WXUNUSED(event))
1789 {
1790   sm_dialogCancelled = TRUE;
1791   EndModal(wxID_CANCEL);
1792 //  Close(TRUE);
1793   this->Destroy();
1794 }
1795
1796 void wxPropertyStringListEditorDialog::OnText(wxCommandEvent& event)
1797 {
1798   if (event.GetEventType() == wxEVT_COMMAND_TEXT_ENTER)
1799   {
1800     SaveCurrentSelection();
1801   }
1802 }
1803
1804 void
1805 wxPropertyStringListEditorDialog::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
1806 {
1807   SaveCurrentSelection();
1808
1809   Destroy();
1810 }
1811
1812 void wxPropertyStringListEditorDialog::SaveCurrentSelection()
1813 {
1814   if (m_currentSelection == -1)
1815     return;
1816
1817   wxNode *node = (wxNode *)m_listBox->wxListBox::GetClientData(m_currentSelection);
1818   if (!node)
1819     return;
1820
1821   wxString txt(m_stringText->GetValue());
1822   if (node->Data())
1823     delete[] (char *)node->Data();
1824   node->SetData((wxObject *)copystring(txt));
1825
1826   m_listBox->SetString(m_currentSelection, (char *)node->Data());
1827 }
1828
1829 void wxPropertyStringListEditorDialog::ShowCurrentSelection()
1830 {
1831   if (m_currentSelection == -1)
1832   {
1833     m_stringText->SetValue("");
1834     return;
1835   }
1836   wxNode *node = (wxNode *)m_listBox->wxListBox::GetClientData(m_currentSelection);
1837   char *txt = (char *)node->Data();
1838   m_stringText->SetValue(txt);
1839   m_stringText->Enable(TRUE);
1840 }
1841
1842 // ----------------------------------------------------------------------------
1843 // global functions
1844 // ----------------------------------------------------------------------------
1845
1846 // FIXME MT-UNSAFE
1847 static wxBitmap *GetTickBitmap()
1848 {
1849     static wxBitmap* s_tickBitmap = (wxBitmap *) NULL;
1850     static bool s_loaded = FALSE;
1851
1852     if ( !s_loaded )
1853     {
1854         s_loaded = TRUE; // set it to TRUE anyhow, we won't try again
1855
1856         #if defined(__WXMSW__) || defined(__WXPM__)
1857             s_tickBitmap = new wxBitmap("tick_bmp", wxBITMAP_TYPE_RESOURCE);
1858         #else
1859             s_tickBitmap = new wxBitmap( tick_xpm );
1860         #endif
1861     }
1862
1863     return s_tickBitmap;
1864 }
1865
1866 static wxBitmap *GetCrossBitmap()
1867 {
1868     static wxBitmap* s_crossBitmap = (wxBitmap *) NULL;
1869     static bool s_loaded = FALSE;
1870
1871     if ( !s_loaded )
1872     {
1873         s_loaded = TRUE; // set it to TRUE anyhow, we won't try again
1874
1875         #if defined(__WXMSW__) || defined(__WXPM__)
1876             s_crossBitmap =  new wxBitmap("cross_bmp", wxBITMAP_TYPE_RESOURCE);
1877         #else // XPMs
1878             s_crossBitmap =  new wxBitmap( cross_xpm );
1879         #endif // BMPs/XPMs
1880     }
1881
1882     return s_crossBitmap;
1883 }
1884
1885 #endif // wxUSE_PROPSHEET