]>
Commit | Line | Data |
---|---|---|
1c4293cb VZ |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: wx/propgrid/props.h | |
3 | // Purpose: wxPropertyGrid Property Classes | |
4 | // Author: Jaakko Salli | |
5 | // Modified by: | |
6 | // Created: 2007-03-28 | |
ea5af9c5 | 7 | // RCS-ID: $Id$ |
1c4293cb VZ |
8 | // Copyright: (c) Jaakko Salli |
9 | // Licence: wxWindows license | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | #ifndef _WX_PROPGRID_PROPS_H_ | |
13 | #define _WX_PROPGRID_PROPS_H_ | |
14 | ||
f4bc1aa2 JS |
15 | #if wxUSE_PROPGRID |
16 | ||
1c4293cb VZ |
17 | // ----------------------------------------------------------------------- |
18 | ||
19 | class wxArrayEditorDialog; | |
20 | ||
21 | #include "wx/propgrid/editors.h" | |
22 | ||
15096961 JS |
23 | #include "wx/filename.h" |
24 | #include "wx/dialog.h" | |
25 | #include "wx/textctrl.h" | |
26 | #include "wx/button.h" | |
27 | #include "wx/listbox.h" | |
28 | ||
1c4293cb VZ |
29 | // ----------------------------------------------------------------------- |
30 | ||
1c4293cb VZ |
31 | // |
32 | // Property class implementation helper macros. | |
33 | // | |
34 | ||
d61d8cff | 35 | #define WX_PG_IMPLEMENT_PROPERTY_CLASS(NAME, UPCLASS, T, T_AS_ARG, EDITOR) \ |
1c4293cb | 36 | IMPLEMENT_DYNAMIC_CLASS(NAME, UPCLASS) \ |
d61d8cff | 37 | WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(NAME, T, EDITOR) |
1c4293cb VZ |
38 | |
39 | // ----------------------------------------------------------------------- | |
40 | ||
41 | // | |
42 | // These macros help creating DoGetValidator | |
43 | #define WX_PG_DOGETVALIDATOR_ENTRY() \ | |
44 | static wxValidator* s_ptr = (wxValidator*) NULL; \ | |
45 | if ( s_ptr ) return s_ptr; | |
46 | ||
47 | // Common function exit | |
48 | #define WX_PG_DOGETVALIDATOR_EXIT(VALIDATOR) \ | |
49 | s_ptr = VALIDATOR; \ | |
f7a094e1 | 50 | wxPGGlobalVars->m_arrValidators.push_back( VALIDATOR ); \ |
1c4293cb VZ |
51 | return VALIDATOR; |
52 | ||
53 | // ----------------------------------------------------------------------- | |
54 | ||
55 | #ifndef SWIG | |
56 | ||
57 | /** @class wxPGInDialogValidator | |
58 | @ingroup classes | |
59 | Creates and manages a temporary wxTextCtrl for validation purposes. | |
60 | Uses wxPropertyGrid's current editor, if available. | |
61 | */ | |
62 | class WXDLLIMPEXP_PROPGRID wxPGInDialogValidator | |
63 | { | |
64 | public: | |
65 | wxPGInDialogValidator() | |
66 | { | |
67 | m_textCtrl = NULL; | |
68 | } | |
69 | ||
70 | ~wxPGInDialogValidator() | |
71 | { | |
72 | if ( m_textCtrl ) | |
73 | m_textCtrl->Destroy(); | |
74 | } | |
75 | ||
76 | bool DoValidate( wxPropertyGrid* propGrid, | |
77 | wxValidator* validator, | |
78 | const wxString& value ); | |
79 | ||
80 | private: | |
81 | wxTextCtrl* m_textCtrl; | |
82 | }; | |
83 | ||
84 | #endif // SWIG | |
85 | ||
86 | ||
87 | // ----------------------------------------------------------------------- | |
88 | // Property classes | |
89 | // ----------------------------------------------------------------------- | |
90 | ||
91 | #define wxPG_PROP_PASSWORD wxPG_PROP_CLASS_SPECIFIC_2 | |
92 | ||
93 | /** @class wxStringProperty | |
94 | @ingroup classes | |
95 | Basic property with string value. | |
96 | ||
97 | <b>Supported special attributes:</b> | |
98 | - "Password": set to 1 inorder to enable wxTE_PASSWORD on the editor. | |
99 | ||
100 | @remarks | |
101 | - If value "<composed>" is set, then actual value is formed (or composed) | |
102 | from values of child properties. | |
103 | */ | |
104 | class WXDLLIMPEXP_PROPGRID wxStringProperty : public wxPGProperty | |
105 | { | |
106 | WX_PG_DECLARE_PROPERTY_CLASS(wxStringProperty) | |
107 | public: | |
108 | wxStringProperty( const wxString& label = wxPG_LABEL, | |
109 | const wxString& name = wxPG_LABEL, | |
110 | const wxString& value = wxEmptyString ); | |
111 | virtual ~wxStringProperty(); | |
112 | ||
1425eca5 | 113 | virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const; |
7eac5c53 JS |
114 | virtual bool StringToValue( wxVariant& variant, |
115 | const wxString& text, | |
116 | int argFlags = 0 ) const; | |
117 | ||
118 | virtual bool DoSetAttribute( const wxString& name, wxVariant& value ); | |
1c4293cb VZ |
119 | |
120 | /** This is updated so "<composed>" special value can be handled. | |
121 | */ | |
122 | virtual void OnSetValue(); | |
123 | ||
124 | protected: | |
125 | }; | |
126 | ||
127 | // ----------------------------------------------------------------------- | |
128 | ||
129 | #ifndef SWIG | |
130 | /** Constants used with DoValidation() methods. | |
131 | */ | |
132 | enum | |
133 | { | |
134 | /** Instead of modifying the value, show an error message. | |
135 | */ | |
136 | wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE = 0, | |
137 | ||
138 | /** Modify value, but stick with the limitations. | |
139 | */ | |
140 | wxPG_PROPERTY_VALIDATION_SATURATE = 1, | |
141 | ||
142 | /** Modify value, wrap around on overflow. | |
143 | */ | |
144 | wxPG_PROPERTY_VALIDATION_WRAP = 2 | |
145 | }; | |
146 | #endif | |
147 | ||
148 | // ----------------------------------------------------------------------- | |
149 | ||
150 | /** @class wxIntProperty | |
151 | @ingroup classes | |
152 | Basic property with integer value. | |
153 | ||
154 | Seamlessly supports 64-bit integer (wxLongLong) on overflow. | |
155 | ||
156 | <b>Example how to use seamless 64-bit integer support</b> | |
157 | ||
158 | Getting value: | |
159 | ||
160 | @code | |
161 | wxLongLong_t value = pg->GetPropertyValueAsLongLong(); | |
162 | @endcode | |
163 | ||
164 | or | |
165 | ||
166 | @code | |
167 | wxLongLong_t value; | |
168 | wxVariant variant = property->GetValue(); | |
169 | if ( variant.GetType() == "wxLongLong" ) | |
170 | value = wxLongLongFromVariant(variant); | |
171 | else | |
172 | value = variant.GetLong(); | |
173 | @endcode | |
174 | ||
175 | Setting value: | |
176 | ||
177 | @code | |
178 | pg->SetPropertyValue(longLongVal); | |
179 | @endcode | |
180 | ||
181 | or | |
182 | ||
183 | @code | |
184 | property->SetValue(WXVARIANT(longLongVal)); | |
185 | @endcode | |
186 | ||
187 | ||
188 | <b>Supported special attributes:</b> | |
189 | - "Min", "Max": Specify acceptable value range. | |
190 | */ | |
191 | class WXDLLIMPEXP_PROPGRID wxIntProperty : public wxPGProperty | |
192 | { | |
193 | WX_PG_DECLARE_PROPERTY_CLASS(wxIntProperty) | |
194 | public: | |
195 | wxIntProperty( const wxString& label = wxPG_LABEL, | |
196 | const wxString& name = wxPG_LABEL, | |
197 | long value = 0 ); | |
198 | virtual ~wxIntProperty(); | |
199 | ||
200 | wxIntProperty( const wxString& label, | |
201 | const wxString& name, | |
202 | const wxLongLong& value ); | |
1425eca5 | 203 | virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const; |
7eac5c53 JS |
204 | virtual bool StringToValue( wxVariant& variant, |
205 | const wxString& text, | |
206 | int argFlags = 0 ) const; | |
1c4293cb VZ |
207 | virtual bool ValidateValue( wxVariant& value, |
208 | wxPGValidationInfo& validationInfo ) const; | |
209 | virtual bool IntToValue( wxVariant& variant, | |
210 | int number, | |
211 | int argFlags = 0 ) const; | |
212 | static wxValidator* GetClassValidator(); | |
213 | virtual wxValidator* DoGetValidator() const; | |
214 | ||
215 | /** Validation helper. | |
216 | */ | |
217 | static bool DoValidation( const wxPGProperty* property, | |
218 | wxLongLong_t& value, | |
219 | wxPGValidationInfo* pValidationInfo, | |
220 | int mode = | |
221 | wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE ); | |
222 | ||
223 | protected: | |
224 | }; | |
225 | ||
226 | // ----------------------------------------------------------------------- | |
227 | ||
228 | /** @class wxUIntProperty | |
229 | @ingroup classes | |
230 | Basic property with unsigned integer value. | |
231 | Seamlessly supports 64-bit integer (wxULongLong) on overflow. | |
232 | ||
233 | <b>Supported special attributes:</b> | |
234 | - "Min", "Max": Specify acceptable value range. | |
235 | - "Base": Define base. Valid constants are wxPG_BASE_OCT, wxPG_BASE_DEC, | |
236 | wxPG_BASE_HEX and wxPG_BASE_HEXL (lowercase characters). Arbitrary bases | |
237 | are <b>not</b> supported. | |
238 | - "Prefix": Possible values are wxPG_PREFIX_NONE, wxPG_PREFIX_0x, and | |
239 | wxPG_PREFIX_DOLLAR_SIGN. Only wxPG_PREFIX_NONE works with Decimal and Octal | |
240 | numbers. | |
241 | ||
242 | @remarks | |
243 | - For example how to use seamless 64-bit integer support, see wxIntProperty | |
244 | documentation (just use wxULongLong instead of wxLongLong). | |
245 | */ | |
246 | class WXDLLIMPEXP_PROPGRID wxUIntProperty : public wxPGProperty | |
247 | { | |
248 | WX_PG_DECLARE_PROPERTY_CLASS(wxUIntProperty) | |
249 | public: | |
250 | wxUIntProperty( const wxString& label = wxPG_LABEL, | |
251 | const wxString& name = wxPG_LABEL, | |
252 | unsigned long value = 0 ); | |
253 | virtual ~wxUIntProperty(); | |
254 | wxUIntProperty( const wxString& label, | |
255 | const wxString& name, | |
256 | const wxULongLong& value ); | |
1425eca5 | 257 | virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const; |
7eac5c53 JS |
258 | virtual bool StringToValue( wxVariant& variant, |
259 | const wxString& text, | |
260 | int argFlags = 0 ) const; | |
261 | virtual bool DoSetAttribute( const wxString& name, wxVariant& value ); | |
1c4293cb VZ |
262 | virtual bool ValidateValue( wxVariant& value, |
263 | wxPGValidationInfo& validationInfo ) const; | |
264 | virtual bool IntToValue( wxVariant& variant, | |
265 | int number, | |
266 | int argFlags = 0 ) const; | |
267 | protected: | |
268 | wxByte m_base; | |
269 | wxByte m_realBase; // translated to 8,16,etc. | |
270 | wxByte m_prefix; | |
271 | private: | |
272 | void Init(); | |
273 | }; | |
274 | ||
275 | // ----------------------------------------------------------------------- | |
276 | ||
277 | /** @class wxFloatProperty | |
278 | @ingroup classes | |
279 | Basic property with double-precision floating point value. | |
280 | ||
281 | <b>Supported special attributes:</b> | |
282 | - "Precision": Sets the (max) precision used when floating point value is | |
283 | rendered as text. The default -1 means infinite precision. | |
284 | */ | |
285 | class WXDLLIMPEXP_PROPGRID wxFloatProperty : public wxPGProperty | |
286 | { | |
287 | WX_PG_DECLARE_PROPERTY_CLASS(wxFloatProperty) | |
288 | public: | |
289 | wxFloatProperty( const wxString& label = wxPG_LABEL, | |
290 | const wxString& name = wxPG_LABEL, | |
291 | double value = 0.0 ); | |
292 | virtual ~wxFloatProperty(); | |
293 | ||
1425eca5 | 294 | virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const; |
7eac5c53 JS |
295 | virtual bool StringToValue( wxVariant& variant, |
296 | const wxString& text, | |
297 | int argFlags = 0 ) const; | |
298 | virtual bool DoSetAttribute( const wxString& name, wxVariant& value ); | |
1c4293cb VZ |
299 | virtual bool ValidateValue( wxVariant& value, |
300 | wxPGValidationInfo& validationInfo ) const; | |
301 | ||
302 | /** Validation helper. | |
303 | */ | |
304 | static bool DoValidation( const wxPGProperty* property, | |
305 | double& value, | |
306 | wxPGValidationInfo* pValidationInfo, | |
307 | int mode = | |
308 | wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE ); | |
470f357f | 309 | virtual wxValidator* DoGetValidator () const; |
1c4293cb VZ |
310 | |
311 | protected: | |
312 | int m_precision; | |
1c4293cb VZ |
313 | }; |
314 | ||
315 | // ----------------------------------------------------------------------- | |
316 | ||
317 | // Exclude class from wxPython bindings | |
318 | #ifndef SWIG | |
319 | ||
320 | /** @class wxBoolProperty | |
321 | @ingroup classes | |
322 | Basic property with boolean value. | |
323 | ||
324 | <b>Supported special attributes:</b> | |
325 | - "UseCheckbox": Set to 1 to use check box editor instead of combo box. | |
326 | - "UseDClickCycling": Set to 1 to cycle combo box instead showing the list. | |
327 | */ | |
328 | class WXDLLIMPEXP_PROPGRID wxBoolProperty : public wxPGProperty | |
329 | { | |
330 | WX_PG_DECLARE_PROPERTY_CLASS(wxBoolProperty) | |
331 | public: | |
332 | wxBoolProperty( const wxString& label = wxPG_LABEL, | |
333 | const wxString& name = wxPG_LABEL, | |
334 | bool value = false ); | |
335 | virtual ~wxBoolProperty(); | |
336 | ||
1425eca5 | 337 | virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const; |
7eac5c53 JS |
338 | virtual bool StringToValue( wxVariant& variant, |
339 | const wxString& text, | |
340 | int argFlags = 0 ) const; | |
341 | virtual bool IntToValue( wxVariant& variant, | |
342 | int number, int argFlags = 0 ) const; | |
343 | virtual bool DoSetAttribute( const wxString& name, wxVariant& value ); | |
1c4293cb VZ |
344 | }; |
345 | ||
346 | #endif // !SWIG | |
347 | ||
348 | // ----------------------------------------------------------------------- | |
349 | ||
78f2d746 JS |
350 | // If set, then selection of choices is static and should not be |
351 | // changed (i.e. returns NULL in GetPropertyChoices). | |
352 | #define wxPG_PROP_STATIC_CHOICES wxPG_PROP_CLASS_SPECIFIC_1 | |
353 | ||
354 | /** @class wxEnumProperty | |
1c4293cb | 355 | @ingroup classes |
78f2d746 JS |
356 | You can derive custom properties with choices from this class. See |
357 | wxBaseEnumProperty for remarks. | |
1c4293cb VZ |
358 | |
359 | @remarks | |
360 | - Updating private index is important. You can do this either by calling | |
361 | SetIndex() in IntToValue, and then letting wxBaseEnumProperty::OnSetValue | |
362 | be called (by not implementing it, or by calling super class function in | |
363 | it) -OR- you can just call SetIndex in OnSetValue. | |
364 | */ | |
78f2d746 | 365 | class WXDLLIMPEXP_PROPGRID wxEnumProperty : public wxPGProperty |
1c4293cb | 366 | { |
78f2d746 | 367 | WX_PG_DECLARE_PROPERTY_CLASS(wxEnumProperty) |
1c4293cb | 368 | public: |
78f2d746 JS |
369 | |
370 | #ifndef SWIG | |
371 | wxEnumProperty( const wxString& label = wxPG_LABEL, | |
372 | const wxString& name = wxPG_LABEL, | |
373 | const wxChar** labels = NULL, | |
374 | const long* values = NULL, | |
375 | int value = 0 ); | |
376 | wxEnumProperty( const wxString& label, | |
377 | const wxString& name, | |
378 | wxPGChoices& choices, | |
379 | int value = 0 ); | |
380 | ||
381 | // Special constructor for caching choices (used by derived class) | |
382 | wxEnumProperty( const wxString& label, | |
383 | const wxString& name, | |
384 | const wxChar** labels, | |
385 | const long* values, | |
386 | wxPGChoices* choicesCache, | |
387 | int value = 0 ); | |
388 | ||
389 | wxEnumProperty( const wxString& label, | |
390 | const wxString& name, | |
391 | const wxArrayString& labels, | |
392 | const wxArrayInt& values = wxArrayInt(), | |
393 | int value = 0 ); | |
394 | #else | |
395 | wxEnumProperty( const wxString& label = wxPG_LABEL, | |
396 | const wxString& name = wxPG_LABEL, | |
397 | const wxArrayString& labels = wxArrayString(), | |
398 | const wxArrayInt& values = wxArrayInt(), | |
399 | int value = 0 ); | |
400 | #endif | |
401 | ||
402 | virtual ~wxEnumProperty(); | |
403 | ||
404 | size_t GetItemCount() const { return m_choices.GetCount(); } | |
1c4293cb VZ |
405 | |
406 | virtual void OnSetValue(); | |
1425eca5 | 407 | virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const; |
1c4293cb VZ |
408 | virtual bool StringToValue( wxVariant& variant, |
409 | const wxString& text, | |
410 | int argFlags = 0 ) const; | |
411 | virtual bool ValidateValue( wxVariant& value, | |
412 | wxPGValidationInfo& validationInfo ) const; | |
413 | ||
414 | // If wxPG_FULL_VALUE is not set in flags, then the value is interpreted | |
415 | // as index to choices list. Otherwise, it is actual value. | |
416 | virtual bool IntToValue( wxVariant& variant, | |
417 | int number, | |
418 | int argFlags = 0 ) const; | |
419 | ||
420 | // | |
421 | // Additional virtuals | |
422 | ||
423 | // This must be overridden to have non-index based value | |
424 | virtual int GetIndexForValue( int value ) const; | |
425 | ||
939d9364 JS |
426 | // GetChoiceSelection needs to overridden since m_index is |
427 | // the true index, and various property classes derived from | |
428 | // this take advantage of it. | |
429 | virtual int GetChoiceSelection() const { return m_index; } | |
430 | ||
d8812c6e JS |
431 | virtual void OnValidationFailure( wxVariant& pendingValue ); |
432 | ||
1c4293cb VZ |
433 | protected: |
434 | ||
435 | int GetIndex() const; | |
436 | void SetIndex( int index ); | |
437 | ||
438 | bool ValueFromString_( wxVariant& value, | |
439 | const wxString& text, | |
440 | int argFlags ) const; | |
441 | bool ValueFromInt_( wxVariant& value, int intVal, int argFlags ) const; | |
442 | ||
443 | static void ResetNextIndex() { ms_nextIndex = -2; } | |
444 | ||
445 | private: | |
446 | // This is private so that classes are guaranteed to use GetIndex | |
447 | // for up-to-date index value. | |
448 | int m_index; | |
449 | ||
450 | // Relies on ValidateValue being called always before OnSetValue | |
451 | static int ms_nextIndex; | |
d8812c6e | 452 | static int ms_prevIndex; |
1c4293cb VZ |
453 | }; |
454 | ||
455 | // ----------------------------------------------------------------------- | |
456 | ||
1c4293cb VZ |
457 | /** @class wxEditEnumProperty |
458 | @ingroup classes | |
459 | wxEnumProperty with wxString value and writable combo box editor. | |
460 | ||
461 | @remarks | |
462 | Uses int value, similar to wxEnumProperty, unless text entered by user is | |
463 | is not in choices (in which case string value is used). | |
464 | */ | |
465 | class WXDLLIMPEXP_PROPGRID wxEditEnumProperty : public wxEnumProperty | |
466 | { | |
467 | WX_PG_DECLARE_PROPERTY_CLASS(wxEditEnumProperty) | |
468 | public: | |
469 | ||
470 | wxEditEnumProperty( const wxString& label, | |
471 | const wxString& name, | |
472 | const wxChar** labels, | |
473 | const long* values, | |
474 | const wxString& value ); | |
475 | wxEditEnumProperty( const wxString& label = wxPG_LABEL, | |
476 | const wxString& name = wxPG_LABEL, | |
477 | const wxArrayString& labels = wxArrayString(), | |
478 | const wxArrayInt& values = wxArrayInt(), | |
479 | const wxString& value = wxEmptyString ); | |
480 | wxEditEnumProperty( const wxString& label, | |
481 | const wxString& name, | |
482 | wxPGChoices& choices, | |
483 | const wxString& value = wxEmptyString ); | |
484 | ||
485 | // Special constructor for caching choices (used by derived class) | |
486 | wxEditEnumProperty( const wxString& label, | |
487 | const wxString& name, | |
488 | const wxChar** labels, | |
489 | const long* values, | |
490 | wxPGChoices* choicesCache, | |
491 | const wxString& value ); | |
492 | ||
493 | virtual ~wxEditEnumProperty(); | |
494 | ||
495 | protected: | |
496 | }; | |
497 | ||
498 | // ----------------------------------------------------------------------- | |
499 | ||
500 | /** @class wxFlagsProperty | |
501 | @ingroup classes | |
502 | Represents a bit set that fits in a long integer. wxBoolProperty | |
503 | sub-properties are created for editing individual bits. Textctrl is created | |
504 | to manually edit the flags as a text; a continous sequence of spaces, | |
505 | commas and semicolons is considered as a flag id separator. | |
506 | <b>Note:</b> When changing "choices" (ie. flag labels) of wxFlagsProperty, | |
507 | you will need to use SetPropertyChoices - otherwise they will not get | |
508 | updated properly. | |
509 | */ | |
510 | class WXDLLIMPEXP_PROPGRID wxFlagsProperty : public wxPGProperty | |
511 | { | |
512 | WX_PG_DECLARE_PROPERTY_CLASS(wxFlagsProperty) | |
513 | public: | |
514 | ||
515 | #ifndef SWIG | |
516 | wxFlagsProperty( const wxString& label, | |
517 | const wxString& name, | |
518 | const wxChar** labels, | |
519 | const long* values = NULL, | |
520 | long value = 0 ); | |
521 | wxFlagsProperty( const wxString& label, | |
522 | const wxString& name, | |
523 | wxPGChoices& choices, | |
524 | long value = 0 ); | |
525 | #endif | |
526 | wxFlagsProperty( const wxString& label = wxPG_LABEL, | |
527 | const wxString& name = wxPG_LABEL, | |
528 | const wxArrayString& labels = wxArrayString(), | |
529 | const wxArrayInt& values = wxArrayInt(), | |
530 | int value = 0 ); | |
531 | virtual ~wxFlagsProperty (); | |
532 | ||
533 | virtual void OnSetValue(); | |
1425eca5 | 534 | virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const; |
1c4293cb VZ |
535 | virtual bool StringToValue( wxVariant& variant, |
536 | const wxString& text, | |
537 | int flags ) const; | |
538 | virtual void ChildChanged( wxVariant& thisValue, | |
539 | int childIndex, | |
540 | wxVariant& childValue ) const; | |
541 | virtual void RefreshChildren(); | |
542 | ||
939d9364 JS |
543 | // GetChoiceSelection needs to overridden since m_choices is |
544 | // used and value is integer, but it is not index. | |
545 | virtual int GetChoiceSelection() const { return wxNOT_FOUND; } | |
1c4293cb VZ |
546 | |
547 | // helpers | |
548 | size_t GetItemCount() const { return m_choices.GetCount(); } | |
549 | const wxString& GetLabel( size_t ind ) const | |
550 | { return m_choices.GetLabel(ind); } | |
551 | ||
552 | protected: | |
1c4293cb VZ |
553 | // Used to detect if choices have been changed |
554 | wxPGChoicesData* m_oldChoicesData; | |
555 | ||
556 | // Needed to properly mark changed sub-properties | |
557 | long m_oldValue; | |
558 | ||
559 | // Converts string id to a relevant bit. | |
560 | long IdToBit( const wxString& id ) const; | |
561 | ||
562 | // Creates children and sets value. | |
563 | void Init(); | |
564 | }; | |
565 | ||
566 | // ----------------------------------------------------------------------- | |
567 | ||
568 | /** @class wxPGFileDialogAdapter | |
569 | @ingroup classes | |
570 | */ | |
571 | class WXDLLIMPEXP_PROPGRID | |
572 | wxPGFileDialogAdapter : public wxPGEditorDialogAdapter | |
573 | { | |
574 | public: | |
575 | virtual bool DoShowDialog( wxPropertyGrid* propGrid, | |
576 | wxPGProperty* property ); | |
577 | }; | |
578 | ||
579 | // ----------------------------------------------------------------------- | |
580 | ||
1c4293cb VZ |
581 | // Indicates first bit useable by derived properties. |
582 | #define wxPG_PROP_SHOW_FULL_FILENAME wxPG_PROP_CLASS_SPECIFIC_1 | |
583 | ||
584 | /** @class wxFileProperty | |
585 | @ingroup classes | |
586 | Like wxLongStringProperty, but the button triggers file selector instead. | |
587 | ||
588 | <b>Supported special attributes:</b> | |
589 | - "Wildcard": Sets wildcard (see wxFileDialog for format details), "All | |
590 | files..." is default. | |
591 | - "ShowFullPath": Default 1. When 0, only the file name is shown (i.e. drive | |
592 | and directory are hidden). | |
593 | - "ShowRelativePath": If set, then the filename is shown relative to the | |
594 | given path string. | |
595 | - "InitialPath": Sets the initial path of where to look for files. | |
596 | - "DialogTitle": Sets a specific title for the dir dialog. | |
597 | */ | |
598 | class WXDLLIMPEXP_PROPGRID wxFileProperty : public wxPGProperty | |
599 | { | |
600 | friend class wxPGFileDialogAdapter; | |
601 | WX_PG_DECLARE_PROPERTY_CLASS(wxFileProperty) | |
602 | public: | |
603 | ||
604 | wxFileProperty( const wxString& label = wxPG_LABEL, | |
605 | const wxString& name = wxPG_LABEL, | |
606 | const wxString& value = wxEmptyString ); | |
607 | virtual ~wxFileProperty (); | |
608 | ||
609 | virtual void OnSetValue(); | |
1425eca5 | 610 | virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const; |
1c4293cb VZ |
611 | virtual bool StringToValue( wxVariant& variant, |
612 | const wxString& text, | |
613 | int argFlags = 0 ) const; | |
614 | virtual wxPGEditorDialogAdapter* GetEditorDialog() const; | |
7eac5c53 | 615 | virtual bool DoSetAttribute( const wxString& name, wxVariant& value ); |
1c4293cb VZ |
616 | |
617 | static wxValidator* GetClassValidator(); | |
618 | virtual wxValidator* DoGetValidator() const; | |
619 | ||
1425eca5 JS |
620 | /** |
621 | Returns filename to file represented by current value. | |
622 | */ | |
623 | wxFileName GetFileName() const; | |
624 | ||
1c4293cb VZ |
625 | protected: |
626 | wxString m_wildcard; | |
627 | wxString m_basePath; // If set, then show path relative to it | |
628 | wxString m_initialPath; // If set, start the file dialog here | |
629 | wxString m_dlgTitle; // If set, used as title for file dialog | |
1c4293cb VZ |
630 | int m_indFilter; // index to the selected filter |
631 | }; | |
632 | ||
633 | // ----------------------------------------------------------------------- | |
634 | ||
635 | #define wxPG_PROP_NO_ESCAPE wxPG_PROP_CLASS_SPECIFIC_1 | |
636 | ||
637 | ||
638 | /** @class wxPGLongStringDialogAdapter | |
639 | @ingroup classes | |
640 | */ | |
641 | class WXDLLIMPEXP_PROPGRID | |
642 | wxPGLongStringDialogAdapter : public wxPGEditorDialogAdapter | |
643 | { | |
644 | public: | |
645 | virtual bool DoShowDialog( wxPropertyGrid* propGrid, | |
646 | wxPGProperty* property ); | |
647 | }; | |
648 | ||
649 | ||
650 | /** @class wxLongStringProperty | |
651 | @ingroup classes | |
652 | Like wxStringProperty, but has a button that triggers a small text | |
653 | editor dialog. | |
654 | */ | |
655 | class WXDLLIMPEXP_PROPGRID wxLongStringProperty : public wxPGProperty | |
656 | { | |
657 | WX_PG_DECLARE_PROPERTY_CLASS(wxLongStringProperty) | |
658 | public: | |
659 | ||
660 | wxLongStringProperty( const wxString& label = wxPG_LABEL, | |
661 | const wxString& name = wxPG_LABEL, | |
662 | const wxString& value = wxEmptyString ); | |
663 | virtual ~wxLongStringProperty(); | |
664 | ||
1425eca5 | 665 | virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const; |
1c4293cb VZ |
666 | virtual bool StringToValue( wxVariant& variant, |
667 | const wxString& text, | |
668 | int argFlags = 0 ) const; | |
7eac5c53 JS |
669 | virtual bool OnEvent( wxPropertyGrid* propgrid, |
670 | wxWindow* primary, wxEvent& event ); | |
1c4293cb VZ |
671 | |
672 | // Shows string editor dialog. Value to be edited should be read from | |
673 | // value, and if dialog is not cancelled, it should be stored back and true | |
674 | // should be returned if that was the case. | |
675 | virtual bool OnButtonClick( wxPropertyGrid* propgrid, wxString& value ); | |
676 | ||
677 | static bool DisplayEditorDialog( wxPGProperty* prop, | |
678 | wxPropertyGrid* propGrid, | |
679 | wxString& value ); | |
680 | ||
681 | protected: | |
682 | }; | |
683 | ||
684 | // ----------------------------------------------------------------------- | |
685 | ||
686 | ||
687 | // Exclude class from wxPython bindings | |
688 | #ifndef SWIG | |
689 | ||
690 | /** @class wxDirProperty | |
691 | @ingroup classes | |
692 | Like wxLongStringProperty, but the button triggers dir selector instead. | |
693 | ||
694 | <b>Supported special attributes:</b> | |
695 | - "DialogMessage": Sets specific message in the dir selector. | |
696 | */ | |
697 | class WXDLLIMPEXP_PROPGRID wxDirProperty : public wxLongStringProperty | |
698 | { | |
699 | #ifndef SWIG | |
700 | DECLARE_DYNAMIC_CLASS(wxDirProperty) | |
701 | #endif | |
702 | public: | |
703 | wxDirProperty( const wxString& name = wxPG_LABEL, | |
704 | const wxString& label = wxPG_LABEL, | |
705 | const wxString& value = wxEmptyString ); | |
706 | virtual ~wxDirProperty(); | |
707 | ||
7eac5c53 JS |
708 | virtual bool DoSetAttribute( const wxString& name, wxVariant& value ); |
709 | virtual wxValidator* DoGetValidator() const; | |
1c4293cb VZ |
710 | |
711 | virtual bool OnButtonClick ( wxPropertyGrid* propGrid, wxString& value ); | |
712 | ||
713 | protected: | |
714 | wxString m_dlgMessage; | |
715 | }; | |
716 | ||
717 | #endif // !SWIG | |
718 | ||
719 | // ----------------------------------------------------------------------- | |
720 | ||
721 | // wxBoolProperty specific flags | |
722 | #define wxPG_PROP_USE_CHECKBOX wxPG_PROP_CLASS_SPECIFIC_1 | |
723 | // DCC = Double Click Cycles | |
724 | #define wxPG_PROP_USE_DCC wxPG_PROP_CLASS_SPECIFIC_2 | |
725 | ||
726 | ||
727 | // ----------------------------------------------------------------------- | |
728 | ||
729 | /** @class wxArrayStringProperty | |
730 | @ingroup classes | |
731 | Property that manages a list of strings. | |
732 | */ | |
733 | class WXDLLIMPEXP_PROPGRID wxArrayStringProperty : public wxPGProperty | |
734 | { | |
735 | WX_PG_DECLARE_PROPERTY_CLASS(wxArrayStringProperty) | |
736 | public: | |
737 | ||
738 | wxArrayStringProperty( const wxString& label = wxPG_LABEL, | |
739 | const wxString& name = wxPG_LABEL, | |
740 | const wxArrayString& value = wxArrayString() ); | |
741 | virtual ~wxArrayStringProperty(); | |
742 | ||
743 | virtual void OnSetValue(); | |
1425eca5 | 744 | virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const; |
7eac5c53 JS |
745 | virtual bool StringToValue( wxVariant& variant, |
746 | const wxString& text, | |
747 | int argFlags = 0 ) const; | |
748 | virtual bool OnEvent( wxPropertyGrid* propgrid, | |
749 | wxWindow* primary, wxEvent& event ); | |
1c4293cb VZ |
750 | |
751 | virtual void GenerateValueAsString(); | |
752 | ||
753 | // Shows string editor dialog. Value to be edited should be read from | |
754 | // value, and if dialog is not cancelled, it should be stored back and true | |
755 | // should be returned if that was the case. | |
756 | virtual bool OnCustomStringEdit( wxWindow* parent, wxString& value ); | |
757 | ||
758 | // Helper. | |
759 | virtual bool OnButtonClick( wxPropertyGrid* propgrid, | |
760 | wxWindow* primary, | |
761 | const wxChar* cbt ); | |
762 | ||
763 | #ifndef SWIG | |
764 | // Creates wxArrayEditorDialog for string editing. Called in OnButtonClick. | |
765 | virtual wxArrayEditorDialog* CreateEditorDialog(); | |
766 | #endif | |
767 | ||
768 | protected: | |
769 | wxString m_display; // Cache for displayed text. | |
770 | }; | |
771 | ||
772 | // ----------------------------------------------------------------------- | |
773 | ||
774 | #define WX_PG_DECLARE_ARRAYSTRING_PROPERTY_WITH_VALIDATOR_WITH_DECL(PROPNAME, \ | |
775 | DECL) \ | |
776 | DECL PROPNAME : public wxArrayStringProperty \ | |
777 | { \ | |
778 | WX_PG_DECLARE_PROPERTY_CLASS(PROPNAME) \ | |
779 | public: \ | |
780 | PROPNAME( const wxString& label = wxPG_LABEL, \ | |
781 | const wxString& name = wxPG_LABEL, \ | |
782 | const wxArrayString& value = wxArrayString() ); \ | |
783 | ~PROPNAME(); \ | |
784 | virtual void GenerateValueAsString(); \ | |
785 | virtual bool StringToValue( wxVariant& value, \ | |
786 | const wxString& text, int = 0 ) const; \ | |
787 | virtual bool OnEvent( wxPropertyGrid* propgrid, \ | |
788 | wxWindow* primary, wxEvent& event ); \ | |
789 | virtual bool OnCustomStringEdit( wxWindow* parent, wxString& value ); \ | |
7eac5c53 | 790 | virtual wxValidator* DoGetValidator() const; \ |
1c4293cb VZ |
791 | }; |
792 | ||
793 | #define WX_PG_DECLARE_ARRAYSTRING_PROPERTY_WITH_VALIDATOR(PROPNAM) \ | |
794 | WX_PG_DECLARE_ARRAYSTRING_PROPERTY_WITH_VALIDATOR(PROPNAM, class) | |
795 | ||
796 | #define WX_PG_IMPLEMENT_ARRAYSTRING_PROPERTY_WITH_VALIDATOR(PROPNAME, \ | |
797 | DELIMCHAR, \ | |
798 | CUSTBUTTXT) \ | |
799 | WX_PG_IMPLEMENT_PROPERTY_CLASS(PROPNAME, wxArrayStringProperty, \ | |
800 | wxArrayString, const wxArrayString&, \ | |
801 | TextCtrlAndButton) \ | |
802 | PROPNAME::PROPNAME( const wxString& label, \ | |
803 | const wxString& name, \ | |
804 | const wxArrayString& value ) \ | |
805 | : wxArrayStringProperty(label,name,value) \ | |
806 | { \ | |
807 | PROPNAME::GenerateValueAsString(); \ | |
808 | } \ | |
809 | PROPNAME::~PROPNAME() { } \ | |
810 | void PROPNAME::GenerateValueAsString() \ | |
811 | { \ | |
812 | wxChar delimChar = DELIMCHAR; \ | |
813 | if ( delimChar == wxS('"') ) \ | |
814 | wxArrayStringProperty::GenerateValueAsString(); \ | |
815 | else \ | |
816 | wxPropertyGrid::ArrayStringToString(m_display, \ | |
817 | m_value.GetArrayString(), \ | |
818 | 0,DELIMCHAR,0); \ | |
819 | } \ | |
820 | bool PROPNAME::StringToValue( wxVariant& variant, \ | |
821 | const wxString& text, int ) const \ | |
822 | { \ | |
823 | wxChar delimChar = DELIMCHAR; \ | |
824 | if ( delimChar == wxS('"') ) \ | |
825 | return wxArrayStringProperty::StringToValue(variant, text, 0); \ | |
826 | \ | |
827 | wxArrayString arr; \ | |
828 | WX_PG_TOKENIZER1_BEGIN(text,DELIMCHAR) \ | |
829 | arr.Add( token ); \ | |
830 | WX_PG_TOKENIZER1_END() \ | |
831 | variant = arr; \ | |
832 | return true; \ | |
833 | } \ | |
834 | bool PROPNAME::OnEvent( wxPropertyGrid* propgrid, \ | |
835 | wxWindow* primary, wxEvent& event ) \ | |
836 | { \ | |
837 | if ( event.GetEventType() == wxEVT_COMMAND_BUTTON_CLICKED ) \ | |
838 | return OnButtonClick(propgrid,primary,(const wxChar*) CUSTBUTTXT); \ | |
839 | return false; \ | |
840 | } | |
841 | ||
842 | #define WX_PG_DECLARE_ARRAYSTRING_PROPERTY(PROPNAME) \ | |
843 | WX_PG_DECLARE_ARRAYSTRING_PROPERTY_WITH_VALIDATOR(PROPNAME) | |
844 | ||
845 | #define WX_PG_DECLARE_ARRAYSTRING_PROPERTY_WITH_DECL(PROPNAME, DECL) \ | |
846 | WX_PG_DECLARE_ARRAYSTRING_PROPERTY_WITH_VALIDATOR_WITH_DECL(PROPNAME, DECL) | |
847 | ||
848 | #define WX_PG_IMPLEMENT_ARRAYSTRING_PROPERTY(PROPNAME,DELIMCHAR,CUSTBUTTXT) \ | |
849 | WX_PG_IMPLEMENT_ARRAYSTRING_PROPERTY_WITH_VALIDATOR(PROPNAME, \ | |
850 | DELIMCHAR, \ | |
851 | CUSTBUTTXT) \ | |
852 | wxValidator* PROPNAME::DoGetValidator () const \ | |
853 | { return (wxValidator*) NULL; } | |
854 | ||
855 | ||
856 | // ----------------------------------------------------------------------- | |
857 | // wxArrayEditorDialog | |
858 | // ----------------------------------------------------------------------- | |
859 | ||
1c4293cb VZ |
860 | #define wxAEDIALOG_STYLE \ |
861 | (wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER | wxOK | wxCANCEL | wxCENTRE) | |
862 | ||
863 | class WXDLLIMPEXP_PROPGRID wxArrayEditorDialog : public wxDialog | |
864 | { | |
865 | public: | |
866 | wxArrayEditorDialog(); | |
867 | virtual ~wxArrayEditorDialog() { } | |
868 | ||
869 | void Init(); | |
870 | ||
871 | wxArrayEditorDialog( wxWindow *parent, | |
872 | const wxString& message, | |
873 | const wxString& caption, | |
874 | long style = wxAEDIALOG_STYLE, | |
875 | const wxPoint& pos = wxDefaultPosition, | |
876 | const wxSize& sz = wxDefaultSize ); | |
877 | ||
878 | bool Create( wxWindow *parent, | |
879 | const wxString& message, | |
880 | const wxString& caption, | |
881 | long style = wxAEDIALOG_STYLE, | |
882 | const wxPoint& pos = wxDefaultPosition, | |
883 | const wxSize& sz = wxDefaultSize ); | |
884 | ||
885 | /** Set value modified by dialog. | |
886 | */ | |
887 | virtual void SetDialogValue( const wxVariant& WXUNUSED(value) ) | |
888 | { | |
889 | wxFAIL_MSG(wxT("re-implement this member function in derived class")); | |
890 | } | |
891 | ||
892 | /** Return value modified by dialog. | |
893 | */ | |
894 | virtual wxVariant GetDialogValue() const | |
895 | { | |
896 | wxFAIL_MSG(wxT("re-implement this member function in derived class")); | |
897 | return wxVariant(); | |
898 | } | |
899 | ||
900 | /** Override to return wxValidator to be used with the wxTextCtrl | |
901 | in dialog. Note that the validator is used in the standard | |
902 | wx way, ie. it immediately prevents user from entering invalid | |
903 | input. | |
904 | ||
905 | @remarks | |
906 | Dialog frees the validator. | |
907 | */ | |
908 | virtual wxValidator* GetTextCtrlValidator() const | |
909 | { | |
910 | return (wxValidator*) NULL; | |
911 | } | |
912 | ||
913 | // Returns true if array was actually modified | |
914 | bool IsModified() const { return m_modified; } | |
915 | ||
916 | //const wxArrayString& GetStrings() const { return m_array; } | |
917 | ||
918 | // implementation from now on | |
919 | void OnUpdateClick(wxCommandEvent& event); | |
920 | void OnAddClick(wxCommandEvent& event); | |
921 | void OnDeleteClick(wxCommandEvent& event); | |
922 | void OnListBoxClick(wxCommandEvent& event); | |
923 | void OnUpClick(wxCommandEvent& event); | |
924 | void OnDownClick(wxCommandEvent& event); | |
925 | //void OnCustomEditClick(wxCommandEvent& event); | |
926 | void OnIdle(wxIdleEvent& event); | |
927 | ||
928 | protected: | |
929 | wxTextCtrl* m_edValue; | |
930 | wxListBox* m_lbStrings; | |
931 | ||
932 | wxButton* m_butAdd; // Button pointers | |
933 | wxButton* m_butCustom; // required for disabling/enabling changing. | |
934 | wxButton* m_butUpdate; | |
935 | wxButton* m_butRemove; | |
936 | wxButton* m_butUp; | |
937 | wxButton* m_butDown; | |
938 | ||
939 | //wxArrayString m_array; | |
940 | ||
941 | const wxChar* m_custBtText; | |
942 | //wxArrayStringPropertyClass* m_pCallingClass; | |
943 | ||
944 | bool m_modified; | |
945 | ||
946 | unsigned char m_curFocus; | |
947 | ||
948 | // These must be overridden - must return true on success. | |
949 | virtual wxString ArrayGet( size_t index ) = 0; | |
950 | virtual size_t ArrayGetCount() = 0; | |
951 | virtual bool ArrayInsert( const wxString& str, int index ) = 0; | |
952 | virtual bool ArraySet( size_t index, const wxString& str ) = 0; | |
953 | virtual void ArrayRemoveAt( int index ) = 0; | |
954 | virtual void ArraySwap( size_t first, size_t second ) = 0; | |
955 | ||
956 | private: | |
957 | #ifndef SWIG | |
958 | DECLARE_DYNAMIC_CLASS_NO_COPY(wxArrayEditorDialog) | |
959 | DECLARE_EVENT_TABLE() | |
960 | #endif | |
961 | }; | |
962 | ||
963 | // ----------------------------------------------------------------------- | |
964 | // wxPGArrayStringEditorDialog | |
965 | // ----------------------------------------------------------------------- | |
966 | ||
967 | class WXDLLIMPEXP_PROPGRID | |
968 | wxPGArrayStringEditorDialog : public wxArrayEditorDialog | |
969 | { | |
970 | public: | |
971 | wxPGArrayStringEditorDialog(); | |
972 | virtual ~wxPGArrayStringEditorDialog() { } | |
973 | ||
974 | void Init(); | |
975 | ||
976 | virtual void SetDialogValue( const wxVariant& value ) | |
977 | { | |
978 | m_array = value.GetArrayString(); | |
979 | } | |
980 | ||
981 | virtual wxVariant GetDialogValue() const | |
982 | { | |
983 | return m_array; | |
984 | } | |
985 | ||
986 | void SetCustomButton( const wxChar* custBtText, wxArrayStringProperty* pcc ) | |
987 | { | |
988 | m_custBtText = custBtText; | |
989 | m_pCallingClass = pcc; | |
990 | } | |
991 | ||
992 | void OnCustomEditClick(wxCommandEvent& event); | |
993 | ||
994 | protected: | |
995 | wxArrayString m_array; | |
996 | ||
997 | wxArrayStringProperty* m_pCallingClass; | |
998 | ||
999 | virtual wxString ArrayGet( size_t index ); | |
1000 | virtual size_t ArrayGetCount(); | |
1001 | virtual bool ArrayInsert( const wxString& str, int index ); | |
1002 | virtual bool ArraySet( size_t index, const wxString& str ); | |
1003 | virtual void ArrayRemoveAt( int index ); | |
1004 | virtual void ArraySwap( size_t first, size_t second ); | |
1005 | ||
1006 | private: | |
1007 | #ifndef SWIG | |
1008 | DECLARE_DYNAMIC_CLASS_NO_COPY(wxPGArrayStringEditorDialog) | |
1009 | DECLARE_EVENT_TABLE() | |
1010 | #endif | |
1011 | }; | |
1012 | ||
1013 | // ----------------------------------------------------------------------- | |
1014 | ||
f4bc1aa2 JS |
1015 | #endif // wxUSE_PROPGRID |
1016 | ||
1c4293cb | 1017 | #endif // _WX_PROPGRID_PROPS_H_ |