]> git.saurik.com Git - wxWidgets.git/blame_incremental - contrib/src/deprecated/proplist.cpp
Updated Scintilla to version 1.58
[wxWidgets.git] / contrib / src / deprecated / proplist.cpp
... / ...
CommitLineData
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
61static 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
69IMPLEMENT_DYNAMIC_CLASS(wxPropertyTextEdit, wxTextCtrl)
70
71wxPropertyTextEdit::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
80void wxPropertyTextEdit::OnSetFocus()
81{
82}
83
84void wxPropertyTextEdit::OnKillFocus()
85{
86}
87
88// ----------------------------------------------------------------------------
89// Property list view
90// ----------------------------------------------------------------------------
91
92bool wxPropertyListView::sm_dialogCancelled = FALSE;
93
94IMPLEMENT_DYNAMIC_CLASS(wxPropertyListView, wxPropertyView)
95
96BEGIN_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)
108END_EVENT_TABLE()
109
110wxPropertyListView::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
128wxPropertyListView::~wxPropertyListView()
129{
130}
131
132void 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.
145bool wxPropertyListView::OnUpdateView()
146{
147 return TRUE;
148}
149
150bool 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
175bool 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
210int 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
221wxString 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.
242bool 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
268bool 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
285bool 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
306void 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
325void 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
346bool 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
365bool 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
394bool wxPropertyListView::EditProperty(wxProperty *WXUNUSED(property))
395{
396 return TRUE;
397}
398
399// Called by the listbox callback
400void 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
413bool 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
535void wxPropertyListView::ShowTextControl(bool show)
536{
537 if (m_valueText)
538 m_valueText->Show(show);
539}
540
541void 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
558void wxPropertyListView::EnableCheck(bool show)
559{
560 if (m_confirmButton)
561 m_confirmButton->Enable(show);
562}
563
564void wxPropertyListView::EnableCross(bool show)
565{
566 if (m_cancelButton)
567 m_cancelButton->Enable(show);
568}
569
570bool wxPropertyListView::OnClose()
571{
572 // Retrieve the value if any
573 wxCommandEvent event;
574 OnCheck(event);
575
576 delete this;
577 return TRUE;
578}
579
580void 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
593void 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
602void wxPropertyListView::OnCancel(wxCommandEvent& WXUNUSED(event))
603{
604// SetReturnCode(wxID_CANCEL);
605 m_managedWindow->Close(TRUE);
606 sm_dialogCancelled = TRUE;
607}
608
609void wxPropertyListView::OnHelp(wxCommandEvent& WXUNUSED(event))
610{
611}
612
613void wxPropertyListView::OnCheck(wxCommandEvent& WXUNUSED(event))
614{
615 if (m_currentProperty)
616 {
617 RetrieveProperty(m_currentProperty);
618 }
619}
620
621void 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
635void 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
649void 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
662void 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
674IMPLEMENT_DYNAMIC_CLASS(wxPropertyListDialog, wxDialog)
675
676BEGIN_EVENT_TABLE(wxPropertyListDialog, wxDialog)
677 EVT_BUTTON(wxID_CANCEL, wxPropertyListDialog::OnCancel)
678 EVT_CLOSE(wxPropertyListDialog::OnCloseWindow)
679END_EVENT_TABLE()
680
681wxPropertyListDialog::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
692void 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
707void wxPropertyListDialog::OnCancel(wxCommandEvent& WXUNUSED(event))
708{
709 SetReturnCode(wxID_CANCEL);
710 this->Close();
711}
712
713void 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
722bool 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
734IMPLEMENT_DYNAMIC_CLASS(wxPropertyListPanel, wxPanel)
735
736BEGIN_EVENT_TABLE(wxPropertyListPanel, wxPanel)
737 EVT_SIZE(wxPropertyListPanel::OnSize)
738END_EVENT_TABLE()
739
740wxPropertyListPanel::~wxPropertyListPanel()
741{
742}
743
744void 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
753bool 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
761void wxPropertyListPanel::OnSize(wxSizeEvent& WXUNUSED(event))
762{
763 Layout();
764}
765
766// ----------------------------------------------------------------------------
767// Property frame
768// ----------------------------------------------------------------------------
769
770IMPLEMENT_DYNAMIC_CLASS(wxPropertyListFrame, wxFrame)
771
772BEGIN_EVENT_TABLE(wxPropertyListFrame, wxFrame)
773 EVT_CLOSE(wxPropertyListFrame::OnCloseWindow)
774END_EVENT_TABLE()
775
776void 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
792wxPropertyListPanel *wxPropertyListFrame::OnCreatePanel(wxFrame *parent, wxPropertyListView *v)
793{
794 return new wxPropertyListPanel(v, parent);
795}
796
797bool 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
815IMPLEMENT_ABSTRACT_CLASS(wxPropertyListValidator, wxPropertyValidator)
816
817bool 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
826bool 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
837bool 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
849bool wxPropertyListValidator::OnRetrieveValue(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
850{
851 if (!view->GetValueText())
852 return FALSE;
853 return FALSE;
854}
855
856void 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
864bool 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
879IMPLEMENT_DYNAMIC_CLASS(wxRealListValidator, wxPropertyListValidator)
880
881///
882/// Real number validator
883///
884bool 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
915bool 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
929bool 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///
945IMPLEMENT_DYNAMIC_CLASS(wxIntegerListValidator, wxPropertyListValidator)
946
947bool 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
977bool 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
991bool 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///
1007IMPLEMENT_DYNAMIC_CLASS(wxBoolListValidator, wxPropertyListValidator)
1008
1009bool 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
1025bool 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 = (value == wxT("True"));
1035 property->GetValue() = (bool)boolValue;
1036 return TRUE;
1037}
1038
1039bool wxBoolListValidator::OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1040{
1041 if (!view->GetValueText())
1042 return FALSE;
1043 wxString str(property->GetValue().GetStringRepresentation());
1044
1045 view->GetValueText()->SetValue(str);
1046
1047 if (view->GetValueList()->IsShown())
1048 {
1049 view->GetValueList()->SetStringSelection(str);
1050 }
1051 return TRUE;
1052}
1053
1054bool wxBoolListValidator::OnPrepareControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1055{
1056 if (view->GetConfirmButton())
1057 view->GetConfirmButton()->Enable(FALSE);
1058 if (view->GetCancelButton())
1059 view->GetCancelButton()->Enable(FALSE);
1060 if (view->GetEditButton())
1061 view->GetEditButton()->Enable(TRUE);
1062 if (view->GetValueText())
1063 view->GetValueText()->Enable(FALSE);
1064 return TRUE;
1065}
1066
1067bool wxBoolListValidator::OnPrepareDetailControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1068{
1069 if (view->GetValueList())
1070 {
1071 view->ShowListBoxControl(TRUE);
1072 view->GetValueList()->Enable(TRUE);
1073
1074 view->GetValueList()->Append(wxT("True"));
1075 view->GetValueList()->Append(wxT("False"));
1076 wxChar *currentString = copystring(view->GetValueText()->GetValue());
1077 view->GetValueList()->SetStringSelection(currentString);
1078 delete[] currentString;
1079 }
1080 return TRUE;
1081}
1082
1083bool wxBoolListValidator::OnClearDetailControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1084{
1085 if (view->GetValueList())
1086 {
1087 view->GetValueList()->Clear();
1088 view->ShowListBoxControl(FALSE);
1089 view->GetValueList()->Enable(FALSE);
1090 }
1091 return TRUE;
1092}
1093
1094// Called when the property is double clicked. Extra functionality can be provided,
1095// cycling through possible values.
1096bool wxBoolListValidator::OnDoubleClick(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1097{
1098 if (!view->GetValueText())
1099 return FALSE;
1100 if (property->GetValue().BoolValue())
1101 property->GetValue() = (bool)FALSE;
1102 else
1103 property->GetValue() = (bool)TRUE;
1104 view->DisplayProperty(property);
1105 view->UpdatePropertyDisplayInList(property);
1106 view->OnPropertyChanged(property);
1107 return TRUE;
1108}
1109
1110///
1111/// String validator
1112///
1113IMPLEMENT_DYNAMIC_CLASS(wxStringListValidator, wxPropertyListValidator)
1114
1115wxStringListValidator::wxStringListValidator(wxStringList *list, long flags):
1116 wxPropertyListValidator(flags)
1117{
1118 m_strings = list;
1119 // If no constraint, we just allow the string to be edited.
1120 if (!m_strings && ((m_validatorFlags & wxPROP_ALLOW_TEXT_EDITING) == 0))
1121 m_validatorFlags |= wxPROP_ALLOW_TEXT_EDITING;
1122}
1123
1124bool wxStringListValidator::OnCheckValue(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *parentWindow)
1125{
1126 if (!m_strings)
1127 return TRUE;
1128
1129 if (!view->GetValueText())
1130 return FALSE;
1131 wxString value(view->GetValueText()->GetValue());
1132
1133 if (!m_strings->Member(value.GetData()))
1134 {
1135 wxString str( wxT("Value ") );
1136 str += value.GetData();
1137 str += wxT(" is not valid.");
1138 wxMessageBox( str.GetData(), wxT("Property value error"), wxOK | wxICON_EXCLAMATION, parentWindow);
1139 return FALSE;
1140 }
1141 return TRUE;
1142}
1143
1144// Called when TICK is pressed or focus is lost or view wants to update
1145// the property list.
1146// Does the transferance from the property editing area to the property itself
1147bool wxStringListValidator::OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1148{
1149 if (!view->GetValueText())
1150 return FALSE;
1151 wxString value(view->GetValueText()->GetValue());
1152 property->GetValue() = value ;
1153 return TRUE;
1154}
1155
1156// Called when TICK is pressed or focus is lost or view wants to update
1157// the property list.
1158// Does the transferance from the property editing area to the property itself
1159bool wxStringListValidator::OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1160{
1161 if (!view->GetValueText())
1162 return FALSE;
1163 wxString str(property->GetValue().GetStringRepresentation());
1164 view->GetValueText()->SetValue(str);
1165 if (m_strings && view->GetValueList() && view->GetValueList()->IsShown() && view->GetValueList()->GetCount() > 0)
1166 {
1167 view->GetValueList()->SetStringSelection(str);
1168 }
1169 return TRUE;
1170}
1171
1172bool wxStringListValidator::OnPrepareControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1173{
1174 // Unconstrained
1175 if (!m_strings)
1176 {
1177 if (view->GetEditButton())
1178 view->GetEditButton()->Enable(FALSE);
1179 if (view->GetConfirmButton())
1180 view->GetConfirmButton()->Enable(TRUE);
1181 if (view->GetCancelButton())
1182 view->GetCancelButton()->Enable(TRUE);
1183 if (view->GetValueText())
1184 view->GetValueText()->Enable(TRUE);
1185 return TRUE;
1186 }
1187
1188 // Constrained
1189 if (view->GetValueText())
1190 view->GetValueText()->Enable(FALSE);
1191
1192 if (view->GetEditButton())
1193 view->GetEditButton()->Enable(TRUE);
1194
1195 if (view->GetConfirmButton())
1196 view->GetConfirmButton()->Enable(FALSE);
1197 if (view->GetCancelButton())
1198 view->GetCancelButton()->Enable(FALSE);
1199 return TRUE;
1200}
1201
1202bool wxStringListValidator::OnPrepareDetailControls( wxProperty *property,
1203 wxPropertyListView *view,
1204 wxWindow *WXUNUSED(parentWindow) )
1205{
1206 if (view->GetValueList())
1207 {
1208 view->ShowListBoxControl(TRUE);
1209 view->GetValueList()->Enable(TRUE);
1210 wxStringList::Node *node = m_strings->GetFirst();
1211 while (node)
1212 {
1213 wxChar *s = node->GetData();
1214 view->GetValueList()->Append(s);
1215 node = node->GetNext();
1216 }
1217 wxChar *currentString = property->GetValue().StringValue();
1218 view->GetValueList()->SetStringSelection(currentString);
1219 }
1220 return TRUE;
1221}
1222
1223bool wxStringListValidator::OnClearDetailControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1224{
1225 if (!m_strings)
1226 {
1227 return TRUE;
1228 }
1229
1230 if (view->GetValueList())
1231 {
1232 view->GetValueList()->Clear();
1233 view->ShowListBoxControl(FALSE);
1234 view->GetValueList()->Enable(FALSE);
1235 }
1236 return TRUE;
1237}
1238
1239// Called when the property is double clicked. Extra functionality can be provided,
1240// cycling through possible values.
1241bool wxStringListValidator::OnDoubleClick( wxProperty *property,
1242 wxPropertyListView *view,
1243 wxWindow *WXUNUSED(parentWindow) )
1244{
1245 if (!view->GetValueText())
1246 return FALSE;
1247 if (!m_strings)
1248 return FALSE;
1249
1250 wxStringList::Node *node = m_strings->GetFirst();
1251 wxChar *currentString = property->GetValue().StringValue();
1252 while (node)
1253 {
1254 wxChar *s = node->GetData();
1255 if (wxStrcmp(s, currentString) == 0)
1256 {
1257 wxChar *nextString;
1258 if (node->GetNext())
1259 nextString = node->GetNext()->GetData();
1260 else
1261 nextString = m_strings->GetFirst()->GetData();
1262 property->GetValue() = wxString(nextString);
1263 view->DisplayProperty(property);
1264 view->UpdatePropertyDisplayInList(property);
1265 view->OnPropertyChanged(property);
1266 return TRUE;
1267 }
1268 else node = node->GetNext();
1269 }
1270 return TRUE;
1271}
1272
1273///
1274/// Filename validator
1275///
1276IMPLEMENT_DYNAMIC_CLASS(wxFilenameListValidator, wxPropertyListValidator)
1277
1278wxFilenameListValidator::wxFilenameListValidator(wxString message , wxString wildcard, long flags):
1279 wxPropertyListValidator(flags), m_filenameWildCard(wildcard), m_filenameMessage(message)
1280{
1281}
1282
1283wxFilenameListValidator::~wxFilenameListValidator()
1284{
1285}
1286
1287bool wxFilenameListValidator::OnCheckValue(wxProperty *WXUNUSED(property), wxPropertyListView *WXUNUSED(view), wxWindow *WXUNUSED(parentWindow))
1288{
1289 return TRUE;
1290}
1291
1292// Called when TICK is pressed or focus is lost or view wants to update
1293// the property list.
1294// Does the transferance from the property editing area to the property itself
1295bool wxFilenameListValidator::OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1296{
1297 if (!view->GetValueText())
1298 return FALSE;
1299 wxString value(view->GetValueText()->GetValue());
1300 property->GetValue() = value ;
1301 return TRUE;
1302}
1303
1304// Called when TICK is pressed or focus is lost or view wants to update
1305// the property list.
1306// Does the transferance from the property editing area to the property itself
1307bool wxFilenameListValidator::OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1308{
1309 if (!view->GetValueText())
1310 return FALSE;
1311 wxString str(property->GetValue().GetStringRepresentation());
1312 view->GetValueText()->SetValue(str);
1313 return TRUE;
1314}
1315
1316// Called when the property is double clicked. Extra functionality can be provided,
1317// cycling through possible values.
1318bool wxFilenameListValidator::OnDoubleClick(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
1319{
1320 if (!view->GetValueText())
1321 return FALSE;
1322 OnEdit(property, view, parentWindow);
1323 return TRUE;
1324}
1325
1326bool wxFilenameListValidator::OnPrepareControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1327{
1328 if (view->GetConfirmButton())
1329 view->GetConfirmButton()->Enable(TRUE);
1330 if (view->GetCancelButton())
1331 view->GetCancelButton()->Enable(TRUE);
1332 if (view->GetEditButton())
1333 view->GetEditButton()->Enable(TRUE);
1334 if (view->GetValueText())
1335 view->GetValueText()->Enable((GetFlags() & wxPROP_ALLOW_TEXT_EDITING) == wxPROP_ALLOW_TEXT_EDITING);
1336 return TRUE;
1337}
1338
1339void wxFilenameListValidator::OnEdit(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
1340{
1341 if (!view->GetValueText())
1342 return;
1343
1344 wxString s = wxFileSelector(
1345 m_filenameMessage.GetData(),
1346 wxPathOnly(property->GetValue().StringValue()),
1347 wxFileNameFromPath(property->GetValue().StringValue()),
1348 NULL,
1349 m_filenameWildCard.GetData(),
1350 0,
1351 parentWindow);
1352 if (s != wxT(""))
1353 {
1354 property->GetValue() = s;
1355 view->DisplayProperty(property);
1356 view->UpdatePropertyDisplayInList(property);
1357 view->OnPropertyChanged(property);
1358 }
1359}
1360
1361///
1362/// Colour validator
1363///
1364IMPLEMENT_DYNAMIC_CLASS(wxColourListValidator, wxPropertyListValidator)
1365
1366wxColourListValidator::wxColourListValidator(long flags):
1367 wxPropertyListValidator(flags)
1368{
1369}
1370
1371wxColourListValidator::~wxColourListValidator()
1372{
1373}
1374
1375bool wxColourListValidator::OnCheckValue(wxProperty *WXUNUSED(property), wxPropertyListView *WXUNUSED(view), wxWindow *WXUNUSED(parentWindow))
1376{
1377 return TRUE;
1378}
1379
1380// Called when TICK is pressed or focus is lost or view wants to update
1381// the property list.
1382// Does the transferance from the property editing area to the property itself
1383bool wxColourListValidator::OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1384{
1385 if (!view->GetValueText())
1386 return FALSE;
1387 wxString value(view->GetValueText()->GetValue());
1388
1389 property->GetValue() = value ;
1390 return TRUE;
1391}
1392
1393// Called when TICK is pressed or focus is lost or view wants to update
1394// the property list.
1395// Does the transferance from the property editing area to the property itself
1396bool wxColourListValidator::OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1397{
1398 if (!view->GetValueText())
1399 return FALSE;
1400 wxString str(property->GetValue().GetStringRepresentation());
1401 view->GetValueText()->SetValue(str);
1402 return TRUE;
1403}
1404
1405// Called when the property is double clicked. Extra functionality can be provided,
1406// cycling through possible values.
1407bool wxColourListValidator::OnDoubleClick(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
1408{
1409 if (!view->GetValueText())
1410 return FALSE;
1411 OnEdit(property, view, parentWindow);
1412 return TRUE;
1413}
1414
1415bool wxColourListValidator::OnPrepareControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1416{
1417 if (view->GetConfirmButton())
1418 view->GetConfirmButton()->Enable(TRUE);
1419 if (view->GetCancelButton())
1420 view->GetCancelButton()->Enable(TRUE);
1421 if (view->GetEditButton())
1422 view->GetEditButton()->Enable(TRUE);
1423 if (view->GetValueText())
1424 view->GetValueText()->Enable((GetFlags() & wxPROP_ALLOW_TEXT_EDITING) == wxPROP_ALLOW_TEXT_EDITING);
1425 return TRUE;
1426}
1427
1428void wxColourListValidator::OnEdit(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
1429{
1430 if (!view->GetValueText())
1431 return;
1432
1433 wxChar *s = property->GetValue().StringValue();
1434 int r = 0;
1435 int g = 0;
1436 int b = 0;
1437 if (s)
1438 {
1439 r = wxHexToDec(s);
1440 g = wxHexToDec(s+2);
1441 b = wxHexToDec(s+4);
1442 }
1443
1444 wxColour col(r,g,b);
1445
1446 wxColourData data;
1447 data.SetChooseFull(TRUE);
1448 data.SetColour(col);
1449
1450 for (int i = 0; i < 16; i++)
1451 {
1452 wxColour colour(i*16, i*16, i*16);
1453 data.SetCustomColour(i, colour);
1454 }
1455
1456 wxColourDialog dialog(parentWindow, &data);
1457 if (dialog.ShowModal() != wxID_CANCEL)
1458 {
1459 wxColourData retData = dialog.GetColourData();
1460 col = retData.GetColour();
1461
1462 wxChar buf[7];
1463 wxDecToHex(col.Red(), buf);
1464 wxDecToHex(col.Green(), buf+2);
1465 wxDecToHex(col.Blue(), buf+4);
1466
1467 property->GetValue() = wxString(buf);
1468 view->DisplayProperty(property);
1469 view->UpdatePropertyDisplayInList(property);
1470 view->OnPropertyChanged(property);
1471 }
1472}
1473
1474///
1475/// List of strings validator. For this we need more user interface than
1476/// we get with a property list; so create a new dialog for editing the list.
1477///
1478IMPLEMENT_DYNAMIC_CLASS(wxListOfStringsListValidator, wxPropertyListValidator)
1479
1480wxListOfStringsListValidator::wxListOfStringsListValidator(long flags):
1481 wxPropertyListValidator(flags)
1482{
1483}
1484
1485bool wxListOfStringsListValidator::OnCheckValue(wxProperty *WXUNUSED(property), wxPropertyListView *WXUNUSED(view), wxWindow *WXUNUSED(parentWindow))
1486{
1487 // No constraints for an arbitrary, user-editable list of strings.
1488 return TRUE;
1489}
1490
1491// Called when TICK is pressed or focus is lost or view wants to update
1492// the property list.
1493// Does the transferance from the property editing area to the property itself.
1494// In this case, the user cannot directly edit the string list.
1495bool wxListOfStringsListValidator::OnRetrieveValue(wxProperty *WXUNUSED(property), wxPropertyListView *WXUNUSED(view), wxWindow *WXUNUSED(parentWindow))
1496{
1497 return TRUE;
1498}
1499
1500bool wxListOfStringsListValidator::OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1501{
1502 if (!view->GetValueText())
1503 return FALSE;
1504 wxString str(property->GetValue().GetStringRepresentation());
1505 view->GetValueText()->SetValue(str);
1506 return TRUE;
1507}
1508
1509bool wxListOfStringsListValidator::OnPrepareControls(wxProperty *WXUNUSED(property), wxPropertyListView *view, wxWindow *WXUNUSED(parentWindow))
1510{
1511 if (view->GetEditButton())
1512 view->GetEditButton()->Enable(TRUE);
1513 if (view->GetValueText())
1514 view->GetValueText()->Enable(FALSE);
1515
1516 if (view->GetConfirmButton())
1517 view->GetConfirmButton()->Enable(FALSE);
1518 if (view->GetCancelButton())
1519 view->GetCancelButton()->Enable(FALSE);
1520 return TRUE;
1521}
1522
1523// Called when the property is double clicked. Extra functionality can be provided,
1524// cycling through possible values.
1525bool wxListOfStringsListValidator::OnDoubleClick(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow)
1526{
1527 OnEdit(property, view, parentWindow);
1528 return TRUE;
1529}
1530
1531void wxListOfStringsListValidator::OnEdit( wxProperty *property,
1532 wxPropertyListView *view,
1533 wxWindow *parentWindow )
1534{
1535 // Convert property value to a list of strings for editing
1536 wxStringList *stringList = new wxStringList;
1537
1538 wxPropertyValue *expr = property->GetValue().GetFirst();
1539 while (expr)
1540 {
1541 wxChar *s = expr->StringValue();
1542 if (s)
1543 stringList->Add(s);
1544 expr = expr->GetNext();
1545 }
1546
1547 wxString title(wxT("Editing "));
1548 title += property->GetName();
1549
1550 if (EditStringList(parentWindow, stringList, title.GetData()))
1551 {
1552 wxPropertyValue& oldValue = property->GetValue();
1553 oldValue.ClearList();
1554 wxStringList::Node *node = stringList->GetFirst();
1555 while (node)
1556 {
1557 wxChar *s = node->GetData();
1558 oldValue.Append(new wxPropertyValue(s));
1559
1560 node = node->GetNext();
1561 }
1562
1563 view->DisplayProperty(property);
1564 view->UpdatePropertyDisplayInList(property);
1565 view->OnPropertyChanged(property);
1566 }
1567 delete stringList;
1568}
1569
1570class wxPropertyStringListEditorDialog: public wxDialog
1571{
1572 public:
1573 wxPropertyStringListEditorDialog(wxWindow *parent, const wxString& title,
1574 const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
1575 long windowStyle = wxDEFAULT_DIALOG_STYLE, const wxString& name = wxT("stringEditorDialogBox")):
1576 wxDialog(parent, -1, title, pos, size, windowStyle, name)
1577 {
1578 m_stringList = NULL;
1579 m_stringText = NULL;
1580 m_listBox = NULL;
1581 sm_dialogCancelled = FALSE;
1582 m_currentSelection = -1;
1583 }
1584 ~wxPropertyStringListEditorDialog(void) {}
1585 void OnCloseWindow(wxCloseEvent& event);
1586 void SaveCurrentSelection(void);
1587 void ShowCurrentSelection(void);
1588
1589 void OnOK(wxCommandEvent& event);
1590 void OnCancel(wxCommandEvent& event);
1591 void OnAdd(wxCommandEvent& event);
1592 void OnDelete(wxCommandEvent& event);
1593 void OnStrings(wxCommandEvent& event);
1594 void OnText(wxCommandEvent& event);
1595
1596public:
1597 wxStringList* m_stringList;
1598 wxListBox* m_listBox;
1599 wxTextCtrl* m_stringText;
1600 static bool sm_dialogCancelled;
1601 int m_currentSelection;
1602DECLARE_EVENT_TABLE()
1603};
1604
1605#define wxID_PROP_SL_ADD 3000
1606#define wxID_PROP_SL_DELETE 3001
1607#define wxID_PROP_SL_STRINGS 3002
1608#define wxID_PROP_SL_TEXT 3003
1609
1610BEGIN_EVENT_TABLE(wxPropertyStringListEditorDialog, wxDialog)
1611 EVT_BUTTON(wxID_OK, wxPropertyStringListEditorDialog::OnOK)
1612 EVT_BUTTON(wxID_CANCEL, wxPropertyStringListEditorDialog::OnCancel)
1613 EVT_BUTTON(wxID_PROP_SL_ADD, wxPropertyStringListEditorDialog::OnAdd)
1614 EVT_BUTTON(wxID_PROP_SL_DELETE, wxPropertyStringListEditorDialog::OnDelete)
1615 EVT_LISTBOX(wxID_PROP_SL_STRINGS, wxPropertyStringListEditorDialog::OnStrings)
1616 EVT_TEXT_ENTER(wxID_PROP_SL_TEXT, wxPropertyStringListEditorDialog::OnText)
1617 EVT_CLOSE(wxPropertyStringListEditorDialog::OnCloseWindow)
1618END_EVENT_TABLE()
1619
1620class wxPropertyStringListEditorText: public wxTextCtrl
1621{
1622 public:
1623 wxPropertyStringListEditorText(wxWindow *parent, wxWindowID id, const wxString& val,
1624 const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
1625 long windowStyle = 0, const wxString& name = wxT("text")):
1626 wxTextCtrl(parent, id, val, pos, size, windowStyle, wxDefaultValidator, name)
1627 {
1628 }
1629 void OnKillFocus()
1630 {
1631 wxPropertyStringListEditorDialog *dialog = (wxPropertyStringListEditorDialog *)GetParent();
1632 dialog->SaveCurrentSelection();
1633 }
1634};
1635
1636bool wxPropertyStringListEditorDialog::sm_dialogCancelled = FALSE;
1637
1638// Edit the string list.
1639bool wxListOfStringsListValidator::EditStringList(wxWindow *parent, wxStringList *stringList, const wxChar *title)
1640{
1641 int largeButtonWidth = 60;
1642 int largeButtonHeight = 25;
1643
1644 wxBeginBusyCursor();
1645 wxPropertyStringListEditorDialog *dialog = new wxPropertyStringListEditorDialog(parent,
1646 title, wxPoint(10, 10), wxSize(400, 400), wxDEFAULT_DIALOG_STYLE|wxDIALOG_MODAL);
1647
1648 dialog->m_stringList = stringList;
1649
1650 dialog->m_listBox = new wxListBox(dialog, wxID_PROP_SL_STRINGS,
1651 wxPoint(-1, -1), wxSize(-1, -1), 0, NULL, wxLB_SINGLE);
1652
1653 dialog->m_stringText = new wxPropertyStringListEditorText(dialog,
1654 wxID_PROP_SL_TEXT, wxT(""), wxPoint(5, 240),
1655 wxSize(300, -1), wxPROCESS_ENTER);
1656 dialog->m_stringText->Enable(FALSE);
1657
1658 wxButton *addButton = new wxButton(dialog, wxID_PROP_SL_ADD, wxT("Add"), wxPoint(-1, -1), wxSize(largeButtonWidth, largeButtonHeight));
1659 wxButton *deleteButton = new wxButton(dialog, wxID_PROP_SL_DELETE, wxT("Delete"), wxPoint(-1, -1), wxSize(largeButtonWidth, largeButtonHeight));
1660 wxButton *cancelButton = new wxButton(dialog, wxID_CANCEL, wxT("Cancel"), wxPoint(-1, -1), wxSize(largeButtonWidth, largeButtonHeight));
1661 wxButton *okButton = new wxButton(dialog, wxID_OK, wxT("OK"), wxPoint(-1, -1), wxSize(largeButtonWidth, largeButtonHeight));
1662
1663#ifndef __WXGTK__
1664 okButton->SetDefault();
1665#endif
1666
1667 wxLayoutConstraints *c = new wxLayoutConstraints;
1668
1669 c->top.SameAs (dialog, wxTop, 2);
1670 c->left.SameAs (dialog, wxLeft, 2);
1671 c->right.SameAs (dialog, wxRight, 2);
1672 c->bottom.SameAs (dialog->m_stringText, wxTop, 2);
1673 dialog->m_listBox->SetConstraints(c);
1674
1675 c = new wxLayoutConstraints;
1676 c->left.SameAs (dialog, wxLeft, 2);
1677 c->right.SameAs (dialog, wxRight, 2);
1678 c->bottom.SameAs (addButton, wxTop, 2);
1679 c->height.AsIs();
1680 dialog->m_stringText->SetConstraints(c);
1681
1682 c = new wxLayoutConstraints;
1683 c->bottom.SameAs (dialog, wxBottom, 2);
1684 c->left.SameAs (dialog, wxLeft, 2);
1685 c->width.AsIs();
1686 c->height.AsIs();
1687 addButton->SetConstraints(c);
1688
1689 c = new wxLayoutConstraints;
1690 c->bottom.SameAs (dialog, wxBottom, 2);
1691 c->left.SameAs (addButton, wxRight, 2);
1692 c->width.AsIs();
1693 c->height.AsIs();
1694 deleteButton->SetConstraints(c);
1695
1696 c = new wxLayoutConstraints;
1697 c->bottom.SameAs (dialog, wxBottom, 2);
1698 c->right.SameAs (dialog, wxRight, 2);
1699 c->width.AsIs();
1700 c->height.AsIs();
1701 cancelButton->SetConstraints(c);
1702
1703 c = new wxLayoutConstraints;
1704 c->bottom.SameAs (dialog, wxBottom, 2);
1705 c->right.SameAs (cancelButton, wxLeft, 2);
1706 c->width.AsIs();
1707 c->height.AsIs();
1708 okButton->SetConstraints(c);
1709
1710 wxStringList::Node *node = stringList->GetFirst();
1711 while (node)
1712 {
1713 wxChar *str = node->GetData();
1714 // Save node as client data for each listbox item
1715 dialog->m_listBox->Append(str, (wxChar *)node);
1716 node = node->GetNext();
1717 }
1718
1719 dialog->SetClientSize(310, 305);
1720 dialog->Layout();
1721
1722 dialog->Centre(wxBOTH);
1723 wxEndBusyCursor();
1724 if (dialog->ShowModal() == wxID_CANCEL)
1725 return FALSE;
1726 else
1727 return TRUE;
1728}
1729
1730/*
1731 * String list editor callbacks
1732 *
1733 */
1734
1735void wxPropertyStringListEditorDialog::OnStrings(wxCommandEvent& WXUNUSED(event))
1736{
1737 int sel = m_listBox->GetSelection();
1738 if (sel > -1)
1739 {
1740 m_currentSelection = sel;
1741
1742 ShowCurrentSelection();
1743 }
1744}
1745
1746void wxPropertyStringListEditorDialog::OnDelete(wxCommandEvent& WXUNUSED(event))
1747{
1748 int sel = m_listBox->GetSelection();
1749 if (sel == -1)
1750 return;
1751
1752 wxNode *node = (wxNode *)m_listBox->wxListBox::GetClientData(sel);
1753 if (!node)
1754 return;
1755
1756 m_listBox->Delete(sel);
1757 delete[] (wxChar *)node->GetData();
1758 delete node;
1759 m_currentSelection = -1;
1760 m_stringText->SetValue(_T(""));
1761}
1762
1763void wxPropertyStringListEditorDialog::OnAdd(wxCommandEvent& WXUNUSED(event))
1764{
1765 SaveCurrentSelection();
1766
1767 wxString initialText;
1768 wxNode *node = m_stringList->Add(initialText);
1769 m_listBox->Append(initialText, (void *)node);
1770 m_currentSelection = m_stringList->GetCount() - 1;
1771 m_listBox->SetSelection(m_currentSelection);
1772 ShowCurrentSelection();
1773 m_stringText->SetFocus();
1774}
1775
1776void wxPropertyStringListEditorDialog::OnOK(wxCommandEvent& WXUNUSED(event))
1777{
1778 SaveCurrentSelection();
1779 EndModal(wxID_OK);
1780 // Close(TRUE);
1781 this->Destroy();
1782}
1783
1784void wxPropertyStringListEditorDialog::OnCancel(wxCommandEvent& WXUNUSED(event))
1785{
1786 sm_dialogCancelled = TRUE;
1787 EndModal(wxID_CANCEL);
1788// Close(TRUE);
1789 this->Destroy();
1790}
1791
1792void wxPropertyStringListEditorDialog::OnText(wxCommandEvent& event)
1793{
1794 if (event.GetEventType() == wxEVT_COMMAND_TEXT_ENTER)
1795 {
1796 SaveCurrentSelection();
1797 }
1798}
1799
1800void
1801wxPropertyStringListEditorDialog::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
1802{
1803 SaveCurrentSelection();
1804
1805 Destroy();
1806}
1807
1808void wxPropertyStringListEditorDialog::SaveCurrentSelection()
1809{
1810 if (m_currentSelection == -1)
1811 return;
1812
1813 wxNode *node = (wxNode *)m_listBox->wxListBox::GetClientData(m_currentSelection);
1814 if (!node)
1815 return;
1816
1817 wxString txt(m_stringText->GetValue());
1818 if (node->GetData())
1819 delete[] (wxChar *)node->GetData();
1820 node->SetData((wxObject *)wxStrdup(txt));
1821
1822 m_listBox->SetString(m_currentSelection, (wxChar *)node->GetData());
1823}
1824
1825void wxPropertyStringListEditorDialog::ShowCurrentSelection()
1826{
1827 if (m_currentSelection == -1)
1828 {
1829 m_stringText->SetValue(wxT(""));
1830 return;
1831 }
1832 wxNode *node = (wxNode *)m_listBox->wxListBox::GetClientData(m_currentSelection);
1833 wxChar *txt = (wxChar *)node->GetData();
1834 m_stringText->SetValue(txt);
1835 m_stringText->Enable(TRUE);
1836}
1837
1838
1839#endif // wxUSE_PROPSHEET