]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: samples/propgrid/propgrid.cpp | |
3 | // Purpose: wxPropertyGrid sample | |
4 | // Author: Jaakko Salli | |
5 | // Modified by: | |
6 | // Created: 2004-09-25 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) Jaakko Salli | |
9 | // Licence: wxWindows licence | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // | |
13 | // | |
14 | // NOTES | |
15 | // | |
16 | // * Examples of custom property classes are in sampleprops.cpp. | |
17 | // | |
18 | // * Additional ones can be found below. | |
19 | // | |
20 | // * Currently there is no example of a custom property editor. However, | |
21 | // SpinCtrl editor sample is well-commented. It can be found in | |
22 | // src/propgrid/advprops.cpp. | |
23 | // | |
24 | // * To find code that populates the grid with properties, search for | |
25 | // string "::Populate". | |
26 | // | |
27 | // * To find code that handles property grid changes, search for string | |
28 | // "::OnPropertyGridChange". | |
29 | // | |
30 | ||
31 | // For compilers that support precompilation, includes "wx/wx.h". | |
32 | #include "wx/wxprec.h" | |
33 | ||
34 | #ifdef __BORLANDC__ | |
35 | #pragma hdrstop | |
36 | #endif | |
37 | ||
38 | // for all others, include the necessary headers (this file is usually all you | |
39 | // need because it includes almost all "standard" wxWidgets headers) | |
40 | #ifndef WX_PRECOMP | |
41 | #include "wx/wx.h" | |
42 | #endif | |
43 | ||
44 | #if !wxUSE_PROPGRID | |
45 | #error "Please set wxUSE_PROPGRID to 1 and rebuild the library." | |
46 | #endif | |
47 | ||
48 | #include <wx/numdlg.h> | |
49 | ||
50 | // ----------------------------------------------------------------------- | |
51 | ||
52 | ||
53 | // Main propertygrid header. | |
54 | #include <wx/propgrid/propgrid.h> | |
55 | ||
56 | // Extra property classes. | |
57 | #include <wx/propgrid/advprops.h> | |
58 | ||
59 | // This defines wxPropertyGridManager. | |
60 | #include <wx/propgrid/manager.h> | |
61 | ||
62 | #include "propgrid.h" | |
63 | #include "sampleprops.h" | |
64 | ||
65 | #if wxUSE_DATEPICKCTRL | |
66 | #include <wx/datectrl.h> | |
67 | #endif | |
68 | ||
69 | #include <wx/artprov.h> | |
70 | ||
71 | #ifndef __WXMSW__ | |
72 | #include "../sample.xpm" | |
73 | #endif | |
74 | ||
75 | // ----------------------------------------------------------------------- | |
76 | // wxSampleMultiButtonEditor | |
77 | // A sample editor class that has multiple buttons. | |
78 | // ----------------------------------------------------------------------- | |
79 | ||
80 | class wxSampleMultiButtonEditor : public wxPGTextCtrlEditor | |
81 | { | |
82 | DECLARE_DYNAMIC_CLASS(wxSampleMultiButtonEditor) | |
83 | public: | |
84 | wxSampleMultiButtonEditor() {} | |
85 | virtual ~wxSampleMultiButtonEditor() {} | |
86 | ||
87 | virtual wxPGWindowList CreateControls( wxPropertyGrid* propGrid, | |
88 | wxPGProperty* property, | |
89 | const wxPoint& pos, | |
90 | const wxSize& sz ) const; | |
91 | virtual bool OnEvent( wxPropertyGrid* propGrid, | |
92 | wxPGProperty* property, | |
93 | wxWindow* ctrl, | |
94 | wxEvent& event ) const; | |
95 | }; | |
96 | ||
97 | IMPLEMENT_DYNAMIC_CLASS(wxSampleMultiButtonEditor, wxPGTextCtrlEditor) | |
98 | ||
99 | wxPGWindowList wxSampleMultiButtonEditor::CreateControls( wxPropertyGrid* propGrid, | |
100 | wxPGProperty* property, | |
101 | const wxPoint& pos, | |
102 | const wxSize& sz ) const | |
103 | { | |
104 | // Create and populate buttons-subwindow | |
105 | wxPGMultiButton* buttons = new wxPGMultiButton( propGrid, sz ); | |
106 | ||
107 | // Add two regular buttons | |
108 | buttons->Add( "..." ); | |
109 | buttons->Add( "A" ); | |
110 | // Add a bitmap button | |
111 | buttons->Add( wxArtProvider::GetBitmap(wxART_FOLDER) ); | |
112 | ||
113 | // Create the 'primary' editor control (textctrl in this case) | |
114 | wxPGWindowList wndList = wxPGTextCtrlEditor::CreateControls | |
115 | ( propGrid, property, pos, | |
116 | buttons->GetPrimarySize() ); | |
117 | ||
118 | // Finally, move buttons-subwindow to correct position and make sure | |
119 | // returned wxPGWindowList contains our custom button list. | |
120 | buttons->Finalize(propGrid, pos); | |
121 | ||
122 | wndList.SetSecondary( buttons ); | |
123 | return wndList; | |
124 | } | |
125 | ||
126 | bool wxSampleMultiButtonEditor::OnEvent( wxPropertyGrid* propGrid, | |
127 | wxPGProperty* property, | |
128 | wxWindow* ctrl, | |
129 | wxEvent& event ) const | |
130 | { | |
131 | if ( event.GetEventType() == wxEVT_COMMAND_BUTTON_CLICKED ) | |
132 | { | |
133 | wxPGMultiButton* buttons = (wxPGMultiButton*) propGrid->GetEditorControlSecondary(); | |
134 | ||
135 | if ( event.GetId() == buttons->GetButtonId(0) ) | |
136 | { | |
137 | // Do something when the first button is pressed | |
138 | wxLogDebug("First button pressed"); | |
139 | return false; // Return false since value did not change | |
140 | } | |
141 | if ( event.GetId() == buttons->GetButtonId(1) ) | |
142 | { | |
143 | // Do something when the second button is pressed | |
144 | wxMessageBox("Second button pressed"); | |
145 | return false; // Return false since value did not change | |
146 | } | |
147 | if ( event.GetId() == buttons->GetButtonId(2) ) | |
148 | { | |
149 | // Do something when the third button is pressed | |
150 | wxMessageBox("Third button pressed"); | |
151 | return false; // Return false since value did not change | |
152 | } | |
153 | } | |
154 | return wxPGTextCtrlEditor::OnEvent(propGrid, property, ctrl, event); | |
155 | } | |
156 | ||
157 | // ----------------------------------------------------------------------- | |
158 | // Validator for wxValidator use sample | |
159 | // ----------------------------------------------------------------------- | |
160 | ||
161 | #if wxUSE_VALIDATORS | |
162 | ||
163 | // wxValidator for testing | |
164 | ||
165 | class wxInvalidWordValidator : public wxValidator | |
166 | { | |
167 | public: | |
168 | ||
169 | wxInvalidWordValidator( const wxString& invalidWord ) | |
170 | : wxValidator(), m_invalidWord(invalidWord) | |
171 | { | |
172 | } | |
173 | ||
174 | virtual wxObject* Clone() const | |
175 | { | |
176 | return new wxInvalidWordValidator(m_invalidWord); | |
177 | } | |
178 | ||
179 | virtual bool Validate(wxWindow* WXUNUSED(parent)) | |
180 | { | |
181 | wxTextCtrl* tc = wxDynamicCast(GetWindow(), wxTextCtrl); | |
182 | wxCHECK_MSG(tc, true, wxT("validator window must be wxTextCtrl")); | |
183 | ||
184 | wxString val = tc->GetValue(); | |
185 | ||
186 | if ( val.find(m_invalidWord) == wxString::npos ) | |
187 | return true; | |
188 | ||
189 | ::wxMessageBox(wxString::Format(wxT("%s is not allowed word"),m_invalidWord.c_str()), | |
190 | wxT("Validation Failure")); | |
191 | ||
192 | return false; | |
193 | } | |
194 | ||
195 | private: | |
196 | wxString m_invalidWord; | |
197 | }; | |
198 | ||
199 | #endif // wxUSE_VALIDATORS | |
200 | ||
201 | // ----------------------------------------------------------------------- | |
202 | // wxVectorProperty | |
203 | // ----------------------------------------------------------------------- | |
204 | ||
205 | // See propgridsample.h for wxVector3f class | |
206 | ||
207 | WX_PG_IMPLEMENT_VARIANT_DATA_DUMMY_EQ(wxVector3f) | |
208 | ||
209 | WX_PG_IMPLEMENT_PROPERTY_CLASS(wxVectorProperty,wxPGProperty, | |
210 | wxVector3f,const wxVector3f&,TextCtrl) | |
211 | ||
212 | ||
213 | wxVectorProperty::wxVectorProperty( const wxString& label, | |
214 | const wxString& name, | |
215 | const wxVector3f& value ) | |
216 | : wxPGProperty(label,name) | |
217 | { | |
218 | SetValue( WXVARIANT(value) ); | |
219 | AddPrivateChild( new wxFloatProperty(wxT("X"),wxPG_LABEL,value.x) ); | |
220 | AddPrivateChild( new wxFloatProperty(wxT("Y"),wxPG_LABEL,value.y) ); | |
221 | AddPrivateChild( new wxFloatProperty(wxT("Z"),wxPG_LABEL,value.z) ); | |
222 | } | |
223 | ||
224 | wxVectorProperty::~wxVectorProperty() { } | |
225 | ||
226 | void wxVectorProperty::RefreshChildren() | |
227 | { | |
228 | if ( !GetChildCount() ) return; | |
229 | const wxVector3f& vector = wxVector3fRefFromVariant(m_value); | |
230 | Item(0)->SetValue( vector.x ); | |
231 | Item(1)->SetValue( vector.y ); | |
232 | Item(2)->SetValue( vector.z ); | |
233 | } | |
234 | ||
235 | wxVariant wxVectorProperty::ChildChanged( wxVariant& thisValue, | |
236 | int childIndex, | |
237 | wxVariant& childValue ) const | |
238 | { | |
239 | wxVector3f vector; | |
240 | vector << thisValue; | |
241 | switch ( childIndex ) | |
242 | { | |
243 | case 0: vector.x = childValue.GetDouble(); break; | |
244 | case 1: vector.y = childValue.GetDouble(); break; | |
245 | case 2: vector.z = childValue.GetDouble(); break; | |
246 | } | |
247 | wxVariant newVariant; | |
248 | newVariant << vector; | |
249 | return newVariant; | |
250 | } | |
251 | ||
252 | ||
253 | // ----------------------------------------------------------------------- | |
254 | // wxTriangleProperty | |
255 | // ----------------------------------------------------------------------- | |
256 | ||
257 | // See propgridsample.h for wxTriangle class | |
258 | ||
259 | WX_PG_IMPLEMENT_VARIANT_DATA_DUMMY_EQ(wxTriangle) | |
260 | ||
261 | WX_PG_IMPLEMENT_PROPERTY_CLASS(wxTriangleProperty,wxPGProperty, | |
262 | wxTriangle,const wxTriangle&,TextCtrl) | |
263 | ||
264 | ||
265 | wxTriangleProperty::wxTriangleProperty( const wxString& label, | |
266 | const wxString& name, | |
267 | const wxTriangle& value) | |
268 | : wxPGProperty(label,name) | |
269 | { | |
270 | SetValue( WXVARIANT(value) ); | |
271 | AddPrivateChild( new wxVectorProperty(wxT("A"),wxPG_LABEL,value.a) ); | |
272 | AddPrivateChild( new wxVectorProperty(wxT("B"),wxPG_LABEL,value.b) ); | |
273 | AddPrivateChild( new wxVectorProperty(wxT("C"),wxPG_LABEL,value.c) ); | |
274 | } | |
275 | ||
276 | wxTriangleProperty::~wxTriangleProperty() { } | |
277 | ||
278 | void wxTriangleProperty::RefreshChildren() | |
279 | { | |
280 | if ( !GetChildCount() ) return; | |
281 | const wxTriangle& triangle = wxTriangleRefFromVariant(m_value); | |
282 | Item(0)->SetValue( WXVARIANT(triangle.a) ); | |
283 | Item(1)->SetValue( WXVARIANT(triangle.b) ); | |
284 | Item(2)->SetValue( WXVARIANT(triangle.c) ); | |
285 | } | |
286 | ||
287 | wxVariant wxTriangleProperty::ChildChanged( wxVariant& thisValue, | |
288 | int childIndex, | |
289 | wxVariant& childValue ) const | |
290 | { | |
291 | wxTriangle triangle; | |
292 | triangle << thisValue; | |
293 | const wxVector3f& vector = wxVector3fRefFromVariant(childValue); | |
294 | switch ( childIndex ) | |
295 | { | |
296 | case 0: triangle.a = vector; break; | |
297 | case 1: triangle.b = vector; break; | |
298 | case 2: triangle.c = vector; break; | |
299 | } | |
300 | wxVariant newVariant; | |
301 | newVariant << triangle; | |
302 | return newVariant; | |
303 | } | |
304 | ||
305 | ||
306 | // ----------------------------------------------------------------------- | |
307 | // wxSingleChoiceDialogAdapter (wxPGEditorDialogAdapter sample) | |
308 | // ----------------------------------------------------------------------- | |
309 | ||
310 | class wxSingleChoiceDialogAdapter : public wxPGEditorDialogAdapter | |
311 | { | |
312 | public: | |
313 | ||
314 | wxSingleChoiceDialogAdapter( const wxPGChoices& choices ) | |
315 | : wxPGEditorDialogAdapter(), m_choices(choices) | |
316 | { | |
317 | } | |
318 | ||
319 | virtual bool DoShowDialog( wxPropertyGrid* WXUNUSED(propGrid), | |
320 | wxPGProperty* WXUNUSED(property) ) | |
321 | { | |
322 | wxString s = ::wxGetSingleChoice(wxT("Message"), | |
323 | wxT("Caption"), | |
324 | m_choices.GetLabels()); | |
325 | if ( !s.empty() ) | |
326 | { | |
327 | SetValue(s); | |
328 | return true; | |
329 | } | |
330 | ||
331 | return false; | |
332 | } | |
333 | ||
334 | protected: | |
335 | const wxPGChoices& m_choices; | |
336 | }; | |
337 | ||
338 | ||
339 | class SingleChoiceProperty : public wxStringProperty | |
340 | { | |
341 | public: | |
342 | ||
343 | SingleChoiceProperty( const wxString& label, | |
344 | const wxString& name = wxPG_LABEL, | |
345 | const wxString& value = wxEmptyString ) | |
346 | : wxStringProperty(label, name, value) | |
347 | { | |
348 | // Prepare choices | |
349 | m_choices.Add(wxT("Cat")); | |
350 | m_choices.Add(wxT("Dog")); | |
351 | m_choices.Add(wxT("Gibbon")); | |
352 | m_choices.Add(wxT("Otter")); | |
353 | } | |
354 | ||
355 | // Set editor to have button | |
356 | virtual const wxPGEditor* DoGetEditorClass() const | |
357 | { | |
358 | return wxPGEditor_TextCtrlAndButton; | |
359 | } | |
360 | ||
361 | // Set what happens on button click | |
362 | virtual wxPGEditorDialogAdapter* GetEditorDialog() const | |
363 | { | |
364 | return new wxSingleChoiceDialogAdapter(m_choices); | |
365 | } | |
366 | ||
367 | protected: | |
368 | wxPGChoices m_choices; | |
369 | }; | |
370 | ||
371 | // ----------------------------------------------------------------------- | |
372 | // Menu IDs | |
373 | // ----------------------------------------------------------------------- | |
374 | ||
375 | enum | |
376 | { | |
377 | PGID = 1, | |
378 | TCID, | |
379 | ID_ABOUT, | |
380 | ID_QUIT, | |
381 | ID_APPENDPROP, | |
382 | ID_APPENDCAT, | |
383 | ID_INSERTPROP, | |
384 | ID_INSERTCAT, | |
385 | ID_ENABLE, | |
386 | ID_SETREADONLY, | |
387 | ID_HIDE, | |
388 | ID_DELETE, | |
389 | ID_DELETER, | |
390 | ID_DELETEALL, | |
391 | ID_UNSPECIFY, | |
392 | ID_ITERATE1, | |
393 | ID_ITERATE2, | |
394 | ID_ITERATE3, | |
395 | ID_ITERATE4, | |
396 | ID_CLEARMODIF, | |
397 | ID_FREEZE, | |
398 | ID_DUMPLIST, | |
399 | ID_COLOURSCHEME1, | |
400 | ID_COLOURSCHEME2, | |
401 | ID_COLOURSCHEME3, | |
402 | ID_CATCOLOURS, | |
403 | ID_SETBGCOLOUR, | |
404 | ID_SETBGCOLOURRECUR, | |
405 | ID_STATICLAYOUT, | |
406 | ID_POPULATE1, | |
407 | ID_POPULATE2, | |
408 | ID_COLLAPSE, | |
409 | ID_COLLAPSEALL, | |
410 | ID_GETVALUES, | |
411 | ID_SETVALUES, | |
412 | ID_SETVALUES2, | |
413 | ID_RUNTESTFULL, | |
414 | ID_RUNTESTPARTIAL, | |
415 | ID_FITCOLUMNS, | |
416 | ID_CHANGEFLAGSITEMS, | |
417 | ID_TESTINSERTCHOICE, | |
418 | ID_TESTDELETECHOICE, | |
419 | ID_INSERTPAGE, | |
420 | ID_REMOVEPAGE, | |
421 | ID_SETSPINCTRLEDITOR, | |
422 | ID_SETPROPERTYVALUE, | |
423 | ID_TESTREPLACE, | |
424 | ID_SETCOLUMNS, | |
425 | ID_TESTXRC, | |
426 | ID_ENABLECOMMONVALUES, | |
427 | ID_SELECTSTYLE, | |
428 | ID_SAVESTATE, | |
429 | ID_RESTORESTATE, | |
430 | ID_RUNMINIMAL, | |
431 | ID_ENABLELABELEDITING, | |
432 | ID_VETOCOLDRAG, | |
433 | ID_SHOWHEADER, | |
434 | ID_ONEXTENDEDKEYNAV | |
435 | }; | |
436 | ||
437 | // ----------------------------------------------------------------------- | |
438 | // Event table | |
439 | // ----------------------------------------------------------------------- | |
440 | ||
441 | BEGIN_EVENT_TABLE(FormMain, wxFrame) | |
442 | EVT_IDLE(FormMain::OnIdle) | |
443 | EVT_MOVE(FormMain::OnMove) | |
444 | EVT_SIZE(FormMain::OnResize) | |
445 | ||
446 | // This occurs when a property is selected | |
447 | EVT_PG_SELECTED( PGID, FormMain::OnPropertyGridSelect ) | |
448 | // This occurs when a property value changes | |
449 | EVT_PG_CHANGED( PGID, FormMain::OnPropertyGridChange ) | |
450 | // This occurs just prior a property value is changed | |
451 | EVT_PG_CHANGING( PGID, FormMain::OnPropertyGridChanging ) | |
452 | // This occurs when a mouse moves over another property | |
453 | EVT_PG_HIGHLIGHTED( PGID, FormMain::OnPropertyGridHighlight ) | |
454 | // This occurs when mouse is right-clicked. | |
455 | EVT_PG_RIGHT_CLICK( PGID, FormMain::OnPropertyGridItemRightClick ) | |
456 | // This occurs when mouse is double-clicked. | |
457 | EVT_PG_DOUBLE_CLICK( PGID, FormMain::OnPropertyGridItemDoubleClick ) | |
458 | // This occurs when propgridmanager's page changes. | |
459 | EVT_PG_PAGE_CHANGED( PGID, FormMain::OnPropertyGridPageChange ) | |
460 | // This occurs when user starts editing a property label | |
461 | EVT_PG_LABEL_EDIT_BEGIN( PGID, | |
462 | FormMain::OnPropertyGridLabelEditBegin ) | |
463 | // This occurs when user stops editing a property label | |
464 | EVT_PG_LABEL_EDIT_ENDING( PGID, | |
465 | FormMain::OnPropertyGridLabelEditEnding ) | |
466 | // This occurs when property's editor button (if any) is clicked. | |
467 | EVT_BUTTON( PGID, FormMain::OnPropertyGridButtonClick ) | |
468 | ||
469 | EVT_PG_ITEM_COLLAPSED( PGID, FormMain::OnPropertyGridItemCollapse ) | |
470 | EVT_PG_ITEM_EXPANDED( PGID, FormMain::OnPropertyGridItemExpand ) | |
471 | ||
472 | EVT_PG_COL_BEGIN_DRAG( PGID, FormMain::OnPropertyGridColBeginDrag ) | |
473 | EVT_PG_COL_DRAGGING( PGID, FormMain::OnPropertyGridColDragging ) | |
474 | EVT_PG_COL_END_DRAG( PGID, FormMain::OnPropertyGridColEndDrag ) | |
475 | ||
476 | EVT_TEXT( PGID, FormMain::OnPropertyGridTextUpdate ) | |
477 | ||
478 | // | |
479 | // Rest of the events are not property grid specific | |
480 | EVT_KEY_DOWN( FormMain::OnPropertyGridKeyEvent ) | |
481 | EVT_KEY_UP( FormMain::OnPropertyGridKeyEvent ) | |
482 | ||
483 | EVT_MENU( ID_APPENDPROP, FormMain::OnAppendPropClick ) | |
484 | EVT_MENU( ID_APPENDCAT, FormMain::OnAppendCatClick ) | |
485 | EVT_MENU( ID_INSERTPROP, FormMain::OnInsertPropClick ) | |
486 | EVT_MENU( ID_INSERTCAT, FormMain::OnInsertCatClick ) | |
487 | EVT_MENU( ID_DELETE, FormMain::OnDelPropClick ) | |
488 | EVT_MENU( ID_DELETER, FormMain::OnDelPropRClick ) | |
489 | EVT_MENU( ID_UNSPECIFY, FormMain::OnMisc ) | |
490 | EVT_MENU( ID_DELETEALL, FormMain::OnClearClick ) | |
491 | EVT_MENU( ID_ENABLE, FormMain::OnEnableDisable ) | |
492 | EVT_MENU( ID_SETREADONLY, FormMain::OnSetReadOnly ) | |
493 | EVT_MENU( ID_HIDE, FormMain::OnHide ) | |
494 | ||
495 | EVT_MENU( ID_ITERATE1, FormMain::OnIterate1Click ) | |
496 | EVT_MENU( ID_ITERATE2, FormMain::OnIterate2Click ) | |
497 | EVT_MENU( ID_ITERATE3, FormMain::OnIterate3Click ) | |
498 | EVT_MENU( ID_ITERATE4, FormMain::OnIterate4Click ) | |
499 | EVT_MENU( ID_ONEXTENDEDKEYNAV, FormMain::OnExtendedKeyNav ) | |
500 | EVT_MENU( ID_SETBGCOLOUR, FormMain::OnSetBackgroundColour ) | |
501 | EVT_MENU( ID_SETBGCOLOURRECUR, FormMain::OnSetBackgroundColour ) | |
502 | EVT_MENU( ID_CLEARMODIF, FormMain::OnClearModifyStatusClick ) | |
503 | EVT_MENU( ID_FREEZE, FormMain::OnFreezeClick ) | |
504 | EVT_MENU( ID_ENABLELABELEDITING, FormMain::OnEnableLabelEditing ) | |
505 | EVT_MENU( ID_SHOWHEADER, FormMain::OnShowHeader ) | |
506 | EVT_MENU( ID_DUMPLIST, FormMain::OnDumpList ) | |
507 | ||
508 | EVT_MENU( ID_COLOURSCHEME1, FormMain::OnColourScheme ) | |
509 | EVT_MENU( ID_COLOURSCHEME2, FormMain::OnColourScheme ) | |
510 | EVT_MENU( ID_COLOURSCHEME3, FormMain::OnColourScheme ) | |
511 | EVT_MENU( ID_COLOURSCHEME4, FormMain::OnColourScheme ) | |
512 | ||
513 | EVT_MENU( ID_ABOUT, FormMain::OnAbout ) | |
514 | EVT_MENU( ID_QUIT, FormMain::OnCloseClick ) | |
515 | ||
516 | EVT_MENU( ID_CATCOLOURS, FormMain::OnCatColours ) | |
517 | EVT_MENU( ID_SETCOLUMNS, FormMain::OnSetColumns ) | |
518 | EVT_MENU( ID_TESTXRC, FormMain::OnTestXRC ) | |
519 | EVT_MENU( ID_ENABLECOMMONVALUES, FormMain::OnEnableCommonValues ) | |
520 | EVT_MENU( ID_SELECTSTYLE, FormMain::OnSelectStyle ) | |
521 | ||
522 | EVT_MENU( ID_STATICLAYOUT, FormMain::OnMisc ) | |
523 | EVT_MENU( ID_COLLAPSE, FormMain::OnMisc ) | |
524 | EVT_MENU( ID_COLLAPSEALL, FormMain::OnMisc ) | |
525 | ||
526 | EVT_MENU( ID_POPULATE1, FormMain::OnPopulateClick ) | |
527 | EVT_MENU( ID_POPULATE2, FormMain::OnPopulateClick ) | |
528 | ||
529 | EVT_MENU( ID_GETVALUES, FormMain::OnMisc ) | |
530 | EVT_MENU( ID_SETVALUES, FormMain::OnMisc ) | |
531 | EVT_MENU( ID_SETVALUES2, FormMain::OnMisc ) | |
532 | ||
533 | EVT_MENU( ID_FITCOLUMNS, FormMain::OnFitColumnsClick ) | |
534 | ||
535 | EVT_MENU( ID_CHANGEFLAGSITEMS, FormMain::OnChangeFlagsPropItemsClick ) | |
536 | ||
537 | EVT_MENU( ID_RUNTESTFULL, FormMain::OnMisc ) | |
538 | EVT_MENU( ID_RUNTESTPARTIAL, FormMain::OnMisc ) | |
539 | ||
540 | EVT_MENU( ID_TESTINSERTCHOICE, FormMain::OnInsertChoice ) | |
541 | EVT_MENU( ID_TESTDELETECHOICE, FormMain::OnDeleteChoice ) | |
542 | ||
543 | EVT_MENU( ID_INSERTPAGE, FormMain::OnInsertPage ) | |
544 | EVT_MENU( ID_REMOVEPAGE, FormMain::OnRemovePage ) | |
545 | ||
546 | EVT_MENU( ID_SAVESTATE, FormMain::OnSaveState ) | |
547 | EVT_MENU( ID_RESTORESTATE, FormMain::OnRestoreState ) | |
548 | ||
549 | EVT_MENU( ID_SETSPINCTRLEDITOR, FormMain::OnSetSpinCtrlEditorClick ) | |
550 | EVT_MENU( ID_TESTREPLACE, FormMain::OnTestReplaceClick ) | |
551 | EVT_MENU( ID_SETPROPERTYVALUE, FormMain::OnSetPropertyValue ) | |
552 | ||
553 | EVT_MENU( ID_RUNMINIMAL, FormMain::OnRunMinimalClick ) | |
554 | ||
555 | EVT_CONTEXT_MENU( FormMain::OnContextMenu ) | |
556 | END_EVENT_TABLE() | |
557 | ||
558 | // ----------------------------------------------------------------------- | |
559 | ||
560 | void FormMain::OnMove( wxMoveEvent& event ) | |
561 | { | |
562 | if ( !m_pPropGridManager ) | |
563 | { | |
564 | // this check is here so the frame layout can be tested | |
565 | // without creating propertygrid | |
566 | event.Skip(); | |
567 | return; | |
568 | } | |
569 | ||
570 | // Update position properties | |
571 | int x, y; | |
572 | GetPosition(&x,&y); | |
573 | ||
574 | wxPGProperty* id; | |
575 | ||
576 | // Must check if properties exist (as they may be deleted). | |
577 | ||
578 | // Using m_pPropGridManager, we can scan all pages automatically. | |
579 | id = m_pPropGridManager->GetPropertyByName( wxT("X") ); | |
580 | if ( id ) | |
581 | m_pPropGridManager->SetPropertyValue( id, x ); | |
582 | ||
583 | id = m_pPropGridManager->GetPropertyByName( wxT("Y") ); | |
584 | if ( id ) | |
585 | m_pPropGridManager->SetPropertyValue( id, y ); | |
586 | ||
587 | id = m_pPropGridManager->GetPropertyByName( wxT("Position") ); | |
588 | if ( id ) | |
589 | m_pPropGridManager->SetPropertyValue( id, WXVARIANT(wxPoint(x,y)) ); | |
590 | ||
591 | // Should always call event.Skip() in frame's MoveEvent handler | |
592 | event.Skip(); | |
593 | } | |
594 | ||
595 | // ----------------------------------------------------------------------- | |
596 | ||
597 | void FormMain::OnResize( wxSizeEvent& event ) | |
598 | { | |
599 | if ( !m_pPropGridManager ) | |
600 | { | |
601 | // this check is here so the frame layout can be tested | |
602 | // without creating propertygrid | |
603 | event.Skip(); | |
604 | return; | |
605 | } | |
606 | ||
607 | // Update size properties | |
608 | int w, h; | |
609 | GetSize(&w,&h); | |
610 | ||
611 | wxPGProperty* id; | |
612 | wxPGProperty* p; | |
613 | ||
614 | // Must check if properties exist (as they may be deleted). | |
615 | ||
616 | // Using m_pPropGridManager, we can scan all pages automatically. | |
617 | p = m_pPropGridManager->GetPropertyByName( wxT("Width") ); | |
618 | if ( p && !p->IsValueUnspecified() ) | |
619 | m_pPropGridManager->SetPropertyValue( p, w ); | |
620 | ||
621 | p = m_pPropGridManager->GetPropertyByName( wxT("Height") ); | |
622 | if ( p && !p->IsValueUnspecified() ) | |
623 | m_pPropGridManager->SetPropertyValue( p, h ); | |
624 | ||
625 | id = m_pPropGridManager->GetPropertyByName ( wxT("Size") ); | |
626 | if ( id ) | |
627 | m_pPropGridManager->SetPropertyValue( id, WXVARIANT(wxSize(w,h)) ); | |
628 | ||
629 | // Should always call event.Skip() in frame's SizeEvent handler | |
630 | event.Skip(); | |
631 | } | |
632 | ||
633 | // ----------------------------------------------------------------------- | |
634 | ||
635 | void FormMain::OnPropertyGridChanging( wxPropertyGridEvent& event ) | |
636 | { | |
637 | wxPGProperty* p = event.GetProperty(); | |
638 | ||
639 | if ( p->GetName() == wxT("Font") ) | |
640 | { | |
641 | int res = | |
642 | wxMessageBox(wxString::Format(wxT("'%s' is about to change (to variant of type '%s')\n\nAllow or deny?"), | |
643 | p->GetName().c_str(),event.GetValue().GetType().c_str()), | |
644 | wxT("Testing wxEVT_PG_CHANGING"), wxYES_NO, m_pPropGridManager); | |
645 | ||
646 | if ( res == wxNO ) | |
647 | { | |
648 | wxASSERT(event.CanVeto()); | |
649 | ||
650 | event.Veto(); | |
651 | ||
652 | // Since we ask a question, it is better if we omit any validation | |
653 | // failure behaviour. | |
654 | event.SetValidationFailureBehavior(0); | |
655 | } | |
656 | } | |
657 | } | |
658 | ||
659 | // | |
660 | // Note how we use three types of value getting in this method: | |
661 | // A) event.GetPropertyValueAsXXX | |
662 | // B) event.GetPropertValue, and then variant's GetXXX | |
663 | // C) grid's GetPropertyValueAsXXX(id) | |
664 | // | |
665 | void FormMain::OnPropertyGridChange( wxPropertyGridEvent& event ) | |
666 | { | |
667 | wxPGProperty* property = event.GetProperty(); | |
668 | ||
669 | const wxString& name = property->GetName(); | |
670 | ||
671 | // Properties store values internally as wxVariants, but it is preferred | |
672 | // to use the more modern wxAny at the interface level | |
673 | wxAny value = property->GetValue(); | |
674 | ||
675 | // Don't handle 'unspecified' values | |
676 | if ( value.IsNull() ) | |
677 | return; | |
678 | ||
679 | // | |
680 | // FIXME-VC6: In order to compile on Visual C++ 6.0, wxANY_AS() | |
681 | // macro is used. Unless you want to support this old | |
682 | // compiler in your own code, you can use the more | |
683 | // nicer form value.As<FOO>() instead of | |
684 | // wxANY_AS(value, FOO). | |
685 | // | |
686 | ||
687 | // Some settings are disabled outside Windows platform | |
688 | if ( name == wxT("X") ) | |
689 | SetSize( wxANY_AS(value, int), -1, -1, -1, wxSIZE_USE_EXISTING ); | |
690 | else if ( name == wxT("Y") ) | |
691 | // wxPGVariantToInt is safe long int value getter | |
692 | SetSize ( -1, wxANY_AS(value, int), -1, -1, wxSIZE_USE_EXISTING ); | |
693 | else if ( name == wxT("Width") ) | |
694 | SetSize ( -1, -1, wxANY_AS(value, int), -1, wxSIZE_USE_EXISTING ); | |
695 | else if ( name == wxT("Height") ) | |
696 | SetSize ( -1, -1, -1, wxANY_AS(value, int), wxSIZE_USE_EXISTING ); | |
697 | else if ( name == wxT("Label") ) | |
698 | { | |
699 | SetTitle( wxANY_AS(value, wxString) ); | |
700 | } | |
701 | else if ( name == wxT("Password") ) | |
702 | { | |
703 | static int pwdMode = 0; | |
704 | ||
705 | //m_pPropGridManager->SetPropertyAttribute(property, wxPG_STRING_PASSWORD, (long)pwdMode); | |
706 | ||
707 | pwdMode++; | |
708 | pwdMode &= 1; | |
709 | } | |
710 | else | |
711 | if ( name == wxT("Font") ) | |
712 | { | |
713 | wxFont font = wxANY_AS(value, wxFont); | |
714 | wxASSERT( font.IsOk() ); | |
715 | ||
716 | m_pPropGridManager->SetFont( font ); | |
717 | } | |
718 | else | |
719 | if ( name == wxT("Margin Colour") ) | |
720 | { | |
721 | wxColourPropertyValue cpv = wxANY_AS(value, wxColourPropertyValue); | |
722 | m_pPropGridManager->GetGrid()->SetMarginColour( cpv.m_colour ); | |
723 | } | |
724 | else if ( name == wxT("Cell Colour") ) | |
725 | { | |
726 | wxColourPropertyValue cpv = wxANY_AS(value, wxColourPropertyValue); | |
727 | m_pPropGridManager->GetGrid()->SetCellBackgroundColour( cpv.m_colour ); | |
728 | } | |
729 | else if ( name == wxT("Line Colour") ) | |
730 | { | |
731 | wxColourPropertyValue cpv = wxANY_AS(value, wxColourPropertyValue); | |
732 | m_pPropGridManager->GetGrid()->SetLineColour( cpv.m_colour ); | |
733 | } | |
734 | else if ( name == wxT("Cell Text Colour") ) | |
735 | { | |
736 | wxColourPropertyValue cpv = wxANY_AS(value, wxColourPropertyValue); | |
737 | m_pPropGridManager->GetGrid()->SetCellTextColour( cpv.m_colour ); | |
738 | } | |
739 | } | |
740 | ||
741 | // ----------------------------------------------------------------------- | |
742 | ||
743 | void FormMain::OnPropertyGridSelect( wxPropertyGridEvent& event ) | |
744 | { | |
745 | wxPGProperty* property = event.GetProperty(); | |
746 | if ( property ) | |
747 | { | |
748 | m_itemEnable->Enable( TRUE ); | |
749 | if ( property->IsEnabled() ) | |
750 | m_itemEnable->SetItemLabel( wxT("Disable") ); | |
751 | else | |
752 | m_itemEnable->SetItemLabel( wxT("Enable") ); | |
753 | } | |
754 | else | |
755 | { | |
756 | m_itemEnable->Enable( FALSE ); | |
757 | } | |
758 | ||
759 | #if wxUSE_STATUSBAR | |
760 | wxPGProperty* prop = event.GetProperty(); | |
761 | wxStatusBar* sb = GetStatusBar(); | |
762 | if ( prop ) | |
763 | { | |
764 | wxString text(wxT("Selected: ")); | |
765 | text += m_pPropGridManager->GetPropertyLabel( prop ); | |
766 | sb->SetStatusText ( text ); | |
767 | } | |
768 | #endif | |
769 | } | |
770 | ||
771 | // ----------------------------------------------------------------------- | |
772 | ||
773 | void FormMain::OnPropertyGridPageChange( wxPropertyGridEvent& WXUNUSED(event) ) | |
774 | { | |
775 | #if wxUSE_STATUSBAR | |
776 | wxStatusBar* sb = GetStatusBar(); | |
777 | wxString text(wxT("Page Changed: ")); | |
778 | text += m_pPropGridManager->GetPageName(m_pPropGridManager->GetSelectedPage()); | |
779 | sb->SetStatusText( text ); | |
780 | #endif | |
781 | } | |
782 | ||
783 | // ----------------------------------------------------------------------- | |
784 | ||
785 | void FormMain::OnPropertyGridLabelEditBegin( wxPropertyGridEvent& event ) | |
786 | { | |
787 | wxLogMessage("wxPG_EVT_LABEL_EDIT_BEGIN(%s)", | |
788 | event.GetProperty()->GetLabel().c_str()); | |
789 | } | |
790 | ||
791 | // ----------------------------------------------------------------------- | |
792 | ||
793 | void FormMain::OnPropertyGridLabelEditEnding( wxPropertyGridEvent& event ) | |
794 | { | |
795 | wxLogMessage("wxPG_EVT_LABEL_EDIT_ENDING(%s)", | |
796 | event.GetProperty()->GetLabel().c_str()); | |
797 | } | |
798 | ||
799 | // ----------------------------------------------------------------------- | |
800 | ||
801 | void FormMain::OnPropertyGridHighlight( wxPropertyGridEvent& WXUNUSED(event) ) | |
802 | { | |
803 | } | |
804 | ||
805 | // ----------------------------------------------------------------------- | |
806 | ||
807 | void FormMain::OnPropertyGridItemRightClick( wxPropertyGridEvent& event ) | |
808 | { | |
809 | #if wxUSE_STATUSBAR | |
810 | wxPGProperty* prop = event.GetProperty(); | |
811 | wxStatusBar* sb = GetStatusBar(); | |
812 | if ( prop ) | |
813 | { | |
814 | wxString text(wxT("Right-clicked: ")); | |
815 | text += prop->GetLabel(); | |
816 | text += wxT(", name="); | |
817 | text += m_pPropGridManager->GetPropertyName(prop); | |
818 | sb->SetStatusText( text ); | |
819 | } | |
820 | else | |
821 | { | |
822 | sb->SetStatusText( wxEmptyString ); | |
823 | } | |
824 | #endif | |
825 | } | |
826 | ||
827 | // ----------------------------------------------------------------------- | |
828 | ||
829 | void FormMain::OnPropertyGridItemDoubleClick( wxPropertyGridEvent& event ) | |
830 | { | |
831 | #if wxUSE_STATUSBAR | |
832 | wxPGProperty* prop = event.GetProperty(); | |
833 | wxStatusBar* sb = GetStatusBar(); | |
834 | if ( prop ) | |
835 | { | |
836 | wxString text(wxT("Double-clicked: ")); | |
837 | text += prop->GetLabel(); | |
838 | text += wxT(", name="); | |
839 | text += m_pPropGridManager->GetPropertyName(prop); | |
840 | sb->SetStatusText ( text ); | |
841 | } | |
842 | else | |
843 | { | |
844 | sb->SetStatusText ( wxEmptyString ); | |
845 | } | |
846 | #endif | |
847 | } | |
848 | ||
849 | // ----------------------------------------------------------------------- | |
850 | ||
851 | void FormMain::OnPropertyGridButtonClick ( wxCommandEvent& ) | |
852 | { | |
853 | #if wxUSE_STATUSBAR | |
854 | wxPGProperty* prop = m_pPropGridManager->GetSelection(); | |
855 | wxStatusBar* sb = GetStatusBar(); | |
856 | if ( prop ) | |
857 | { | |
858 | wxString text(wxT("Button clicked: ")); | |
859 | text += m_pPropGridManager->GetPropertyLabel(prop); | |
860 | text += wxT(", name="); | |
861 | text += m_pPropGridManager->GetPropertyName(prop); | |
862 | sb->SetStatusText( text ); | |
863 | } | |
864 | else | |
865 | { | |
866 | ::wxMessageBox(wxT("SHOULD NOT HAPPEN!!!")); | |
867 | } | |
868 | #endif | |
869 | } | |
870 | ||
871 | // ----------------------------------------------------------------------- | |
872 | ||
873 | void FormMain::OnPropertyGridItemCollapse( wxPropertyGridEvent& ) | |
874 | { | |
875 | wxLogMessage(wxT("Item was Collapsed")); | |
876 | } | |
877 | ||
878 | // ----------------------------------------------------------------------- | |
879 | ||
880 | void FormMain::OnPropertyGridItemExpand( wxPropertyGridEvent& ) | |
881 | { | |
882 | wxLogMessage(wxT("Item was Expanded")); | |
883 | } | |
884 | ||
885 | // ----------------------------------------------------------------------- | |
886 | ||
887 | void FormMain::OnPropertyGridColBeginDrag( wxPropertyGridEvent& event ) | |
888 | { | |
889 | if ( m_itemVetoDragging->IsChecked() ) | |
890 | { | |
891 | wxLogMessage("Splitter %i resize was vetoed", event.GetColumn()); | |
892 | event.Veto(); | |
893 | } | |
894 | else | |
895 | { | |
896 | wxLogMessage("Splitter %i resize began", event.GetColumn()); | |
897 | } | |
898 | } | |
899 | ||
900 | // ----------------------------------------------------------------------- | |
901 | ||
902 | void FormMain::OnPropertyGridColDragging( wxPropertyGridEvent& event ) | |
903 | { | |
904 | wxUnusedVar(event); | |
905 | // For now, let's not spam the log output | |
906 | //wxLogMessage("Splitter %i is being resized", event.GetColumn()); | |
907 | } | |
908 | ||
909 | // ----------------------------------------------------------------------- | |
910 | ||
911 | void FormMain::OnPropertyGridColEndDrag( wxPropertyGridEvent& event ) | |
912 | { | |
913 | wxLogMessage("Splitter %i resize ended", event.GetColumn()); | |
914 | } | |
915 | ||
916 | // ----------------------------------------------------------------------- | |
917 | ||
918 | // EVT_TEXT handling | |
919 | void FormMain::OnPropertyGridTextUpdate( wxCommandEvent& event ) | |
920 | { | |
921 | event.Skip(); | |
922 | } | |
923 | ||
924 | // ----------------------------------------------------------------------- | |
925 | ||
926 | void FormMain::OnPropertyGridKeyEvent( wxKeyEvent& WXUNUSED(event) ) | |
927 | { | |
928 | // Occurs on wxGTK mostly, but not wxMSW. | |
929 | } | |
930 | ||
931 | // ----------------------------------------------------------------------- | |
932 | ||
933 | void FormMain::OnLabelTextChange( wxCommandEvent& WXUNUSED(event) ) | |
934 | { | |
935 | // Uncomment following to allow property label modify in real-time | |
936 | // wxPGProperty& p = m_pPropGridManager->GetGrid()->GetSelection(); | |
937 | // if ( !p.IsOk() ) return; | |
938 | // m_pPropGridManager->SetPropertyLabel( p, m_tcPropLabel->DoGetValue() ); | |
939 | } | |
940 | ||
941 | // ----------------------------------------------------------------------- | |
942 | ||
943 | static const wxChar* _fs_windowstyle_labels[] = { | |
944 | wxT("wxSIMPLE_BORDER"), | |
945 | wxT("wxDOUBLE_BORDER"), | |
946 | wxT("wxSUNKEN_BORDER"), | |
947 | wxT("wxRAISED_BORDER"), | |
948 | wxT("wxNO_BORDER"), | |
949 | wxT("wxTRANSPARENT_WINDOW"), | |
950 | wxT("wxTAB_TRAVERSAL"), | |
951 | wxT("wxWANTS_CHARS"), | |
952 | #if wxNO_FULL_REPAINT_ON_RESIZE | |
953 | wxT("wxNO_FULL_REPAINT_ON_RESIZE"), | |
954 | #endif | |
955 | wxT("wxVSCROLL"), | |
956 | wxT("wxALWAYS_SHOW_SB"), | |
957 | wxT("wxCLIP_CHILDREN"), | |
958 | #if wxFULL_REPAINT_ON_RESIZE | |
959 | wxT("wxFULL_REPAINT_ON_RESIZE"), | |
960 | #endif | |
961 | (const wxChar*) NULL // terminator is always needed | |
962 | }; | |
963 | ||
964 | static const long _fs_windowstyle_values[] = { | |
965 | wxSIMPLE_BORDER, | |
966 | wxDOUBLE_BORDER, | |
967 | wxSUNKEN_BORDER, | |
968 | wxRAISED_BORDER, | |
969 | wxNO_BORDER, | |
970 | wxTRANSPARENT_WINDOW, | |
971 | wxTAB_TRAVERSAL, | |
972 | wxWANTS_CHARS, | |
973 | #if wxNO_FULL_REPAINT_ON_RESIZE | |
974 | wxNO_FULL_REPAINT_ON_RESIZE, | |
975 | #endif | |
976 | wxVSCROLL, | |
977 | wxALWAYS_SHOW_SB, | |
978 | wxCLIP_CHILDREN, | |
979 | #if wxFULL_REPAINT_ON_RESIZE | |
980 | wxFULL_REPAINT_ON_RESIZE | |
981 | #endif | |
982 | }; | |
983 | ||
984 | static const wxChar* _fs_framestyle_labels[] = { | |
985 | wxT("wxCAPTION"), | |
986 | wxT("wxMINIMIZE"), | |
987 | wxT("wxMAXIMIZE"), | |
988 | wxT("wxCLOSE_BOX"), | |
989 | wxT("wxSTAY_ON_TOP"), | |
990 | wxT("wxSYSTEM_MENU"), | |
991 | wxT("wxRESIZE_BORDER"), | |
992 | wxT("wxFRAME_TOOL_WINDOW"), | |
993 | wxT("wxFRAME_NO_TASKBAR"), | |
994 | wxT("wxFRAME_FLOAT_ON_PARENT"), | |
995 | wxT("wxFRAME_SHAPED"), | |
996 | (const wxChar*) NULL | |
997 | }; | |
998 | ||
999 | static const long _fs_framestyle_values[] = { | |
1000 | wxCAPTION, | |
1001 | wxMINIMIZE, | |
1002 | wxMAXIMIZE, | |
1003 | wxCLOSE_BOX, | |
1004 | wxSTAY_ON_TOP, | |
1005 | wxSYSTEM_MENU, | |
1006 | wxRESIZE_BORDER, | |
1007 | wxFRAME_TOOL_WINDOW, | |
1008 | wxFRAME_NO_TASKBAR, | |
1009 | wxFRAME_FLOAT_ON_PARENT, | |
1010 | wxFRAME_SHAPED | |
1011 | }; | |
1012 | ||
1013 | // ----------------------------------------------------------------------- | |
1014 | ||
1015 | void FormMain::OnTestXRC(wxCommandEvent& WXUNUSED(event)) | |
1016 | { | |
1017 | wxMessageBox(wxT("Sorrt, not yet implemented")); | |
1018 | } | |
1019 | ||
1020 | void FormMain::OnEnableCommonValues(wxCommandEvent& WXUNUSED(event)) | |
1021 | { | |
1022 | wxPGProperty* prop = m_pPropGridManager->GetSelection(); | |
1023 | if ( prop ) | |
1024 | prop->EnableCommonValue(); | |
1025 | else | |
1026 | wxMessageBox(wxT("First select a property")); | |
1027 | } | |
1028 | ||
1029 | void FormMain::PopulateWithStandardItems () | |
1030 | { | |
1031 | wxPropertyGridManager* pgman = m_pPropGridManager; | |
1032 | wxPropertyGridPage* pg = pgman->GetPage(wxT("Standard Items")); | |
1033 | ||
1034 | // Append is ideal way to add items to wxPropertyGrid. | |
1035 | pg->Append( new wxPropertyCategory(wxT("Appearance"),wxPG_LABEL) ); | |
1036 | ||
1037 | pg->Append( new wxStringProperty(wxT("Label"),wxPG_LABEL,GetTitle()) ); | |
1038 | pg->Append( new wxFontProperty(wxT("Font"),wxPG_LABEL) ); | |
1039 | pg->SetPropertyHelpString ( wxT("Font"), wxT("Editing this will change font used in the property grid.") ); | |
1040 | ||
1041 | pg->Append( new wxSystemColourProperty(wxT("Margin Colour"),wxPG_LABEL, | |
1042 | pg->GetGrid()->GetMarginColour()) ); | |
1043 | ||
1044 | pg->Append( new wxSystemColourProperty(wxT("Cell Colour"),wxPG_LABEL, | |
1045 | pg->GetGrid()->GetCellBackgroundColour()) ); | |
1046 | pg->Append( new wxSystemColourProperty(wxT("Cell Text Colour"),wxPG_LABEL, | |
1047 | pg->GetGrid()->GetCellTextColour()) ); | |
1048 | pg->Append( new wxSystemColourProperty(wxT("Line Colour"),wxPG_LABEL, | |
1049 | pg->GetGrid()->GetLineColour()) ); | |
1050 | pg->Append( new wxFlagsProperty(wxT("Window Styles"),wxPG_LABEL, | |
1051 | m_combinedFlags, GetWindowStyle()) ); | |
1052 | ||
1053 | //pg->SetPropertyAttribute(wxT("Window Styles"),wxPG_BOOL_USE_CHECKBOX,true,wxPG_RECURSE); | |
1054 | ||
1055 | pg->Append( new wxCursorProperty(wxT("Cursor"),wxPG_LABEL) ); | |
1056 | ||
1057 | pg->Append( new wxPropertyCategory(wxT("Position"),wxT("PositionCategory")) ); | |
1058 | pg->SetPropertyHelpString( wxT("PositionCategory"), wxT("Change in items in this category will cause respective changes in frame.") ); | |
1059 | ||
1060 | // Let's demonstrate 'Units' attribute here | |
1061 | ||
1062 | // Note that we use many attribute constants instead of strings here | |
1063 | // (for instance, wxPG_ATTR_MIN, instead of wxT("min")). | |
1064 | // Using constant may reduce binary size. | |
1065 | ||
1066 | pg->Append( new wxIntProperty(wxT("Height"),wxPG_LABEL,480) ); | |
1067 | pg->SetPropertyAttribute(wxT("Height"), wxPG_ATTR_MIN, (long)10 ); | |
1068 | pg->SetPropertyAttribute(wxT("Height"), wxPG_ATTR_MAX, (long)2048 ); | |
1069 | pg->SetPropertyAttribute(wxT("Height"), wxPG_ATTR_UNITS, wxT("Pixels") ); | |
1070 | ||
1071 | // Set value to unspecified so that Hint attribute will be demonstrated | |
1072 | pg->SetPropertyValueUnspecified("Height"); | |
1073 | pg->SetPropertyAttribute("Height", wxPG_ATTR_HINT, | |
1074 | "Enter new height for window" ); | |
1075 | ||
1076 | // Difference between hint and help string is that the hint is shown in | |
1077 | // an empty value cell, while help string is shown either in the | |
1078 | // description text box, as a tool tip, or on the status bar. | |
1079 | pg->SetPropertyHelpString("Height", | |
1080 | "This property uses attributes \"Units\" and \"Hint\"." ); | |
1081 | ||
1082 | pg->Append( new wxIntProperty(wxT("Width"),wxPG_LABEL,640) ); | |
1083 | pg->SetPropertyAttribute(wxT("Width"), wxPG_ATTR_MIN, (long)10 ); | |
1084 | pg->SetPropertyAttribute(wxT("Width"), wxPG_ATTR_MAX, (long)2048 ); | |
1085 | pg->SetPropertyAttribute(wxT("Width"), wxPG_ATTR_UNITS, wxT("Pixels") ); | |
1086 | ||
1087 | pg->SetPropertyValueUnspecified(wxT("Width")); | |
1088 | pg->SetPropertyAttribute("Width", wxPG_ATTR_HINT, | |
1089 | "Enter new width for window" ); | |
1090 | pg->SetPropertyHelpString("Width", | |
1091 | "This property uses attributes \"Units\" and \"Hint\"." ); | |
1092 | ||
1093 | pg->Append( new wxIntProperty(wxT("X"),wxPG_LABEL,10) ); | |
1094 | pg->SetPropertyAttribute(wxT("X"), wxPG_ATTR_UNITS, wxT("Pixels") ); | |
1095 | pg->SetPropertyHelpString(wxT("X"), wxT("This property uses \"Units\" attribute.") ); | |
1096 | ||
1097 | pg->Append( new wxIntProperty(wxT("Y"),wxPG_LABEL,10) ); | |
1098 | pg->SetPropertyAttribute(wxT("Y"), wxPG_ATTR_UNITS, wxT("Pixels") ); | |
1099 | pg->SetPropertyHelpString(wxT("Y"), wxT("This property uses \"Units\" attribute.") ); | |
1100 | ||
1101 | const wxChar* disabledHelpString = wxT("This property is simply disabled. In order to have label disabled as well, ") | |
1102 | wxT("you need to set wxPG_EX_GREY_LABEL_WHEN_DISABLED using SetExtraStyle."); | |
1103 | ||
1104 | pg->Append( new wxPropertyCategory(wxT("Environment"),wxPG_LABEL) ); | |
1105 | pg->Append( new wxStringProperty(wxT("Operating System"),wxPG_LABEL,::wxGetOsDescription()) ); | |
1106 | ||
1107 | pg->Append( new wxStringProperty(wxT("User Id"),wxPG_LABEL,::wxGetUserId()) ); | |
1108 | pg->Append( new wxDirProperty(wxT("User Home"),wxPG_LABEL,::wxGetUserHome()) ); | |
1109 | pg->Append( new wxStringProperty(wxT("User Name"),wxPG_LABEL,::wxGetUserName()) ); | |
1110 | ||
1111 | // Disable some of them | |
1112 | pg->DisableProperty( wxT("Operating System") ); | |
1113 | pg->DisableProperty( wxT("User Id") ); | |
1114 | pg->DisableProperty( wxT("User Name") ); | |
1115 | ||
1116 | pg->SetPropertyHelpString( wxT("Operating System"), disabledHelpString ); | |
1117 | pg->SetPropertyHelpString( wxT("User Id"), disabledHelpString ); | |
1118 | pg->SetPropertyHelpString( wxT("User Name"), disabledHelpString ); | |
1119 | ||
1120 | pg->Append( new wxPropertyCategory(wxT("More Examples"),wxPG_LABEL) ); | |
1121 | ||
1122 | pg->Append( new wxFontDataProperty( wxT("FontDataProperty"), wxPG_LABEL) ); | |
1123 | pg->SetPropertyHelpString( wxT("FontDataProperty"), | |
1124 | wxT("This demonstrates wxFontDataProperty class defined in this sample app. ") | |
1125 | wxT("It is exactly like wxFontProperty from the library, but also has colour sub-property.") | |
1126 | ); | |
1127 | ||
1128 | pg->Append( new wxDirsProperty(wxT("DirsProperty"),wxPG_LABEL) ); | |
1129 | pg->SetPropertyHelpString( wxT("DirsProperty"), | |
1130 | wxT("This demonstrates wxDirsProperty class defined in this sample app. ") | |
1131 | wxT("It is built with WX_PG_IMPLEMENT_ARRAYSTRING_PROPERTY_WITH_VALIDATOR macro, ") | |
1132 | wxT("with custom action (dir dialog popup) defined.") | |
1133 | ); | |
1134 | ||
1135 | wxArrayDouble arrdbl; | |
1136 | arrdbl.Add(-1.0); | |
1137 | arrdbl.Add(-0.5); | |
1138 | arrdbl.Add(0.0); | |
1139 | arrdbl.Add(0.5); | |
1140 | arrdbl.Add(1.0); | |
1141 | ||
1142 | pg->Append( new wxArrayDoubleProperty(wxT("ArrayDoubleProperty"),wxPG_LABEL,arrdbl) ); | |
1143 | //pg->SetPropertyAttribute(wxT("ArrayDoubleProperty"),wxPG_FLOAT_PRECISION,(long)2); | |
1144 | pg->SetPropertyHelpString( wxT("ArrayDoubleProperty"), | |
1145 | wxT("This demonstrates wxArrayDoubleProperty class defined in this sample app. ") | |
1146 | wxT("It is an example of a custom list editor property.") | |
1147 | ); | |
1148 | ||
1149 | pg->Append( new wxLongStringProperty(wxT("Information"),wxPG_LABEL, | |
1150 | wxT("Editing properties will have immediate effect on this window, ") | |
1151 | wxT("and vice versa (atleast in most cases, that is).") | |
1152 | ) ); | |
1153 | pg->SetPropertyHelpString( wxT("Information"), | |
1154 | wxT("This property is read-only.") ); | |
1155 | ||
1156 | pg->SetPropertyReadOnly( wxT("Information"), true ); | |
1157 | ||
1158 | // | |
1159 | // Set test information for cells in columns 3 and 4 | |
1160 | // (reserve column 2 for displaying units) | |
1161 | wxPropertyGridIterator it; | |
1162 | wxBitmap bmp = wxArtProvider::GetBitmap(wxART_FOLDER); | |
1163 | ||
1164 | for ( it = pg->GetGrid()->GetIterator(); | |
1165 | !it.AtEnd(); | |
1166 | it++ ) | |
1167 | { | |
1168 | wxPGProperty* p = *it; | |
1169 | if ( p->IsCategory() ) | |
1170 | continue; | |
1171 | ||
1172 | pg->SetPropertyCell( p, 3, wxT("Cell 3"), bmp ); | |
1173 | pg->SetPropertyCell( p, 4, wxT("Cell 4"), wxNullBitmap, *wxWHITE, *wxBLACK ); | |
1174 | } | |
1175 | } | |
1176 | ||
1177 | // ----------------------------------------------------------------------- | |
1178 | ||
1179 | void FormMain::PopulateWithExamples () | |
1180 | { | |
1181 | wxPropertyGridManager* pgman = m_pPropGridManager; | |
1182 | wxPropertyGridPage* pg = pgman->GetPage(wxT("Examples")); | |
1183 | wxPGProperty* pid; | |
1184 | wxPGProperty* prop; | |
1185 | ||
1186 | //pg->Append( new wxPropertyCategory(wxT("Examples (low priority)"),wxT("Examples")) ); | |
1187 | //pg->SetPropertyHelpString ( wxT("Examples"), wxT("This category has example of (almost) every built-in property class.") ); | |
1188 | ||
1189 | #if wxUSE_SPINBTN | |
1190 | pg->Append( new wxIntProperty ( wxT("SpinCtrl"), wxPG_LABEL, 0 ) ); | |
1191 | ||
1192 | pg->SetPropertyEditor( wxT("SpinCtrl"), wxPGEditor_SpinCtrl ); | |
1193 | pg->SetPropertyAttribute( wxT("SpinCtrl"), wxPG_ATTR_MIN, (long)-10 ); // Use constants instead of string | |
1194 | pg->SetPropertyAttribute( wxT("SpinCtrl"), wxPG_ATTR_MAX, (long)16384 ); // for reduced binary size. | |
1195 | pg->SetPropertyAttribute( wxT("SpinCtrl"), wxT("Step"), (long)2 ); | |
1196 | pg->SetPropertyAttribute( wxT("SpinCtrl"), wxT("MotionSpin"), true ); | |
1197 | //pg->SetPropertyAttribute( wxT("SpinCtrl"), wxT("Wrap"), true ); | |
1198 | ||
1199 | pg->SetPropertyHelpString( wxT("SpinCtrl"), | |
1200 | wxT("This is regular wxIntProperty, which editor has been ") | |
1201 | wxT("changed to wxPGEditor_SpinCtrl. Note however that ") | |
1202 | wxT("static wxPropertyGrid::RegisterAdditionalEditors() ") | |
1203 | wxT("needs to be called prior to using it.")); | |
1204 | ||
1205 | #endif | |
1206 | ||
1207 | // Add bool property | |
1208 | pg->Append( new wxBoolProperty( wxT("BoolProperty"), wxPG_LABEL, false ) ); | |
1209 | ||
1210 | // Add bool property with check box | |
1211 | pg->Append( new wxBoolProperty( wxT("BoolProperty with CheckBox"), wxPG_LABEL, false ) ); | |
1212 | pg->SetPropertyAttribute( wxT("BoolProperty with CheckBox"), | |
1213 | wxPG_BOOL_USE_CHECKBOX, | |
1214 | true ); | |
1215 | ||
1216 | pg->SetPropertyHelpString( wxT("BoolProperty with CheckBox"), | |
1217 | wxT("Property attribute wxPG_BOOL_USE_CHECKBOX has been set to true.") ); | |
1218 | ||
1219 | prop = pg->Append( new wxFloatProperty("FloatProperty", | |
1220 | wxPG_LABEL, | |
1221 | 1234500.23) ); | |
1222 | prop->SetAttribute("Min", -100.12); | |
1223 | ||
1224 | // A string property that can be edited in a separate editor dialog. | |
1225 | pg->Append( new wxLongStringProperty( wxT("LongStringProperty"), wxT("LongStringProp"), | |
1226 | wxT("This is much longer string than the first one. Edit it by clicking the button.") ) ); | |
1227 | ||
1228 | // A property that edits a wxArrayString. | |
1229 | wxArrayString example_array; | |
1230 | example_array.Add( wxT("String 1")); | |
1231 | example_array.Add( wxT("String 2")); | |
1232 | example_array.Add( wxT("String 3")); | |
1233 | pg->Append( new wxArrayStringProperty( wxT("ArrayStringProperty"), wxPG_LABEL, | |
1234 | example_array) ); | |
1235 | ||
1236 | // Test adding same category multiple times ( should not actually create a new one ) | |
1237 | //pg->Append( new wxPropertyCategory(wxT("Examples (low priority)"),wxT("Examples")) ); | |
1238 | ||
1239 | // A file selector property. Note that argument between name | |
1240 | // and initial value is wildcard (format same as in wxFileDialog). | |
1241 | prop = new wxFileProperty( wxT("FileProperty"), wxT("TextFile") ); | |
1242 | pg->Append( prop ); | |
1243 | ||
1244 | prop->SetAttribute(wxPG_FILE_WILDCARD,wxT("Text Files (*.txt)|*.txt")); | |
1245 | prop->SetAttribute(wxPG_FILE_DIALOG_TITLE,wxT("Custom File Dialog Title")); | |
1246 | prop->SetAttribute(wxPG_FILE_SHOW_FULL_PATH,false); | |
1247 | ||
1248 | #ifdef __WXMSW__ | |
1249 | prop->SetAttribute(wxPG_FILE_SHOW_RELATIVE_PATH,wxT("C:\\Windows")); | |
1250 | pg->SetPropertyValue(prop,wxT("C:\\Windows\\System32\\msvcrt71.dll")); | |
1251 | #endif | |
1252 | ||
1253 | #if wxUSE_IMAGE | |
1254 | // An image file property. Arguments are just like for FileProperty, but | |
1255 | // wildcard is missing (it is autogenerated from supported image formats). | |
1256 | // If you really need to override it, create property separately, and call | |
1257 | // its SetWildcard method. | |
1258 | pg->Append( new wxImageFileProperty( wxT("ImageFile"), wxPG_LABEL ) ); | |
1259 | #endif | |
1260 | ||
1261 | pid = pg->Append( new wxColourProperty(wxT("ColourProperty"),wxPG_LABEL,*wxRED) ); | |
1262 | pg->SetPropertyEditor( wxT("ColourProperty"), wxPGEditor_ComboBox ); | |
1263 | pg->GetProperty(wxT("ColourProperty"))->SetAutoUnspecified(true); | |
1264 | pg->SetPropertyHelpString( wxT("ColourProperty"), | |
1265 | wxT("wxPropertyGrid::SetPropertyEditor method has been used to change ") | |
1266 | wxT("editor of this property to wxPGEditor_ComboBox)")); | |
1267 | ||
1268 | pid = pg->Append( new wxColourProperty("ColourPropertyWithAlpha", | |
1269 | wxPG_LABEL, | |
1270 | wxColour(15, 200, 95, 128)) ); | |
1271 | pg->SetPropertyAttribute("ColourPropertyWithAlpha", "HasAlpha", true); | |
1272 | pg->SetPropertyHelpString("ColourPropertyWithAlpha", | |
1273 | "Attribute \"HasAlpha\" is set to true for this property."); | |
1274 | ||
1275 | // | |
1276 | // This demonstrates using alternative editor for colour property | |
1277 | // to trigger colour dialog directly from button. | |
1278 | pg->Append( new wxColourProperty(wxT("ColourProperty2"),wxPG_LABEL,*wxGREEN) ); | |
1279 | ||
1280 | // | |
1281 | // wxEnumProperty does not store strings or even list of strings | |
1282 | // ( so that's why they are static in function ). | |
1283 | static const wxChar* enum_prop_labels[] = { wxT("One Item"), | |
1284 | wxT("Another Item"), wxT("One More"), wxT("This Is Last"), NULL }; | |
1285 | ||
1286 | // this value array would be optional if values matched string indexes | |
1287 | static long enum_prop_values[] = { 40, 80, 120, 160 }; | |
1288 | ||
1289 | // note that the initial value (the last argument) is the actual value, | |
1290 | // not index or anything like that. Thus, our value selects "Another Item". | |
1291 | // | |
1292 | // 0 before value is number of items. If it is 0, like in our example, | |
1293 | // number of items is calculated, and this requires that the string pointer | |
1294 | // array is terminated with NULL. | |
1295 | pg->Append( new wxEnumProperty(wxT("EnumProperty"),wxPG_LABEL, | |
1296 | enum_prop_labels, enum_prop_values, 80 ) ); | |
1297 | ||
1298 | wxPGChoices soc; | |
1299 | ||
1300 | // use basic table from our previous example | |
1301 | // can also set/add wxArrayStrings and wxArrayInts directly. | |
1302 | soc.Set( enum_prop_labels, enum_prop_values ); | |
1303 | ||
1304 | // add extra items | |
1305 | soc.Add( wxT("Look, it continues"), 200 ); | |
1306 | soc.Add( wxT("Even More"), 240 ); | |
1307 | soc.Add( wxT("And More"), 280 ); | |
1308 | soc.Add( "", 300 ); | |
1309 | soc.Add( wxT("True End of the List"), 320 ); | |
1310 | ||
1311 | // Test custom colours ([] operator of wxPGChoices returns | |
1312 | // references to wxPGChoiceEntry). | |
1313 | soc[1].SetFgCol(*wxRED); | |
1314 | soc[1].SetBgCol(*wxLIGHT_GREY); | |
1315 | soc[2].SetFgCol(*wxGREEN); | |
1316 | soc[2].SetBgCol(*wxLIGHT_GREY); | |
1317 | soc[3].SetFgCol(*wxBLUE); | |
1318 | soc[3].SetBgCol(*wxLIGHT_GREY); | |
1319 | soc[4].SetBitmap(wxArtProvider::GetBitmap(wxART_FOLDER)); | |
1320 | ||
1321 | pg->Append( new wxEnumProperty(wxT("EnumProperty 2"), | |
1322 | wxPG_LABEL, | |
1323 | soc, | |
1324 | 240) ); | |
1325 | pg->GetProperty(wxT("EnumProperty 2"))->AddChoice(wxT("Testing Extra"), 360); | |
1326 | ||
1327 | // Here we only display the original 'soc' choices | |
1328 | pg->Append( new wxEnumProperty(wxT("EnumProperty 3"),wxPG_LABEL, | |
1329 | soc, 240 ) ); | |
1330 | ||
1331 | // Test Hint attribute in EnumProperty | |
1332 | pg->GetProperty("EnumProperty 3")->SetAttribute("Hint", "Dummy Hint"); | |
1333 | ||
1334 | pg->SetPropertyHelpString("EnumProperty 3", | |
1335 | "This property uses \"Hint\" attribute."); | |
1336 | ||
1337 | // 'soc' plus one exclusive extra choice "4th only" | |
1338 | pg->Append( new wxEnumProperty(wxT("EnumProperty 4"),wxPG_LABEL, | |
1339 | soc, 240 ) ); | |
1340 | pg->GetProperty(wxT("EnumProperty 4"))->AddChoice(wxT("4th only"), 360); | |
1341 | ||
1342 | pg->SetPropertyHelpString(wxT("EnumProperty 4"), | |
1343 | wxT("Should have one extra item when compared to EnumProperty 3")); | |
1344 | ||
1345 | // Password property example. | |
1346 | pg->Append( new wxStringProperty(wxT("Password"),wxPG_LABEL, wxT("password")) ); | |
1347 | pg->SetPropertyAttribute( wxT("Password"), wxPG_STRING_PASSWORD, true ); | |
1348 | pg->SetPropertyHelpString( wxT("Password"), | |
1349 | wxT("Has attribute wxPG_STRING_PASSWORD set to true") ); | |
1350 | ||
1351 | // String editor with dir selector button. Uses wxEmptyString as name, which | |
1352 | // is allowed (naturally, in this case property cannot be accessed by name). | |
1353 | pg->Append( new wxDirProperty( wxT("DirProperty"), wxPG_LABEL, ::wxGetUserHome()) ); | |
1354 | pg->SetPropertyAttribute( wxT("DirProperty"), | |
1355 | wxPG_DIR_DIALOG_MESSAGE, | |
1356 | wxT("This is a custom dir dialog message") ); | |
1357 | ||
1358 | // Add string property - first arg is label, second name, and third initial value | |
1359 | pg->Append( new wxStringProperty ( wxT("StringProperty"), wxPG_LABEL ) ); | |
1360 | pg->SetPropertyMaxLength( wxT("StringProperty"), 6 ); | |
1361 | pg->SetPropertyHelpString( wxT("StringProperty"), | |
1362 | wxT("Max length of this text has been limited to 6, using wxPropertyGrid::SetPropertyMaxLength.") ); | |
1363 | ||
1364 | // Set value after limiting so that it will be applied | |
1365 | pg->SetPropertyValue( wxT("StringProperty"), wxT("some text") ); | |
1366 | ||
1367 | // | |
1368 | // Demonstrate "AutoComplete" attribute | |
1369 | pg->Append( new wxStringProperty( "StringProperty AutoComplete", | |
1370 | wxPG_LABEL ) ); | |
1371 | ||
1372 | wxArrayString autoCompleteStrings; | |
1373 | autoCompleteStrings.Add("One choice"); | |
1374 | autoCompleteStrings.Add("Another choice"); | |
1375 | autoCompleteStrings.Add("Another choice, yeah"); | |
1376 | autoCompleteStrings.Add("Yet another choice"); | |
1377 | autoCompleteStrings.Add("Yet another choice, bear with me"); | |
1378 | pg->SetPropertyAttribute( "StringProperty AutoComplete", | |
1379 | "AutoComplete", | |
1380 | autoCompleteStrings ); | |
1381 | ||
1382 | pg->SetPropertyHelpString( "StringProperty AutoComplete", | |
1383 | "AutoComplete attribute has been set for this property " | |
1384 | "(try writing something beginning with 'a', 'o' or 'y')."); | |
1385 | ||
1386 | // Add string property with arbitrarily wide bitmap in front of it. We | |
1387 | // intentionally lower-than-typical row height here so that the ugly | |
1388 | // scaling code wont't be run. | |
1389 | pg->Append( new wxStringProperty( wxT("StringPropertyWithBitmap"), | |
1390 | wxPG_LABEL, | |
1391 | wxT("Test Text")) ); | |
1392 | wxBitmap myTestBitmap(60, 15, 32); | |
1393 | wxMemoryDC mdc; | |
1394 | mdc.SelectObject(myTestBitmap); | |
1395 | mdc.Clear(); | |
1396 | mdc.SetPen(*wxBLACK); | |
1397 | mdc.DrawLine(0, 0, 60, 15); | |
1398 | mdc.SelectObject(wxNullBitmap); | |
1399 | pg->SetPropertyImage( wxT("StringPropertyWithBitmap"), myTestBitmap ); | |
1400 | ||
1401 | ||
1402 | // this value array would be optional if values matched string indexes | |
1403 | //long flags_prop_values[] = { wxICONIZE, wxCAPTION, wxMINIMIZE_BOX, wxMAXIMIZE_BOX }; | |
1404 | ||
1405 | //pg->Append( wxFlagsProperty(wxT("Example of FlagsProperty"),wxT("FlagsProp"), | |
1406 | // flags_prop_labels, flags_prop_values, 0, GetWindowStyle() ) ); | |
1407 | ||
1408 | ||
1409 | // Multi choice dialog. | |
1410 | wxArrayString tchoices; | |
1411 | tchoices.Add(wxT("Cabbage")); | |
1412 | tchoices.Add(wxT("Carrot")); | |
1413 | tchoices.Add(wxT("Onion")); | |
1414 | tchoices.Add(wxT("Potato")); | |
1415 | tchoices.Add(wxT("Strawberry")); | |
1416 | ||
1417 | wxArrayString tchoicesValues; | |
1418 | tchoicesValues.Add(wxT("Carrot")); | |
1419 | tchoicesValues.Add(wxT("Potato")); | |
1420 | ||
1421 | pg->Append( new wxEnumProperty(wxT("EnumProperty X"),wxPG_LABEL, tchoices ) ); | |
1422 | ||
1423 | pg->Append( new wxMultiChoiceProperty( wxT("MultiChoiceProperty"), wxPG_LABEL, | |
1424 | tchoices, tchoicesValues ) ); | |
1425 | pg->SetPropertyAttribute( wxT("MultiChoiceProperty"), wxT("UserStringMode"), true ); | |
1426 | ||
1427 | pg->Append( new wxSizeProperty( wxT("SizeProperty"), wxT("Size"), GetSize() ) ); | |
1428 | pg->Append( new wxPointProperty( wxT("PointProperty"), wxT("Position"), GetPosition() ) ); | |
1429 | ||
1430 | // UInt samples | |
1431 | pg->Append( new wxUIntProperty( wxT("UIntProperty"), wxPG_LABEL, wxULongLong(wxULL(0xFEEEFEEEFEEE)))); | |
1432 | pg->SetPropertyAttribute( wxT("UIntProperty"), wxPG_UINT_PREFIX, wxPG_PREFIX_NONE ); | |
1433 | pg->SetPropertyAttribute( wxT("UIntProperty"), wxPG_UINT_BASE, wxPG_BASE_HEX ); | |
1434 | //pg->SetPropertyAttribute( wxT("UIntProperty"), wxPG_UINT_PREFIX, wxPG_PREFIX_NONE ); | |
1435 | //pg->SetPropertyAttribute( wxT("UIntProperty"), wxPG_UINT_BASE, wxPG_BASE_OCT ); | |
1436 | ||
1437 | // | |
1438 | // wxEditEnumProperty | |
1439 | wxPGChoices eech; | |
1440 | eech.Add(wxT("Choice 1")); | |
1441 | eech.Add(wxT("Choice 2")); | |
1442 | eech.Add(wxT("Choice 3")); | |
1443 | pg->Append( new wxEditEnumProperty("EditEnumProperty", | |
1444 | wxPG_LABEL, | |
1445 | eech, | |
1446 | "Choice not in the list") ); | |
1447 | ||
1448 | // Test Hint attribute in EditEnumProperty | |
1449 | pg->GetProperty("EditEnumProperty")->SetAttribute("Hint", "Dummy Hint"); | |
1450 | ||
1451 | //wxString v_; | |
1452 | //wxTextValidator validator1(wxFILTER_NUMERIC,&v_); | |
1453 | //pg->SetPropertyValidator( wxT("EditEnumProperty"), validator1 ); | |
1454 | ||
1455 | #if wxUSE_DATETIME | |
1456 | // | |
1457 | // wxDateTimeProperty | |
1458 | pg->Append( new wxDateProperty(wxT("DateProperty"), wxPG_LABEL, wxDateTime::Now() ) ); | |
1459 | ||
1460 | #if wxUSE_DATEPICKCTRL | |
1461 | pg->SetPropertyAttribute( wxT("DateProperty"), wxPG_DATE_PICKER_STYLE, | |
1462 | (long)(wxDP_DROPDOWN | | |
1463 | wxDP_SHOWCENTURY | | |
1464 | wxDP_ALLOWNONE) ); | |
1465 | ||
1466 | pg->SetPropertyHelpString( wxT("DateProperty"), | |
1467 | wxT("Attribute wxPG_DATE_PICKER_STYLE has been set to (long)") | |
1468 | wxT("(wxDP_DROPDOWN | wxDP_SHOWCENTURY | wxDP_ALLOWNONE).") ); | |
1469 | #endif | |
1470 | ||
1471 | #endif | |
1472 | ||
1473 | // | |
1474 | // Add Triangle properties as both wxTriangleProperty and | |
1475 | // a generic parent property (using wxStringProperty). | |
1476 | // | |
1477 | wxPGProperty* topId = pg->Append( new wxStringProperty(wxT("3D Object"), wxPG_LABEL, wxT("<composed>")) ); | |
1478 | ||
1479 | pid = pg->AppendIn( topId, new wxStringProperty(wxT("Triangle 1"), wxT("Triangle 1"), wxT("<composed>")) ); | |
1480 | pg->AppendIn( pid, new wxVectorProperty( wxT("A"), wxPG_LABEL ) ); | |
1481 | pg->AppendIn( pid, new wxVectorProperty( wxT("B"), wxPG_LABEL ) ); | |
1482 | pg->AppendIn( pid, new wxVectorProperty( wxT("C"), wxPG_LABEL ) ); | |
1483 | ||
1484 | pg->AppendIn( topId, new wxTriangleProperty( wxT("Triangle 2"), wxT("Triangle 2") ) ); | |
1485 | ||
1486 | pg->SetPropertyHelpString( wxT("3D Object"), | |
1487 | wxT("3D Object is wxStringProperty with value \"<composed>\". Two of its children are similar wxStringProperties with ") | |
1488 | wxT("three wxVectorProperty children, and other two are custom wxTriangleProperties.") ); | |
1489 | ||
1490 | pid = pg->AppendIn( topId, new wxStringProperty(wxT("Triangle 3"), wxT("Triangle 3"), wxT("<composed>")) ); | |
1491 | pg->AppendIn( pid, new wxVectorProperty( wxT("A"), wxPG_LABEL ) ); | |
1492 | pg->AppendIn( pid, new wxVectorProperty( wxT("B"), wxPG_LABEL ) ); | |
1493 | pg->AppendIn( pid, new wxVectorProperty( wxT("C"), wxPG_LABEL ) ); | |
1494 | ||
1495 | pg->AppendIn( topId, new wxTriangleProperty( wxT("Triangle 4"), wxT("Triangle 4") ) ); | |
1496 | ||
1497 | // | |
1498 | // This snippet is a doc sample test | |
1499 | // | |
1500 | wxPGProperty* carProp = pg->Append(new wxStringProperty(wxT("Car"), | |
1501 | wxPG_LABEL, | |
1502 | wxT("<composed>"))); | |
1503 | ||
1504 | pg->AppendIn(carProp, new wxStringProperty(wxT("Model"), | |
1505 | wxPG_LABEL, | |
1506 | wxT("Lamborghini Diablo SV"))); | |
1507 | ||
1508 | pg->AppendIn(carProp, new wxIntProperty(wxT("Engine Size (cc)"), | |
1509 | wxPG_LABEL, | |
1510 | 5707) ); | |
1511 | ||
1512 | wxPGProperty* speedsProp = pg->AppendIn(carProp, | |
1513 | new wxStringProperty(wxT("Speeds"), | |
1514 | wxPG_LABEL, | |
1515 | wxT("<composed>"))); | |
1516 | ||
1517 | pg->AppendIn( speedsProp, new wxIntProperty(wxT("Max. Speed (mph)"), | |
1518 | wxPG_LABEL,290) ); | |
1519 | pg->AppendIn( speedsProp, new wxFloatProperty(wxT("0-100 mph (sec)"), | |
1520 | wxPG_LABEL,3.9) ); | |
1521 | pg->AppendIn( speedsProp, new wxFloatProperty(wxT("1/4 mile (sec)"), | |
1522 | wxPG_LABEL,8.6) ); | |
1523 | ||
1524 | // This is how child property can be referred to by name | |
1525 | pg->SetPropertyValue( wxT("Car.Speeds.Max. Speed (mph)"), 300 ); | |
1526 | ||
1527 | pg->AppendIn(carProp, new wxIntProperty(wxT("Price ($)"), | |
1528 | wxPG_LABEL, | |
1529 | 300000) ); | |
1530 | ||
1531 | pg->AppendIn(carProp, new wxBoolProperty(wxT("Convertible"), | |
1532 | wxPG_LABEL, | |
1533 | false) ); | |
1534 | ||
1535 | // Displayed value of "Car" property is now very close to this: | |
1536 | // "Lamborghini Diablo SV; 5707 [300; 3.9; 8.6] 300000" | |
1537 | ||
1538 | // | |
1539 | // Test wxSampleMultiButtonEditor | |
1540 | pg->Append( new wxLongStringProperty(wxT("MultipleButtons"), wxPG_LABEL) ); | |
1541 | pg->SetPropertyEditor(wxT("MultipleButtons"), m_pSampleMultiButtonEditor ); | |
1542 | ||
1543 | // Test SingleChoiceProperty | |
1544 | pg->Append( new SingleChoiceProperty(wxT("SingleChoiceProperty")) ); | |
1545 | ||
1546 | ||
1547 | // | |
1548 | // Test adding variable height bitmaps in wxPGChoices | |
1549 | wxPGChoices bc; | |
1550 | ||
1551 | bc.Add(wxT("Wee"), wxBitmap(16, 16)); | |
1552 | bc.Add(wxT("Not so wee"), wxBitmap(32, 32)); | |
1553 | bc.Add(wxT("Friggin' huge"), wxBitmap(64, 64)); | |
1554 | ||
1555 | pg->Append( new wxEnumProperty(wxT("Variable Height Bitmaps"), | |
1556 | wxPG_LABEL, | |
1557 | bc, | |
1558 | 0) ); | |
1559 | ||
1560 | // | |
1561 | // Test how non-editable composite strings appear | |
1562 | pid = new wxStringProperty(wxT("wxWidgets Traits"), wxPG_LABEL, wxT("<composed>")); | |
1563 | pg->SetPropertyReadOnly(pid); | |
1564 | ||
1565 | // | |
1566 | // For testing purposes, combine two methods of adding children | |
1567 | // | |
1568 | ||
1569 | pid->AppendChild( new wxStringProperty(wxT("Latest Release"), | |
1570 | wxPG_LABEL, | |
1571 | wxT("2.8.10"))); | |
1572 | pid->AppendChild( new wxBoolProperty(wxT("Win API"), | |
1573 | wxPG_LABEL, | |
1574 | true) ); | |
1575 | ||
1576 | pg->Append( pid ); | |
1577 | ||
1578 | pg->AppendIn(pid, new wxBoolProperty(wxT("QT"), wxPG_LABEL, false) ); | |
1579 | pg->AppendIn(pid, new wxBoolProperty(wxT("Cocoa"), wxPG_LABEL, true) ); | |
1580 | pg->AppendIn(pid, new wxBoolProperty(wxT("BeOS"), wxPG_LABEL, false) ); | |
1581 | pg->AppendIn(pid, new wxStringProperty(wxT("SVN Trunk Version"), wxPG_LABEL, wxT("2.9.0")) ); | |
1582 | pg->AppendIn(pid, new wxBoolProperty(wxT("GTK+"), wxPG_LABEL, true) ); | |
1583 | pg->AppendIn(pid, new wxBoolProperty(wxT("Sky OS"), wxPG_LABEL, false) ); | |
1584 | pg->AppendIn(pid, new wxBoolProperty(wxT("QT"), wxPG_LABEL, false) ); | |
1585 | ||
1586 | AddTestProperties(pg); | |
1587 | } | |
1588 | ||
1589 | // ----------------------------------------------------------------------- | |
1590 | ||
1591 | void FormMain::PopulateWithLibraryConfig () | |
1592 | { | |
1593 | wxPropertyGridManager* pgman = m_pPropGridManager; | |
1594 | wxPropertyGridPage* pg = pgman->GetPage(wxT("wxWidgets Library Config")); | |
1595 | ||
1596 | // Set custom column proportions (here in the sample app we need | |
1597 | // to check if the grid has wxPG_SPLITTER_AUTO_CENTER style. You usually | |
1598 | // need not to do it in your application). | |
1599 | if ( pgman->HasFlag(wxPG_SPLITTER_AUTO_CENTER) ) | |
1600 | { | |
1601 | pg->SetColumnProportion(0, 3); | |
1602 | pg->SetColumnProportion(1, 1); | |
1603 | } | |
1604 | ||
1605 | wxPGProperty* cat; | |
1606 | ||
1607 | wxBitmap bmp = wxArtProvider::GetBitmap(wxART_REPORT_VIEW); | |
1608 | ||
1609 | wxPGProperty* pid; | |
1610 | ||
1611 | wxFont italicFont = pgman->GetGrid()->GetCaptionFont(); | |
1612 | italicFont.SetStyle(wxFONTSTYLE_ITALIC); | |
1613 | ||
1614 | wxString italicFontHelp = "Font of this property's wxPGCell has " | |
1615 | "been modified. Obtain property's cell " | |
1616 | "with wxPGProperty::" | |
1617 | "GetOrCreateCell(column)."; | |
1618 | ||
1619 | #define ADD_WX_LIB_CONF_GROUP(A) \ | |
1620 | cat = pg->AppendIn( pid, new wxPropertyCategory(A) ); \ | |
1621 | pg->SetPropertyCell( cat, 0, wxPG_LABEL, bmp ); \ | |
1622 | cat->GetCell(0).SetFont(italicFont); \ | |
1623 | cat->SetHelpString(italicFontHelp); | |
1624 | ||
1625 | #define ADD_WX_LIB_CONF(A) pg->Append( new wxBoolProperty(wxT(#A),wxPG_LABEL,(bool)((A>0)?true:false))); | |
1626 | #define ADD_WX_LIB_CONF_NODEF(A) pg->Append( new wxBoolProperty(wxT(#A),wxPG_LABEL,(bool)false) ); \ | |
1627 | pg->DisableProperty(wxT(#A)); | |
1628 | ||
1629 | pid = pg->Append( new wxPropertyCategory( wxT("wxWidgets Library Configuration") ) ); | |
1630 | pg->SetPropertyCell( pid, 0, wxPG_LABEL, bmp ); | |
1631 | ||
1632 | // Both of following lines would set a label for the second column | |
1633 | pg->SetPropertyCell( pid, 1, "Is Enabled" ); | |
1634 | pid->SetValue("Is Enabled"); | |
1635 | ||
1636 | ADD_WX_LIB_CONF_GROUP(wxT("Global Settings")) | |
1637 | ADD_WX_LIB_CONF( wxUSE_GUI ) | |
1638 | ||
1639 | ADD_WX_LIB_CONF_GROUP(wxT("Compatibility Settings")) | |
1640 | #if defined(WXWIN_COMPATIBILITY_2_2) | |
1641 | ADD_WX_LIB_CONF( WXWIN_COMPATIBILITY_2_2 ) | |
1642 | #endif | |
1643 | #if defined(WXWIN_COMPATIBILITY_2_4) | |
1644 | ADD_WX_LIB_CONF( WXWIN_COMPATIBILITY_2_4 ) | |
1645 | #endif | |
1646 | #if defined(WXWIN_COMPATIBILITY_2_6) | |
1647 | ADD_WX_LIB_CONF( WXWIN_COMPATIBILITY_2_6 ) | |
1648 | #endif | |
1649 | #if defined(WXWIN_COMPATIBILITY_2_8) | |
1650 | ADD_WX_LIB_CONF( WXWIN_COMPATIBILITY_2_8 ) | |
1651 | #endif | |
1652 | #ifdef wxFONT_SIZE_COMPATIBILITY | |
1653 | ADD_WX_LIB_CONF( wxFONT_SIZE_COMPATIBILITY ) | |
1654 | #else | |
1655 | ADD_WX_LIB_CONF_NODEF ( wxFONT_SIZE_COMPATIBILITY ) | |
1656 | #endif | |
1657 | #ifdef wxDIALOG_UNIT_COMPATIBILITY | |
1658 | ADD_WX_LIB_CONF( wxDIALOG_UNIT_COMPATIBILITY ) | |
1659 | #else | |
1660 | ADD_WX_LIB_CONF_NODEF ( wxDIALOG_UNIT_COMPATIBILITY ) | |
1661 | #endif | |
1662 | ||
1663 | ADD_WX_LIB_CONF_GROUP(wxT("Debugging Settings")) | |
1664 | ADD_WX_LIB_CONF( wxUSE_DEBUG_CONTEXT ) | |
1665 | ADD_WX_LIB_CONF( wxUSE_MEMORY_TRACING ) | |
1666 | ADD_WX_LIB_CONF( wxUSE_GLOBAL_MEMORY_OPERATORS ) | |
1667 | ADD_WX_LIB_CONF( wxUSE_DEBUG_NEW_ALWAYS ) | |
1668 | ADD_WX_LIB_CONF( wxUSE_ON_FATAL_EXCEPTION ) | |
1669 | ||
1670 | ADD_WX_LIB_CONF_GROUP(wxT("Unicode Support")) | |
1671 | ADD_WX_LIB_CONF( wxUSE_UNICODE ) | |
1672 | ADD_WX_LIB_CONF( wxUSE_UNICODE_MSLU ) | |
1673 | ||
1674 | ADD_WX_LIB_CONF_GROUP(wxT("Global Features")) | |
1675 | ADD_WX_LIB_CONF( wxUSE_EXCEPTIONS ) | |
1676 | ADD_WX_LIB_CONF( wxUSE_EXTENDED_RTTI ) | |
1677 | ADD_WX_LIB_CONF( wxUSE_STL ) | |
1678 | ADD_WX_LIB_CONF( wxUSE_LOG ) | |
1679 | ADD_WX_LIB_CONF( wxUSE_LOGWINDOW ) | |
1680 | ADD_WX_LIB_CONF( wxUSE_LOGGUI ) | |
1681 | ADD_WX_LIB_CONF( wxUSE_LOG_DIALOG ) | |
1682 | ADD_WX_LIB_CONF( wxUSE_CMDLINE_PARSER ) | |
1683 | ADD_WX_LIB_CONF( wxUSE_THREADS ) | |
1684 | ADD_WX_LIB_CONF( wxUSE_STREAMS ) | |
1685 | ADD_WX_LIB_CONF( wxUSE_STD_IOSTREAM ) | |
1686 | ||
1687 | ADD_WX_LIB_CONF_GROUP(wxT("Non-GUI Features")) | |
1688 | ADD_WX_LIB_CONF( wxUSE_LONGLONG ) | |
1689 | ADD_WX_LIB_CONF( wxUSE_FILE ) | |
1690 | ADD_WX_LIB_CONF( wxUSE_FFILE ) | |
1691 | ADD_WX_LIB_CONF( wxUSE_FSVOLUME ) | |
1692 | ADD_WX_LIB_CONF( wxUSE_TEXTBUFFER ) | |
1693 | ADD_WX_LIB_CONF( wxUSE_TEXTFILE ) | |
1694 | ADD_WX_LIB_CONF( wxUSE_INTL ) | |
1695 | ADD_WX_LIB_CONF( wxUSE_DATETIME ) | |
1696 | ADD_WX_LIB_CONF( wxUSE_TIMER ) | |
1697 | ADD_WX_LIB_CONF( wxUSE_STOPWATCH ) | |
1698 | ADD_WX_LIB_CONF( wxUSE_CONFIG ) | |
1699 | #ifdef wxUSE_CONFIG_NATIVE | |
1700 | ADD_WX_LIB_CONF( wxUSE_CONFIG_NATIVE ) | |
1701 | #else | |
1702 | ADD_WX_LIB_CONF_NODEF ( wxUSE_CONFIG_NATIVE ) | |
1703 | #endif | |
1704 | ADD_WX_LIB_CONF( wxUSE_DIALUP_MANAGER ) | |
1705 | ADD_WX_LIB_CONF( wxUSE_DYNLIB_CLASS ) | |
1706 | ADD_WX_LIB_CONF( wxUSE_DYNAMIC_LOADER ) | |
1707 | ADD_WX_LIB_CONF( wxUSE_SOCKETS ) | |
1708 | ADD_WX_LIB_CONF( wxUSE_FILESYSTEM ) | |
1709 | ADD_WX_LIB_CONF( wxUSE_FS_ZIP ) | |
1710 | ADD_WX_LIB_CONF( wxUSE_FS_INET ) | |
1711 | ADD_WX_LIB_CONF( wxUSE_ZIPSTREAM ) | |
1712 | ADD_WX_LIB_CONF( wxUSE_ZLIB ) | |
1713 | ADD_WX_LIB_CONF( wxUSE_APPLE_IEEE ) | |
1714 | ADD_WX_LIB_CONF( wxUSE_JOYSTICK ) | |
1715 | ADD_WX_LIB_CONF( wxUSE_FONTMAP ) | |
1716 | ADD_WX_LIB_CONF( wxUSE_MIMETYPE ) | |
1717 | ADD_WX_LIB_CONF( wxUSE_PROTOCOL ) | |
1718 | ADD_WX_LIB_CONF( wxUSE_PROTOCOL_FILE ) | |
1719 | ADD_WX_LIB_CONF( wxUSE_PROTOCOL_FTP ) | |
1720 | ADD_WX_LIB_CONF( wxUSE_PROTOCOL_HTTP ) | |
1721 | ADD_WX_LIB_CONF( wxUSE_URL ) | |
1722 | #ifdef wxUSE_URL_NATIVE | |
1723 | ADD_WX_LIB_CONF( wxUSE_URL_NATIVE ) | |
1724 | #else | |
1725 | ADD_WX_LIB_CONF_NODEF ( wxUSE_URL_NATIVE ) | |
1726 | #endif | |
1727 | ADD_WX_LIB_CONF( wxUSE_REGEX ) | |
1728 | ADD_WX_LIB_CONF( wxUSE_SYSTEM_OPTIONS ) | |
1729 | ADD_WX_LIB_CONF( wxUSE_SOUND ) | |
1730 | #ifdef wxUSE_XRC | |
1731 | ADD_WX_LIB_CONF( wxUSE_XRC ) | |
1732 | #else | |
1733 | ADD_WX_LIB_CONF_NODEF ( wxUSE_XRC ) | |
1734 | #endif | |
1735 | ADD_WX_LIB_CONF( wxUSE_XML ) | |
1736 | ||
1737 | // Set them to use check box. | |
1738 | pg->SetPropertyAttribute(pid,wxPG_BOOL_USE_CHECKBOX,true,wxPG_RECURSE); | |
1739 | } | |
1740 | ||
1741 | ||
1742 | // | |
1743 | // Handle events of the third page here. | |
1744 | class wxMyPropertyGridPage : public wxPropertyGridPage | |
1745 | { | |
1746 | public: | |
1747 | ||
1748 | // Return false here to indicate unhandled events should be | |
1749 | // propagated to manager's parent, as normal. | |
1750 | virtual bool IsHandlingAllEvents() const { return false; } | |
1751 | ||
1752 | protected: | |
1753 | ||
1754 | virtual wxPGProperty* DoInsert( wxPGProperty* parent, | |
1755 | int index, | |
1756 | wxPGProperty* property ) | |
1757 | { | |
1758 | return wxPropertyGridPage::DoInsert(parent,index,property); | |
1759 | } | |
1760 | ||
1761 | void OnPropertySelect( wxPropertyGridEvent& event ); | |
1762 | void OnPropertyChanging( wxPropertyGridEvent& event ); | |
1763 | void OnPropertyChange( wxPropertyGridEvent& event ); | |
1764 | void OnPageChange( wxPropertyGridEvent& event ); | |
1765 | ||
1766 | private: | |
1767 | DECLARE_EVENT_TABLE() | |
1768 | }; | |
1769 | ||
1770 | ||
1771 | BEGIN_EVENT_TABLE(wxMyPropertyGridPage, wxPropertyGridPage) | |
1772 | EVT_PG_SELECTED( wxID_ANY, wxMyPropertyGridPage::OnPropertySelect ) | |
1773 | EVT_PG_CHANGING( wxID_ANY, wxMyPropertyGridPage::OnPropertyChanging ) | |
1774 | EVT_PG_CHANGED( wxID_ANY, wxMyPropertyGridPage::OnPropertyChange ) | |
1775 | EVT_PG_PAGE_CHANGED( wxID_ANY, wxMyPropertyGridPage::OnPageChange ) | |
1776 | END_EVENT_TABLE() | |
1777 | ||
1778 | ||
1779 | void wxMyPropertyGridPage::OnPropertySelect( wxPropertyGridEvent& WXUNUSED(event) ) | |
1780 | { | |
1781 | wxLogDebug(wxT("wxMyPropertyGridPage::OnPropertySelect()")); | |
1782 | } | |
1783 | ||
1784 | void wxMyPropertyGridPage::OnPropertyChange( wxPropertyGridEvent& event ) | |
1785 | { | |
1786 | wxPGProperty* p = event.GetProperty(); | |
1787 | wxLogVerbose(wxT("wxMyPropertyGridPage::OnPropertyChange('%s', to value '%s')"), | |
1788 | p->GetName().c_str(), | |
1789 | p->GetDisplayedString().c_str()); | |
1790 | } | |
1791 | ||
1792 | void wxMyPropertyGridPage::OnPropertyChanging( wxPropertyGridEvent& event ) | |
1793 | { | |
1794 | wxPGProperty* p = event.GetProperty(); | |
1795 | wxLogVerbose(wxT("wxMyPropertyGridPage::OnPropertyChanging('%s', to value '%s')"), | |
1796 | p->GetName().c_str(), | |
1797 | event.GetValue().GetString().c_str()); | |
1798 | } | |
1799 | ||
1800 | void wxMyPropertyGridPage::OnPageChange( wxPropertyGridEvent& WXUNUSED(event) ) | |
1801 | { | |
1802 | wxLogDebug(wxT("wxMyPropertyGridPage::OnPageChange()")); | |
1803 | } | |
1804 | ||
1805 | ||
1806 | class wxPGKeyHandler : public wxEvtHandler | |
1807 | { | |
1808 | public: | |
1809 | ||
1810 | void OnKeyEvent( wxKeyEvent& event ) | |
1811 | { | |
1812 | wxMessageBox(wxString::Format(wxT("%i"),event.GetKeyCode())); | |
1813 | event.Skip(); | |
1814 | } | |
1815 | private: | |
1816 | DECLARE_EVENT_TABLE() | |
1817 | }; | |
1818 | ||
1819 | BEGIN_EVENT_TABLE(wxPGKeyHandler,wxEvtHandler) | |
1820 | EVT_KEY_DOWN( wxPGKeyHandler::OnKeyEvent ) | |
1821 | END_EVENT_TABLE() | |
1822 | ||
1823 | ||
1824 | // ----------------------------------------------------------------------- | |
1825 | ||
1826 | void FormMain::InitPanel() | |
1827 | { | |
1828 | if ( m_panel ) | |
1829 | m_panel->Destroy(); | |
1830 | ||
1831 | wxWindow* panel = new wxPanel(this, wxID_ANY, | |
1832 | wxPoint(0, 0), wxSize(400, 400), | |
1833 | wxTAB_TRAVERSAL); | |
1834 | m_panel = panel; | |
1835 | ||
1836 | // Column | |
1837 | wxBoxSizer* topSizer = new wxBoxSizer ( wxVERTICAL ); | |
1838 | ||
1839 | m_topSizer = topSizer; | |
1840 | } | |
1841 | ||
1842 | void FormMain::FinalizePanel( bool wasCreated ) | |
1843 | { | |
1844 | // Button for tab traversal testing | |
1845 | m_topSizer->Add( new wxButton(m_panel, wxID_ANY, | |
1846 | wxS("Should be able to move here with Tab")), | |
1847 | 0, wxEXPAND ); | |
1848 | ||
1849 | m_panel->SetSizer( m_topSizer ); | |
1850 | m_topSizer->SetSizeHints( m_panel ); | |
1851 | ||
1852 | wxBoxSizer* panelSizer = new wxBoxSizer( wxHORIZONTAL ); | |
1853 | panelSizer->Add( m_panel, 1, wxEXPAND|wxFIXED_MINSIZE ); | |
1854 | ||
1855 | SetSizer( panelSizer ); | |
1856 | panelSizer->SetSizeHints( this ); | |
1857 | ||
1858 | if ( wasCreated ) | |
1859 | FinalizeFramePosition(); | |
1860 | } | |
1861 | ||
1862 | void FormMain::PopulateGrid() | |
1863 | { | |
1864 | wxPropertyGridManager* pgman = m_pPropGridManager; | |
1865 | pgman->AddPage(wxT("Standard Items")); | |
1866 | ||
1867 | PopulateWithStandardItems(); | |
1868 | ||
1869 | pgman->AddPage(wxT("wxWidgets Library Config")); | |
1870 | ||
1871 | PopulateWithLibraryConfig(); | |
1872 | ||
1873 | wxPropertyGridPage* myPage = new wxMyPropertyGridPage(); | |
1874 | myPage->Append( new wxIntProperty ( wxT("IntProperty"), wxPG_LABEL, 12345678 ) ); | |
1875 | ||
1876 | // Use wxMyPropertyGridPage (see above) to test the | |
1877 | // custom wxPropertyGridPage feature. | |
1878 | pgman->AddPage(wxT("Examples"),wxNullBitmap,myPage); | |
1879 | ||
1880 | PopulateWithExamples(); | |
1881 | } | |
1882 | ||
1883 | void FormMain::CreateGrid( int style, int extraStyle ) | |
1884 | { | |
1885 | // | |
1886 | // This function (re)creates the property grid in our sample | |
1887 | // | |
1888 | ||
1889 | if ( style == -1 ) | |
1890 | style = // default style | |
1891 | wxPG_BOLD_MODIFIED | | |
1892 | wxPG_SPLITTER_AUTO_CENTER | | |
1893 | wxPG_AUTO_SORT | | |
1894 | //wxPG_HIDE_MARGIN|wxPG_STATIC_SPLITTER | | |
1895 | //wxPG_TOOLTIPS | | |
1896 | //wxPG_HIDE_CATEGORIES | | |
1897 | //wxPG_LIMITED_EDITING | | |
1898 | wxPG_TOOLBAR | | |
1899 | wxPG_DESCRIPTION; | |
1900 | ||
1901 | if ( extraStyle == -1 ) | |
1902 | // default extra style | |
1903 | extraStyle = wxPG_EX_MODE_BUTTONS | | |
1904 | wxPG_EX_MULTIPLE_SELECTION; | |
1905 | //| wxPG_EX_AUTO_UNSPECIFIED_VALUES | |
1906 | //| wxPG_EX_GREY_LABEL_WHEN_DISABLED | |
1907 | //| wxPG_EX_NATIVE_DOUBLE_BUFFERING | |
1908 | //| wxPG_EX_HELP_AS_TOOLTIPS | |
1909 | ||
1910 | bool wasCreated = m_panel ? false : true; | |
1911 | ||
1912 | InitPanel(); | |
1913 | ||
1914 | // | |
1915 | // This shows how to combine two static choice descriptors | |
1916 | m_combinedFlags.Add( _fs_windowstyle_labels, _fs_windowstyle_values ); | |
1917 | m_combinedFlags.Add( _fs_framestyle_labels, _fs_framestyle_values ); | |
1918 | ||
1919 | wxPropertyGridManager* pgman = m_pPropGridManager = | |
1920 | new wxPropertyGridManager(m_panel, | |
1921 | // Don't change this into wxID_ANY in the sample, or the | |
1922 | // event handling will obviously be broken. | |
1923 | PGID, /*wxID_ANY*/ | |
1924 | wxDefaultPosition, | |
1925 | wxSize(100, 100), // FIXME: wxDefaultSize gives assertion in propgrid. | |
1926 | // But calling SetInitialSize in manager changes the code | |
1927 | // order to the grid gets created immediately, before SetExtraStyle | |
1928 | // is called. | |
1929 | style ); | |
1930 | ||
1931 | m_propGrid = pgman->GetGrid(); | |
1932 | ||
1933 | pgman->SetExtraStyle(extraStyle); | |
1934 | ||
1935 | // This is the default validation failure behaviour | |
1936 | m_pPropGridManager->SetValidationFailureBehavior( wxPG_VFB_MARK_CELL | | |
1937 | wxPG_VFB_SHOW_MESSAGEBOX ); | |
1938 | ||
1939 | m_pPropGridManager->GetGrid()->SetVerticalSpacing( 2 ); | |
1940 | ||
1941 | // | |
1942 | // Set somewhat different unspecified value appearance | |
1943 | wxPGCell cell; | |
1944 | cell.SetText("Unspecified"); | |
1945 | cell.SetFgCol(*wxLIGHT_GREY); | |
1946 | m_propGrid->SetUnspecifiedValueAppearance(cell); | |
1947 | ||
1948 | PopulateGrid(); | |
1949 | ||
1950 | // Change some attributes in all properties | |
1951 | //pgman->SetPropertyAttributeAll(wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING,true); | |
1952 | //pgman->SetPropertyAttributeAll(wxPG_BOOL_USE_CHECKBOX,true); | |
1953 | ||
1954 | //m_pPropGridManager->SetSplitterLeft(true); | |
1955 | //m_pPropGridManager->SetSplitterPosition(137); | |
1956 | ||
1957 | /* | |
1958 | // This would setup event handling without event table entries | |
1959 | Connect(m_pPropGridManager->GetId(), wxEVT_PG_SELECTED, | |
1960 | wxPropertyGridEventHandler(FormMain::OnPropertyGridSelect) ); | |
1961 | Connect(m_pPropGridManager->GetId(), wxEVT_PG_CHANGED, | |
1962 | wxPropertyGridEventHandler(FormMain::OnPropertyGridChange) ); | |
1963 | */ | |
1964 | ||
1965 | m_topSizer->Add( m_pPropGridManager, 1, wxEXPAND ); | |
1966 | ||
1967 | FinalizePanel(wasCreated); | |
1968 | } | |
1969 | ||
1970 | // ----------------------------------------------------------------------- | |
1971 | ||
1972 | FormMain::FormMain(const wxString& title, const wxPoint& pos, const wxSize& size) : | |
1973 | wxFrame((wxFrame *)NULL, -1, title, pos, size, | |
1974 | (wxMINIMIZE_BOX|wxMAXIMIZE_BOX|wxRESIZE_BORDER|wxSYSTEM_MENU|wxCAPTION| | |
1975 | wxTAB_TRAVERSAL|wxCLOSE_BOX|wxNO_FULL_REPAINT_ON_RESIZE) ) | |
1976 | { | |
1977 | SetIcon(wxICON(sample)); | |
1978 | ||
1979 | m_propGrid = NULL; | |
1980 | m_panel = NULL; | |
1981 | ||
1982 | #ifdef __WXMAC__ | |
1983 | // we need this in order to allow the about menu relocation, since ABOUT is | |
1984 | // not the default id of the about menu | |
1985 | wxApp::s_macAboutMenuItemId = ID_ABOUT; | |
1986 | #endif | |
1987 | ||
1988 | #if wxUSE_IMAGE | |
1989 | // This is here to really test the wxImageFileProperty. | |
1990 | wxInitAllImageHandlers(); | |
1991 | #endif | |
1992 | ||
1993 | // Register all editors (SpinCtrl etc.) | |
1994 | m_pPropGridManager->RegisterAdditionalEditors(); | |
1995 | ||
1996 | // Register our sample custom editors | |
1997 | m_pSampleMultiButtonEditor = | |
1998 | wxPropertyGrid::RegisterEditorClass(new wxSampleMultiButtonEditor()); | |
1999 | ||
2000 | CreateGrid( // style | |
2001 | wxPG_BOLD_MODIFIED | | |
2002 | wxPG_SPLITTER_AUTO_CENTER | | |
2003 | wxPG_AUTO_SORT | | |
2004 | //wxPG_HIDE_MARGIN|wxPG_STATIC_SPLITTER | | |
2005 | //wxPG_TOOLTIPS | | |
2006 | //wxPG_HIDE_CATEGORIES | | |
2007 | //wxPG_LIMITED_EDITING | | |
2008 | wxPG_TOOLBAR | | |
2009 | wxPG_DESCRIPTION, | |
2010 | // extra style | |
2011 | wxPG_EX_MODE_BUTTONS | | |
2012 | wxPG_EX_MULTIPLE_SELECTION | |
2013 | //| wxPG_EX_AUTO_UNSPECIFIED_VALUES | |
2014 | //| wxPG_EX_GREY_LABEL_WHEN_DISABLED | |
2015 | //| wxPG_EX_NATIVE_DOUBLE_BUFFERING | |
2016 | //| wxPG_EX_HELP_AS_TOOLTIPS | |
2017 | ); | |
2018 | ||
2019 | // | |
2020 | // Create menubar | |
2021 | wxMenu *menuFile = new wxMenu(wxEmptyString, wxMENU_TEAROFF); | |
2022 | wxMenu *menuTry = new wxMenu; | |
2023 | wxMenu *menuTools1 = new wxMenu; | |
2024 | wxMenu *menuTools2 = new wxMenu; | |
2025 | wxMenu *menuHelp = new wxMenu; | |
2026 | ||
2027 | menuHelp->Append(ID_ABOUT, wxT("&About..."), wxT("Show about dialog") ); | |
2028 | ||
2029 | menuTools1->Append(ID_APPENDPROP, wxT("Append New Property") ); | |
2030 | menuTools1->Append(ID_APPENDCAT, wxT("Append New Category\tCtrl-S") ); | |
2031 | menuTools1->AppendSeparator(); | |
2032 | menuTools1->Append(ID_INSERTPROP, wxT("Insert New Property\tCtrl-Q") ); | |
2033 | menuTools1->Append(ID_INSERTCAT, wxT("Insert New Category\tCtrl-W") ); | |
2034 | menuTools1->AppendSeparator(); | |
2035 | menuTools1->Append(ID_DELETE, wxT("Delete Selected") ); | |
2036 | menuTools1->Append(ID_DELETER, wxT("Delete Random") ); | |
2037 | menuTools1->Append(ID_DELETEALL, wxT("Delete All") ); | |
2038 | menuTools1->AppendSeparator(); | |
2039 | menuTools1->Append(ID_SETBGCOLOUR, wxT("Set Bg Colour") ); | |
2040 | menuTools1->Append(ID_SETBGCOLOURRECUR, wxT("Set Bg Colour (Recursively)") ); | |
2041 | menuTools1->Append(ID_UNSPECIFY, "Set Value to Unspecified"); | |
2042 | menuTools1->AppendSeparator(); | |
2043 | m_itemEnable = menuTools1->Append(ID_ENABLE, wxT("Enable"), | |
2044 | wxT("Toggles item's enabled state.") ); | |
2045 | m_itemEnable->Enable( FALSE ); | |
2046 | menuTools1->Append(ID_HIDE, "Hide", "Hides a property" ); | |
2047 | menuTools1->Append(ID_SETREADONLY, "Set as Read-Only", | |
2048 | "Set property as read-only" ); | |
2049 | ||
2050 | menuTools2->Append(ID_ITERATE1, wxT("Iterate Over Properties") ); | |
2051 | menuTools2->Append(ID_ITERATE2, wxT("Iterate Over Visible Items") ); | |
2052 | menuTools2->Append(ID_ITERATE3, wxT("Reverse Iterate Over Properties") ); | |
2053 | menuTools2->Append(ID_ITERATE4, wxT("Iterate Over Categories") ); | |
2054 | menuTools2->AppendSeparator(); | |
2055 | menuTools2->Append(ID_ONEXTENDEDKEYNAV, "Extend Keyboard Navigation", | |
2056 | "This will set Enter to navigate to next property, " | |
2057 | "and allows arrow keys to navigate even when in " | |
2058 | "editor control."); | |
2059 | menuTools2->AppendSeparator(); | |
2060 | menuTools2->Append(ID_SETPROPERTYVALUE, wxT("Set Property Value") ); | |
2061 | menuTools2->Append(ID_CLEARMODIF, wxT("Clear Modified Status"), wxT("Clears wxPG_MODIFIED flag from all properties.") ); | |
2062 | menuTools2->AppendSeparator(); | |
2063 | m_itemFreeze = menuTools2->AppendCheckItem(ID_FREEZE, wxT("Freeze"), | |
2064 | wxT("Disables painting, auto-sorting, etc.") ); | |
2065 | menuTools2->AppendSeparator(); | |
2066 | menuTools2->Append(ID_DUMPLIST, wxT("Display Values as wxVariant List"), wxT("Tests GetAllValues method and wxVariant conversion.") ); | |
2067 | menuTools2->AppendSeparator(); | |
2068 | menuTools2->Append(ID_GETVALUES, wxT("Get Property Values"), wxT("Stores all property values.") ); | |
2069 | menuTools2->Append(ID_SETVALUES, wxT("Set Property Values"), wxT("Reverts property values to those last stored.") ); | |
2070 | menuTools2->Append(ID_SETVALUES2, wxT("Set Property Values 2"), wxT("Adds property values that should not initially be as items (so new items are created).") ); | |
2071 | menuTools2->AppendSeparator(); | |
2072 | menuTools2->Append(ID_SAVESTATE, wxT("Save Editable State") ); | |
2073 | menuTools2->Append(ID_RESTORESTATE, wxT("Restore Editable State") ); | |
2074 | menuTools2->AppendSeparator(); | |
2075 | menuTools2->Append(ID_ENABLECOMMONVALUES, wxT("Enable Common Value"), | |
2076 | wxT("Enable values that are common to all properties, for selected property.")); | |
2077 | menuTools2->AppendSeparator(); | |
2078 | menuTools2->Append(ID_COLLAPSE, wxT("Collapse Selected") ); | |
2079 | menuTools2->Append(ID_COLLAPSEALL, wxT("Collapse All") ); | |
2080 | menuTools2->AppendSeparator(); | |
2081 | menuTools2->Append(ID_INSERTPAGE, wxT("Add Page") ); | |
2082 | menuTools2->Append(ID_REMOVEPAGE, wxT("Remove Page") ); | |
2083 | menuTools2->AppendSeparator(); | |
2084 | menuTools2->Append(ID_FITCOLUMNS, wxT("Fit Columns") ); | |
2085 | m_itemVetoDragging = | |
2086 | menuTools2->AppendCheckItem(ID_VETOCOLDRAG, | |
2087 | "Veto Column Dragging"); | |
2088 | menuTools2->AppendSeparator(); | |
2089 | menuTools2->Append(ID_CHANGEFLAGSITEMS, wxT("Change Children of FlagsProp") ); | |
2090 | menuTools2->AppendSeparator(); | |
2091 | menuTools2->Append(ID_TESTINSERTCHOICE, wxT("Test InsertPropertyChoice") ); | |
2092 | menuTools2->Append(ID_TESTDELETECHOICE, wxT("Test DeletePropertyChoice") ); | |
2093 | menuTools2->AppendSeparator(); | |
2094 | menuTools2->Append(ID_SETSPINCTRLEDITOR, wxT("Use SpinCtrl Editor") ); | |
2095 | menuTools2->Append(ID_TESTREPLACE, wxT("Test ReplaceProperty") ); | |
2096 | ||
2097 | menuTry->Append(ID_SELECTSTYLE, wxT("Set Window Style"), | |
2098 | wxT("Select window style flags used by the grid.")); | |
2099 | menuTry->Append(ID_ENABLELABELEDITING, "Enable label editing", | |
2100 | "This calls wxPropertyGrid::MakeColumnEditable(0)"); | |
2101 | menuTry->AppendCheckItem(ID_SHOWHEADER, | |
2102 | "Enable header", | |
2103 | "This calls wxPropertyGridManager::ShowHeader()"); | |
2104 | menuTry->AppendSeparator(); | |
2105 | menuTry->AppendRadioItem( ID_COLOURSCHEME1, wxT("Standard Colour Scheme") ); | |
2106 | menuTry->AppendRadioItem( ID_COLOURSCHEME2, wxT("White Colour Scheme") ); | |
2107 | menuTry->AppendRadioItem( ID_COLOURSCHEME3, wxT(".NET Colour Scheme") ); | |
2108 | menuTry->AppendRadioItem( ID_COLOURSCHEME4, wxT("Cream Colour Scheme") ); | |
2109 | menuTry->AppendSeparator(); | |
2110 | m_itemCatColours = menuTry->AppendCheckItem(ID_CATCOLOURS, wxT("Category Specific Colours"), | |
2111 | wxT("Switches between category-specific cell colours and default scheme (actually done using SetPropertyTextColour and SetPropertyBackgroundColour).") ); | |
2112 | menuTry->AppendSeparator(); | |
2113 | menuTry->AppendCheckItem(ID_STATICLAYOUT, wxT("Static Layout"), | |
2114 | wxT("Switches between user-modifiedable and static layouts.") ); | |
2115 | menuTry->Append(ID_SETCOLUMNS, wxT("Set Number of Columns") ); | |
2116 | menuTry->AppendSeparator(); | |
2117 | menuTry->Append(ID_TESTXRC, wxT("Display XRC sample") ); | |
2118 | menuTry->AppendSeparator(); | |
2119 | menuTry->Append(ID_RUNTESTFULL, wxT("Run Tests (full)") ); | |
2120 | menuTry->Append(ID_RUNTESTPARTIAL, wxT("Run Tests (fast)") ); | |
2121 | ||
2122 | menuFile->Append(ID_RUNMINIMAL, wxT("Run Minimal Sample") ); | |
2123 | menuFile->AppendSeparator(); | |
2124 | menuFile->Append(ID_QUIT, wxT("E&xit\tAlt-X"), wxT("Quit this program") ); | |
2125 | ||
2126 | // Now append the freshly created menu to the menu bar... | |
2127 | wxMenuBar *menuBar = new wxMenuBar(); | |
2128 | menuBar->Append(menuFile, wxT("&File") ); | |
2129 | menuBar->Append(menuTry, wxT("&Try These!") ); | |
2130 | menuBar->Append(menuTools1, wxT("&Basic") ); | |
2131 | menuBar->Append(menuTools2, wxT("&Advanced") ); | |
2132 | menuBar->Append(menuHelp, wxT("&Help") ); | |
2133 | ||
2134 | // ... and attach this menu bar to the frame | |
2135 | SetMenuBar(menuBar); | |
2136 | ||
2137 | #if wxUSE_STATUSBAR | |
2138 | // create a status bar | |
2139 | CreateStatusBar(1); | |
2140 | SetStatusText(wxEmptyString); | |
2141 | #endif // wxUSE_STATUSBAR | |
2142 | ||
2143 | FinalizeFramePosition(); | |
2144 | ||
2145 | #if wxUSE_LOGWINDOW | |
2146 | // Create log window | |
2147 | m_logWindow = new wxLogWindow(this, "Log Messages", false); | |
2148 | m_logWindow->GetFrame()->Move(GetPosition().x + GetSize().x + 10, | |
2149 | GetPosition().y); | |
2150 | m_logWindow->Show(); | |
2151 | #endif | |
2152 | } | |
2153 | ||
2154 | void FormMain::FinalizeFramePosition() | |
2155 | { | |
2156 | wxSize frameSize((wxSystemSettings::GetMetric(wxSYS_SCREEN_X)/10)*4, | |
2157 | (wxSystemSettings::GetMetric(wxSYS_SCREEN_Y)/10)*8); | |
2158 | ||
2159 | if ( frameSize.x > 500 ) | |
2160 | frameSize.x = 500; | |
2161 | ||
2162 | SetSize(frameSize); | |
2163 | ||
2164 | Centre(); | |
2165 | } | |
2166 | ||
2167 | // | |
2168 | // Normally, wxPropertyGrid does not check whether item with identical | |
2169 | // label already exists. However, since in this sample we use labels for | |
2170 | // identifying properties, we have to be sure not to generate identical | |
2171 | // labels. | |
2172 | // | |
2173 | void GenerateUniquePropertyLabel( wxPropertyGridManager* pg, wxString& baselabel ) | |
2174 | { | |
2175 | int count = -1; | |
2176 | wxString newlabel; | |
2177 | ||
2178 | if ( pg->GetPropertyByLabel( baselabel ) ) | |
2179 | { | |
2180 | for (;;) | |
2181 | { | |
2182 | count++; | |
2183 | newlabel.Printf(wxT("%s%i"),baselabel.c_str(),count); | |
2184 | if ( !pg->GetPropertyByLabel( newlabel ) ) break; | |
2185 | } | |
2186 | } | |
2187 | ||
2188 | if ( count >= 0 ) | |
2189 | { | |
2190 | baselabel = newlabel; | |
2191 | } | |
2192 | } | |
2193 | ||
2194 | // ----------------------------------------------------------------------- | |
2195 | ||
2196 | void FormMain::OnInsertPropClick( wxCommandEvent& WXUNUSED(event) ) | |
2197 | { | |
2198 | wxString propLabel; | |
2199 | ||
2200 | if ( !m_pPropGridManager->GetGrid()->GetRoot()->GetChildCount() ) | |
2201 | { | |
2202 | wxMessageBox(wxT("No items to relate - first add some with Append.")); | |
2203 | return; | |
2204 | } | |
2205 | ||
2206 | wxPGProperty* id = m_pPropGridManager->GetGrid()->GetSelection(); | |
2207 | if ( !id ) | |
2208 | { | |
2209 | wxMessageBox(wxT("First select a property - new one will be inserted right before that.")); | |
2210 | return; | |
2211 | } | |
2212 | if ( propLabel.Len() < 1 ) propLabel = wxT("Property"); | |
2213 | ||
2214 | GenerateUniquePropertyLabel( m_pPropGridManager, propLabel ); | |
2215 | ||
2216 | m_pPropGridManager->Insert( m_pPropGridManager->GetPropertyParent(id), | |
2217 | id->GetIndexInParent(), | |
2218 | new wxStringProperty(propLabel) ); | |
2219 | ||
2220 | } | |
2221 | ||
2222 | // ----------------------------------------------------------------------- | |
2223 | ||
2224 | void FormMain::OnAppendPropClick( wxCommandEvent& WXUNUSED(event) ) | |
2225 | { | |
2226 | wxString propLabel; | |
2227 | ||
2228 | if ( propLabel.Len() < 1 ) propLabel = wxT("Property"); | |
2229 | ||
2230 | GenerateUniquePropertyLabel( m_pPropGridManager, propLabel ); | |
2231 | ||
2232 | m_pPropGridManager->Append( new wxStringProperty(propLabel) ); | |
2233 | ||
2234 | m_pPropGridManager->Refresh(); | |
2235 | } | |
2236 | ||
2237 | // ----------------------------------------------------------------------- | |
2238 | ||
2239 | void FormMain::OnClearClick( wxCommandEvent& WXUNUSED(event) ) | |
2240 | { | |
2241 | m_pPropGridManager->GetGrid()->Clear(); | |
2242 | } | |
2243 | ||
2244 | // ----------------------------------------------------------------------- | |
2245 | ||
2246 | void FormMain::OnAppendCatClick( wxCommandEvent& WXUNUSED(event) ) | |
2247 | { | |
2248 | wxString propLabel; | |
2249 | ||
2250 | if ( propLabel.Len() < 1 ) propLabel = wxT("Category"); | |
2251 | ||
2252 | GenerateUniquePropertyLabel( m_pPropGridManager, propLabel ); | |
2253 | ||
2254 | m_pPropGridManager->Append( new wxPropertyCategory (propLabel) ); | |
2255 | ||
2256 | m_pPropGridManager->Refresh(); | |
2257 | ||
2258 | } | |
2259 | ||
2260 | // ----------------------------------------------------------------------- | |
2261 | ||
2262 | void FormMain::OnInsertCatClick( wxCommandEvent& WXUNUSED(event) ) | |
2263 | { | |
2264 | wxString propLabel; | |
2265 | ||
2266 | if ( !m_pPropGridManager->GetGrid()->GetRoot()->GetChildCount() ) | |
2267 | { | |
2268 | wxMessageBox(wxT("No items to relate - first add some with Append.")); | |
2269 | return; | |
2270 | } | |
2271 | ||
2272 | wxPGProperty* id = m_pPropGridManager->GetGrid()->GetSelection(); | |
2273 | if ( !id ) | |
2274 | { | |
2275 | wxMessageBox(wxT("First select a property - new one will be inserted right before that.")); | |
2276 | return; | |
2277 | } | |
2278 | ||
2279 | if ( propLabel.Len() < 1 ) propLabel = wxT("Category"); | |
2280 | ||
2281 | GenerateUniquePropertyLabel( m_pPropGridManager, propLabel ); | |
2282 | ||
2283 | m_pPropGridManager->Insert( m_pPropGridManager->GetPropertyParent(id), | |
2284 | id->GetIndexInParent(), | |
2285 | new wxPropertyCategory (propLabel) ); | |
2286 | } | |
2287 | ||
2288 | // ----------------------------------------------------------------------- | |
2289 | ||
2290 | void FormMain::OnDelPropClick( wxCommandEvent& WXUNUSED(event) ) | |
2291 | { | |
2292 | wxPGProperty* id = m_pPropGridManager->GetGrid()->GetSelection(); | |
2293 | if ( !id ) | |
2294 | { | |
2295 | wxMessageBox(wxT("First select a property.")); | |
2296 | return; | |
2297 | } | |
2298 | ||
2299 | m_pPropGridManager->DeleteProperty( id ); | |
2300 | } | |
2301 | ||
2302 | // ----------------------------------------------------------------------- | |
2303 | ||
2304 | void FormMain::OnDelPropRClick( wxCommandEvent& WXUNUSED(event) ) | |
2305 | { | |
2306 | // Delete random property | |
2307 | wxPGProperty* p = m_pPropGridManager->GetGrid()->GetRoot(); | |
2308 | ||
2309 | for (;;) | |
2310 | { | |
2311 | if ( !p->IsCategory() ) | |
2312 | { | |
2313 | m_pPropGridManager->DeleteProperty( p ); | |
2314 | break; | |
2315 | } | |
2316 | ||
2317 | if ( !p->GetChildCount() ) | |
2318 | break; | |
2319 | ||
2320 | int n = rand() % ((int)p->GetChildCount()); | |
2321 | ||
2322 | p = p->Item(n); | |
2323 | } | |
2324 | } | |
2325 | ||
2326 | // ----------------------------------------------------------------------- | |
2327 | ||
2328 | void FormMain::OnContextMenu( wxContextMenuEvent& event ) | |
2329 | { | |
2330 | wxLogDebug(wxT("FormMain::OnContextMenu(%i,%i)"), | |
2331 | event.GetPosition().x,event.GetPosition().y); | |
2332 | ||
2333 | wxUnusedVar(event); | |
2334 | ||
2335 | //event.Skip(); | |
2336 | } | |
2337 | ||
2338 | // ----------------------------------------------------------------------- | |
2339 | ||
2340 | void FormMain::OnCloseClick( wxCommandEvent& WXUNUSED(event) ) | |
2341 | { | |
2342 | /*#ifdef __WXDEBUG__ | |
2343 | m_pPropGridManager->GetGrid()->DumpAllocatedChoiceSets(); | |
2344 | wxLogDebug(wxT("\\-> Don't worry, this is perfectly normal in this sample.")); | |
2345 | #endif*/ | |
2346 | ||
2347 | Close(false); | |
2348 | } | |
2349 | ||
2350 | // ----------------------------------------------------------------------- | |
2351 | ||
2352 | int IterateMessage( wxPGProperty* prop ) | |
2353 | { | |
2354 | wxString s; | |
2355 | ||
2356 | s.Printf( wxT("\"%s\" class = %s, valuetype = %s"), prop->GetLabel().c_str(), | |
2357 | prop->GetClassInfo()->GetClassName(), prop->GetValueType().c_str() ); | |
2358 | ||
2359 | return wxMessageBox( s, wxT("Iterating... (press CANCEL to end)"), wxOK|wxCANCEL ); | |
2360 | } | |
2361 | ||
2362 | // ----------------------------------------------------------------------- | |
2363 | ||
2364 | void FormMain::OnIterate1Click( wxCommandEvent& WXUNUSED(event) ) | |
2365 | { | |
2366 | wxPropertyGridIterator it; | |
2367 | ||
2368 | for ( it = m_pPropGridManager->GetCurrentPage()-> | |
2369 | GetIterator(); | |
2370 | !it.AtEnd(); | |
2371 | it++ ) | |
2372 | { | |
2373 | wxPGProperty* p = *it; | |
2374 | int res = IterateMessage( p ); | |
2375 | if ( res == wxCANCEL ) break; | |
2376 | } | |
2377 | } | |
2378 | ||
2379 | // ----------------------------------------------------------------------- | |
2380 | ||
2381 | void FormMain::OnIterate2Click( wxCommandEvent& WXUNUSED(event) ) | |
2382 | { | |
2383 | wxPropertyGridIterator it; | |
2384 | ||
2385 | for ( it = m_pPropGridManager->GetCurrentPage()-> | |
2386 | GetIterator( wxPG_ITERATE_VISIBLE ); | |
2387 | !it.AtEnd(); | |
2388 | it++ ) | |
2389 | { | |
2390 | wxPGProperty* p = *it; | |
2391 | ||
2392 | int res = IterateMessage( p ); | |
2393 | if ( res == wxCANCEL ) break; | |
2394 | } | |
2395 | } | |
2396 | ||
2397 | // ----------------------------------------------------------------------- | |
2398 | ||
2399 | void FormMain::OnIterate3Click( wxCommandEvent& WXUNUSED(event) ) | |
2400 | { | |
2401 | // iterate over items in reverse order | |
2402 | wxPropertyGridIterator it; | |
2403 | ||
2404 | for ( it = m_pPropGridManager->GetCurrentPage()-> | |
2405 | GetIterator( wxPG_ITERATE_DEFAULT, wxBOTTOM ); | |
2406 | !it.AtEnd(); | |
2407 | it-- ) | |
2408 | { | |
2409 | wxPGProperty* p = *it; | |
2410 | ||
2411 | int res = IterateMessage( p ); | |
2412 | if ( res == wxCANCEL ) break; | |
2413 | } | |
2414 | } | |
2415 | ||
2416 | // ----------------------------------------------------------------------- | |
2417 | ||
2418 | void FormMain::OnIterate4Click( wxCommandEvent& WXUNUSED(event) ) | |
2419 | { | |
2420 | wxPropertyGridIterator it; | |
2421 | ||
2422 | for ( it = m_pPropGridManager->GetCurrentPage()-> | |
2423 | GetIterator( wxPG_ITERATE_CATEGORIES ); | |
2424 | !it.AtEnd(); | |
2425 | it++ ) | |
2426 | { | |
2427 | wxPGProperty* p = *it; | |
2428 | ||
2429 | int res = IterateMessage( p ); | |
2430 | if ( res == wxCANCEL ) break; | |
2431 | } | |
2432 | } | |
2433 | ||
2434 | // ----------------------------------------------------------------------- | |
2435 | ||
2436 | void FormMain::OnExtendedKeyNav( wxCommandEvent& WXUNUSED(event) ) | |
2437 | { | |
2438 | // Use AddActionTrigger() and DedicateKey() to set up Enter, | |
2439 | // Up, and Down keys for navigating between properties. | |
2440 | wxPropertyGrid* propGrid = m_pPropGridManager->GetGrid(); | |
2441 | ||
2442 | propGrid->AddActionTrigger(wxPG_ACTION_NEXT_PROPERTY, | |
2443 | WXK_RETURN); | |
2444 | propGrid->DedicateKey(WXK_RETURN); | |
2445 | ||
2446 | // Up and Down keys are alredy associated with navigation, | |
2447 | // but we must also prevent them from being eaten by | |
2448 | // editor controls. | |
2449 | propGrid->DedicateKey(WXK_UP); | |
2450 | propGrid->DedicateKey(WXK_DOWN); | |
2451 | } | |
2452 | ||
2453 | // ----------------------------------------------------------------------- | |
2454 | ||
2455 | void FormMain::OnFitColumnsClick( wxCommandEvent& WXUNUSED(event) ) | |
2456 | { | |
2457 | wxPropertyGridPage* page = m_pPropGridManager->GetCurrentPage(); | |
2458 | ||
2459 | // Remove auto-centering | |
2460 | m_pPropGridManager->SetWindowStyle( m_pPropGridManager->GetWindowStyle() & ~wxPG_SPLITTER_AUTO_CENTER); | |
2461 | ||
2462 | // Grow manager size just prior fit - otherwise | |
2463 | // column information may be lost. | |
2464 | wxSize oldGridSize = m_pPropGridManager->GetGrid()->GetClientSize(); | |
2465 | wxSize oldFullSize = GetSize(); | |
2466 | SetSize(1000, oldFullSize.y); | |
2467 | ||
2468 | wxSize newSz = page->FitColumns(); | |
2469 | ||
2470 | int dx = oldFullSize.x - oldGridSize.x; | |
2471 | int dy = oldFullSize.y - oldGridSize.y; | |
2472 | ||
2473 | newSz.x += dx; | |
2474 | newSz.y += dy; | |
2475 | ||
2476 | SetSize(newSz); | |
2477 | } | |
2478 | ||
2479 | // ----------------------------------------------------------------------- | |
2480 | ||
2481 | void FormMain::OnChangeFlagsPropItemsClick( wxCommandEvent& WXUNUSED(event) ) | |
2482 | { | |
2483 | wxPGProperty* p = m_pPropGridManager->GetPropertyByName(wxT("Window Styles")); | |
2484 | ||
2485 | wxPGChoices newChoices; | |
2486 | ||
2487 | newChoices.Add(wxT("Fast"),0x1); | |
2488 | newChoices.Add(wxT("Powerful"),0x2); | |
2489 | newChoices.Add(wxT("Safe"),0x4); | |
2490 | newChoices.Add(wxT("Sleek"),0x8); | |
2491 | ||
2492 | p->SetChoices(newChoices); | |
2493 | } | |
2494 | ||
2495 | // ----------------------------------------------------------------------- | |
2496 | ||
2497 | void FormMain::OnEnableDisable( wxCommandEvent& ) | |
2498 | { | |
2499 | wxPGProperty* id = m_pPropGridManager->GetGrid()->GetSelection(); | |
2500 | if ( !id ) | |
2501 | { | |
2502 | wxMessageBox(wxT("First select a property.")); | |
2503 | return; | |
2504 | } | |
2505 | ||
2506 | if ( m_pPropGridManager->IsPropertyEnabled( id ) ) | |
2507 | { | |
2508 | m_pPropGridManager->DisableProperty ( id ); | |
2509 | m_itemEnable->SetItemLabel( wxT("Enable") ); | |
2510 | } | |
2511 | else | |
2512 | { | |
2513 | m_pPropGridManager->EnableProperty ( id ); | |
2514 | m_itemEnable->SetItemLabel( wxT("Disable") ); | |
2515 | } | |
2516 | } | |
2517 | ||
2518 | // ----------------------------------------------------------------------- | |
2519 | ||
2520 | void FormMain::OnSetReadOnly( wxCommandEvent& WXUNUSED(event) ) | |
2521 | { | |
2522 | wxPGProperty* p = m_pPropGridManager->GetGrid()->GetSelection(); | |
2523 | if ( !p ) | |
2524 | { | |
2525 | wxMessageBox(wxT("First select a property.")); | |
2526 | return; | |
2527 | } | |
2528 | m_pPropGridManager->SetPropertyReadOnly(p); | |
2529 | } | |
2530 | ||
2531 | // ----------------------------------------------------------------------- | |
2532 | ||
2533 | void FormMain::OnHide( wxCommandEvent& WXUNUSED(event) ) | |
2534 | { | |
2535 | wxPGProperty* id = m_pPropGridManager->GetGrid()->GetSelection(); | |
2536 | if ( !id ) | |
2537 | { | |
2538 | wxMessageBox(wxT("First select a property.")); | |
2539 | return; | |
2540 | } | |
2541 | ||
2542 | m_pPropGridManager->HideProperty( id, true ); | |
2543 | } | |
2544 | ||
2545 | // ----------------------------------------------------------------------- | |
2546 | ||
2547 | #include "wx/colordlg.h" | |
2548 | ||
2549 | void | |
2550 | FormMain::OnSetBackgroundColour( wxCommandEvent& event ) | |
2551 | { | |
2552 | wxPropertyGrid* pg = m_pPropGridManager->GetGrid(); | |
2553 | wxPGProperty* prop = pg->GetSelection(); | |
2554 | if ( !prop ) | |
2555 | { | |
2556 | wxMessageBox(wxT("First select a property.")); | |
2557 | return; | |
2558 | } | |
2559 | ||
2560 | wxColour col = ::wxGetColourFromUser(this, *wxWHITE, "Choose colour"); | |
2561 | ||
2562 | if ( col.IsOk() ) | |
2563 | { | |
2564 | bool recursively = (event.GetId()==ID_SETBGCOLOURRECUR) ? true : false; | |
2565 | pg->SetPropertyBackgroundColour(prop, col, recursively); | |
2566 | } | |
2567 | } | |
2568 | ||
2569 | // ----------------------------------------------------------------------- | |
2570 | ||
2571 | void FormMain::OnInsertPage( wxCommandEvent& WXUNUSED(event) ) | |
2572 | { | |
2573 | m_pPropGridManager->AddPage(wxT("New Page")); | |
2574 | } | |
2575 | ||
2576 | // ----------------------------------------------------------------------- | |
2577 | ||
2578 | void FormMain::OnRemovePage( wxCommandEvent& WXUNUSED(event) ) | |
2579 | { | |
2580 | m_pPropGridManager->RemovePage(m_pPropGridManager->GetSelectedPage()); | |
2581 | } | |
2582 | ||
2583 | // ----------------------------------------------------------------------- | |
2584 | ||
2585 | void FormMain::OnSaveState( wxCommandEvent& WXUNUSED(event) ) | |
2586 | { | |
2587 | m_savedState = m_pPropGridManager->SaveEditableState(); | |
2588 | wxLogDebug(wxT("Saved editable state string: \"%s\""), m_savedState.c_str()); | |
2589 | } | |
2590 | ||
2591 | // ----------------------------------------------------------------------- | |
2592 | ||
2593 | void FormMain::OnRestoreState( wxCommandEvent& WXUNUSED(event) ) | |
2594 | { | |
2595 | m_pPropGridManager->RestoreEditableState(m_savedState); | |
2596 | } | |
2597 | ||
2598 | // ----------------------------------------------------------------------- | |
2599 | ||
2600 | void FormMain::OnSetSpinCtrlEditorClick( wxCommandEvent& WXUNUSED(event) ) | |
2601 | { | |
2602 | #if wxUSE_SPINBTN | |
2603 | wxPGProperty* pgId = m_pPropGridManager->GetSelection(); | |
2604 | if ( pgId ) | |
2605 | m_pPropGridManager->SetPropertyEditor( pgId, wxPGEditor_SpinCtrl ); | |
2606 | else | |
2607 | wxMessageBox(wxT("First select a property")); | |
2608 | #endif | |
2609 | } | |
2610 | ||
2611 | // ----------------------------------------------------------------------- | |
2612 | ||
2613 | void FormMain::OnTestReplaceClick( wxCommandEvent& WXUNUSED(event) ) | |
2614 | { | |
2615 | wxPGProperty* pgId = m_pPropGridManager->GetSelection(); | |
2616 | if ( pgId ) | |
2617 | { | |
2618 | wxPGChoices choices; | |
2619 | choices.Add(wxT("Flag 0"),0x0001); | |
2620 | choices.Add(wxT("Flag 1"),0x0002); | |
2621 | choices.Add(wxT("Flag 2"),0x0004); | |
2622 | choices.Add(wxT("Flag 3"),0x0008); | |
2623 | wxPGProperty* newId = m_pPropGridManager->ReplaceProperty( pgId, | |
2624 | new wxFlagsProperty(wxT("ReplaceFlagsProperty"), wxPG_LABEL, choices, 0x0003) ); | |
2625 | m_pPropGridManager->SetPropertyAttribute( newId, | |
2626 | wxPG_BOOL_USE_CHECKBOX, | |
2627 | true, | |
2628 | wxPG_RECURSE ); | |
2629 | } | |
2630 | else | |
2631 | wxMessageBox(wxT("First select a property")); | |
2632 | } | |
2633 | ||
2634 | // ----------------------------------------------------------------------- | |
2635 | ||
2636 | void FormMain::OnClearModifyStatusClick( wxCommandEvent& WXUNUSED(event) ) | |
2637 | { | |
2638 | m_pPropGridManager->ClearModifiedStatus(); | |
2639 | } | |
2640 | ||
2641 | // ----------------------------------------------------------------------- | |
2642 | ||
2643 | // Freeze check-box checked? | |
2644 | void FormMain::OnFreezeClick( wxCommandEvent& event ) | |
2645 | { | |
2646 | if ( !m_pPropGridManager ) return; | |
2647 | ||
2648 | if ( event.IsChecked() ) | |
2649 | { | |
2650 | if ( !m_pPropGridManager->IsFrozen() ) | |
2651 | { | |
2652 | m_pPropGridManager->Freeze(); | |
2653 | } | |
2654 | } | |
2655 | else | |
2656 | { | |
2657 | if ( m_pPropGridManager->IsFrozen() ) | |
2658 | { | |
2659 | m_pPropGridManager->Thaw(); | |
2660 | m_pPropGridManager->Refresh(); | |
2661 | } | |
2662 | } | |
2663 | } | |
2664 | ||
2665 | // ----------------------------------------------------------------------- | |
2666 | ||
2667 | void FormMain::OnEnableLabelEditing( wxCommandEvent& WXUNUSED(event) ) | |
2668 | { | |
2669 | m_propGrid->MakeColumnEditable(0); | |
2670 | } | |
2671 | ||
2672 | // ----------------------------------------------------------------------- | |
2673 | ||
2674 | void FormMain::OnShowHeader( wxCommandEvent& event ) | |
2675 | { | |
2676 | m_pPropGridManager->ShowHeader(event.IsChecked()); | |
2677 | m_pPropGridManager->SetColumnTitle(2, _("Units")); | |
2678 | } | |
2679 | ||
2680 | // ----------------------------------------------------------------------- | |
2681 | ||
2682 | void FormMain::OnAbout(wxCommandEvent& WXUNUSED(event)) | |
2683 | { | |
2684 | wxString msg; | |
2685 | msg.Printf( wxT("wxPropertyGrid Sample") | |
2686 | #if wxUSE_UNICODE | |
2687 | #if defined(wxUSE_UNICODE_UTF8) && wxUSE_UNICODE_UTF8 | |
2688 | wxT(" <utf-8>") | |
2689 | #else | |
2690 | wxT(" <unicode>") | |
2691 | #endif | |
2692 | #else | |
2693 | wxT(" <ansi>") | |
2694 | #endif | |
2695 | #ifdef __WXDEBUG__ | |
2696 | wxT(" <debug>") | |
2697 | #else | |
2698 | wxT(" <release>") | |
2699 | #endif | |
2700 | wxT("\n\n") | |
2701 | wxT("Programmed by %s\n\n") | |
2702 | wxT("Using %s\n\n"), | |
2703 | wxT("Jaakko Salli"), wxVERSION_STRING | |
2704 | ); | |
2705 | ||
2706 | wxMessageBox(msg, wxT("About"), wxOK | wxICON_INFORMATION, this); | |
2707 | } | |
2708 | ||
2709 | // ----------------------------------------------------------------------- | |
2710 | ||
2711 | void FormMain::OnColourScheme( wxCommandEvent& event ) | |
2712 | { | |
2713 | int id = event.GetId(); | |
2714 | if ( id == ID_COLOURSCHEME1 ) | |
2715 | { | |
2716 | m_pPropGridManager->GetGrid()->ResetColours(); | |
2717 | } | |
2718 | else if ( id == ID_COLOURSCHEME2 ) | |
2719 | { | |
2720 | // white | |
2721 | wxColour my_grey_1(212,208,200); | |
2722 | wxColour my_grey_3(113,111,100); | |
2723 | m_pPropGridManager->Freeze(); | |
2724 | m_pPropGridManager->GetGrid()->SetMarginColour( *wxWHITE ); | |
2725 | m_pPropGridManager->GetGrid()->SetCaptionBackgroundColour( *wxWHITE ); | |
2726 | m_pPropGridManager->GetGrid()->SetCellBackgroundColour( *wxWHITE ); | |
2727 | m_pPropGridManager->GetGrid()->SetCellTextColour( my_grey_3 ); | |
2728 | m_pPropGridManager->GetGrid()->SetLineColour( my_grey_1 ); //wxColour(160,160,160) | |
2729 | m_pPropGridManager->Thaw(); | |
2730 | } | |
2731 | else if ( id == ID_COLOURSCHEME3 ) | |
2732 | { | |
2733 | // .NET | |
2734 | wxColour my_grey_1(212,208,200); | |
2735 | wxColour my_grey_2(236,233,216); | |
2736 | m_pPropGridManager->Freeze(); | |
2737 | m_pPropGridManager->GetGrid()->SetMarginColour( my_grey_1 ); | |
2738 | m_pPropGridManager->GetGrid()->SetCaptionBackgroundColour( my_grey_1 ); | |
2739 | m_pPropGridManager->GetGrid()->SetLineColour( my_grey_1 ); | |
2740 | m_pPropGridManager->Thaw(); | |
2741 | } | |
2742 | else if ( id == ID_COLOURSCHEME4 ) | |
2743 | { | |
2744 | // cream | |
2745 | ||
2746 | wxColour my_grey_1(212,208,200); | |
2747 | wxColour my_grey_2(241,239,226); | |
2748 | wxColour my_grey_3(113,111,100); | |
2749 | m_pPropGridManager->Freeze(); | |
2750 | m_pPropGridManager->GetGrid()->SetMarginColour( *wxWHITE ); | |
2751 | m_pPropGridManager->GetGrid()->SetCaptionBackgroundColour( *wxWHITE ); | |
2752 | m_pPropGridManager->GetGrid()->SetCellBackgroundColour( my_grey_2 ); | |
2753 | m_pPropGridManager->GetGrid()->SetCellBackgroundColour( my_grey_2 ); | |
2754 | m_pPropGridManager->GetGrid()->SetCellTextColour( my_grey_3 ); | |
2755 | m_pPropGridManager->GetGrid()->SetLineColour( my_grey_1 ); | |
2756 | m_pPropGridManager->Thaw(); | |
2757 | } | |
2758 | } | |
2759 | ||
2760 | // ----------------------------------------------------------------------- | |
2761 | ||
2762 | void FormMain::OnCatColours( wxCommandEvent& event ) | |
2763 | { | |
2764 | wxPropertyGrid* pg = m_pPropGridManager->GetGrid(); | |
2765 | m_pPropGridManager->Freeze(); | |
2766 | ||
2767 | if ( event.IsChecked() ) | |
2768 | { | |
2769 | // Set custom colours. | |
2770 | pg->SetPropertyTextColour( wxT("Appearance"), wxColour(255,0,0), false ); | |
2771 | pg->SetPropertyBackgroundColour( wxT("Appearance"), wxColour(255,255,183) ); | |
2772 | pg->SetPropertyTextColour( wxT("Appearance"), wxColour(255,0,183) ); | |
2773 | pg->SetPropertyTextColour( wxT("PositionCategory"), wxColour(0,255,0), false ); | |
2774 | pg->SetPropertyBackgroundColour( wxT("PositionCategory"), wxColour(255,226,190) ); | |
2775 | pg->SetPropertyTextColour( wxT("PositionCategory"), wxColour(255,0,190) ); | |
2776 | pg->SetPropertyTextColour( wxT("Environment"), wxColour(0,0,255), false ); | |
2777 | pg->SetPropertyBackgroundColour( wxT("Environment"), wxColour(208,240,175) ); | |
2778 | pg->SetPropertyTextColour( wxT("Environment"), wxColour(255,255,255) ); | |
2779 | pg->SetPropertyBackgroundColour( wxT("More Examples"), wxColour(172,237,255) ); | |
2780 | pg->SetPropertyTextColour( wxT("More Examples"), wxColour(172,0,255) ); | |
2781 | } | |
2782 | else | |
2783 | { | |
2784 | // Revert to original. | |
2785 | pg->SetPropertyColoursToDefault( wxT("Appearance") ); | |
2786 | pg->SetPropertyColoursToDefault( wxT("PositionCategory") ); | |
2787 | pg->SetPropertyColoursToDefault( wxT("Environment") ); | |
2788 | pg->SetPropertyColoursToDefault( wxT("More Examples") ); | |
2789 | } | |
2790 | m_pPropGridManager->Thaw(); | |
2791 | m_pPropGridManager->Refresh(); | |
2792 | } | |
2793 | ||
2794 | // ----------------------------------------------------------------------- | |
2795 | ||
2796 | #define ADD_FLAG(FLAG) \ | |
2797 | chs.Add(wxT(#FLAG)); \ | |
2798 | vls.Add(FLAG); \ | |
2799 | if ( (flags & FLAG) == FLAG ) sel.Add(ind); \ | |
2800 | ind++; | |
2801 | ||
2802 | void FormMain::OnSelectStyle( wxCommandEvent& WXUNUSED(event) ) | |
2803 | { | |
2804 | int style = 0; | |
2805 | int extraStyle = 0; | |
2806 | ||
2807 | { | |
2808 | wxArrayString chs; | |
2809 | wxArrayInt vls; | |
2810 | wxArrayInt sel; | |
2811 | unsigned int ind = 0; | |
2812 | int flags = m_pPropGridManager->GetWindowStyle(); | |
2813 | ADD_FLAG(wxPG_HIDE_CATEGORIES) | |
2814 | ADD_FLAG(wxPG_AUTO_SORT) | |
2815 | ADD_FLAG(wxPG_BOLD_MODIFIED) | |
2816 | ADD_FLAG(wxPG_SPLITTER_AUTO_CENTER) | |
2817 | ADD_FLAG(wxPG_TOOLTIPS) | |
2818 | ADD_FLAG(wxPG_STATIC_SPLITTER) | |
2819 | ADD_FLAG(wxPG_HIDE_MARGIN) | |
2820 | ADD_FLAG(wxPG_LIMITED_EDITING) | |
2821 | ADD_FLAG(wxPG_TOOLBAR) | |
2822 | ADD_FLAG(wxPG_DESCRIPTION) | |
2823 | ADD_FLAG(wxPG_NO_INTERNAL_BORDER) | |
2824 | wxMultiChoiceDialog dlg( this, wxT("Select window styles to use"), | |
2825 | wxT("wxPropertyGrid Window Style"), chs ); | |
2826 | dlg.SetSelections(sel); | |
2827 | if ( dlg.ShowModal() == wxID_CANCEL ) | |
2828 | return; | |
2829 | ||
2830 | flags = 0; | |
2831 | sel = dlg.GetSelections(); | |
2832 | for ( ind = 0; ind < sel.size(); ind++ ) | |
2833 | flags |= vls[sel[ind]]; | |
2834 | ||
2835 | style = flags; | |
2836 | } | |
2837 | ||
2838 | { | |
2839 | wxArrayString chs; | |
2840 | wxArrayInt vls; | |
2841 | wxArrayInt sel; | |
2842 | unsigned int ind = 0; | |
2843 | int flags = m_pPropGridManager->GetExtraStyle(); | |
2844 | ADD_FLAG(wxPG_EX_INIT_NOCAT) | |
2845 | ADD_FLAG(wxPG_EX_NO_FLAT_TOOLBAR) | |
2846 | ADD_FLAG(wxPG_EX_MODE_BUTTONS) | |
2847 | ADD_FLAG(wxPG_EX_HELP_AS_TOOLTIPS) | |
2848 | ADD_FLAG(wxPG_EX_NATIVE_DOUBLE_BUFFERING) | |
2849 | ADD_FLAG(wxPG_EX_AUTO_UNSPECIFIED_VALUES) | |
2850 | ADD_FLAG(wxPG_EX_WRITEONLY_BUILTIN_ATTRIBUTES) | |
2851 | ADD_FLAG(wxPG_EX_HIDE_PAGE_BUTTONS) | |
2852 | ADD_FLAG(wxPG_EX_MULTIPLE_SELECTION) | |
2853 | ADD_FLAG(wxPG_EX_ENABLE_TLP_TRACKING) | |
2854 | ADD_FLAG(wxPG_EX_NO_TOOLBAR_DIVIDER) | |
2855 | ADD_FLAG(wxPG_EX_TOOLBAR_SEPARATOR) | |
2856 | wxMultiChoiceDialog dlg( this, wxT("Select extra window styles to use"), | |
2857 | wxT("wxPropertyGrid Extra Style"), chs ); | |
2858 | dlg.SetSelections(sel); | |
2859 | if ( dlg.ShowModal() == wxID_CANCEL ) | |
2860 | return; | |
2861 | ||
2862 | flags = 0; | |
2863 | sel = dlg.GetSelections(); | |
2864 | for ( ind = 0; ind < sel.size(); ind++ ) | |
2865 | flags |= vls[sel[ind]]; | |
2866 | ||
2867 | extraStyle = flags; | |
2868 | } | |
2869 | ||
2870 | CreateGrid( style, extraStyle ); | |
2871 | ||
2872 | FinalizeFramePosition(); | |
2873 | } | |
2874 | ||
2875 | // ----------------------------------------------------------------------- | |
2876 | ||
2877 | void FormMain::OnSetColumns( wxCommandEvent& WXUNUSED(event) ) | |
2878 | { | |
2879 | long colCount = ::wxGetNumberFromUser(wxT("Enter number of columns (2-20)."),wxT("Columns:"), | |
2880 | wxT("Change Columns"),m_pPropGridManager->GetColumnCount(), | |
2881 | 2,20); | |
2882 | ||
2883 | if ( colCount >= 2 ) | |
2884 | { | |
2885 | m_pPropGridManager->SetColumnCount(colCount); | |
2886 | } | |
2887 | } | |
2888 | ||
2889 | // ----------------------------------------------------------------------- | |
2890 | ||
2891 | void FormMain::OnSetPropertyValue( wxCommandEvent& WXUNUSED(event) ) | |
2892 | { | |
2893 | wxPropertyGrid* pg = m_pPropGridManager->GetGrid(); | |
2894 | wxPGProperty* selected = pg->GetSelection(); | |
2895 | ||
2896 | if ( selected ) | |
2897 | { | |
2898 | wxString value = ::wxGetTextFromUser( wxT("Enter new value:") ); | |
2899 | pg->SetPropertyValue( selected, value ); | |
2900 | } | |
2901 | } | |
2902 | ||
2903 | // ----------------------------------------------------------------------- | |
2904 | ||
2905 | void FormMain::OnInsertChoice( wxCommandEvent& WXUNUSED(event) ) | |
2906 | { | |
2907 | wxPropertyGrid* pg = m_pPropGridManager->GetGrid(); | |
2908 | ||
2909 | wxPGProperty* selected = pg->GetSelection(); | |
2910 | const wxPGChoices& choices = selected->GetChoices(); | |
2911 | ||
2912 | // Insert new choice to the center of list | |
2913 | ||
2914 | if ( choices.IsOk() ) | |
2915 | { | |
2916 | int pos = choices.GetCount() / 2; | |
2917 | selected->InsertChoice(wxT("New Choice"), pos); | |
2918 | } | |
2919 | else | |
2920 | { | |
2921 | ::wxMessageBox(wxT("First select a property with some choices.")); | |
2922 | } | |
2923 | } | |
2924 | ||
2925 | // ----------------------------------------------------------------------- | |
2926 | ||
2927 | void FormMain::OnDeleteChoice( wxCommandEvent& WXUNUSED(event) ) | |
2928 | { | |
2929 | wxPropertyGrid* pg = m_pPropGridManager->GetGrid(); | |
2930 | ||
2931 | wxPGProperty* selected = pg->GetSelection(); | |
2932 | const wxPGChoices& choices = selected->GetChoices(); | |
2933 | ||
2934 | // Deletes choice from the center of list | |
2935 | ||
2936 | if ( choices.IsOk() ) | |
2937 | { | |
2938 | int pos = choices.GetCount() / 2; | |
2939 | selected->DeleteChoice(pos); | |
2940 | } | |
2941 | else | |
2942 | { | |
2943 | ::wxMessageBox(wxT("First select a property with some choices.")); | |
2944 | } | |
2945 | } | |
2946 | ||
2947 | // ----------------------------------------------------------------------- | |
2948 | ||
2949 | #include <wx/colordlg.h> | |
2950 | ||
2951 | void FormMain::OnMisc ( wxCommandEvent& event ) | |
2952 | { | |
2953 | int id = event.GetId(); | |
2954 | if ( id == ID_STATICLAYOUT ) | |
2955 | { | |
2956 | long wsf = m_pPropGridManager->GetWindowStyleFlag(); | |
2957 | if ( event.IsChecked() ) m_pPropGridManager->SetWindowStyleFlag( wsf|wxPG_STATIC_LAYOUT ); | |
2958 | else m_pPropGridManager->SetWindowStyleFlag( wsf&~(wxPG_STATIC_LAYOUT) ); | |
2959 | } | |
2960 | else if ( id == ID_COLLAPSEALL ) | |
2961 | { | |
2962 | wxPGVIterator it; | |
2963 | wxPropertyGrid* pg = m_pPropGridManager->GetGrid(); | |
2964 | ||
2965 | for ( it = pg->GetVIterator( wxPG_ITERATE_ALL ); !it.AtEnd(); it.Next() ) | |
2966 | it.GetProperty()->SetExpanded( false ); | |
2967 | ||
2968 | pg->RefreshGrid(); | |
2969 | } | |
2970 | else if ( id == ID_GETVALUES ) | |
2971 | { | |
2972 | m_storedValues = m_pPropGridManager->GetGrid()->GetPropertyValues(wxT("Test"), | |
2973 | m_pPropGridManager->GetGrid()->GetRoot(), | |
2974 | wxPG_KEEP_STRUCTURE|wxPG_INC_ATTRIBUTES); | |
2975 | } | |
2976 | else if ( id == ID_SETVALUES ) | |
2977 | { | |
2978 | if ( m_storedValues.GetType() == wxT("list") ) | |
2979 | { | |
2980 | m_pPropGridManager->GetGrid()->SetPropertyValues(m_storedValues); | |
2981 | } | |
2982 | else | |
2983 | wxMessageBox(wxT("First use Get Property Values.")); | |
2984 | } | |
2985 | else if ( id == ID_SETVALUES2 ) | |
2986 | { | |
2987 | wxVariant list; | |
2988 | list.NullList(); | |
2989 | list.Append( wxVariant((long)1234,wxT("VariantLong")) ); | |
2990 | list.Append( wxVariant((bool)TRUE,wxT("VariantBool")) ); | |
2991 | list.Append( wxVariant(wxT("Test Text"),wxT("VariantString")) ); | |
2992 | m_pPropGridManager->GetGrid()->SetPropertyValues(list); | |
2993 | } | |
2994 | else if ( id == ID_COLLAPSE ) | |
2995 | { | |
2996 | // Collapses selected. | |
2997 | wxPGProperty* id = m_pPropGridManager->GetSelection(); | |
2998 | if ( id ) | |
2999 | { | |
3000 | m_pPropGridManager->Collapse(id); | |
3001 | } | |
3002 | } | |
3003 | else if ( id == ID_RUNTESTFULL ) | |
3004 | { | |
3005 | // Runs a regression test. | |
3006 | RunTests(true); | |
3007 | } | |
3008 | else if ( id == ID_RUNTESTPARTIAL ) | |
3009 | { | |
3010 | // Runs a regression test. | |
3011 | RunTests(false); | |
3012 | } | |
3013 | else if ( id == ID_UNSPECIFY ) | |
3014 | { | |
3015 | wxPGProperty* prop = m_pPropGridManager->GetSelection(); | |
3016 | if ( prop ) | |
3017 | { | |
3018 | m_pPropGridManager->SetPropertyValueUnspecified(prop); | |
3019 | prop->RefreshEditor(); | |
3020 | } | |
3021 | } | |
3022 | } | |
3023 | ||
3024 | // ----------------------------------------------------------------------- | |
3025 | ||
3026 | void FormMain::OnPopulateClick( wxCommandEvent& event ) | |
3027 | { | |
3028 | int id = event.GetId(); | |
3029 | m_propGrid->Clear(); | |
3030 | m_propGrid->Freeze(); | |
3031 | if ( id == ID_POPULATE1 ) | |
3032 | { | |
3033 | PopulateWithStandardItems(); | |
3034 | } | |
3035 | else if ( id == ID_POPULATE2 ) | |
3036 | { | |
3037 | PopulateWithLibraryConfig(); | |
3038 | } | |
3039 | m_propGrid->Thaw(); | |
3040 | } | |
3041 | ||
3042 | // ----------------------------------------------------------------------- | |
3043 | ||
3044 | void DisplayMinimalFrame(wxWindow* parent); // in minimal.cpp | |
3045 | ||
3046 | void FormMain::OnRunMinimalClick( wxCommandEvent& WXUNUSED(event) ) | |
3047 | { | |
3048 | DisplayMinimalFrame(this); | |
3049 | } | |
3050 | ||
3051 | // ----------------------------------------------------------------------- | |
3052 | ||
3053 | FormMain::~FormMain() | |
3054 | { | |
3055 | } | |
3056 | ||
3057 | // ----------------------------------------------------------------------- | |
3058 | ||
3059 | IMPLEMENT_APP(cxApplication) | |
3060 | ||
3061 | bool cxApplication::OnInit() | |
3062 | { | |
3063 | //wxLocale Locale; | |
3064 | //Locale.Init(wxLANGUAGE_FINNISH); | |
3065 | ||
3066 | FormMain* frame = Form1 = new FormMain( wxT("wxPropertyGrid Sample"), wxPoint(0,0), wxSize(300,500) ); | |
3067 | frame->Show(true); | |
3068 | ||
3069 | // | |
3070 | // Parse command-line | |
3071 | wxApp& app = wxGetApp(); | |
3072 | if ( app.argc > 1 ) | |
3073 | { | |
3074 | wxString s = app.argv[1]; | |
3075 | if ( s == wxT("--run-tests") ) | |
3076 | { | |
3077 | // | |
3078 | // Run tests | |
3079 | bool testResult = frame->RunTests(true); | |
3080 | ||
3081 | if ( testResult ) | |
3082 | return false; | |
3083 | } | |
3084 | } | |
3085 | ||
3086 | return true; | |
3087 | } | |
3088 | ||
3089 | // ----------------------------------------------------------------------- | |
3090 | ||
3091 | void FormMain::OnIdle( wxIdleEvent& event ) | |
3092 | { | |
3093 | /* | |
3094 | // This code is useful for debugging focus problems | |
3095 | static wxWindow* last_focus = (wxWindow*) NULL; | |
3096 | ||
3097 | wxWindow* cur_focus = ::wxWindow::FindFocus(); | |
3098 | ||
3099 | if ( cur_focus != last_focus ) | |
3100 | { | |
3101 | const wxChar* class_name = wxT("<none>"); | |
3102 | if ( cur_focus ) | |
3103 | class_name = cur_focus->GetClassInfo()->GetClassName(); | |
3104 | last_focus = cur_focus; | |
3105 | wxLogDebug( wxT("FOCUSED: %s %X"), | |
3106 | class_name, | |
3107 | (unsigned int)cur_focus); | |
3108 | } | |
3109 | */ | |
3110 | ||
3111 | event.Skip(); | |
3112 | } | |
3113 | ||
3114 | // ----------------------------------------------------------------------- |