]> git.saurik.com Git - wxWidgets.git/blob - src/propgrid/props.cpp
Increase the number of visible OS X combo items.
[wxWidgets.git] / src / propgrid / props.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/propgrid/props.cpp
3 // Purpose: Basic Property Classes
4 // Author: Jaakko Salli
5 // Modified by:
6 // Created: 2005-05-14
7 // Copyright: (c) Jaakko Salli
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
10
11 // For compilers that support precompilation, includes "wx/wx.h".
12 #include "wx/wxprec.h"
13
14 #ifdef __BORLANDC__
15 #pragma hdrstop
16 #endif
17
18 #if wxUSE_PROPGRID
19
20 #ifndef WX_PRECOMP
21 #include "wx/defs.h"
22 #include "wx/object.h"
23 #include "wx/hash.h"
24 #include "wx/string.h"
25 #include "wx/log.h"
26 #include "wx/event.h"
27 #include "wx/window.h"
28 #include "wx/panel.h"
29 #include "wx/dc.h"
30 #include "wx/dcclient.h"
31 #include "wx/dcmemory.h"
32 #include "wx/button.h"
33 #include "wx/bmpbuttn.h"
34 #include "wx/pen.h"
35 #include "wx/brush.h"
36 #include "wx/cursor.h"
37 #include "wx/dialog.h"
38 #include "wx/settings.h"
39 #include "wx/msgdlg.h"
40 #include "wx/choice.h"
41 #include "wx/stattext.h"
42 #include "wx/scrolwin.h"
43 #include "wx/dirdlg.h"
44 #include "wx/combobox.h"
45 #include "wx/layout.h"
46 #include "wx/sizer.h"
47 #include "wx/textdlg.h"
48 #include "wx/filedlg.h"
49 #include "wx/intl.h"
50 #endif
51
52 #include "wx/filename.h"
53
54 #include "wx/propgrid/propgrid.h"
55
56 #define wxPG_CUSTOM_IMAGE_WIDTH 20 // for wxColourProperty etc.
57
58
59 // -----------------------------------------------------------------------
60 // wxStringProperty
61 // -----------------------------------------------------------------------
62
63 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxStringProperty,wxPGProperty,
64 wxString,const wxString&,TextCtrl)
65
66 wxStringProperty::wxStringProperty( const wxString& label,
67 const wxString& name,
68 const wxString& value )
69 : wxPGProperty(label,name)
70 {
71 SetValue(value);
72 }
73
74 void wxStringProperty::OnSetValue()
75 {
76 if ( !m_value.IsNull() && m_value.GetString() == wxS("<composed>") )
77 SetFlag(wxPG_PROP_COMPOSED_VALUE);
78
79 if ( HasFlag(wxPG_PROP_COMPOSED_VALUE) )
80 {
81 wxString s;
82 DoGenerateComposedValue(s);
83 m_value = s;
84 }
85 }
86
87 wxStringProperty::~wxStringProperty() { }
88
89 wxString wxStringProperty::ValueToString( wxVariant& value,
90 int argFlags ) const
91 {
92 wxString s = value.GetString();
93
94 if ( GetChildCount() && HasFlag(wxPG_PROP_COMPOSED_VALUE) )
95 {
96 // Value stored in m_value is non-editable, non-full value
97 if ( (argFlags & wxPG_FULL_VALUE) ||
98 (argFlags & wxPG_EDITABLE_VALUE) ||
99 !s.length() )
100 {
101 // Calling this under incorrect conditions will fail
102 wxASSERT_MSG( argFlags & wxPG_VALUE_IS_CURRENT,
103 "Sorry, currently default wxPGProperty::ValueToString() "
104 "implementation only works if value is m_value." );
105
106 DoGenerateComposedValue(s, argFlags);
107 }
108
109 return s;
110 }
111
112 // If string is password and value is for visual purposes,
113 // then return asterisks instead the actual string.
114 if ( (m_flags & wxPG_PROP_PASSWORD) && !(argFlags & (wxPG_FULL_VALUE|wxPG_EDITABLE_VALUE)) )
115 return wxString(wxChar('*'), s.Length());
116
117 return s;
118 }
119
120 bool wxStringProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
121 {
122 if ( GetChildCount() && HasFlag(wxPG_PROP_COMPOSED_VALUE) )
123 return wxPGProperty::StringToValue(variant, text, argFlags);
124
125 if ( variant != text )
126 {
127 variant = text;
128 return true;
129 }
130
131 return false;
132 }
133
134 bool wxStringProperty::DoSetAttribute( const wxString& name, wxVariant& value )
135 {
136 if ( name == wxPG_STRING_PASSWORD )
137 {
138 m_flags &= ~(wxPG_PROP_PASSWORD);
139 if ( value.GetLong() ) m_flags |= wxPG_PROP_PASSWORD;
140 RecreateEditor();
141 return false;
142 }
143 return true;
144 }
145
146 // -----------------------------------------------------------------------
147 // wxNumericPropertyValidator
148 // -----------------------------------------------------------------------
149
150 #if wxUSE_VALIDATORS
151
152 wxNumericPropertyValidator::
153 wxNumericPropertyValidator( NumericType numericType, int base )
154 : wxTextValidator(wxFILTER_INCLUDE_CHAR_LIST)
155 {
156 wxArrayString arr;
157 arr.Add(wxS("0"));
158 arr.Add(wxS("1"));
159 arr.Add(wxS("2"));
160 arr.Add(wxS("3"));
161 arr.Add(wxS("4"));
162 arr.Add(wxS("5"));
163 arr.Add(wxS("6"));
164 arr.Add(wxS("7"));
165
166 if ( base >= 10 )
167 {
168 arr.Add(wxS("8"));
169 arr.Add(wxS("9"));
170 if ( base >= 16 )
171 {
172 arr.Add(wxS("a")); arr.Add(wxS("A"));
173 arr.Add(wxS("b")); arr.Add(wxS("B"));
174 arr.Add(wxS("c")); arr.Add(wxS("C"));
175 arr.Add(wxS("d")); arr.Add(wxS("D"));
176 arr.Add(wxS("e")); arr.Add(wxS("E"));
177 arr.Add(wxS("f")); arr.Add(wxS("F"));
178 }
179 }
180
181 if ( numericType == Signed )
182 {
183 arr.Add(wxS("+"));
184 arr.Add(wxS("-"));
185 }
186 else if ( numericType == Float )
187 {
188 arr.Add(wxS("+"));
189 arr.Add(wxS("-"));
190 arr.Add(wxS("e"));
191
192 // Use locale-specific decimal point
193 arr.Add(wxString::Format("%g", 1.1)[1]);
194 }
195
196 SetIncludes(arr);
197 }
198
199 bool wxNumericPropertyValidator::Validate(wxWindow* parent)
200 {
201 if ( !wxTextValidator::Validate(parent) )
202 return false;
203
204 wxWindow* wnd = GetWindow();
205 if ( !wxDynamicCast(wnd, wxTextCtrl) )
206 return true;
207
208 // Do not allow zero-length string
209 wxTextCtrl* tc = static_cast<wxTextCtrl*>(wnd);
210 wxString text = tc->GetValue();
211
212 if ( text.empty() )
213 return false;
214
215 return true;
216 }
217
218 #endif // wxUSE_VALIDATORS
219
220 // -----------------------------------------------------------------------
221 // wxIntProperty
222 // -----------------------------------------------------------------------
223
224 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxIntProperty,wxPGProperty,
225 long,long,TextCtrl)
226
227 wxIntProperty::wxIntProperty( const wxString& label, const wxString& name,
228 long value ) : wxPGProperty(label,name)
229 {
230 SetValue(value);
231 }
232
233 wxIntProperty::wxIntProperty( const wxString& label, const wxString& name,
234 const wxLongLong& value ) : wxPGProperty(label,name)
235 {
236 SetValue(WXVARIANT(value));
237 }
238
239 wxIntProperty::~wxIntProperty() { }
240
241 wxString wxIntProperty::ValueToString( wxVariant& value,
242 int WXUNUSED(argFlags) ) const
243 {
244 if ( value.GetType() == wxPG_VARIANT_TYPE_LONG )
245 {
246 return wxString::Format(wxS("%li"),value.GetLong());
247 }
248 else if ( value.GetType() == wxPG_VARIANT_TYPE_LONGLONG )
249 {
250 wxLongLong ll = value.GetLongLong();
251 return ll.ToString();
252 }
253
254 return wxEmptyString;
255 }
256
257 bool wxIntProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
258 {
259 wxString s;
260 long value32;
261
262 if ( text.empty() )
263 {
264 variant.MakeNull();
265 return true;
266 }
267
268 // We know it is a number, but let's still check
269 // the return value.
270 if ( text.IsNumber() )
271 {
272 // Remove leading zeroes, so that the number is not interpreted as octal
273 wxString::const_iterator i = text.begin();
274 wxString::const_iterator iMax = text.end() - 1; // Let's allow one, last zero though
275
276 int firstNonZeroPos = 0;
277
278 for ( ; i != iMax; ++i )
279 {
280 wxChar c = *i;
281 if ( c != wxS('0') && c != wxS(' ') )
282 break;
283 firstNonZeroPos++;
284 }
285
286 wxString useText = text.substr(firstNonZeroPos, text.length() - firstNonZeroPos);
287
288 wxString variantType = variant.GetType();
289 bool isPrevLong = variantType == wxPG_VARIANT_TYPE_LONG;
290
291 wxLongLong_t value64 = 0;
292
293 if ( useText.ToLongLong(&value64, 10) &&
294 ( value64 >= INT_MAX || value64 <= INT_MIN )
295 )
296 {
297 bool doChangeValue = isPrevLong;
298
299 if ( !isPrevLong && variantType == wxPG_VARIANT_TYPE_LONGLONG )
300 {
301 wxLongLong oldValue = variant.GetLongLong();
302 if ( oldValue.GetValue() != value64 )
303 doChangeValue = true;
304 }
305
306 if ( doChangeValue )
307 {
308 wxLongLong ll(value64);
309 variant = ll;
310 return true;
311 }
312 }
313
314 if ( useText.ToLong( &value32, 0 ) )
315 {
316 if ( !isPrevLong || variant != value32 )
317 {
318 variant = value32;
319 return true;
320 }
321 }
322 }
323 else if ( argFlags & wxPG_REPORT_ERROR )
324 {
325 }
326 return false;
327 }
328
329 bool wxIntProperty::IntToValue( wxVariant& variant, int value, int WXUNUSED(argFlags) ) const
330 {
331 if ( variant.GetType() != wxPG_VARIANT_TYPE_LONG || variant != (long)value )
332 {
333 variant = (long)value;
334 return true;
335 }
336 return false;
337 }
338
339 //
340 // Common validation code to be called in ValidateValue()
341 // implementations.
342 //
343 // Note that 'value' is reference on purpose, so we can write
344 // back to it when mode is wxPG_PROPERTY_VALIDATION_SATURATE.
345 //
346 template<typename T>
347 bool NumericValidation( const wxPGProperty* property,
348 T& value,
349 wxPGValidationInfo* pValidationInfo,
350 int mode,
351 const wxString& strFmt )
352 {
353 T min = (T) wxINT64_MIN;
354 T max = (T) wxINT64_MAX;
355 wxVariant variant;
356 bool minOk = false;
357 bool maxOk = false;
358
359 variant = property->GetAttribute(wxPGGlobalVars->m_strMin);
360 if ( !variant.IsNull() )
361 {
362 variant.Convert(&min);
363 minOk = true;
364 }
365
366 variant = property->GetAttribute(wxPGGlobalVars->m_strMax);
367 if ( !variant.IsNull() )
368 {
369 variant.Convert(&max);
370 maxOk = true;
371 }
372
373 if ( minOk )
374 {
375 if ( value < min )
376 {
377 if ( mode == wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE )
378 {
379 wxString msg;
380 wxString smin = wxString::Format(strFmt, min);
381 wxString smax = wxString::Format(strFmt, max);
382 if ( !maxOk )
383 msg = wxString::Format(
384 _("Value must be %s or higher."),
385 smin.c_str());
386 else
387 msg = wxString::Format(
388 _("Value must be between %s and %s."),
389 smin.c_str(), smax.c_str());
390 pValidationInfo->SetFailureMessage(msg);
391 }
392 else if ( mode == wxPG_PROPERTY_VALIDATION_SATURATE )
393 value = min;
394 else
395 value = max - (min - value);
396 return false;
397 }
398 }
399
400 if ( maxOk )
401 {
402 if ( value > max )
403 {
404 if ( mode == wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE )
405 {
406 wxString msg;
407 wxString smin = wxString::Format(strFmt, min);
408 wxString smax = wxString::Format(strFmt, max);
409 if ( !minOk )
410 msg = wxString::Format(
411 _("Value must be %s or less."),
412 smax.c_str());
413 else
414 msg = wxString::Format(
415 _("Value must be between %s and %s."),
416 smin.c_str(), smax.c_str());
417 pValidationInfo->SetFailureMessage(msg);
418 }
419 else if ( mode == wxPG_PROPERTY_VALIDATION_SATURATE )
420 value = max;
421 else
422 value = min + (value - max);
423 return false;
424 }
425 }
426 return true;
427 }
428
429 bool wxIntProperty::DoValidation( const wxPGProperty* property,
430 wxLongLong_t& value,
431 wxPGValidationInfo* pValidationInfo,
432 int mode )
433 {
434 return NumericValidation<wxLongLong_t>(property,
435 value,
436 pValidationInfo,
437 mode,
438 wxS("%lld"));
439 }
440
441 bool wxIntProperty::ValidateValue( wxVariant& value,
442 wxPGValidationInfo& validationInfo ) const
443 {
444 wxLongLong_t ll = value.GetLongLong().GetValue();
445 return DoValidation(this, ll, &validationInfo,
446 wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE);
447 }
448
449 wxValidator* wxIntProperty::GetClassValidator()
450 {
451 #if wxUSE_VALIDATORS
452 WX_PG_DOGETVALIDATOR_ENTRY()
453
454 wxValidator* validator = new wxNumericPropertyValidator(
455 wxNumericPropertyValidator::Signed);
456
457 WX_PG_DOGETVALIDATOR_EXIT(validator)
458 #else
459 return NULL;
460 #endif
461 }
462
463 wxValidator* wxIntProperty::DoGetValidator() const
464 {
465 return GetClassValidator();
466 }
467
468 // -----------------------------------------------------------------------
469 // wxUIntProperty
470 // -----------------------------------------------------------------------
471
472
473 #define wxPG_UINT_TEMPLATE_MAX 8
474
475 static const wxChar* const gs_uintTemplates32[wxPG_UINT_TEMPLATE_MAX] = {
476 wxT("%lx"),wxT("0x%lx"),wxT("$%lx"),
477 wxT("%lX"),wxT("0x%lX"),wxT("$%lX"),
478 wxT("%lu"),wxT("%lo")
479 };
480
481 static const char* const gs_uintTemplates64[wxPG_UINT_TEMPLATE_MAX] = {
482 "%" wxLongLongFmtSpec "x",
483 "0x%" wxLongLongFmtSpec "x",
484 "$%" wxLongLongFmtSpec "x",
485 "%" wxLongLongFmtSpec "X",
486 "0x%" wxLongLongFmtSpec "X",
487 "$%" wxLongLongFmtSpec "X",
488 "%" wxLongLongFmtSpec "u",
489 "%" wxLongLongFmtSpec "o"
490 };
491
492 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxUIntProperty,wxPGProperty,
493 long,unsigned long,TextCtrl)
494
495 void wxUIntProperty::Init()
496 {
497 m_base = 6; // This is magic number for dec base (must be same as in setattribute)
498 m_realBase = 10;
499 m_prefix = wxPG_PREFIX_NONE;
500 }
501
502 wxUIntProperty::wxUIntProperty( const wxString& label, const wxString& name,
503 unsigned long value ) : wxPGProperty(label,name)
504 {
505 Init();
506 SetValue((long)value);
507 }
508
509 wxUIntProperty::wxUIntProperty( const wxString& label, const wxString& name,
510 const wxULongLong& value ) : wxPGProperty(label,name)
511 {
512 Init();
513 SetValue(WXVARIANT(value));
514 }
515
516 wxUIntProperty::~wxUIntProperty() { }
517
518 wxString wxUIntProperty::ValueToString( wxVariant& value,
519 int WXUNUSED(argFlags) ) const
520 {
521 size_t index = m_base + m_prefix;
522 if ( index >= wxPG_UINT_TEMPLATE_MAX )
523 index = wxPG_BASE_DEC;
524
525 if ( value.GetType() == wxPG_VARIANT_TYPE_LONG )
526 {
527 return wxString::Format(gs_uintTemplates32[index],
528 (unsigned long)value.GetLong());
529 }
530
531 wxULongLong ull = value.GetULongLong();
532
533 return wxString::Format(gs_uintTemplates64[index], ull.GetValue());
534 }
535
536 bool wxUIntProperty::StringToValue( wxVariant& variant, const wxString& text, int WXUNUSED(argFlags) ) const
537 {
538 wxString variantType = variant.GetType();
539 bool isPrevLong = variantType == wxPG_VARIANT_TYPE_LONG;
540
541 if ( text.empty() )
542 {
543 variant.MakeNull();
544 return true;
545 }
546
547 size_t start = 0;
548 if ( text[0] == wxS('$') )
549 start++;
550
551 wxULongLong_t value64 = 0;
552 wxString s = text.substr(start, text.length() - start);
553
554 if ( s.ToULongLong(&value64, (unsigned int)m_realBase) )
555 {
556 if ( value64 >= LONG_MAX )
557 {
558 bool doChangeValue = isPrevLong;
559
560 if ( !isPrevLong && variantType == wxPG_VARIANT_TYPE_ULONGLONG )
561 {
562 wxULongLong oldValue = variant.GetULongLong();
563 if ( oldValue.GetValue() != value64 )
564 doChangeValue = true;
565 }
566
567 if ( doChangeValue )
568 {
569 variant = wxULongLong(value64);
570 return true;
571 }
572 }
573 else
574 {
575 unsigned long value32 = wxLongLong(value64).GetLo();
576 if ( !isPrevLong || m_value != (long)value32 )
577 {
578 variant = (long)value32;
579 return true;
580 }
581 }
582
583 }
584 return false;
585 }
586
587 bool wxUIntProperty::IntToValue( wxVariant& variant, int number, int WXUNUSED(argFlags) ) const
588 {
589 if ( variant != (long)number )
590 {
591 variant = (long)number;
592 return true;
593 }
594 return false;
595 }
596
597 bool wxUIntProperty::ValidateValue( wxVariant& value, wxPGValidationInfo& validationInfo ) const
598 {
599 wxULongLong_t uul = value.GetULongLong().GetValue();
600 return
601 NumericValidation<wxULongLong_t>(this,
602 uul,
603 &validationInfo,
604 wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE,
605 wxS("%llu"));
606 }
607
608 wxValidator* wxUIntProperty::DoGetValidator() const
609 {
610 #if wxUSE_VALIDATORS
611 WX_PG_DOGETVALIDATOR_ENTRY()
612
613 wxValidator* validator = new wxNumericPropertyValidator(
614 wxNumericPropertyValidator::Unsigned,
615 m_realBase);
616
617 WX_PG_DOGETVALIDATOR_EXIT(validator)
618 #else
619 return NULL;
620 #endif
621 }
622
623 bool wxUIntProperty::DoSetAttribute( const wxString& name, wxVariant& value )
624 {
625 if ( name == wxPG_UINT_BASE )
626 {
627 int val = value.GetLong();
628
629 m_realBase = (wxByte) val;
630 if ( m_realBase > 16 )
631 m_realBase = 16;
632
633 //
634 // Translate logical base to a template array index
635 m_base = 7; // oct
636 if ( val == wxPG_BASE_HEX )
637 m_base = 3;
638 else if ( val == wxPG_BASE_DEC )
639 m_base = 6;
640 else if ( val == wxPG_BASE_HEXL )
641 m_base = 0;
642 return true;
643 }
644 else if ( name == wxPG_UINT_PREFIX )
645 {
646 m_prefix = (wxByte) value.GetLong();
647 return true;
648 }
649 return false;
650 }
651
652 // -----------------------------------------------------------------------
653 // wxFloatProperty
654 // -----------------------------------------------------------------------
655
656 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxFloatProperty,wxPGProperty,
657 double,double,TextCtrl)
658
659 wxFloatProperty::wxFloatProperty( const wxString& label,
660 const wxString& name,
661 double value )
662 : wxPGProperty(label,name)
663 {
664 m_precision = -1;
665 SetValue(value);
666 }
667
668 wxFloatProperty::~wxFloatProperty() { }
669
670 // This helper method provides standard way for floating point-using
671 // properties to convert values to string.
672 const wxString& wxPropertyGrid::DoubleToString(wxString& target,
673 double value,
674 int precision,
675 bool removeZeroes,
676 wxString* precTemplate)
677 {
678 if ( precision >= 0 )
679 {
680 wxString text1;
681 if (!precTemplate)
682 precTemplate = &text1;
683
684 if ( precTemplate->empty() )
685 {
686 *precTemplate = wxS("%.");
687 *precTemplate << wxString::Format( wxS("%i"), precision );
688 *precTemplate << wxS('f');
689 }
690
691 target.Printf( precTemplate->c_str(), value );
692 }
693 else
694 {
695 target.Printf( wxS("%f"), value );
696 }
697
698 if ( removeZeroes && precision != 0 && !target.empty() )
699 {
700 // Remove excess zeroes (do not remove this code just yet,
701 // since sprintf can't do the same consistently across platforms).
702 wxString::const_iterator i = target.end() - 1;
703 size_t new_len = target.length() - 1;
704
705 for ( ; i != target.begin(); --i )
706 {
707 if ( *i != wxS('0') )
708 break;
709 new_len--;
710 }
711
712 wxChar cur_char = *i;
713 if ( cur_char != wxS('.') && cur_char != wxS(',') )
714 new_len++;
715
716 if ( new_len != target.length() )
717 target.resize(new_len);
718 }
719
720 // Remove sign from zero
721 if ( target.length() >= 2 && target[0] == wxS('-') )
722 {
723 bool isZero = true;
724 wxString::const_iterator i = target.begin() + 1;
725
726 for ( ; i != target.end(); i++ )
727 {
728 if ( *i != wxS('0') && *i != wxS('.') && *i != wxS(',') )
729 {
730 isZero = false;
731 break;
732 }
733 }
734
735 if ( isZero )
736 target.erase(target.begin());
737 }
738
739 return target;
740 }
741
742 wxString wxFloatProperty::ValueToString( wxVariant& value,
743 int argFlags ) const
744 {
745 wxString text;
746 if ( !value.IsNull() )
747 {
748 wxPropertyGrid::DoubleToString(text,
749 value,
750 m_precision,
751 !(argFlags & wxPG_FULL_VALUE),
752 NULL);
753 }
754 return text;
755 }
756
757 bool wxFloatProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
758 {
759 wxString s;
760 double value;
761
762 if ( text.empty() )
763 {
764 variant.MakeNull();
765 return true;
766 }
767
768 bool res = text.ToDouble(&value);
769 if ( res )
770 {
771 if ( variant != value )
772 {
773 variant = value;
774 return true;
775 }
776 }
777 else if ( argFlags & wxPG_REPORT_ERROR )
778 {
779 }
780 return false;
781 }
782
783 bool wxFloatProperty::DoValidation( const wxPGProperty* property,
784 double& value,
785 wxPGValidationInfo* pValidationInfo,
786 int mode )
787 {
788 return NumericValidation<double>(property,
789 value,
790 pValidationInfo,
791 mode,
792 wxS("%g"));
793 }
794
795 bool
796 wxFloatProperty::ValidateValue( wxVariant& value,
797 wxPGValidationInfo& validationInfo ) const
798 {
799 double fpv = value.GetDouble();
800 return DoValidation(this, fpv, &validationInfo,
801 wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE);
802 }
803
804 bool wxFloatProperty::DoSetAttribute( const wxString& name, wxVariant& value )
805 {
806 if ( name == wxPG_FLOAT_PRECISION )
807 {
808 m_precision = value.GetLong();
809 return true;
810 }
811 return false;
812 }
813
814 wxValidator*
815 wxFloatProperty::GetClassValidator()
816 {
817 #if wxUSE_VALIDATORS
818 WX_PG_DOGETVALIDATOR_ENTRY()
819
820 wxValidator* validator = new wxNumericPropertyValidator(
821 wxNumericPropertyValidator::Float);
822
823 WX_PG_DOGETVALIDATOR_EXIT(validator)
824 #else
825 return NULL;
826 #endif
827 }
828
829 wxValidator* wxFloatProperty::DoGetValidator() const
830 {
831 return GetClassValidator();
832 }
833
834 // -----------------------------------------------------------------------
835 // wxBoolProperty
836 // -----------------------------------------------------------------------
837
838 // We cannot use standard WX_PG_IMPLEMENT_PROPERTY_CLASS macro, since
839 // there is a custom GetEditorClass.
840
841 IMPLEMENT_DYNAMIC_CLASS(wxBoolProperty, wxPGProperty)
842
843 const wxPGEditor* wxBoolProperty::DoGetEditorClass() const
844 {
845 // Select correct editor control.
846 #if wxPG_INCLUDE_CHECKBOX
847 if ( !(m_flags & wxPG_PROP_USE_CHECKBOX) )
848 return wxPGEditor_Choice;
849 return wxPGEditor_CheckBox;
850 #else
851 return wxPGEditor_Choice;
852 #endif
853 }
854
855 wxBoolProperty::wxBoolProperty( const wxString& label, const wxString& name, bool value ) :
856 wxPGProperty(label,name)
857 {
858 m_choices.Assign(wxPGGlobalVars->m_boolChoices);
859
860 SetValue(wxPGVariant_Bool(value));
861
862 m_flags |= wxPG_PROP_USE_DCC;
863 }
864
865 wxBoolProperty::~wxBoolProperty() { }
866
867 wxString wxBoolProperty::ValueToString( wxVariant& value,
868 int argFlags ) const
869 {
870 bool boolValue = value.GetBool();
871
872 // As a fragment of composite string value,
873 // make it a little more readable.
874 if ( argFlags & wxPG_COMPOSITE_FRAGMENT )
875 {
876 if ( boolValue )
877 {
878 return m_label;
879 }
880 else
881 {
882 if ( argFlags & wxPG_UNEDITABLE_COMPOSITE_FRAGMENT )
883 return wxEmptyString;
884
885 wxString notFmt;
886 if ( wxPGGlobalVars->m_autoGetTranslation )
887 notFmt = _("Not %s");
888 else
889 notFmt = wxS("Not %s");
890
891 return wxString::Format(notFmt.c_str(), m_label.c_str());
892 }
893 }
894
895 if ( !(argFlags & wxPG_FULL_VALUE) )
896 {
897 return wxPGGlobalVars->m_boolChoices[boolValue?1:0].GetText();
898 }
899
900 wxString text;
901
902 if ( boolValue ) text = wxS("true");
903 else text = wxS("false");
904
905 return text;
906 }
907
908 bool wxBoolProperty::StringToValue( wxVariant& variant, const wxString& text, int WXUNUSED(argFlags) ) const
909 {
910 bool boolValue = false;
911 if ( text.CmpNoCase(wxPGGlobalVars->m_boolChoices[1].GetText()) == 0 ||
912 text.CmpNoCase(wxS("true")) == 0 ||
913 text.CmpNoCase(m_label) == 0 )
914 boolValue = true;
915
916 if ( text.empty() )
917 {
918 variant.MakeNull();
919 return true;
920 }
921
922 if ( variant != boolValue )
923 {
924 variant = wxPGVariant_Bool(boolValue);
925 return true;
926 }
927 return false;
928 }
929
930 bool wxBoolProperty::IntToValue( wxVariant& variant, int value, int ) const
931 {
932 bool boolValue = value ? true : false;
933
934 if ( variant != boolValue )
935 {
936 variant = wxPGVariant_Bool(boolValue);
937 return true;
938 }
939 return false;
940 }
941
942 bool wxBoolProperty::DoSetAttribute( const wxString& name, wxVariant& value )
943 {
944 #if wxPG_INCLUDE_CHECKBOX
945 if ( name == wxPG_BOOL_USE_CHECKBOX )
946 {
947 if ( value.GetLong() )
948 m_flags |= wxPG_PROP_USE_CHECKBOX;
949 else
950 m_flags &= ~(wxPG_PROP_USE_CHECKBOX);
951 return true;
952 }
953 #endif
954 if ( name == wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING )
955 {
956 if ( value.GetLong() )
957 m_flags |= wxPG_PROP_USE_DCC;
958 else
959 m_flags &= ~(wxPG_PROP_USE_DCC);
960 return true;
961 }
962 return false;
963 }
964
965 // -----------------------------------------------------------------------
966 // wxEnumProperty
967 // -----------------------------------------------------------------------
968
969 IMPLEMENT_DYNAMIC_CLASS(wxEnumProperty, wxPGProperty)
970
971 WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxEnumProperty,long,Choice)
972
973 wxEnumProperty::wxEnumProperty( const wxString& label, const wxString& name, const wxChar* const* labels,
974 const long* values, int value ) : wxPGProperty(label,name)
975 {
976 SetIndex(0);
977
978 if ( labels )
979 {
980 m_choices.Add(labels,values);
981
982 if ( GetItemCount() )
983 SetValue( (long)value );
984 }
985 }
986
987 wxEnumProperty::wxEnumProperty( const wxString& label, const wxString& name, const wxChar* const* labels,
988 const long* values, wxPGChoices* choicesCache, int value )
989 : wxPGProperty(label,name)
990 {
991 SetIndex(0);
992
993 wxASSERT( choicesCache );
994
995 if ( choicesCache->IsOk() )
996 {
997 m_choices.Assign( *choicesCache );
998 m_value = wxPGVariant_Zero;
999 }
1000 else if ( labels )
1001 {
1002 m_choices.Add(labels,values);
1003
1004 if ( GetItemCount() )
1005 SetValue( (long)value );
1006 }
1007 }
1008
1009 wxEnumProperty::wxEnumProperty( const wxString& label, const wxString& name,
1010 const wxArrayString& labels, const wxArrayInt& values, int value )
1011 : wxPGProperty(label,name)
1012 {
1013 SetIndex(0);
1014
1015 if ( &labels && labels.size() )
1016 {
1017 m_choices.Set(labels, values);
1018
1019 if ( GetItemCount() )
1020 SetValue( (long)value );
1021 }
1022 }
1023
1024 wxEnumProperty::wxEnumProperty( const wxString& label, const wxString& name,
1025 wxPGChoices& choices, int value )
1026 : wxPGProperty(label,name)
1027 {
1028 m_choices.Assign( choices );
1029
1030 if ( GetItemCount() )
1031 SetValue( (long)value );
1032 }
1033
1034 int wxEnumProperty::GetIndexForValue( int value ) const
1035 {
1036 if ( !m_choices.IsOk() )
1037 return -1;
1038
1039 int intVal = m_choices.Index(value);
1040 if ( intVal >= 0 )
1041 return intVal;
1042
1043 return value;
1044 }
1045
1046 wxEnumProperty::~wxEnumProperty ()
1047 {
1048 }
1049
1050 int wxEnumProperty::ms_nextIndex = -2;
1051
1052 void wxEnumProperty::OnSetValue()
1053 {
1054 wxString variantType = m_value.GetType();
1055
1056 if ( variantType == wxPG_VARIANT_TYPE_LONG )
1057 {
1058 ValueFromInt_( m_value, m_value.GetLong(), wxPG_FULL_VALUE );
1059 }
1060 else if ( variantType == wxPG_VARIANT_TYPE_STRING )
1061 {
1062 ValueFromString_( m_value, m_value.GetString(), 0 );
1063 }
1064 else
1065 {
1066 wxFAIL;
1067 }
1068
1069 if ( ms_nextIndex != -2 )
1070 {
1071 m_index = ms_nextIndex;
1072 ms_nextIndex = -2;
1073 }
1074 }
1075
1076 bool wxEnumProperty::ValidateValue( wxVariant& value, wxPGValidationInfo& WXUNUSED(validationInfo) ) const
1077 {
1078 // Make sure string value is in the list,
1079 // unless property has string as preferred value type
1080 // To reduce code size, use conversion here as well
1081 if ( value.GetType() == wxPG_VARIANT_TYPE_STRING &&
1082 !wxDynamicCastThis(wxEditEnumProperty) )
1083 return ValueFromString_( value, value.GetString(), wxPG_PROPERTY_SPECIFIC );
1084
1085 return true;
1086 }
1087
1088 wxString wxEnumProperty::ValueToString( wxVariant& value,
1089 int WXUNUSED(argFlags) ) const
1090 {
1091 if ( value.GetType() == wxPG_VARIANT_TYPE_STRING )
1092 return value.GetString();
1093
1094 int index = m_choices.Index(value.GetLong());
1095 if ( index < 0 )
1096 return wxEmptyString;
1097
1098 return m_choices.GetLabel(index);
1099 }
1100
1101 bool wxEnumProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
1102 {
1103 return ValueFromString_( variant, text, argFlags );
1104 }
1105
1106 bool wxEnumProperty::IntToValue( wxVariant& variant, int intVal, int argFlags ) const
1107 {
1108 return ValueFromInt_( variant, intVal, argFlags );
1109 }
1110
1111 bool wxEnumProperty::ValueFromString_( wxVariant& value, const wxString& text, int argFlags ) const
1112 {
1113 int useIndex = -1;
1114 long useValue = 0;
1115
1116 for ( unsigned int i=0; i<m_choices.GetCount(); i++ )
1117 {
1118 const wxString& entryLabel = m_choices.GetLabel(i);
1119 if ( text.CmpNoCase(entryLabel) == 0 )
1120 {
1121 useIndex = (int)i;
1122 useValue = m_choices.GetValue(i);
1123 break;
1124 }
1125 }
1126
1127 bool asText = false;
1128
1129 bool isEdit = this->IsKindOf(wxCLASSINFO(wxEditEnumProperty));
1130
1131 // If text not any of the choices, store as text instead
1132 // (but only if we are wxEditEnumProperty)
1133 if ( useIndex == -1 && isEdit )
1134 {
1135 asText = true;
1136 }
1137
1138 int setAsNextIndex = -2;
1139
1140 if ( asText )
1141 {
1142 setAsNextIndex = -1;
1143 value = text;
1144 }
1145 else if ( useIndex != GetIndex() )
1146 {
1147 if ( useIndex != -1 )
1148 {
1149 setAsNextIndex = useIndex;
1150 value = (long)useValue;
1151 }
1152 else
1153 {
1154 setAsNextIndex = -1;
1155 value = wxPGVariant_MinusOne;
1156 }
1157 }
1158
1159 if ( setAsNextIndex != -2 )
1160 {
1161 // If wxPG_PROPERTY_SPECIFIC is set, then this is done for
1162 // validation purposes only, and index must not be changed
1163 if ( !(argFlags & wxPG_PROPERTY_SPECIFIC) )
1164 ms_nextIndex = setAsNextIndex;
1165
1166 if ( isEdit || setAsNextIndex != -1 )
1167 return true;
1168 else
1169 return false;
1170 }
1171 return false;
1172 }
1173
1174 bool wxEnumProperty::ValueFromInt_( wxVariant& variant, int intVal, int argFlags ) const
1175 {
1176 // If wxPG_FULL_VALUE is *not* in argFlags, then intVal is index from combo box.
1177 //
1178 ms_nextIndex = -2;
1179
1180 if ( argFlags & wxPG_FULL_VALUE )
1181 {
1182 ms_nextIndex = GetIndexForValue( intVal );
1183 }
1184 else
1185 {
1186 if ( intVal != GetIndex() )
1187 {
1188 ms_nextIndex = intVal;
1189 }
1190 }
1191
1192 if ( ms_nextIndex != -2 )
1193 {
1194 if ( !(argFlags & wxPG_FULL_VALUE) )
1195 intVal = m_choices.GetValue(intVal);
1196
1197 variant = (long)intVal;
1198
1199 return true;
1200 }
1201
1202 return false;
1203 }
1204
1205 void
1206 wxEnumProperty::OnValidationFailure( wxVariant& WXUNUSED(pendingValue) )
1207 {
1208 // Revert index
1209 ResetNextIndex();
1210 }
1211
1212 void wxEnumProperty::SetIndex( int index )
1213 {
1214 ms_nextIndex = -2;
1215 m_index = index;
1216 }
1217
1218 int wxEnumProperty::GetIndex() const
1219 {
1220 if ( m_value.IsNull() )
1221 return -1;
1222
1223 if ( ms_nextIndex != -2 )
1224 return ms_nextIndex;
1225
1226 return m_index;
1227 }
1228
1229 // -----------------------------------------------------------------------
1230 // wxEditEnumProperty
1231 // -----------------------------------------------------------------------
1232
1233 IMPLEMENT_DYNAMIC_CLASS(wxEditEnumProperty, wxPGProperty)
1234
1235 WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxEditEnumProperty,wxString,ComboBox)
1236
1237 wxEditEnumProperty::wxEditEnumProperty( const wxString& label, const wxString& name, const wxChar* const* labels,
1238 const long* values, const wxString& value )
1239 : wxEnumProperty(label,name,labels,values,0)
1240 {
1241 SetValue( value );
1242 }
1243
1244 wxEditEnumProperty::wxEditEnumProperty( const wxString& label, const wxString& name, const wxChar* const* labels,
1245 const long* values, wxPGChoices* choicesCache, const wxString& value )
1246 : wxEnumProperty(label,name,labels,values,choicesCache,0)
1247 {
1248 SetValue( value );
1249 }
1250
1251 wxEditEnumProperty::wxEditEnumProperty( const wxString& label, const wxString& name,
1252 const wxArrayString& labels, const wxArrayInt& values, const wxString& value )
1253 : wxEnumProperty(label,name,labels,values,0)
1254 {
1255 SetValue( value );
1256 }
1257
1258 wxEditEnumProperty::wxEditEnumProperty( const wxString& label, const wxString& name,
1259 wxPGChoices& choices, const wxString& value )
1260 : wxEnumProperty(label,name,choices,0)
1261 {
1262 SetValue( value );
1263 }
1264
1265 wxEditEnumProperty::~wxEditEnumProperty()
1266 {
1267 }
1268
1269 // -----------------------------------------------------------------------
1270 // wxFlagsProperty
1271 // -----------------------------------------------------------------------
1272
1273 IMPLEMENT_DYNAMIC_CLASS(wxFlagsProperty,wxPGProperty)
1274
1275 WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxFlagsProperty,long,TextCtrl)
1276
1277 void wxFlagsProperty::Init()
1278 {
1279 long value = m_value;
1280
1281 //
1282 // Generate children
1283 //
1284 unsigned int i;
1285
1286 unsigned int prevChildCount = m_children.size();
1287
1288 int oldSel = -1;
1289 if ( prevChildCount )
1290 {
1291 wxPropertyGridPageState* state = GetParentState();
1292
1293 // State safety check (it may be NULL in immediate parent)
1294 wxASSERT( state );
1295
1296 if ( state )
1297 {
1298 wxPGProperty* selected = state->GetSelection();
1299 if ( selected )
1300 {
1301 if ( selected->GetParent() == this )
1302 oldSel = selected->GetIndexInParent();
1303 else if ( selected == this )
1304 oldSel = -2;
1305 }
1306 }
1307 state->DoClearSelection();
1308 }
1309
1310 // Delete old children
1311 for ( i=0; i<prevChildCount; i++ )
1312 delete m_children[i];
1313
1314 m_children.clear();
1315
1316 // Relay wxPG_BOOL_USE_CHECKBOX and wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING
1317 // to child bool property controls.
1318 long attrUseCheckBox = GetAttributeAsLong(wxPG_BOOL_USE_CHECKBOX, 0);
1319 long attrUseDCC = GetAttributeAsLong(wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING,
1320 0);
1321
1322 if ( m_choices.IsOk() )
1323 {
1324 const wxPGChoices& choices = m_choices;
1325
1326 for ( i=0; i<GetItemCount(); i++ )
1327 {
1328 bool child_val;
1329 child_val = ( value & choices.GetValue(i) )?true:false;
1330
1331 wxPGProperty* boolProp;
1332 wxString label = GetLabel(i);
1333
1334 #if wxUSE_INTL
1335 if ( wxPGGlobalVars->m_autoGetTranslation )
1336 {
1337 boolProp = new wxBoolProperty( ::wxGetTranslation(label), label, child_val );
1338 }
1339 else
1340 #endif
1341 {
1342 boolProp = new wxBoolProperty( label, label, child_val );
1343 }
1344 if ( attrUseCheckBox )
1345 boolProp->SetAttribute(wxPG_BOOL_USE_CHECKBOX,
1346 true);
1347 if ( attrUseDCC )
1348 boolProp->SetAttribute(wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING,
1349 true);
1350 AddPrivateChild(boolProp);
1351 }
1352
1353 m_oldChoicesData = m_choices.GetDataPtr();
1354 }
1355
1356 m_oldValue = m_value;
1357
1358 if ( prevChildCount )
1359 SubPropsChanged(oldSel);
1360 }
1361
1362 wxFlagsProperty::wxFlagsProperty( const wxString& label, const wxString& name,
1363 const wxChar* const* labels, const long* values, long value ) : wxPGProperty(label,name)
1364 {
1365 m_oldChoicesData = NULL;
1366
1367 if ( labels )
1368 {
1369 m_choices.Set(labels,values);
1370
1371 wxASSERT( GetItemCount() );
1372
1373 SetValue( value );
1374 }
1375 else
1376 {
1377 m_value = wxPGVariant_Zero;
1378 }
1379 }
1380
1381 wxFlagsProperty::wxFlagsProperty( const wxString& label, const wxString& name,
1382 const wxArrayString& labels, const wxArrayInt& values, int value )
1383 : wxPGProperty(label,name)
1384 {
1385 m_oldChoicesData = NULL;
1386
1387 if ( &labels && labels.size() )
1388 {
1389 m_choices.Set(labels,values);
1390
1391 wxASSERT( GetItemCount() );
1392
1393 SetValue( (long)value );
1394 }
1395 else
1396 {
1397 m_value = wxPGVariant_Zero;
1398 }
1399 }
1400
1401 wxFlagsProperty::wxFlagsProperty( const wxString& label, const wxString& name,
1402 wxPGChoices& choices, long value )
1403 : wxPGProperty(label,name)
1404 {
1405 m_oldChoicesData = NULL;
1406
1407 if ( choices.IsOk() )
1408 {
1409 m_choices.Assign(choices);
1410
1411 wxASSERT( GetItemCount() );
1412
1413 SetValue( value );
1414 }
1415 else
1416 {
1417 m_value = wxPGVariant_Zero;
1418 }
1419 }
1420
1421 wxFlagsProperty::~wxFlagsProperty()
1422 {
1423 }
1424
1425 void wxFlagsProperty::OnSetValue()
1426 {
1427 if ( !m_choices.IsOk() || !GetItemCount() )
1428 {
1429 m_value = wxPGVariant_Zero;
1430 }
1431 else
1432 {
1433 long val = m_value.GetLong();
1434
1435 long fullFlags = 0;
1436
1437 // normalize the value (i.e. remove extra flags)
1438 unsigned int i;
1439 const wxPGChoices& choices = m_choices;
1440 for ( i = 0; i < GetItemCount(); i++ )
1441 {
1442 fullFlags |= choices.GetValue(i);
1443 }
1444
1445 val &= fullFlags;
1446
1447 m_value = val;
1448
1449 // Need to (re)init now?
1450 if ( GetChildCount() != GetItemCount() ||
1451 m_choices.GetDataPtr() != m_oldChoicesData )
1452 {
1453 Init();
1454 }
1455 }
1456
1457 long newFlags = m_value;
1458
1459 if ( newFlags != m_oldValue )
1460 {
1461 // Set child modified states
1462 unsigned int i;
1463 const wxPGChoices& choices = m_choices;
1464 for ( i = 0; i<GetItemCount(); i++ )
1465 {
1466 int flag;
1467
1468 flag = choices.GetValue(i);
1469
1470 if ( (newFlags & flag) != (m_oldValue & flag) )
1471 Item(i)->ChangeFlag( wxPG_PROP_MODIFIED, true );
1472 }
1473
1474 m_oldValue = newFlags;
1475 }
1476 }
1477
1478 wxString wxFlagsProperty::ValueToString( wxVariant& value,
1479 int WXUNUSED(argFlags) ) const
1480 {
1481 wxString text;
1482
1483 if ( !m_choices.IsOk() )
1484 return text;
1485
1486 long flags = value;
1487 unsigned int i;
1488 const wxPGChoices& choices = m_choices;
1489
1490 for ( i = 0; i < GetItemCount(); i++ )
1491 {
1492 int doAdd;
1493 doAdd = ( (flags & choices.GetValue(i)) == choices.GetValue(i) );
1494
1495 if ( doAdd )
1496 {
1497 text += choices.GetLabel(i);
1498 text += wxS(", ");
1499 }
1500 }
1501
1502 // remove last comma
1503 if ( text.Len() > 1 )
1504 text.Truncate ( text.Len() - 2 );
1505
1506 return text;
1507 }
1508
1509 // Translate string into flag tokens
1510 bool wxFlagsProperty::StringToValue( wxVariant& variant, const wxString& text, int ) const
1511 {
1512 if ( !m_choices.IsOk() )
1513 return false;
1514
1515 long newFlags = 0;
1516
1517 // semicolons are no longer valid delimeters
1518 WX_PG_TOKENIZER1_BEGIN(text,wxS(','))
1519
1520 if ( !token.empty() )
1521 {
1522 // Determine which one it is
1523 long bit = IdToBit( token );
1524
1525 if ( bit != -1 )
1526 {
1527 // Changed?
1528 newFlags |= bit;
1529 }
1530 else
1531 {
1532 break;
1533 }
1534 }
1535
1536 WX_PG_TOKENIZER1_END()
1537
1538 if ( variant != (long)newFlags )
1539 {
1540 variant = (long)newFlags;
1541 return true;
1542 }
1543
1544 return false;
1545 }
1546
1547 // Converts string id to a relevant bit.
1548 long wxFlagsProperty::IdToBit( const wxString& id ) const
1549 {
1550 unsigned int i;
1551 for ( i = 0; i < GetItemCount(); i++ )
1552 {
1553 if ( id == GetLabel(i) )
1554 {
1555 return m_choices.GetValue(i);
1556 }
1557 }
1558 return -1;
1559 }
1560
1561 void wxFlagsProperty::RefreshChildren()
1562 {
1563 if ( !m_choices.IsOk() || !GetChildCount() ) return;
1564
1565 int flags = m_value.GetLong();
1566
1567 const wxPGChoices& choices = m_choices;
1568 unsigned int i;
1569 for ( i = 0; i < GetItemCount(); i++ )
1570 {
1571 long flag;
1572
1573 flag = choices.GetValue(i);
1574
1575 long subVal = flags & flag;
1576 wxPGProperty* p = Item(i);
1577
1578 if ( subVal != (m_oldValue & flag) )
1579 p->ChangeFlag( wxPG_PROP_MODIFIED, true );
1580
1581 p->SetValue( subVal == flag?true:false );
1582 }
1583
1584 m_oldValue = flags;
1585 }
1586
1587 wxVariant wxFlagsProperty::ChildChanged( wxVariant& thisValue,
1588 int childIndex,
1589 wxVariant& childValue ) const
1590 {
1591 long oldValue = thisValue.GetLong();
1592 long val = childValue.GetLong();
1593 unsigned long vi = m_choices.GetValue(childIndex);
1594
1595 if ( val )
1596 return (long) (oldValue | vi);
1597
1598 return (long) (oldValue & ~(vi));
1599 }
1600
1601 bool wxFlagsProperty::DoSetAttribute( const wxString& name, wxVariant& value )
1602 {
1603 if ( name == wxPG_BOOL_USE_CHECKBOX ||
1604 name == wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING )
1605 {
1606 for ( size_t i=0; i<GetChildCount(); i++ )
1607 {
1608 Item(i)->SetAttribute(name, value);
1609 }
1610 // Must return false so that the attribute is stored in
1611 // flag property's actual property storage
1612 return false;
1613 }
1614 return false;
1615 }
1616
1617 // -----------------------------------------------------------------------
1618 // wxDirProperty
1619 // -----------------------------------------------------------------------
1620
1621 IMPLEMENT_DYNAMIC_CLASS(wxDirProperty, wxLongStringProperty)
1622
1623 wxDirProperty::wxDirProperty( const wxString& name, const wxString& label, const wxString& value )
1624 : wxLongStringProperty(name,label,value)
1625 {
1626 m_flags |= wxPG_PROP_NO_ESCAPE;
1627 }
1628
1629 wxDirProperty::~wxDirProperty() { }
1630
1631 wxValidator* wxDirProperty::DoGetValidator() const
1632 {
1633 return wxFileProperty::GetClassValidator();
1634 }
1635
1636 bool wxDirProperty::OnButtonClick( wxPropertyGrid* propGrid, wxString& value )
1637 {
1638 // Update property value from editor, if necessary
1639 wxSize dlg_sz(300,400);
1640
1641 wxString dlgMessage(m_dlgMessage);
1642 if ( dlgMessage.empty() )
1643 dlgMessage = _("Choose a directory:");
1644 wxDirDialog dlg( propGrid,
1645 dlgMessage,
1646 value,
1647 0,
1648 #if !wxPG_SMALL_SCREEN
1649 propGrid->GetGoodEditorDialogPosition(this,dlg_sz),
1650 dlg_sz
1651 #else
1652 wxDefaultPosition,
1653 wxDefaultSize
1654 #endif
1655 );
1656
1657 if ( dlg.ShowModal() == wxID_OK )
1658 {
1659 value = dlg.GetPath();
1660 return true;
1661 }
1662 return false;
1663 }
1664
1665 bool wxDirProperty::DoSetAttribute( const wxString& name, wxVariant& value )
1666 {
1667 if ( name == wxPG_DIR_DIALOG_MESSAGE )
1668 {
1669 m_dlgMessage = value.GetString();
1670 return true;
1671 }
1672 return false;
1673 }
1674
1675 // -----------------------------------------------------------------------
1676 // wxPGFileDialogAdapter
1677 // -----------------------------------------------------------------------
1678
1679 bool wxPGFileDialogAdapter::DoShowDialog( wxPropertyGrid* propGrid, wxPGProperty* property )
1680 {
1681 wxFileProperty* fileProp = NULL;
1682 wxString path;
1683 int indFilter = -1;
1684
1685 if ( wxDynamicCast(property, wxFileProperty) )
1686 {
1687 fileProp = ((wxFileProperty*)property);
1688 wxFileName filename = fileProp->GetValue().GetString();
1689 path = filename.GetPath();
1690 indFilter = fileProp->m_indFilter;
1691
1692 if ( path.empty() && !fileProp->m_basePath.empty() )
1693 path = fileProp->m_basePath;
1694 }
1695 else
1696 {
1697 wxFileName fn(property->GetValue().GetString());
1698 path = fn.GetPath();
1699 }
1700
1701 wxFileDialog dlg( propGrid->GetPanel(),
1702 property->GetAttribute(wxS("DialogTitle"), _("Choose a file")),
1703 property->GetAttribute(wxS("InitialPath"), path),
1704 wxEmptyString,
1705 property->GetAttribute(wxPG_FILE_WILDCARD, wxALL_FILES),
1706 property->GetAttributeAsLong(wxPG_FILE_DIALOG_STYLE, 0),
1707 wxDefaultPosition );
1708
1709 if ( indFilter >= 0 )
1710 dlg.SetFilterIndex( indFilter );
1711
1712 if ( dlg.ShowModal() == wxID_OK )
1713 {
1714 if ( fileProp )
1715 fileProp->m_indFilter = dlg.GetFilterIndex();
1716 SetValue( dlg.GetPath() );
1717 return true;
1718 }
1719 return false;
1720 }
1721
1722 // -----------------------------------------------------------------------
1723 // wxFileProperty
1724 // -----------------------------------------------------------------------
1725
1726 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxFileProperty,wxPGProperty,
1727 wxString,const wxString&,TextCtrlAndButton)
1728
1729 wxFileProperty::wxFileProperty( const wxString& label, const wxString& name,
1730 const wxString& value ) : wxPGProperty(label,name)
1731 {
1732 m_flags |= wxPG_PROP_SHOW_FULL_FILENAME;
1733 m_indFilter = -1;
1734 SetAttribute( wxPG_FILE_WILDCARD, wxALL_FILES);
1735
1736 SetValue(value);
1737 }
1738
1739 wxFileProperty::~wxFileProperty() {}
1740
1741 wxValidator* wxFileProperty::GetClassValidator()
1742 {
1743 #if wxUSE_VALIDATORS
1744 WX_PG_DOGETVALIDATOR_ENTRY()
1745
1746 // Atleast wxPython 2.6.2.1 required that the string argument is given
1747 static wxString v;
1748 wxTextValidator* validator = new wxTextValidator(wxFILTER_EXCLUDE_CHAR_LIST,&v);
1749
1750 wxArrayString exChars;
1751 exChars.Add(wxS("?"));
1752 exChars.Add(wxS("*"));
1753 exChars.Add(wxS("|"));
1754 exChars.Add(wxS("<"));
1755 exChars.Add(wxS(">"));
1756 exChars.Add(wxS("\""));
1757
1758 validator->SetExcludes(exChars);
1759
1760 WX_PG_DOGETVALIDATOR_EXIT(validator)
1761 #else
1762 return NULL;
1763 #endif
1764 }
1765
1766 wxValidator* wxFileProperty::DoGetValidator() const
1767 {
1768 return GetClassValidator();
1769 }
1770
1771 void wxFileProperty::OnSetValue()
1772 {
1773 const wxString& fnstr = m_value.GetString();
1774
1775 wxFileName filename = fnstr;
1776
1777 if ( !filename.HasName() )
1778 {
1779 m_value = wxPGVariant_EmptyString;
1780 }
1781
1782 // Find index for extension.
1783 if ( m_indFilter < 0 && !fnstr.empty() )
1784 {
1785 wxString ext = filename.GetExt();
1786 int curind = 0;
1787 size_t pos = 0;
1788 size_t len = m_wildcard.length();
1789
1790 pos = m_wildcard.find(wxS("|"), pos);
1791 while ( pos != wxString::npos && pos < (len-3) )
1792 {
1793 size_t ext_begin = pos + 3;
1794
1795 pos = m_wildcard.find(wxS("|"), ext_begin);
1796 if ( pos == wxString::npos )
1797 pos = len;
1798 wxString found_ext = m_wildcard.substr(ext_begin, pos-ext_begin);
1799
1800 if ( !found_ext.empty() )
1801 {
1802 if ( found_ext[0] == wxS('*') )
1803 {
1804 m_indFilter = curind;
1805 break;
1806 }
1807 if ( ext.CmpNoCase(found_ext) == 0 )
1808 {
1809 m_indFilter = curind;
1810 break;
1811 }
1812 }
1813
1814 if ( pos != len )
1815 pos = m_wildcard.find(wxS("|"), pos+1);
1816
1817 curind++;
1818 }
1819 }
1820 }
1821
1822 wxFileName wxFileProperty::GetFileName() const
1823 {
1824 wxFileName filename;
1825
1826 if ( !m_value.IsNull() )
1827 filename = m_value.GetString();
1828
1829 return filename;
1830 }
1831
1832 wxString wxFileProperty::ValueToString( wxVariant& value,
1833 int argFlags ) const
1834 {
1835 wxFileName filename = value.GetString();
1836
1837 if ( !filename.HasName() )
1838 return wxEmptyString;
1839
1840 wxString fullName = filename.GetFullName();
1841 if ( fullName.empty() )
1842 return wxEmptyString;
1843
1844 if ( argFlags & wxPG_FULL_VALUE )
1845 {
1846 return filename.GetFullPath();
1847 }
1848 else if ( m_flags & wxPG_PROP_SHOW_FULL_FILENAME )
1849 {
1850 if ( !m_basePath.empty() )
1851 {
1852 wxFileName fn2(filename);
1853 fn2.MakeRelativeTo(m_basePath);
1854 return fn2.GetFullPath();
1855 }
1856 return filename.GetFullPath();
1857 }
1858
1859 return filename.GetFullName();
1860 }
1861
1862 wxPGEditorDialogAdapter* wxFileProperty::GetEditorDialog() const
1863 {
1864 return new wxPGFileDialogAdapter();
1865 }
1866
1867 bool wxFileProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
1868 {
1869 wxFileName filename = variant.GetString();
1870
1871 if ( (m_flags & wxPG_PROP_SHOW_FULL_FILENAME) || (argFlags & wxPG_FULL_VALUE) )
1872 {
1873 if ( filename != text )
1874 {
1875 variant = text;
1876 return true;
1877 }
1878 }
1879 else
1880 {
1881 if ( filename.GetFullName() != text )
1882 {
1883 wxFileName fn = filename;
1884 fn.SetFullName(text);
1885 variant = fn.GetFullPath();
1886 return true;
1887 }
1888 }
1889
1890 return false;
1891 }
1892
1893 bool wxFileProperty::DoSetAttribute( const wxString& name, wxVariant& value )
1894 {
1895 // Return false on some occasions to make sure those attribs will get
1896 // stored in m_attributes.
1897 if ( name == wxPG_FILE_SHOW_FULL_PATH )
1898 {
1899 if ( value.GetLong() )
1900 m_flags |= wxPG_PROP_SHOW_FULL_FILENAME;
1901 else
1902 m_flags &= ~(wxPG_PROP_SHOW_FULL_FILENAME);
1903 return true;
1904 }
1905 else if ( name == wxPG_FILE_WILDCARD )
1906 {
1907 m_wildcard = value.GetString();
1908 }
1909 else if ( name == wxPG_FILE_SHOW_RELATIVE_PATH )
1910 {
1911 m_basePath = value.GetString();
1912
1913 // Make sure wxPG_FILE_SHOW_FULL_PATH is also set
1914 m_flags |= wxPG_PROP_SHOW_FULL_FILENAME;
1915 }
1916 else if ( name == wxPG_FILE_INITIAL_PATH )
1917 {
1918 m_initialPath = value.GetString();
1919 return true;
1920 }
1921 else if ( name == wxPG_FILE_DIALOG_TITLE )
1922 {
1923 m_dlgTitle = value.GetString();
1924 return true;
1925 }
1926 return false;
1927 }
1928
1929 // -----------------------------------------------------------------------
1930 // wxPGLongStringDialogAdapter
1931 // -----------------------------------------------------------------------
1932
1933 bool wxPGLongStringDialogAdapter::DoShowDialog( wxPropertyGrid* propGrid, wxPGProperty* property )
1934 {
1935 wxString val1 = property->GetValueAsString(0);
1936 wxString val_orig = val1;
1937
1938 wxString value;
1939 if ( !property->HasFlag(wxPG_PROP_NO_ESCAPE) )
1940 wxPropertyGrid::ExpandEscapeSequences(value, val1);
1941 else
1942 value = wxString(val1);
1943
1944 // Run editor dialog.
1945 if ( wxLongStringProperty::DisplayEditorDialog(property, propGrid, value) )
1946 {
1947 if ( !property->HasFlag(wxPG_PROP_NO_ESCAPE) )
1948 wxPropertyGrid::CreateEscapeSequences(val1,value);
1949 else
1950 val1 = value;
1951
1952 if ( val1 != val_orig )
1953 {
1954 SetValue( val1 );
1955 return true;
1956 }
1957 }
1958 return false;
1959 }
1960
1961 // -----------------------------------------------------------------------
1962 // wxLongStringProperty
1963 // -----------------------------------------------------------------------
1964
1965 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxLongStringProperty,wxPGProperty,
1966 wxString,const wxString&,TextCtrlAndButton)
1967
1968 wxLongStringProperty::wxLongStringProperty( const wxString& label, const wxString& name,
1969 const wxString& value ) : wxPGProperty(label,name)
1970 {
1971 SetValue(value);
1972 }
1973
1974 wxLongStringProperty::~wxLongStringProperty() {}
1975
1976 wxString wxLongStringProperty::ValueToString( wxVariant& value,
1977 int WXUNUSED(argFlags) ) const
1978 {
1979 return value;
1980 }
1981
1982 bool wxLongStringProperty::OnEvent( wxPropertyGrid* propGrid, wxWindow* WXUNUSED(primary),
1983 wxEvent& event )
1984 {
1985 if ( propGrid->IsMainButtonEvent(event) )
1986 {
1987 // Update the value
1988 wxVariant useValue = propGrid->GetUncommittedPropertyValue();
1989
1990 wxString val1 = useValue.GetString();
1991 wxString val_orig = val1;
1992
1993 wxString value;
1994 if ( !(m_flags & wxPG_PROP_NO_ESCAPE) )
1995 wxPropertyGrid::ExpandEscapeSequences(value,val1);
1996 else
1997 value = wxString(val1);
1998
1999 // Run editor dialog.
2000 if ( OnButtonClick(propGrid,value) )
2001 {
2002 if ( !(m_flags & wxPG_PROP_NO_ESCAPE) )
2003 wxPropertyGrid::CreateEscapeSequences(val1,value);
2004 else
2005 val1 = value;
2006
2007 if ( val1 != val_orig )
2008 {
2009 SetValueInEvent( val1 );
2010 return true;
2011 }
2012 }
2013 }
2014 return false;
2015 }
2016
2017 bool wxLongStringProperty::OnButtonClick( wxPropertyGrid* propGrid, wxString& value )
2018 {
2019 return DisplayEditorDialog(this, propGrid, value);
2020 }
2021
2022 bool wxLongStringProperty::DisplayEditorDialog( wxPGProperty* prop, wxPropertyGrid* propGrid, wxString& value )
2023
2024 {
2025 // launch editor dialog
2026 wxDialog* dlg = new wxDialog(propGrid,-1,prop->GetLabel(),wxDefaultPosition,wxDefaultSize,
2027 wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER|wxCLIP_CHILDREN);
2028
2029 dlg->SetFont(propGrid->GetFont()); // To allow entering chars of the same set as the propGrid
2030
2031 // Multi-line text editor dialog.
2032 #if !wxPG_SMALL_SCREEN
2033 const int spacing = 8;
2034 #else
2035 const int spacing = 4;
2036 #endif
2037 wxBoxSizer* topsizer = new wxBoxSizer( wxVERTICAL );
2038 wxBoxSizer* rowsizer = new wxBoxSizer( wxHORIZONTAL );
2039 wxTextCtrl* ed = new wxTextCtrl(dlg,11,value,
2040 wxDefaultPosition,wxDefaultSize,wxTE_MULTILINE);
2041
2042 rowsizer->Add( ed, 1, wxEXPAND|wxALL, spacing );
2043 topsizer->Add( rowsizer, 1, wxEXPAND, 0 );
2044
2045 wxStdDialogButtonSizer* buttonSizer = new wxStdDialogButtonSizer();
2046 buttonSizer->AddButton(new wxButton(dlg, wxID_OK));
2047 buttonSizer->AddButton(new wxButton(dlg, wxID_CANCEL));
2048 buttonSizer->Realize();
2049 topsizer->Add( buttonSizer, 0,
2050 wxALIGN_RIGHT|wxALIGN_CENTRE_VERTICAL|wxBOTTOM|wxRIGHT,
2051 spacing );
2052
2053 dlg->SetSizer( topsizer );
2054 topsizer->SetSizeHints( dlg );
2055
2056 #if !wxPG_SMALL_SCREEN
2057 dlg->SetSize(400,300);
2058
2059 dlg->Move( propGrid->GetGoodEditorDialogPosition(prop,dlg->GetSize()) );
2060 #endif
2061
2062 int res = dlg->ShowModal();
2063
2064 if ( res == wxID_OK )
2065 {
2066 value = ed->GetValue();
2067 dlg->Destroy();
2068 return true;
2069 }
2070 dlg->Destroy();
2071 return false;
2072 }
2073
2074 bool wxLongStringProperty::StringToValue( wxVariant& variant, const wxString& text, int ) const
2075 {
2076 if ( variant != text )
2077 {
2078 variant = text;
2079 return true;
2080 }
2081 return false;
2082 }
2083
2084 #if wxUSE_EDITABLELISTBOX
2085
2086 // -----------------------------------------------------------------------
2087 // wxPGArrayEditorDialog
2088 // -----------------------------------------------------------------------
2089
2090 BEGIN_EVENT_TABLE(wxPGArrayEditorDialog, wxDialog)
2091 EVT_IDLE(wxPGArrayEditorDialog::OnIdle)
2092 END_EVENT_TABLE()
2093
2094 IMPLEMENT_ABSTRACT_CLASS(wxPGArrayEditorDialog, wxDialog)
2095
2096 #include "wx/editlbox.h"
2097 #include "wx/listctrl.h"
2098
2099 // -----------------------------------------------------------------------
2100
2101 void wxPGArrayEditorDialog::OnIdle(wxIdleEvent& event)
2102 {
2103 // Repair focus - wxEditableListBox has bitmap buttons, which
2104 // get focus, and lose focus (into the oblivion) when they
2105 // become disabled due to change in control state.
2106
2107 wxWindow* lastFocused = m_lastFocused;
2108 wxWindow* focus = ::wxWindow::FindFocus();
2109
2110 // If last focused control became disabled, set focus back to
2111 // wxEditableListBox
2112 if ( lastFocused && focus != lastFocused &&
2113 lastFocused->GetParent() == m_elbSubPanel &&
2114 !lastFocused->IsEnabled() )
2115 {
2116 m_elb->GetListCtrl()->SetFocus();
2117 }
2118
2119 m_lastFocused = focus;
2120
2121 event.Skip();
2122 }
2123
2124 // -----------------------------------------------------------------------
2125
2126 wxPGArrayEditorDialog::wxPGArrayEditorDialog()
2127 : wxDialog()
2128 {
2129 Init();
2130 }
2131
2132 // -----------------------------------------------------------------------
2133
2134 void wxPGArrayEditorDialog::Init()
2135 {
2136 m_lastFocused = NULL;
2137 m_hasCustomNewAction = false;
2138 m_itemPendingAtIndex = -1;
2139 }
2140
2141 // -----------------------------------------------------------------------
2142
2143 wxPGArrayEditorDialog::wxPGArrayEditorDialog( wxWindow *parent,
2144 const wxString& message,
2145 const wxString& caption,
2146 long style,
2147 const wxPoint& pos,
2148 const wxSize& sz )
2149 : wxDialog()
2150 {
2151 Init();
2152 Create(parent,message,caption,style,pos,sz);
2153 }
2154
2155 // -----------------------------------------------------------------------
2156
2157 bool wxPGArrayEditorDialog::Create( wxWindow *parent,
2158 const wxString& message,
2159 const wxString& caption,
2160 long style,
2161 const wxPoint& pos,
2162 const wxSize& sz )
2163 {
2164 // On wxMAC the dialog shows incorrectly if style is not exactly wxCAPTION
2165 // FIXME: This should be only a temporary fix.
2166 #ifdef __WXMAC__
2167 wxUnusedVar(style);
2168 int useStyle = wxCAPTION;
2169 #else
2170 int useStyle = style;
2171 #endif
2172
2173 bool res = wxDialog::Create(parent, wxID_ANY, caption, pos, sz, useStyle);
2174
2175 SetFont(parent->GetFont()); // To allow entering chars of the same set as the propGrid
2176
2177 #if !wxPG_SMALL_SCREEN
2178 const int spacing = 4;
2179 #else
2180 const int spacing = 3;
2181 #endif
2182
2183 m_modified = false;
2184
2185 wxBoxSizer* topsizer = new wxBoxSizer( wxVERTICAL );
2186
2187 // Message
2188 if ( !message.empty() )
2189 topsizer->Add( new wxStaticText(this,-1,message),
2190 0, wxALIGN_LEFT|wxALIGN_CENTRE_VERTICAL|wxALL, spacing );
2191
2192 m_elb = new wxEditableListBox(this, wxID_ANY, message,
2193 wxDefaultPosition,
2194 wxDefaultSize,
2195 wxEL_ALLOW_NEW |
2196 wxEL_ALLOW_EDIT |
2197 wxEL_ALLOW_DELETE);
2198
2199 // Populate the list box
2200 wxArrayString arr;
2201 for ( unsigned int i=0; i<ArrayGetCount(); i++ )
2202 arr.push_back(ArrayGet(i));
2203 m_elb->SetStrings(arr);
2204
2205 // Connect event handlers
2206 wxButton* but;
2207 wxListCtrl* lc = m_elb->GetListCtrl();
2208
2209 but = m_elb->GetNewButton();
2210 m_elbSubPanel = but->GetParent();
2211 but->Connect(but->GetId(), wxEVT_BUTTON,
2212 wxCommandEventHandler(wxPGArrayEditorDialog::OnAddClick),
2213 NULL, this);
2214
2215 but = m_elb->GetDelButton();
2216 but->Connect(but->GetId(), wxEVT_BUTTON,
2217 wxCommandEventHandler(wxPGArrayEditorDialog::OnDeleteClick),
2218 NULL, this);
2219
2220 but = m_elb->GetUpButton();
2221 but->Connect(but->GetId(), wxEVT_BUTTON,
2222 wxCommandEventHandler(wxPGArrayEditorDialog::OnUpClick),
2223 NULL, this);
2224
2225 but = m_elb->GetDownButton();
2226 but->Connect(but->GetId(), wxEVT_BUTTON,
2227 wxCommandEventHandler(wxPGArrayEditorDialog::OnDownClick),
2228 NULL, this);
2229
2230 lc->Connect(lc->GetId(), wxEVT_LIST_END_LABEL_EDIT,
2231 wxListEventHandler(wxPGArrayEditorDialog::OnEndLabelEdit),
2232 NULL, this);
2233
2234 topsizer->Add( m_elb, 1, wxEXPAND, spacing );
2235
2236 // Standard dialog buttons
2237 wxStdDialogButtonSizer* buttonSizer = new wxStdDialogButtonSizer();
2238 buttonSizer->AddButton(new wxButton(this, wxID_OK));
2239 buttonSizer->AddButton(new wxButton(this, wxID_CANCEL));
2240 buttonSizer->Realize();
2241 topsizer->Add( buttonSizer, 0,
2242 wxALIGN_RIGHT|wxALIGN_CENTRE_VERTICAL|wxALL,
2243 spacing );
2244
2245 m_elb->SetFocus();
2246
2247 SetSizer( topsizer );
2248 topsizer->SetSizeHints( this );
2249
2250 #if !wxPG_SMALL_SCREEN
2251 if ( sz.x == wxDefaultSize.x &&
2252 sz.y == wxDefaultSize.y )
2253 SetSize( wxSize(275,360) );
2254 else
2255 SetSize(sz);
2256 #endif
2257
2258 return res;
2259 }
2260
2261 // -----------------------------------------------------------------------
2262
2263 int wxPGArrayEditorDialog::GetSelection() const
2264 {
2265 wxListCtrl* lc = m_elb->GetListCtrl();
2266
2267 int index = lc->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
2268 if ( index == -1 )
2269 return wxNOT_FOUND;
2270
2271 return index;
2272 }
2273
2274 // -----------------------------------------------------------------------
2275
2276 void wxPGArrayEditorDialog::OnAddClick(wxCommandEvent& event)
2277 {
2278 wxListCtrl* lc = m_elb->GetListCtrl();
2279 int newItemIndex = lc->GetItemCount() - 1;
2280
2281 if ( m_hasCustomNewAction )
2282 {
2283 wxString str;
2284 if ( OnCustomNewAction(&str) )
2285 {
2286 if ( ArrayInsert(str, newItemIndex) )
2287 {
2288 lc->InsertItem(newItemIndex, str);
2289 m_modified = true;
2290 }
2291 }
2292
2293 // Do *not* skip the event! We do not want the wxEditableListBox
2294 // to do anything.
2295 }
2296 else
2297 {
2298 m_itemPendingAtIndex = newItemIndex;
2299
2300 event.Skip();
2301 }
2302 }
2303
2304 // -----------------------------------------------------------------------
2305
2306 void wxPGArrayEditorDialog::OnDeleteClick(wxCommandEvent& event)
2307 {
2308 int index = GetSelection();
2309 if ( index >= 0 )
2310 {
2311 ArrayRemoveAt( index );
2312 m_modified = true;
2313 }
2314
2315 event.Skip();
2316 }
2317
2318 // -----------------------------------------------------------------------
2319
2320 void wxPGArrayEditorDialog::OnUpClick(wxCommandEvent& event)
2321 {
2322 int index = GetSelection();
2323 if ( index > 0 )
2324 {
2325 ArraySwap(index-1,index);
2326 m_modified = true;
2327 }
2328
2329 event.Skip();
2330 }
2331
2332 // -----------------------------------------------------------------------
2333
2334 void wxPGArrayEditorDialog::OnDownClick(wxCommandEvent& event)
2335 {
2336 wxListCtrl* lc = m_elb->GetListCtrl();
2337 int index = GetSelection();
2338 int lastStringIndex = lc->GetItemCount() - 1;
2339 if ( index >= 0 && index < lastStringIndex )
2340 {
2341 ArraySwap(index, index+1);
2342 m_modified = true;
2343 }
2344
2345 event.Skip();
2346 }
2347
2348 // -----------------------------------------------------------------------
2349
2350 void wxPGArrayEditorDialog::OnEndLabelEdit(wxListEvent& event)
2351 {
2352 wxString str = event.GetLabel();
2353
2354 if ( m_itemPendingAtIndex >= 0 )
2355 {
2356 // Add a new item
2357 if ( ArrayInsert(str, m_itemPendingAtIndex) )
2358 {
2359 m_modified = true;
2360 }
2361 else
2362 {
2363 // Editable list box doesn't really respect Veto(), but
2364 // it recognizes if no text was added, so we simulate
2365 // Veto() using it.
2366 event.m_item.SetText(wxEmptyString);
2367 m_elb->GetListCtrl()->SetItemText(m_itemPendingAtIndex,
2368 wxEmptyString);
2369
2370 event.Veto();
2371 }
2372 }
2373 else
2374 {
2375 // Change an existing item
2376 int index = GetSelection();
2377 wxASSERT( index != wxNOT_FOUND );
2378 if ( ArraySet(index, str) )
2379 m_modified = true;
2380 else
2381 event.Veto();
2382 }
2383
2384 event.Skip();
2385 }
2386
2387 #endif // wxUSE_EDITABLELISTBOX
2388
2389 // -----------------------------------------------------------------------
2390 // wxPGArrayStringEditorDialog
2391 // -----------------------------------------------------------------------
2392
2393 IMPLEMENT_DYNAMIC_CLASS(wxPGArrayStringEditorDialog, wxPGArrayEditorDialog)
2394
2395 BEGIN_EVENT_TABLE(wxPGArrayStringEditorDialog, wxPGArrayEditorDialog)
2396 END_EVENT_TABLE()
2397
2398 // -----------------------------------------------------------------------
2399
2400 wxString wxPGArrayStringEditorDialog::ArrayGet( size_t index )
2401 {
2402 return m_array[index];
2403 }
2404
2405 size_t wxPGArrayStringEditorDialog::ArrayGetCount()
2406 {
2407 return m_array.size();
2408 }
2409
2410 bool wxPGArrayStringEditorDialog::ArrayInsert( const wxString& str, int index )
2411 {
2412 if (index<0)
2413 m_array.Add(str);
2414 else
2415 m_array.Insert(str,index);
2416 return true;
2417 }
2418
2419 bool wxPGArrayStringEditorDialog::ArraySet( size_t index, const wxString& str )
2420 {
2421 m_array[index] = str;
2422 return true;
2423 }
2424
2425 void wxPGArrayStringEditorDialog::ArrayRemoveAt( int index )
2426 {
2427 m_array.RemoveAt(index);
2428 }
2429
2430 void wxPGArrayStringEditorDialog::ArraySwap( size_t first, size_t second )
2431 {
2432 wxString old_str = m_array[first];
2433 wxString new_str = m_array[second];
2434 m_array[first] = new_str;
2435 m_array[second] = old_str;
2436 }
2437
2438 wxPGArrayStringEditorDialog::wxPGArrayStringEditorDialog()
2439 : wxPGArrayEditorDialog()
2440 {
2441 Init();
2442 }
2443
2444 void wxPGArrayStringEditorDialog::Init()
2445 {
2446 m_pCallingClass = NULL;
2447 }
2448
2449 bool
2450 wxPGArrayStringEditorDialog::OnCustomNewAction(wxString* resString)
2451 {
2452 return m_pCallingClass->OnCustomStringEdit(m_parent, *resString);
2453 }
2454
2455 // -----------------------------------------------------------------------
2456 // wxArrayStringProperty
2457 // -----------------------------------------------------------------------
2458
2459 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxArrayStringProperty, // Property name
2460 wxPGProperty, // Property we inherit from
2461 wxArrayString, // Value type name
2462 const wxArrayString&, // Value type, as given in constructor
2463 TextCtrlAndButton) // Initial editor
2464
2465 wxArrayStringProperty::wxArrayStringProperty( const wxString& label,
2466 const wxString& name,
2467 const wxArrayString& array )
2468 : wxPGProperty(label,name)
2469 {
2470 m_delimiter = ',';
2471 SetValue( array );
2472 }
2473
2474 wxArrayStringProperty::~wxArrayStringProperty() { }
2475
2476 void wxArrayStringProperty::OnSetValue()
2477 {
2478 GenerateValueAsString();
2479 }
2480
2481 void
2482 wxArrayStringProperty::ConvertArrayToString(const wxArrayString& arr,
2483 wxString* pString,
2484 const wxUniChar& delimiter) const
2485 {
2486 if ( delimiter == '"' || delimiter == '\'' )
2487 {
2488 // Quoted strings
2489 ArrayStringToString(*pString,
2490 arr,
2491 delimiter,
2492 Escape | QuoteStrings);
2493 }
2494 else
2495 {
2496 // Regular delimiter
2497 ArrayStringToString(*pString,
2498 arr,
2499 delimiter,
2500 0);
2501 }
2502 }
2503
2504 wxString wxArrayStringProperty::ValueToString( wxVariant& WXUNUSED(value),
2505 int argFlags ) const
2506 {
2507 //
2508 // If this is called from GetValueAsString(), return cached string
2509 if ( argFlags & wxPG_VALUE_IS_CURRENT )
2510 {
2511 return m_display;
2512 }
2513
2514 wxArrayString arr = m_value.GetArrayString();
2515 wxString s;
2516 ConvertArrayToString(arr, &s, m_delimiter);
2517 return s;
2518 }
2519
2520 // Converts wxArrayString to a string separated by delimeters and spaces.
2521 // preDelim is useful for "str1" "str2" style. Set flags to 1 to do slash
2522 // conversion.
2523 void
2524 wxArrayStringProperty::ArrayStringToString( wxString& dst,
2525 const wxArrayString& src,
2526 wxUniChar delimiter, int flags )
2527 {
2528 wxString pdr;
2529 wxString preas;
2530
2531 unsigned int i;
2532 unsigned int itemCount = src.size();
2533
2534 dst.Empty();
2535
2536 if ( flags & Escape )
2537 {
2538 preas = delimiter;
2539 pdr = wxS("\\");
2540 pdr += delimiter;
2541 }
2542
2543 if ( itemCount )
2544 dst.append( preas );
2545
2546 wxString delimStr(delimiter);
2547
2548 for ( i = 0; i < itemCount; i++ )
2549 {
2550 wxString str( src.Item(i) );
2551
2552 // Do some character conversion.
2553 // Converts \ to \\ and $delimiter to \$delimiter
2554 // Useful when quoting.
2555 if ( flags & Escape )
2556 {
2557 str.Replace( wxS("\\"), wxS("\\\\"), true );
2558 if ( !pdr.empty() )
2559 str.Replace( preas, pdr, true );
2560 }
2561
2562 dst.append( str );
2563
2564 if ( i < (itemCount-1) )
2565 {
2566 dst.append( delimStr );
2567 dst.append( wxS(" ") );
2568 dst.append( preas );
2569 }
2570 else if ( flags & QuoteStrings )
2571 dst.append( delimStr );
2572 }
2573 }
2574
2575 void wxArrayStringProperty::GenerateValueAsString()
2576 {
2577 wxArrayString arr = m_value.GetArrayString();
2578 ConvertArrayToString(arr, &m_display, m_delimiter);
2579 }
2580
2581 // Default implementation doesn't do anything.
2582 bool wxArrayStringProperty::OnCustomStringEdit( wxWindow*, wxString& )
2583 {
2584 return false;
2585 }
2586
2587 wxPGArrayEditorDialog* wxArrayStringProperty::CreateEditorDialog()
2588 {
2589 return new wxPGArrayStringEditorDialog();
2590 }
2591
2592 bool wxArrayStringProperty::OnButtonClick( wxPropertyGrid* propGrid,
2593 wxWindow* WXUNUSED(primaryCtrl),
2594 const wxChar* cbt )
2595 {
2596 // Update the value
2597 wxVariant useValue = propGrid->GetUncommittedPropertyValue();
2598
2599 if ( !propGrid->EditorValidate() )
2600 return false;
2601
2602 // Create editor dialog.
2603 wxPGArrayEditorDialog* dlg = CreateEditorDialog();
2604 #if wxUSE_VALIDATORS
2605 wxValidator* validator = GetValidator();
2606 wxPGInDialogValidator dialogValidator;
2607 #endif
2608
2609 wxPGArrayStringEditorDialog* strEdDlg = wxDynamicCast(dlg, wxPGArrayStringEditorDialog);
2610
2611 if ( strEdDlg )
2612 strEdDlg->SetCustomButton(cbt, this);
2613
2614 dlg->SetDialogValue( useValue );
2615 dlg->Create(propGrid, wxEmptyString, m_label);
2616
2617 #if !wxPG_SMALL_SCREEN
2618 dlg->Move( propGrid->GetGoodEditorDialogPosition(this,dlg->GetSize()) );
2619 #endif
2620
2621 bool retVal;
2622
2623 for (;;)
2624 {
2625 retVal = false;
2626
2627 int res = dlg->ShowModal();
2628
2629 if ( res == wxID_OK && dlg->IsModified() )
2630 {
2631 wxVariant value = dlg->GetDialogValue();
2632 if ( !value.IsNull() )
2633 {
2634 wxArrayString actualValue = value.GetArrayString();
2635 wxString tempStr;
2636 ConvertArrayToString(actualValue, &tempStr, m_delimiter);
2637 #if wxUSE_VALIDATORS
2638 if ( dialogValidator.DoValidate(propGrid, validator,
2639 tempStr) )
2640 #endif
2641 {
2642 SetValueInEvent( actualValue );
2643 retVal = true;
2644 break;
2645 }
2646 }
2647 else
2648 break;
2649 }
2650 else
2651 break;
2652 }
2653
2654 delete dlg;
2655
2656 return retVal;
2657 }
2658
2659 bool wxArrayStringProperty::OnEvent( wxPropertyGrid* propGrid,
2660 wxWindow* primary,
2661 wxEvent& event )
2662 {
2663 if ( propGrid->IsMainButtonEvent(event) )
2664 return OnButtonClick(propGrid,primary,(const wxChar*) NULL);
2665 return false;
2666 }
2667
2668 bool wxArrayStringProperty::StringToValue( wxVariant& variant,
2669 const wxString& text, int ) const
2670 {
2671 wxArrayString arr;
2672
2673 if ( m_delimiter == '"' || m_delimiter == '\'' )
2674 {
2675 // Quoted strings
2676 WX_PG_TOKENIZER2_BEGIN(text, m_delimiter)
2677
2678 // Need to replace backslashes with empty characters
2679 // (opposite what is done in ConvertArrayToString()).
2680 token.Replace ( wxS("\\\\"), wxS("\\"), true );
2681
2682 arr.Add( token );
2683
2684 WX_PG_TOKENIZER2_END()
2685 }
2686 else
2687 {
2688 // Regular delimiter
2689 WX_PG_TOKENIZER1_BEGIN(text, m_delimiter)
2690 arr.Add( token );
2691 WX_PG_TOKENIZER1_END()
2692 }
2693
2694 variant = arr;
2695
2696 return true;
2697 }
2698
2699 bool wxArrayStringProperty::DoSetAttribute( const wxString& name, wxVariant& value )
2700 {
2701 if ( name == wxPG_ARRAY_DELIMITER )
2702 {
2703 m_delimiter = value.GetChar();
2704 GenerateValueAsString();
2705 return false;
2706 }
2707 return true;
2708 }
2709
2710 // -----------------------------------------------------------------------
2711 // wxPGInDialogValidator
2712 // -----------------------------------------------------------------------
2713
2714 #if wxUSE_VALIDATORS
2715 bool wxPGInDialogValidator::DoValidate( wxPropertyGrid* propGrid,
2716 wxValidator* validator,
2717 const wxString& value )
2718 {
2719 if ( !validator )
2720 return true;
2721
2722 wxTextCtrl* tc = m_textCtrl;
2723
2724 if ( !tc )
2725 {
2726 {
2727 tc = new wxTextCtrl( propGrid, wxPG_SUBID_TEMP1, wxEmptyString,
2728 wxPoint(30000,30000));
2729 tc->Hide();
2730 }
2731
2732 m_textCtrl = tc;
2733 }
2734
2735 tc->SetValue(value);
2736
2737 validator->SetWindow(tc);
2738 bool res = validator->Validate(propGrid);
2739
2740 return res;
2741 }
2742 #else
2743 bool wxPGInDialogValidator::DoValidate( wxPropertyGrid* WXUNUSED(propGrid),
2744 wxValidator* WXUNUSED(validator),
2745 const wxString& WXUNUSED(value) )
2746 {
2747 return true;
2748 }
2749 #endif
2750
2751 // -----------------------------------------------------------------------
2752
2753 #endif // wxUSE_PROPGRID