]> git.saurik.com Git - wxWidgets.git/blob - contrib/src/deprecated/proplist.cpp
projects / wxWidgets.git / blob
? search:


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