1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/propgrid/props.cpp
3 // Purpose: Basic Property Classes
4 // Author: Jaakko Salli
8 // Copyright: (c) Jaakko Salli
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
12 // For compilers that support precompilation, includes "wx/wx.h".
13 #include "wx/wxprec.h"
23 #include "wx/object.h"
25 #include "wx/string.h"
28 #include "wx/window.h"
31 #include "wx/dcclient.h"
32 #include "wx/dcmemory.h"
33 #include "wx/button.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"
47 #include "wx/textdlg.h"
48 #include "wx/filedlg.h"
52 #include "wx/filename.h"
54 #include "wx/propgrid/propgrid.h"
56 #define wxPG_CUSTOM_IMAGE_WIDTH 20 // for wxColourProperty etc.
59 // -----------------------------------------------------------------------
61 // -----------------------------------------------------------------------
63 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxStringProperty
,wxPGProperty
,
64 wxString
,const wxString
&,TextCtrl
)
66 wxStringProperty::wxStringProperty( const wxString
& label
,
68 const wxString
& value
)
69 : wxPGProperty(label
,name
)
74 void wxStringProperty::OnSetValue()
76 if ( !m_value
.IsNull() && m_value
.GetString() == wxS("<composed>") )
77 SetFlag(wxPG_PROP_COMPOSED_VALUE
);
79 if ( HasFlag(wxPG_PROP_COMPOSED_VALUE
) )
82 DoGenerateComposedValue(s
);
87 wxStringProperty::~wxStringProperty() { }
89 wxString
wxStringProperty::ValueToString( wxVariant
& value
,
92 wxString s
= value
.GetString();
94 if ( GetChildCount() && HasFlag(wxPG_PROP_COMPOSED_VALUE
) )
96 // Value stored in m_value is non-editable, non-full value
97 if ( (argFlags
& wxPG_FULL_VALUE
) || (argFlags
& wxPG_EDITABLE_VALUE
) )
99 // Calling this under incorrect conditions will fail
100 wxASSERT_MSG( argFlags
& wxPG_VALUE_IS_CURRENT
,
101 "Sorry, currently default wxPGProperty::ValueToString() "
102 "implementation only works if value is m_value." );
104 DoGenerateComposedValue(s
, argFlags
);
110 // If string is password and value is for visual purposes,
111 // then return asterisks instead the actual string.
112 if ( (m_flags
& wxPG_PROP_PASSWORD
) && !(argFlags
& (wxPG_FULL_VALUE
|wxPG_EDITABLE_VALUE
)) )
113 return wxString(wxChar('*'), s
.Length());
118 bool wxStringProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int argFlags
) const
120 if ( GetChildCount() && HasFlag(wxPG_PROP_COMPOSED_VALUE
) )
121 return wxPGProperty::StringToValue(variant
, text
, argFlags
);
123 if ( variant
!= text
)
132 bool wxStringProperty::DoSetAttribute( const wxString
& name
, wxVariant
& value
)
134 if ( name
== wxPG_STRING_PASSWORD
)
136 m_flags
&= ~(wxPG_PROP_PASSWORD
);
137 if ( value
.GetLong() ) m_flags
|= wxPG_PROP_PASSWORD
;
144 // -----------------------------------------------------------------------
146 // -----------------------------------------------------------------------
148 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxIntProperty
,wxPGProperty
,
151 wxIntProperty::wxIntProperty( const wxString
& label
, const wxString
& name
,
152 long value
) : wxPGProperty(label
,name
)
157 wxIntProperty::wxIntProperty( const wxString
& label
, const wxString
& name
,
158 const wxLongLong
& value
) : wxPGProperty(label
,name
)
160 SetValue(WXVARIANT(value
));
163 wxIntProperty::~wxIntProperty() { }
165 wxString
wxIntProperty::ValueToString( wxVariant
& value
,
166 int WXUNUSED(argFlags
) ) const
168 if ( value
.GetType() == wxPG_VARIANT_TYPE_LONG
)
170 return wxString::Format(wxS("%li"),value
.GetLong());
172 else if ( value
.GetType() == wxPG_VARIANT_TYPE_LONGLONG
)
174 wxLongLong ll
= value
.GetLongLong();
175 return ll
.ToString();
178 return wxEmptyString
;
181 bool wxIntProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int argFlags
) const
186 if ( text
.length() == 0 )
192 // We know it is a number, but let's still check
194 if ( text
.IsNumber() )
196 // Remove leading zeroes, so that the number is not interpreted as octal
197 wxString::const_iterator i
= text
.begin();
198 wxString::const_iterator iMax
= text
.end() - 1; // Let's allow one, last zero though
200 int firstNonZeroPos
= 0;
202 for ( ; i
!= iMax
; ++i
)
205 if ( c
!= wxS('0') && c
!= wxS(' ') )
210 wxString useText
= text
.substr(firstNonZeroPos
, text
.length() - firstNonZeroPos
);
212 wxString variantType
= variant
.GetType();
213 bool isPrevLong
= variantType
== wxPG_VARIANT_TYPE_LONG
;
215 wxLongLong_t value64
= 0;
217 if ( useText
.ToLongLong(&value64
, 10) &&
218 ( value64
>= INT_MAX
|| value64
<= INT_MIN
)
221 bool doChangeValue
= isPrevLong
;
223 if ( !isPrevLong
&& variantType
== wxPG_VARIANT_TYPE_LONGLONG
)
225 wxLongLong oldValue
= variant
.GetLongLong();
226 if ( oldValue
.GetValue() != value64
)
227 doChangeValue
= true;
232 wxLongLong
ll(value64
);
238 if ( useText
.ToLong( &value32
, 0 ) )
240 if ( !isPrevLong
|| variant
!= value32
)
247 else if ( argFlags
& wxPG_REPORT_ERROR
)
253 bool wxIntProperty::IntToValue( wxVariant
& variant
, int value
, int WXUNUSED(argFlags
) ) const
255 if ( variant
.GetType() != wxPG_VARIANT_TYPE_LONG
|| variant
!= (long)value
)
257 variant
= (long)value
;
263 bool wxIntProperty::DoValidation( const wxPGProperty
* property
, wxLongLong_t
& value
, wxPGValidationInfo
* pValidationInfo
, int mode
)
266 wxLongLong_t min
= wxINT64_MIN
;
267 wxLongLong_t max
= wxINT64_MAX
;
272 variant
= property
->GetAttribute(wxPGGlobalVars
->m_strMin
);
273 if ( !variant
.IsNull() )
275 min
= variant
.GetLongLong().GetValue();
279 variant
= property
->GetAttribute(wxPGGlobalVars
->m_strMax
);
280 if ( !variant
.IsNull() )
282 max
= variant
.GetLongLong().GetValue();
290 if ( mode
== wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE
)
291 pValidationInfo
->SetFailureMessage(
292 wxString::Format(_("Value must be %lld or higher"),min
)
294 else if ( mode
== wxPG_PROPERTY_VALIDATION_SATURATE
)
297 value
= max
- (min
- value
);
306 if ( mode
== wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE
)
307 pValidationInfo
->SetFailureMessage(
308 wxString::Format(_("Value must be %lld or higher"),min
)
310 else if ( mode
== wxPG_PROPERTY_VALIDATION_SATURATE
)
313 value
= min
+ (value
- max
);
320 bool wxIntProperty::ValidateValue( wxVariant
& value
,
321 wxPGValidationInfo
& validationInfo
) const
323 wxLongLong_t ll
= value
.GetLongLong().GetValue();
324 return DoValidation(this, ll
, &validationInfo
,
325 wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE
);
328 wxValidator
* wxIntProperty::GetClassValidator()
331 WX_PG_DOGETVALIDATOR_ENTRY()
333 // Atleast wxPython 2.6.2.1 required that the string argument is given
335 wxTextValidator
* validator
= new wxTextValidator(wxFILTER_NUMERIC
,&v
);
337 WX_PG_DOGETVALIDATOR_EXIT(validator
)
343 wxValidator
* wxIntProperty::DoGetValidator() const
345 return GetClassValidator();
348 // -----------------------------------------------------------------------
350 // -----------------------------------------------------------------------
353 #define wxPG_UINT_TEMPLATE_MAX 8
355 static const wxChar
* gs_uintTemplates32
[wxPG_UINT_TEMPLATE_MAX
] = {
356 wxT("%x"),wxT("0x%x"),wxT("$%x"),
357 wxT("%X"),wxT("0x%X"),wxT("$%X"),
361 static const wxChar
* gs_uintTemplates64
[wxPG_UINT_TEMPLATE_MAX
] = {
362 wxT("%") wxLongLongFmtSpec
wxT("x"),
363 wxT("0x%") wxLongLongFmtSpec
wxT("x"),
364 wxT("$%") wxLongLongFmtSpec
wxT("x"),
365 wxT("%") wxLongLongFmtSpec
wxT("X"),
366 wxT("0x%") wxLongLongFmtSpec
wxT("X"),
367 wxT("$%") wxLongLongFmtSpec
wxT("X"),
368 wxT("%") wxLongLongFmtSpec
wxT("u"),
369 wxT("%") wxLongLongFmtSpec
wxT("o")
372 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxUIntProperty
,wxPGProperty
,
373 long,unsigned long,TextCtrl
)
375 void wxUIntProperty::Init()
377 m_base
= 6; // This is magic number for dec base (must be same as in setattribute)
379 m_prefix
= wxPG_PREFIX_NONE
;
382 wxUIntProperty::wxUIntProperty( const wxString
& label
, const wxString
& name
,
383 unsigned long value
) : wxPGProperty(label
,name
)
386 SetValue((long)value
);
389 wxUIntProperty::wxUIntProperty( const wxString
& label
, const wxString
& name
,
390 const wxULongLong
& value
) : wxPGProperty(label
,name
)
393 SetValue(WXVARIANT(value
));
396 wxUIntProperty::~wxUIntProperty() { }
398 wxString
wxUIntProperty::ValueToString( wxVariant
& value
,
399 int WXUNUSED(argFlags
) ) const
401 size_t index
= m_base
+ m_prefix
;
402 if ( index
>= wxPG_UINT_TEMPLATE_MAX
)
403 index
= wxPG_BASE_DEC
;
405 if ( value
.GetType() == wxPG_VARIANT_TYPE_LONG
)
407 return wxString::Format(gs_uintTemplates32
[index
],
408 (unsigned long)value
.GetLong());
411 wxULongLong ull
= value
.GetULongLong();
413 return wxString::Format(gs_uintTemplates64
[index
], ull
.GetValue());
416 bool wxUIntProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int WXUNUSED(argFlags
) ) const
418 wxString variantType
= variant
.GetType();
419 bool isPrevLong
= variantType
== wxPG_VARIANT_TYPE_LONG
;
421 if ( text
.length() == 0 )
428 if ( text
[0] == wxS('$') )
431 wxULongLong_t value64
= 0;
432 wxString s
= text
.substr(start
, text
.length() - start
);
434 if ( s
.ToULongLong(&value64
, (unsigned int)m_realBase
) )
436 if ( value64
>= LONG_MAX
)
438 bool doChangeValue
= isPrevLong
;
440 if ( !isPrevLong
&& variantType
== wxPG_VARIANT_TYPE_ULONGLONG
)
442 wxULongLong oldValue
= variant
.GetULongLong();
443 if ( oldValue
.GetValue() != value64
)
444 doChangeValue
= true;
449 variant
= wxULongLong(value64
);
455 unsigned long value32
= wxLongLong(value64
).GetLo();
456 if ( !isPrevLong
|| m_value
!= (long)value32
)
458 variant
= (long)value32
;
467 bool wxUIntProperty::IntToValue( wxVariant
& variant
, int number
, int WXUNUSED(argFlags
) ) const
469 if ( variant
!= (long)number
)
471 variant
= (long)number
;
477 bool wxUIntProperty::ValidateValue( wxVariant
& value
, wxPGValidationInfo
& validationInfo
) const
480 wxULongLong_t ll
= value
.GetULongLong().GetValue();
482 wxULongLong_t min
= 0;
483 wxULongLong_t max
= wxUINT64_MAX
;
486 variant
= GetAttribute(wxPGGlobalVars
->m_strMin
);
487 if ( !variant
.IsNull() )
489 min
= variant
.GetULongLong().GetValue();
492 validationInfo
.SetFailureMessage(
493 wxString::Format(_("Value must be %llu or higher"),min
)
498 variant
= GetAttribute(wxPGGlobalVars
->m_strMax
);
499 if ( !variant
.IsNull() )
501 max
= variant
.GetULongLong().GetValue();
504 validationInfo
.SetFailureMessage(
505 wxString::Format(_("Value must be %llu or less"),max
)
514 bool wxUIntProperty::DoSetAttribute( const wxString
& name
, wxVariant
& value
)
516 if ( name
== wxPG_UINT_BASE
)
518 int val
= value
.GetLong();
520 m_realBase
= (wxByte
) val
;
521 if ( m_realBase
> 16 )
525 // Translate logical base to a template array index
527 if ( val
== wxPG_BASE_HEX
)
529 else if ( val
== wxPG_BASE_DEC
)
531 else if ( val
== wxPG_BASE_HEXL
)
535 else if ( name
== wxPG_UINT_PREFIX
)
537 m_prefix
= (wxByte
) value
.GetLong();
543 // -----------------------------------------------------------------------
545 // -----------------------------------------------------------------------
547 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxFloatProperty
,wxPGProperty
,
548 double,double,TextCtrl
)
550 wxFloatProperty::wxFloatProperty( const wxString
& label
,
551 const wxString
& name
,
553 : wxPGProperty(label
,name
)
559 wxFloatProperty::~wxFloatProperty() { }
561 // This helper method provides standard way for floating point-using
562 // properties to convert values to string.
563 void wxPropertyGrid::DoubleToString(wxString
& target
,
567 wxString
* precTemplate
)
569 if ( precision
>= 0 )
573 precTemplate
= &text1
;
575 if ( !precTemplate
->length() )
577 *precTemplate
= wxS("%.");
578 *precTemplate
<< wxString::Format( wxS("%i"), precision
);
579 *precTemplate
<< wxS('f');
582 target
.Printf( precTemplate
->c_str(), value
);
586 target
.Printf( wxS("%f"), value
);
589 if ( removeZeroes
&& precision
!= 0 && target
.length() )
591 // Remove excess zeroes (do not remove this code just yet,
592 // since sprintf can't do the same consistently across platforms).
593 wxString::const_iterator i
= target
.end() - 1;
594 size_t new_len
= target
.length() - 1;
596 for ( ; i
!= target
.begin(); --i
)
598 if ( *i
!= wxS('0') )
603 wxChar cur_char
= *i
;
604 if ( cur_char
!= wxS('.') && cur_char
!= wxS(',') )
607 if ( new_len
!= target
.length() )
608 target
.resize(new_len
);
612 wxString
wxFloatProperty::ValueToString( wxVariant
& value
,
616 if ( !value
.IsNull() )
618 wxPropertyGrid::DoubleToString(text
,
621 !(argFlags
& wxPG_FULL_VALUE
),
627 bool wxFloatProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int argFlags
) const
632 if ( text
.length() == 0 )
638 bool res
= text
.ToDouble(&value
);
641 if ( variant
!= value
)
647 else if ( argFlags
& wxPG_REPORT_ERROR
)
653 bool wxFloatProperty::DoValidation( const wxPGProperty
* property
,
655 wxPGValidationInfo
* pValidationInfo
,
659 double min
= (double)wxINT64_MIN
;
660 double max
= (double)wxINT64_MAX
;
665 variant
= property
->GetAttribute(wxPGGlobalVars
->m_strMin
);
666 if ( !variant
.IsNull() )
668 min
= variant
.GetDouble();
672 variant
= property
->GetAttribute(wxPGGlobalVars
->m_strMax
);
673 if ( !variant
.IsNull() )
675 max
= variant
.GetDouble();
683 if ( mode
== wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE
)
684 pValidationInfo
->SetFailureMessage(
685 wxString::Format(_("Value must be %f or higher"),min
)
687 else if ( mode
== wxPG_PROPERTY_VALIDATION_SATURATE
)
690 value
= max
- (min
- value
);
697 max
= variant
.GetDouble();
700 if ( mode
== wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE
)
701 pValidationInfo
->SetFailureMessage(
702 wxString::Format(_("Value must be %f or less"),max
)
704 else if ( mode
== wxPG_PROPERTY_VALIDATION_SATURATE
)
707 value
= min
+ (value
- max
);
715 wxFloatProperty::ValidateValue( wxVariant
& value
,
716 wxPGValidationInfo
& validationInfo
) const
718 double fpv
= value
.GetDouble();
719 return DoValidation(this, fpv
, &validationInfo
,
720 wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE
);
723 bool wxFloatProperty::DoSetAttribute( const wxString
& name
, wxVariant
& value
)
725 if ( name
== wxPG_FLOAT_PRECISION
)
727 m_precision
= value
.GetLong();
733 wxValidator
* wxFloatProperty::DoGetValidator() const
735 return wxIntProperty::GetClassValidator();
738 // -----------------------------------------------------------------------
740 // -----------------------------------------------------------------------
742 // We cannot use standard WX_PG_IMPLEMENT_PROPERTY_CLASS macro, since
743 // there is a custom GetEditorClass.
745 IMPLEMENT_DYNAMIC_CLASS(wxBoolProperty
, wxPGProperty
)
747 const wxPGEditor
* wxBoolProperty::DoGetEditorClass() const
749 // Select correct editor control.
750 #if wxPG_INCLUDE_CHECKBOX
751 if ( !(m_flags
& wxPG_PROP_USE_CHECKBOX
) )
752 return wxPGEditor_Choice
;
753 return wxPGEditor_CheckBox
;
755 return wxPGEditor_Choice
;
759 wxBoolProperty::wxBoolProperty( const wxString
& label
, const wxString
& name
, bool value
) :
760 wxPGProperty(label
,name
)
762 m_choices
.Assign(wxPGGlobalVars
->m_boolChoices
);
764 SetValue(wxPGVariant_Bool(value
));
766 m_flags
|= wxPG_PROP_USE_DCC
;
769 wxBoolProperty::~wxBoolProperty() { }
771 wxString
wxBoolProperty::ValueToString( wxVariant
& value
,
774 bool boolValue
= value
.GetBool();
776 // As a fragment of composite string value,
777 // make it a little more readable.
778 if ( argFlags
& wxPG_COMPOSITE_FRAGMENT
)
786 if ( argFlags
& wxPG_UNEDITABLE_COMPOSITE_FRAGMENT
)
787 return wxEmptyString
;
790 if ( wxPGGlobalVars
->m_autoGetTranslation
)
791 notFmt
= _("Not %s");
793 notFmt
= wxS("Not %s");
795 return wxString::Format(notFmt
.c_str(), m_label
.c_str());
799 if ( !(argFlags
& wxPG_FULL_VALUE
) )
801 return wxPGGlobalVars
->m_boolChoices
[boolValue
?1:0].GetText();
806 if ( boolValue
) text
= wxS("true");
807 else text
= wxS("false");
812 bool wxBoolProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int WXUNUSED(argFlags
) ) const
814 bool boolValue
= false;
815 if ( text
.CmpNoCase(wxPGGlobalVars
->m_boolChoices
[1].GetText()) == 0 ||
816 text
.CmpNoCase(wxS("true")) == 0 ||
817 text
.CmpNoCase(m_label
) == 0 )
820 if ( text
.length() == 0 )
826 if ( variant
!= boolValue
)
828 variant
= wxPGVariant_Bool(boolValue
);
834 bool wxBoolProperty::IntToValue( wxVariant
& variant
, int value
, int ) const
836 bool boolValue
= value
? true : false;
838 if ( variant
!= boolValue
)
840 variant
= wxPGVariant_Bool(boolValue
);
846 bool wxBoolProperty::DoSetAttribute( const wxString
& name
, wxVariant
& value
)
848 #if wxPG_INCLUDE_CHECKBOX
849 if ( name
== wxPG_BOOL_USE_CHECKBOX
)
851 if ( value
.GetLong() )
852 m_flags
|= wxPG_PROP_USE_CHECKBOX
;
854 m_flags
&= ~(wxPG_PROP_USE_CHECKBOX
);
858 if ( name
== wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING
)
860 if ( value
.GetLong() )
861 m_flags
|= wxPG_PROP_USE_DCC
;
863 m_flags
&= ~(wxPG_PROP_USE_DCC
);
869 // -----------------------------------------------------------------------
871 // -----------------------------------------------------------------------
873 IMPLEMENT_DYNAMIC_CLASS(wxEnumProperty
, wxPGProperty
)
875 WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxEnumProperty
,long,Choice
)
877 wxEnumProperty::wxEnumProperty( const wxString
& label
, const wxString
& name
, const wxChar
** labels
,
878 const long* values
, int value
) : wxPGProperty(label
,name
)
884 m_choices
.Add(labels
,values
);
886 if ( GetItemCount() )
887 SetValue( (long)value
);
891 wxEnumProperty::wxEnumProperty( const wxString
& label
, const wxString
& name
, const wxChar
** labels
,
892 const long* values
, wxPGChoices
* choicesCache
, int value
)
893 : wxPGProperty(label
,name
)
897 wxASSERT( choicesCache
);
899 if ( choicesCache
->IsOk() )
901 m_choices
.Assign( *choicesCache
);
902 m_value
= wxPGVariant_Zero
;
906 m_choices
.Add(labels
,values
);
908 if ( GetItemCount() )
909 SetValue( (long)value
);
913 wxEnumProperty::wxEnumProperty( const wxString
& label
, const wxString
& name
,
914 const wxArrayString
& labels
, const wxArrayInt
& values
, int value
)
915 : wxPGProperty(label
,name
)
919 if ( &labels
&& labels
.size() )
921 m_choices
.Set(labels
, values
);
923 if ( GetItemCount() )
924 SetValue( (long)value
);
928 wxEnumProperty::wxEnumProperty( const wxString
& label
, const wxString
& name
,
929 wxPGChoices
& choices
, int value
)
930 : wxPGProperty(label
,name
)
932 m_choices
.Assign( choices
);
934 if ( GetItemCount() )
935 SetValue( (long)value
);
938 int wxEnumProperty::GetIndexForValue( int value
) const
940 if ( !m_choices
.IsOk() )
943 int intVal
= m_choices
.Index(value
);
950 wxEnumProperty::~wxEnumProperty ()
954 int wxEnumProperty::ms_nextIndex
= -2;
956 void wxEnumProperty::OnSetValue()
958 wxString variantType
= m_value
.GetType();
960 if ( variantType
== wxPG_VARIANT_TYPE_LONG
)
962 ValueFromInt_( m_value
, m_value
.GetLong(), wxPG_FULL_VALUE
);
964 else if ( variantType
== wxPG_VARIANT_TYPE_STRING
)
966 ValueFromString_( m_value
, m_value
.GetString(), 0 );
973 if ( ms_nextIndex
!= -2 )
975 m_index
= ms_nextIndex
;
980 bool wxEnumProperty::ValidateValue( wxVariant
& value
, wxPGValidationInfo
& WXUNUSED(validationInfo
) ) const
982 // Make sure string value is in the list,
983 // unless property has string as preferred value type
984 // To reduce code size, use conversion here as well
985 if ( value
.GetType() == wxPG_VARIANT_TYPE_STRING
&&
986 !this->IsKindOf(CLASSINFO(wxEditEnumProperty
)) )
987 return ValueFromString_( value
, value
.GetString(), wxPG_PROPERTY_SPECIFIC
);
992 wxString
wxEnumProperty::ValueToString( wxVariant
& value
,
993 int WXUNUSED(argFlags
) ) const
995 if ( value
.GetType() == wxPG_VARIANT_TYPE_STRING
)
996 return value
.GetString();
998 int index
= m_choices
.Index(value
.GetLong());
1000 return wxEmptyString
;
1002 return m_choices
.GetLabel(index
);
1005 bool wxEnumProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int argFlags
) const
1007 return ValueFromString_( variant
, text
, argFlags
);
1010 bool wxEnumProperty::IntToValue( wxVariant
& variant
, int intVal
, int argFlags
) const
1012 return ValueFromInt_( variant
, intVal
, argFlags
);
1015 bool wxEnumProperty::ValueFromString_( wxVariant
& value
, const wxString
& text
, int argFlags
) const
1020 for ( unsigned int i
=0; i
<m_choices
.GetCount(); i
++ )
1022 const wxString
& entryLabel
= m_choices
.GetLabel(i
);
1023 if ( text
.CmpNoCase(entryLabel
) == 0 )
1026 useValue
= m_choices
.GetValue(i
);
1031 bool asText
= false;
1033 bool isEdit
= this->IsKindOf(CLASSINFO(wxEditEnumProperty
));
1035 // If text not any of the choices, store as text instead
1036 // (but only if we are wxEditEnumProperty)
1037 if ( useIndex
== -1 &&
1038 (value
.GetType() != wxPG_VARIANT_TYPE_STRING
|| (m_value
.GetString() != text
)) &&
1044 int setAsNextIndex
= -2;
1048 setAsNextIndex
= -1;
1051 else if ( useIndex
!= GetIndex() )
1053 if ( useIndex
!= -1 )
1055 setAsNextIndex
= useIndex
;
1056 value
= (long)useValue
;
1060 setAsNextIndex
= -1;
1061 value
= wxPGVariant_MinusOne
;
1065 if ( setAsNextIndex
!= -2 )
1067 // If wxPG_PROPERTY_SPECIFIC is set, then this is done for
1068 // validation purposes only, and index must not be changed
1069 if ( !(argFlags
& wxPG_PROPERTY_SPECIFIC
) )
1070 ms_nextIndex
= setAsNextIndex
;
1072 if ( isEdit
|| setAsNextIndex
!= -1 )
1080 bool wxEnumProperty::ValueFromInt_( wxVariant
& variant
, int intVal
, int argFlags
) const
1082 // If wxPG_FULL_VALUE is *not* in argFlags, then intVal is index from combo box.
1086 if ( argFlags
& wxPG_FULL_VALUE
)
1088 ms_nextIndex
= GetIndexForValue( intVal
);
1092 if ( intVal
!= GetIndex() )
1094 ms_nextIndex
= intVal
;
1098 if ( ms_nextIndex
!= -2 )
1100 if ( !(argFlags
& wxPG_FULL_VALUE
) )
1101 intVal
= m_choices
.GetValue(intVal
);
1103 variant
= (long)intVal
;
1112 wxEnumProperty::OnValidationFailure( wxVariant
& WXUNUSED(pendingValue
) )
1118 void wxEnumProperty::SetIndex( int index
)
1124 int wxEnumProperty::GetIndex() const
1126 if ( m_value
.IsNull() )
1129 if ( ms_nextIndex
!= -2 )
1130 return ms_nextIndex
;
1135 // -----------------------------------------------------------------------
1136 // wxEditEnumProperty
1137 // -----------------------------------------------------------------------
1139 IMPLEMENT_DYNAMIC_CLASS(wxEditEnumProperty
, wxPGProperty
)
1141 WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxEditEnumProperty
,wxString
,ComboBox
)
1143 wxEditEnumProperty::wxEditEnumProperty( const wxString
& label
, const wxString
& name
, const wxChar
** labels
,
1144 const long* values
, const wxString
& value
)
1145 : wxEnumProperty(label
,name
,labels
,values
,0)
1150 wxEditEnumProperty::wxEditEnumProperty( const wxString
& label
, const wxString
& name
, const wxChar
** labels
,
1151 const long* values
, wxPGChoices
* choicesCache
, const wxString
& value
)
1152 : wxEnumProperty(label
,name
,labels
,values
,choicesCache
,0)
1157 wxEditEnumProperty::wxEditEnumProperty( const wxString
& label
, const wxString
& name
,
1158 const wxArrayString
& labels
, const wxArrayInt
& values
, const wxString
& value
)
1159 : wxEnumProperty(label
,name
,labels
,values
,0)
1164 wxEditEnumProperty::wxEditEnumProperty( const wxString
& label
, const wxString
& name
,
1165 wxPGChoices
& choices
, const wxString
& value
)
1166 : wxEnumProperty(label
,name
,choices
,0)
1171 wxEditEnumProperty::~wxEditEnumProperty()
1175 // -----------------------------------------------------------------------
1177 // -----------------------------------------------------------------------
1179 IMPLEMENT_DYNAMIC_CLASS(wxFlagsProperty
,wxPGProperty
)
1181 WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxFlagsProperty
,long,TextCtrl
)
1183 void wxFlagsProperty::Init()
1185 long value
= m_value
;
1188 // Generate children
1192 unsigned int prevChildCount
= m_children
.size();
1195 if ( prevChildCount
)
1197 wxPropertyGridPageState
* state
= GetParentState();
1199 // State safety check (it may be NULL in immediate parent)
1204 wxPGProperty
* selected
= state
->GetSelection();
1207 if ( selected
->GetParent() == this )
1208 oldSel
= selected
->GetIndexInParent();
1209 else if ( selected
== this )
1213 state
->DoClearSelection();
1216 // Delete old children
1217 for ( i
=0; i
<prevChildCount
; i
++ )
1218 delete m_children
[i
];
1222 // Relay wxPG_BOOL_USE_CHECKBOX and wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING
1223 // to child bool property controls.
1224 long attrUseCheckBox
= GetAttributeAsLong(wxPG_BOOL_USE_CHECKBOX
, 0);
1225 long attrUseDCC
= GetAttributeAsLong(wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING
,
1228 if ( m_choices
.IsOk() )
1230 const wxPGChoices
& choices
= m_choices
;
1232 for ( i
=0; i
<GetItemCount(); i
++ )
1235 child_val
= ( value
& choices
.GetValue(i
) )?true:false;
1237 wxPGProperty
* boolProp
;
1238 wxString label
= GetLabel(i
);
1241 if ( wxPGGlobalVars
->m_autoGetTranslation
)
1243 boolProp
= new wxBoolProperty( ::wxGetTranslation(label
), label
, child_val
);
1248 boolProp
= new wxBoolProperty( label
, label
, child_val
);
1250 if ( attrUseCheckBox
)
1251 boolProp
->SetAttribute(wxPG_BOOL_USE_CHECKBOX
,
1254 boolProp
->SetAttribute(wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING
,
1256 AddPrivateChild(boolProp
);
1259 m_oldChoicesData
= m_choices
.GetDataPtr();
1262 m_oldValue
= m_value
;
1264 if ( prevChildCount
)
1265 SubPropsChanged(oldSel
);
1268 wxFlagsProperty::wxFlagsProperty( const wxString
& label
, const wxString
& name
,
1269 const wxChar
** labels
, const long* values
, long value
) : wxPGProperty(label
,name
)
1271 m_oldChoicesData
= NULL
;
1275 m_choices
.Set(labels
,values
);
1277 wxASSERT( GetItemCount() );
1283 m_value
= wxPGVariant_Zero
;
1287 wxFlagsProperty::wxFlagsProperty( const wxString
& label
, const wxString
& name
,
1288 const wxArrayString
& labels
, const wxArrayInt
& values
, int value
)
1289 : wxPGProperty(label
,name
)
1291 m_oldChoicesData
= NULL
;
1293 if ( &labels
&& labels
.size() )
1295 m_choices
.Set(labels
,values
);
1297 wxASSERT( GetItemCount() );
1299 SetValue( (long)value
);
1303 m_value
= wxPGVariant_Zero
;
1307 wxFlagsProperty::wxFlagsProperty( const wxString
& label
, const wxString
& name
,
1308 wxPGChoices
& choices
, long value
)
1309 : wxPGProperty(label
,name
)
1311 m_oldChoicesData
= NULL
;
1313 if ( choices
.IsOk() )
1315 m_choices
.Assign(choices
);
1317 wxASSERT( GetItemCount() );
1323 m_value
= wxPGVariant_Zero
;
1327 wxFlagsProperty::~wxFlagsProperty()
1331 void wxFlagsProperty::OnSetValue()
1333 if ( !m_choices
.IsOk() || !GetItemCount() )
1335 m_value
= wxPGVariant_Zero
;
1339 long val
= m_value
.GetLong();
1343 // normalize the value (i.e. remove extra flags)
1345 const wxPGChoices
& choices
= m_choices
;
1346 for ( i
= 0; i
< GetItemCount(); i
++ )
1348 fullFlags
|= choices
.GetValue(i
);
1355 // Need to (re)init now?
1356 if ( GetChildCount() != GetItemCount() ||
1357 m_choices
.GetDataPtr() != m_oldChoicesData
)
1363 long newFlags
= m_value
;
1365 if ( newFlags
!= m_oldValue
)
1367 // Set child modified states
1369 const wxPGChoices
& choices
= m_choices
;
1370 for ( i
= 0; i
<GetItemCount(); i
++ )
1374 flag
= choices
.GetValue(i
);
1376 if ( (newFlags
& flag
) != (m_oldValue
& flag
) )
1377 Item(i
)->SetFlag( wxPG_PROP_MODIFIED
);
1380 m_oldValue
= newFlags
;
1384 wxString
wxFlagsProperty::ValueToString( wxVariant
& value
,
1385 int WXUNUSED(argFlags
) ) const
1389 if ( !m_choices
.IsOk() )
1394 const wxPGChoices
& choices
= m_choices
;
1396 for ( i
= 0; i
< GetItemCount(); i
++ )
1399 doAdd
= ( flags
& choices
.GetValue(i
) );
1403 text
+= choices
.GetLabel(i
);
1408 // remove last comma
1409 if ( text
.Len() > 1 )
1410 text
.Truncate ( text
.Len() - 2 );
1415 // Translate string into flag tokens
1416 bool wxFlagsProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int ) const
1418 if ( !m_choices
.IsOk() )
1423 // semicolons are no longer valid delimeters
1424 WX_PG_TOKENIZER1_BEGIN(text
,wxS(','))
1426 if ( token
.length() )
1428 // Determine which one it is
1429 long bit
= IdToBit( token
);
1442 WX_PG_TOKENIZER1_END()
1444 if ( variant
!= (long)newFlags
)
1446 variant
= (long)newFlags
;
1453 // Converts string id to a relevant bit.
1454 long wxFlagsProperty::IdToBit( const wxString
& id
) const
1457 for ( i
= 0; i
< GetItemCount(); i
++ )
1459 if ( id
== GetLabel(i
) )
1461 return m_choices
.GetValue(i
);
1467 void wxFlagsProperty::RefreshChildren()
1469 if ( !m_choices
.IsOk() || !GetChildCount() ) return;
1471 int flags
= m_value
.GetLong();
1473 const wxPGChoices
& choices
= m_choices
;
1475 for ( i
= 0; i
< GetItemCount(); i
++ )
1479 flag
= choices
.GetValue(i
);
1481 long subVal
= flags
& flag
;
1482 wxPGProperty
* p
= Item(i
);
1484 if ( subVal
!= (m_oldValue
& flag
) )
1485 p
->SetFlag( wxPG_PROP_MODIFIED
);
1487 p
->SetValue( subVal
?true:false );
1493 wxVariant
wxFlagsProperty::ChildChanged( wxVariant
& thisValue
,
1495 wxVariant
& childValue
) const
1497 long oldValue
= thisValue
.GetLong();
1498 long val
= childValue
.GetLong();
1499 unsigned long vi
= m_choices
.GetValue(childIndex
);
1502 return (long) (oldValue
| vi
);
1504 return (long) (oldValue
& ~(vi
));
1507 bool wxFlagsProperty::DoSetAttribute( const wxString
& name
, wxVariant
& value
)
1509 if ( name
== wxPG_BOOL_USE_CHECKBOX
||
1510 name
== wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING
)
1512 for ( size_t i
=0; i
<GetChildCount(); i
++ )
1514 Item(i
)->SetAttribute(name
, value
);
1516 // Must return false so that the attribute is stored in
1517 // flag property's actual property storage
1523 // -----------------------------------------------------------------------
1525 // -----------------------------------------------------------------------
1527 IMPLEMENT_DYNAMIC_CLASS(wxDirProperty
, wxLongStringProperty
)
1529 wxDirProperty::wxDirProperty( const wxString
& name
, const wxString
& label
, const wxString
& value
)
1530 : wxLongStringProperty(name
,label
,value
)
1532 m_flags
|= wxPG_PROP_NO_ESCAPE
;
1535 wxDirProperty::~wxDirProperty() { }
1537 wxValidator
* wxDirProperty::DoGetValidator() const
1539 return wxFileProperty::GetClassValidator();
1542 bool wxDirProperty::OnButtonClick( wxPropertyGrid
* propGrid
, wxString
& value
)
1544 // Update property value from editor, if necessary
1545 wxSize
dlg_sz(300,400);
1547 wxString
dlgMessage(m_dlgMessage
);
1548 if ( dlgMessage
.empty() )
1549 dlgMessage
= _("Choose a directory:");
1550 wxDirDialog
dlg( propGrid
,
1554 #if !wxPG_SMALL_SCREEN
1555 propGrid
->GetGoodEditorDialogPosition(this,dlg_sz
),
1563 if ( dlg
.ShowModal() == wxID_OK
)
1565 value
= dlg
.GetPath();
1571 bool wxDirProperty::DoSetAttribute( const wxString
& name
, wxVariant
& value
)
1573 if ( name
== wxPG_DIR_DIALOG_MESSAGE
)
1575 m_dlgMessage
= value
.GetString();
1581 // -----------------------------------------------------------------------
1582 // wxPGFileDialogAdapter
1583 // -----------------------------------------------------------------------
1585 bool wxPGFileDialogAdapter::DoShowDialog( wxPropertyGrid
* propGrid
, wxPGProperty
* property
)
1587 wxFileProperty
* fileProp
= NULL
;
1591 if ( property
->IsKindOf(CLASSINFO(wxFileProperty
)) )
1593 fileProp
= ((wxFileProperty
*)property
);
1594 wxFileName filename
= fileProp
->GetValue().GetString();
1595 path
= filename
.GetPath();
1596 indFilter
= fileProp
->m_indFilter
;
1598 if ( !path
.length() && fileProp
->m_basePath
.length() )
1599 path
= fileProp
->m_basePath
;
1603 wxFileName
fn(property
->GetValue().GetString());
1604 path
= fn
.GetPath();
1607 wxFileDialog
dlg( propGrid
->GetPanel(),
1608 property
->GetAttribute(wxS("DialogTitle"), _("Choose a file")),
1609 property
->GetAttribute(wxS("InitialPath"), path
),
1611 property
->GetAttribute(wxPG_FILE_WILDCARD
, _("All files (*.*)|*.*")),
1613 wxDefaultPosition
);
1615 if ( indFilter
>= 0 )
1616 dlg
.SetFilterIndex( indFilter
);
1618 if ( dlg
.ShowModal() == wxID_OK
)
1621 fileProp
->m_indFilter
= dlg
.GetFilterIndex();
1622 SetValue( dlg
.GetPath() );
1628 // -----------------------------------------------------------------------
1630 // -----------------------------------------------------------------------
1632 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxFileProperty
,wxPGProperty
,
1633 wxString
,const wxString
&,TextCtrlAndButton
)
1635 wxFileProperty::wxFileProperty( const wxString
& label
, const wxString
& name
,
1636 const wxString
& value
) : wxPGProperty(label
,name
)
1638 m_flags
|= wxPG_PROP_SHOW_FULL_FILENAME
;
1640 SetAttribute( wxPG_FILE_WILDCARD
, _("All files (*.*)|*.*") );
1645 wxFileProperty::~wxFileProperty() {}
1647 #if wxUSE_VALIDATORS
1649 wxValidator
* wxFileProperty::GetClassValidator()
1651 WX_PG_DOGETVALIDATOR_ENTRY()
1653 // Atleast wxPython 2.6.2.1 required that the string argument is given
1655 wxTextValidator
* validator
= new wxTextValidator(wxFILTER_EXCLUDE_CHAR_LIST
,&v
);
1657 wxArrayString exChars
;
1658 exChars
.Add(wxS("?"));
1659 exChars
.Add(wxS("*"));
1660 exChars
.Add(wxS("|"));
1661 exChars
.Add(wxS("<"));
1662 exChars
.Add(wxS(">"));
1663 exChars
.Add(wxS("\""));
1665 validator
->SetExcludes(exChars
);
1667 WX_PG_DOGETVALIDATOR_EXIT(validator
)
1670 wxValidator
* wxFileProperty::DoGetValidator() const
1672 return GetClassValidator();
1677 void wxFileProperty::OnSetValue()
1679 const wxString
& fnstr
= m_value
.GetString();
1681 wxFileName filename
= fnstr
;
1683 if ( !filename
.HasName() )
1685 m_value
= wxPGVariant_EmptyString
;
1688 // Find index for extension.
1689 if ( m_indFilter
< 0 && fnstr
.length() )
1691 wxString ext
= filename
.GetExt();
1694 size_t len
= m_wildcard
.length();
1696 pos
= m_wildcard
.find(wxS("|"), pos
);
1697 while ( pos
!= wxString::npos
&& pos
< (len
-3) )
1699 size_t ext_begin
= pos
+ 3;
1701 pos
= m_wildcard
.find(wxS("|"), ext_begin
);
1702 if ( pos
== wxString::npos
)
1704 wxString found_ext
= m_wildcard
.substr(ext_begin
, pos
-ext_begin
);
1706 if ( found_ext
.length() > 0 )
1708 if ( found_ext
[0] == wxS('*') )
1710 m_indFilter
= curind
;
1713 if ( ext
.CmpNoCase(found_ext
) == 0 )
1715 m_indFilter
= curind
;
1721 pos
= m_wildcard
.find(wxS("|"), pos
+1);
1728 wxFileName
wxFileProperty::GetFileName() const
1730 wxFileName filename
;
1732 if ( !m_value
.IsNull() )
1733 filename
= m_value
.GetString();
1738 wxString
wxFileProperty::ValueToString( wxVariant
& value
,
1739 int argFlags
) const
1741 wxFileName filename
= value
.GetString();
1743 if ( !filename
.HasName() )
1744 return wxEmptyString
;
1746 wxString fullName
= filename
.GetFullName();
1747 if ( !fullName
.length() )
1748 return wxEmptyString
;
1750 if ( argFlags
& wxPG_FULL_VALUE
)
1752 return filename
.GetFullPath();
1754 else if ( m_flags
& wxPG_PROP_SHOW_FULL_FILENAME
)
1756 if ( m_basePath
.Length() )
1758 wxFileName
fn2(filename
);
1759 fn2
.MakeRelativeTo(m_basePath
);
1760 return fn2
.GetFullPath();
1762 return filename
.GetFullPath();
1765 return filename
.GetFullName();
1768 wxPGEditorDialogAdapter
* wxFileProperty::GetEditorDialog() const
1770 return new wxPGFileDialogAdapter();
1773 bool wxFileProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int argFlags
) const
1775 wxFileName filename
= variant
.GetString();
1777 if ( (m_flags
& wxPG_PROP_SHOW_FULL_FILENAME
) || (argFlags
& wxPG_FULL_VALUE
) )
1779 if ( filename
!= text
)
1787 if ( filename
.GetFullName() != text
)
1789 wxFileName fn
= filename
;
1790 fn
.SetFullName(text
);
1791 variant
= fn
.GetFullPath();
1799 bool wxFileProperty::DoSetAttribute( const wxString
& name
, wxVariant
& value
)
1801 // Return false on some occasions to make sure those attribs will get
1802 // stored in m_attributes.
1803 if ( name
== wxPG_FILE_SHOW_FULL_PATH
)
1805 if ( value
.GetLong() )
1806 m_flags
|= wxPG_PROP_SHOW_FULL_FILENAME
;
1808 m_flags
&= ~(wxPG_PROP_SHOW_FULL_FILENAME
);
1811 else if ( name
== wxPG_FILE_WILDCARD
)
1813 m_wildcard
= value
.GetString();
1815 else if ( name
== wxPG_FILE_SHOW_RELATIVE_PATH
)
1817 m_basePath
= value
.GetString();
1819 // Make sure wxPG_FILE_SHOW_FULL_PATH is also set
1820 m_flags
|= wxPG_PROP_SHOW_FULL_FILENAME
;
1822 else if ( name
== wxPG_FILE_INITIAL_PATH
)
1824 m_initialPath
= value
.GetString();
1827 else if ( name
== wxPG_FILE_DIALOG_TITLE
)
1829 m_dlgTitle
= value
.GetString();
1835 // -----------------------------------------------------------------------
1836 // wxPGLongStringDialogAdapter
1837 // -----------------------------------------------------------------------
1839 bool wxPGLongStringDialogAdapter::DoShowDialog( wxPropertyGrid
* propGrid
, wxPGProperty
* property
)
1841 wxString val1
= property
->GetValueAsString(0);
1842 wxString val_orig
= val1
;
1845 if ( !property
->HasFlag(wxPG_PROP_NO_ESCAPE
) )
1846 wxPropertyGrid::ExpandEscapeSequences(value
, val1
);
1848 value
= wxString(val1
);
1850 // Run editor dialog.
1851 if ( wxLongStringProperty::DisplayEditorDialog(property
, propGrid
, value
) )
1853 if ( !property
->HasFlag(wxPG_PROP_NO_ESCAPE
) )
1854 wxPropertyGrid::CreateEscapeSequences(val1
,value
);
1858 if ( val1
!= val_orig
)
1867 // -----------------------------------------------------------------------
1868 // wxLongStringProperty
1869 // -----------------------------------------------------------------------
1871 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxLongStringProperty
,wxPGProperty
,
1872 wxString
,const wxString
&,TextCtrlAndButton
)
1874 wxLongStringProperty::wxLongStringProperty( const wxString
& label
, const wxString
& name
,
1875 const wxString
& value
) : wxPGProperty(label
,name
)
1880 wxLongStringProperty::~wxLongStringProperty() {}
1882 wxString
wxLongStringProperty::ValueToString( wxVariant
& value
,
1883 int WXUNUSED(argFlags
) ) const
1888 bool wxLongStringProperty::OnEvent( wxPropertyGrid
* propGrid
, wxWindow
* WXUNUSED(primary
),
1891 if ( propGrid
->IsMainButtonEvent(event
) )
1894 wxVariant useValue
= propGrid
->GetUncommittedPropertyValue();
1896 wxString val1
= useValue
.GetString();
1897 wxString val_orig
= val1
;
1900 if ( !(m_flags
& wxPG_PROP_NO_ESCAPE
) )
1901 wxPropertyGrid::ExpandEscapeSequences(value
,val1
);
1903 value
= wxString(val1
);
1905 // Run editor dialog.
1906 if ( OnButtonClick(propGrid
,value
) )
1908 if ( !(m_flags
& wxPG_PROP_NO_ESCAPE
) )
1909 wxPropertyGrid::CreateEscapeSequences(val1
,value
);
1913 if ( val1
!= val_orig
)
1915 SetValueInEvent( val1
);
1923 bool wxLongStringProperty::OnButtonClick( wxPropertyGrid
* propGrid
, wxString
& value
)
1925 return DisplayEditorDialog(this, propGrid
, value
);
1928 bool wxLongStringProperty::DisplayEditorDialog( wxPGProperty
* prop
, wxPropertyGrid
* propGrid
, wxString
& value
)
1931 // launch editor dialog
1932 wxDialog
* dlg
= new wxDialog(propGrid
,-1,prop
->GetLabel(),wxDefaultPosition
,wxDefaultSize
,
1933 wxDEFAULT_DIALOG_STYLE
|wxRESIZE_BORDER
|wxCLIP_CHILDREN
);
1935 dlg
->SetFont(propGrid
->GetFont()); // To allow entering chars of the same set as the propGrid
1937 // Multi-line text editor dialog.
1938 #if !wxPG_SMALL_SCREEN
1939 const int spacing
= 8;
1941 const int spacing
= 4;
1943 wxBoxSizer
* topsizer
= new wxBoxSizer( wxVERTICAL
);
1944 wxBoxSizer
* rowsizer
= new wxBoxSizer( wxHORIZONTAL
);
1945 wxTextCtrl
* ed
= new wxTextCtrl(dlg
,11,value
,
1946 wxDefaultPosition
,wxDefaultSize
,wxTE_MULTILINE
);
1948 rowsizer
->Add( ed
, 1, wxEXPAND
|wxALL
, spacing
);
1949 topsizer
->Add( rowsizer
, 1, wxEXPAND
, 0 );
1951 wxStdDialogButtonSizer
* buttonSizer
= new wxStdDialogButtonSizer();
1952 buttonSizer
->AddButton(new wxButton(dlg
, wxID_OK
));
1953 buttonSizer
->AddButton(new wxButton(dlg
, wxID_CANCEL
));
1954 buttonSizer
->Realize();
1955 topsizer
->Add( buttonSizer
, 0,
1956 wxALIGN_RIGHT
|wxALIGN_CENTRE_VERTICAL
|wxBOTTOM
|wxRIGHT
,
1959 dlg
->SetSizer( topsizer
);
1960 topsizer
->SetSizeHints( dlg
);
1962 #if !wxPG_SMALL_SCREEN
1963 dlg
->SetSize(400,300);
1965 dlg
->Move( propGrid
->GetGoodEditorDialogPosition(prop
,dlg
->GetSize()) );
1968 int res
= dlg
->ShowModal();
1970 if ( res
== wxID_OK
)
1972 value
= ed
->GetValue();
1980 bool wxLongStringProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int ) const
1982 if ( variant
!= text
)
1990 // -----------------------------------------------------------------------
1991 // wxArrayEditorDialog
1992 // -----------------------------------------------------------------------
1994 BEGIN_EVENT_TABLE(wxArrayEditorDialog
, wxDialog
)
1995 EVT_IDLE(wxArrayEditorDialog::OnIdle
)
1996 EVT_LISTBOX(24, wxArrayEditorDialog::OnListBoxClick
)
1997 EVT_TEXT_ENTER(21, wxArrayEditorDialog::OnAddClick
)
1998 EVT_BUTTON(22, wxArrayEditorDialog::OnAddClick
)
1999 EVT_BUTTON(23, wxArrayEditorDialog::OnDeleteClick
)
2000 EVT_BUTTON(25, wxArrayEditorDialog::OnUpClick
)
2001 EVT_BUTTON(26, wxArrayEditorDialog::OnDownClick
)
2002 EVT_BUTTON(27, wxArrayEditorDialog::OnUpdateClick
)
2003 //EVT_BUTTON(28, wxArrayEditorDialog::OnCustomEditClick)
2006 IMPLEMENT_ABSTRACT_CLASS(wxArrayEditorDialog
, wxDialog
)
2008 #include "wx/statline.h"
2010 // -----------------------------------------------------------------------
2012 void wxArrayEditorDialog::OnIdle(wxIdleEvent
& event
)
2015 // Do control focus detection here.
2018 wxWindow
* focused
= FindFocus();
2020 // This strange focus thing is a workaround for wxGTK wxListBox focus
2022 if ( m_curFocus
== 0 && focused
!= m_edValue
&&
2023 focused
!= m_butAdd
&& focused
!= m_butUpdate
&&
2024 m_lbStrings
->GetSelection() >= 0 )
2026 // ListBox was just focused.
2027 m_butAdd
->Enable(false);
2028 m_butUpdate
->Enable(false);
2029 m_butRemove
->Enable(true);
2030 m_butUp
->Enable(true);
2031 m_butDown
->Enable(true);
2034 else if ( (m_curFocus
== 1 && focused
== m_edValue
) /*|| m_curFocus == 2*/ )
2036 // TextCtrl was just focused.
2037 m_butAdd
->Enable(true);
2038 bool upd_enable
= false;
2039 if ( m_lbStrings
->GetCount() && m_lbStrings
->GetSelection() >= 0 )
2041 m_butUpdate
->Enable(upd_enable
);
2042 m_butRemove
->Enable(false);
2043 m_butUp
->Enable(false);
2044 m_butDown
->Enable(false);
2051 // -----------------------------------------------------------------------
2053 wxArrayEditorDialog::wxArrayEditorDialog()
2059 // -----------------------------------------------------------------------
2061 void wxArrayEditorDialog::Init()
2063 m_custBtText
= (const wxChar
*) NULL
;
2066 // -----------------------------------------------------------------------
2068 wxArrayEditorDialog::wxArrayEditorDialog( wxWindow
*parent
,
2069 const wxString
& message
,
2070 const wxString
& caption
,
2077 Create(parent
,message
,caption
,style
,pos
,sz
);
2080 // -----------------------------------------------------------------------
2082 bool wxArrayEditorDialog::Create( wxWindow
*parent
,
2083 const wxString
& message
,
2084 const wxString
& caption
,
2089 // On wxMAC the dialog shows incorrectly if style is not exactly wxCAPTION
2090 // FIXME: This should be only a temporary fix.
2093 int useStyle
= wxCAPTION
;
2095 int useStyle
= style
;
2098 bool res
= wxDialog::Create(parent
, wxID_ANY
, caption
, pos
, sz
, useStyle
);
2100 SetFont(parent
->GetFont()); // To allow entering chars of the same set as the propGrid
2102 #if !wxPG_SMALL_SCREEN
2103 const int spacing
= 4;
2105 const int spacing
= 3;
2112 wxBoxSizer
* topsizer
= new wxBoxSizer( wxVERTICAL
);
2115 if ( message
.length() )
2116 topsizer
->Add( new wxStaticText(this,-1,message
),
2117 0, wxALIGN_LEFT
|wxALIGN_CENTRE_VERTICAL
|wxALL
, spacing
);
2120 wxBoxSizer
* rowsizer
= new wxBoxSizer( wxHORIZONTAL
);
2121 m_edValue
= new wxTextCtrl(this,21,wxEmptyString
,
2122 wxDefaultPosition
,wxDefaultSize
,wxTE_PROCESS_ENTER
);
2123 #if wxUSE_VALIDATORS
2124 wxValidator
* validator
= GetTextCtrlValidator();
2127 m_edValue
->SetValidator( *validator
);
2131 rowsizer
->Add( m_edValue
,
2132 1, wxALIGN_LEFT
|wxALIGN_CENTRE_VERTICAL
|wxALL
, spacing
);
2135 m_butAdd
= new wxButton(this,22,_("Add"));
2136 rowsizer
->Add( m_butAdd
,
2137 0, wxALIGN_LEFT
|wxALIGN_CENTRE_VERTICAL
|wxTOP
|wxBOTTOM
|wxRIGHT
, spacing
);
2138 topsizer
->Add( rowsizer
, 0, wxEXPAND
, spacing
);
2141 topsizer
->Add( new wxStaticLine(this,-1),
2142 0, wxEXPAND
|wxBOTTOM
|wxLEFT
|wxRIGHT
, spacing
);
2144 rowsizer
= new wxBoxSizer( wxHORIZONTAL
);
2147 m_lbStrings
= new wxListBox(this, 24, wxDefaultPosition
, wxDefaultSize
);
2149 for ( i
=0; i
<ArrayGetCount(); i
++ )
2150 m_lbStrings
->Append( ArrayGet(i
) );
2151 rowsizer
->Add( m_lbStrings
, 1, wxEXPAND
|wxRIGHT
, spacing
);
2153 // Manipulator buttons
2154 wxBoxSizer
* colsizer
= new wxBoxSizer( wxVERTICAL
);
2158 m_butCustom
= new wxButton(this,28,::wxGetTranslation(m_custBtText
));
2159 colsizer
->Add( m_butCustom
,
2160 0, wxALIGN_CENTER
|wxTOP
/*wxALIGN_LEFT|wxALIGN_CENTRE_VERTICAL|wxTOP|wxBOTTOM|wxRIGHT*/,
2163 m_butUpdate
= new wxButton(this,27,_("Update"));
2164 colsizer
->Add( m_butUpdate
,
2165 0, wxALIGN_CENTER
|wxTOP
, spacing
);
2166 m_butRemove
= new wxButton(this,23,_("Remove"));
2167 colsizer
->Add( m_butRemove
,
2168 0, wxALIGN_CENTER
|wxTOP
, spacing
);
2169 m_butUp
= new wxButton(this,25,_("Up"));
2170 colsizer
->Add( m_butUp
,
2171 0, wxALIGN_CENTER
|wxTOP
, spacing
);
2172 m_butDown
= new wxButton(this,26,_("Down"));
2173 colsizer
->Add( m_butDown
,
2174 0, wxALIGN_CENTER
|wxTOP
, spacing
);
2175 rowsizer
->Add( colsizer
, 0, 0, spacing
);
2177 topsizer
->Add( rowsizer
, 1, wxLEFT
|wxRIGHT
|wxEXPAND
, spacing
);
2180 topsizer
->Add( new wxStaticLine(this,-1),
2181 0, wxEXPAND
|wxTOP
|wxLEFT
|wxRIGHT
, spacing
);
2183 // Standard dialog buttons
2184 wxStdDialogButtonSizer
* buttonSizer
= new wxStdDialogButtonSizer();
2185 buttonSizer
->AddButton(new wxButton(this, wxID_OK
));
2186 buttonSizer
->AddButton(new wxButton(this, wxID_CANCEL
));
2187 buttonSizer
->Realize();
2188 topsizer
->Add( buttonSizer
, 0,
2189 wxALIGN_RIGHT
|wxALIGN_CENTRE_VERTICAL
|wxALL
,
2192 m_edValue
->SetFocus();
2194 SetSizer( topsizer
);
2195 topsizer
->SetSizeHints( this );
2197 #if !wxPG_SMALL_SCREEN
2198 if ( sz
.x
== wxDefaultSize
.x
&&
2199 sz
.y
== wxDefaultSize
.y
)
2200 SetSize( wxSize(275,360) );
2208 // -----------------------------------------------------------------------
2210 void wxArrayEditorDialog::OnAddClick(wxCommandEvent
& )
2212 wxString text
= m_edValue
->GetValue();
2213 if ( text
.length() )
2215 if ( ArrayInsert( text
, -1 ) )
2217 m_lbStrings
->Append( text
);
2224 // -----------------------------------------------------------------------
2226 void wxArrayEditorDialog::OnDeleteClick(wxCommandEvent
& )
2228 int index
= m_lbStrings
->GetSelection();
2231 ArrayRemoveAt( index
);
2232 m_lbStrings
->Delete ( index
);
2237 // -----------------------------------------------------------------------
2239 void wxArrayEditorDialog::OnUpClick(wxCommandEvent
& )
2241 int index
= m_lbStrings
->GetSelection();
2244 ArraySwap(index
-1,index
);
2245 /*wxString old_str = m_array[index-1];
2246 wxString new_str = m_array[index];
2247 m_array[index-1] = new_str;
2248 m_array[index] = old_str;*/
2249 m_lbStrings
->SetString ( index
-1, ArrayGet(index
-1) );
2250 m_lbStrings
->SetString ( index
, ArrayGet(index
) );
2251 m_lbStrings
->SetSelection ( index
-1 );
2256 // -----------------------------------------------------------------------
2258 void wxArrayEditorDialog::OnDownClick(wxCommandEvent
& )
2260 int index
= m_lbStrings
->GetSelection();
2261 int lastStringIndex
= ((int) m_lbStrings
->GetCount()) - 1;
2262 if ( index
>= 0 && index
< lastStringIndex
)
2264 ArraySwap(index
,index
+1);
2265 /*wxString old_str = m_array[index+1];
2266 wxString new_str = m_array[index];
2267 m_array[index+1] = new_str;
2268 m_array[index] = old_str;*/
2269 m_lbStrings
->SetString ( index
+1, ArrayGet(index
+1) );
2270 m_lbStrings
->SetString ( index
, ArrayGet(index
) );
2271 m_lbStrings
->SetSelection ( index
+1 );
2276 // -----------------------------------------------------------------------
2278 void wxArrayEditorDialog::OnUpdateClick(wxCommandEvent
& )
2280 int index
= m_lbStrings
->GetSelection();
2283 wxString str
= m_edValue
->GetValue();
2284 if ( ArraySet(index
,str
) )
2286 m_lbStrings
->SetString ( index
, str
);
2287 //m_array[index] = str;
2293 // -----------------------------------------------------------------------
2295 void wxArrayEditorDialog::OnListBoxClick(wxCommandEvent
& )
2297 int index
= m_lbStrings
->GetSelection();
2300 m_edValue
->SetValue( m_lbStrings
->GetString(index
) );
2304 // -----------------------------------------------------------------------
2305 // wxPGArrayStringEditorDialog
2306 // -----------------------------------------------------------------------
2308 IMPLEMENT_DYNAMIC_CLASS(wxPGArrayStringEditorDialog
, wxArrayEditorDialog
)
2310 BEGIN_EVENT_TABLE(wxPGArrayStringEditorDialog
, wxArrayEditorDialog
)
2311 EVT_BUTTON(28, wxPGArrayStringEditorDialog::OnCustomEditClick
)
2314 // -----------------------------------------------------------------------
2316 wxString
wxPGArrayStringEditorDialog::ArrayGet( size_t index
)
2318 return m_array
[index
];
2321 size_t wxPGArrayStringEditorDialog::ArrayGetCount()
2323 return m_array
.size();
2326 bool wxPGArrayStringEditorDialog::ArrayInsert( const wxString
& str
, int index
)
2331 m_array
.Insert(str
,index
);
2335 bool wxPGArrayStringEditorDialog::ArraySet( size_t index
, const wxString
& str
)
2337 m_array
[index
] = str
;
2341 void wxPGArrayStringEditorDialog::ArrayRemoveAt( int index
)
2343 m_array
.RemoveAt(index
);
2346 void wxPGArrayStringEditorDialog::ArraySwap( size_t first
, size_t second
)
2348 wxString old_str
= m_array
[first
];
2349 wxString new_str
= m_array
[second
];
2350 m_array
[first
] = new_str
;
2351 m_array
[second
] = old_str
;
2354 wxPGArrayStringEditorDialog::wxPGArrayStringEditorDialog()
2355 : wxArrayEditorDialog()
2360 void wxPGArrayStringEditorDialog::Init()
2362 m_pCallingClass
= NULL
;
2365 void wxPGArrayStringEditorDialog::OnCustomEditClick(wxCommandEvent
& )
2367 wxASSERT( m_pCallingClass
);
2368 wxString str
= m_edValue
->GetValue();
2369 if ( m_pCallingClass
->OnCustomStringEdit(m_parent
,str
) )
2371 //m_edValue->SetValue ( str );
2372 m_lbStrings
->Append ( str
);
2373 m_array
.Add ( str
);
2378 // -----------------------------------------------------------------------
2379 // wxArrayStringProperty
2380 // -----------------------------------------------------------------------
2382 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxArrayStringProperty
, // Property name
2383 wxPGProperty
, // Property we inherit from
2384 wxArrayString
, // Value type name
2385 const wxArrayString
&, // Value type, as given in constructor
2386 TextCtrlAndButton
) // Initial editor
2388 wxArrayStringProperty::wxArrayStringProperty( const wxString
& label
,
2389 const wxString
& name
,
2390 const wxArrayString
& array
)
2391 : wxPGProperty(label
,name
)
2396 wxArrayStringProperty::~wxArrayStringProperty() { }
2398 void wxArrayStringProperty::OnSetValue()
2400 GenerateValueAsString();
2403 #define ARRSTRPROP_ARRAY_TO_STRING(STRING,ARRAY) \
2404 wxPropertyGrid::ArrayStringToString(STRING,ARRAY,wxS('"'),wxS('"'),1)
2406 wxString
wxArrayStringProperty::ValueToString( wxVariant
& WXUNUSED(value
),
2407 int argFlags
) const
2410 // If this is called from GetValueAsString(), return cached string
2411 if ( argFlags
& wxPG_VALUE_IS_CURRENT
)
2416 wxArrayString arr
= m_value
.GetArrayString();
2418 ARRSTRPROP_ARRAY_TO_STRING(s
, arr
);
2422 // Converts wxArrayString to a string separated by delimeters and spaces.
2423 // preDelim is useful for "str1" "str2" style. Set flags to 1 to do slash
2425 void wxPropertyGrid::ArrayStringToString( wxString
& dst
, const wxArrayString
& src
,
2426 wxChar preDelim
, wxChar postDelim
,
2432 unsigned int itemCount
= src
.size();
2434 wxChar preas
[2] = { 0, 0 };
2440 preas
[0] = preDelim
;
2446 dst
.append( preas
);
2448 wxASSERT( postDelim
);
2449 wxString
postDelimStr(postDelim
);
2450 //wxString preDelimStr(preDelim);
2452 for ( i
= 0; i
< itemCount
; i
++ )
2454 wxString
str( src
.Item(i
) );
2456 // Do some character conversion.
2457 // Convertes \ to \\ and <preDelim> to \<preDelim>
2458 // Useful when preDelim and postDelim are "\"".
2461 str
.Replace( wxS("\\"), wxS("\\\\"), true );
2463 str
.Replace( preas
, pdr
, true );
2468 if ( i
< (itemCount
-1) )
2470 dst
.append( postDelimStr
);
2471 dst
.append( wxS(" ") );
2472 dst
.append( preas
);
2474 else if ( preDelim
)
2475 dst
.append( postDelimStr
);
2479 void wxArrayStringProperty::GenerateValueAsString()
2481 wxArrayString arr
= m_value
.GetArrayString();
2482 ARRSTRPROP_ARRAY_TO_STRING(m_display
, arr
);
2485 // Default implementation doesn't do anything.
2486 bool wxArrayStringProperty::OnCustomStringEdit( wxWindow
*, wxString
& )
2491 wxArrayEditorDialog
* wxArrayStringProperty::CreateEditorDialog()
2493 return new wxPGArrayStringEditorDialog();
2496 bool wxArrayStringProperty::OnButtonClick( wxPropertyGrid
* propGrid
,
2497 wxWindow
* WXUNUSED(primaryCtrl
),
2501 wxVariant useValue
= propGrid
->GetUncommittedPropertyValue();
2503 if ( !propGrid
->EditorValidate() )
2506 // Create editor dialog.
2507 wxArrayEditorDialog
* dlg
= CreateEditorDialog();
2508 #if wxUSE_VALIDATORS
2509 wxValidator
* validator
= GetValidator();
2510 wxPGInDialogValidator dialogValidator
;
2513 wxPGArrayStringEditorDialog
* strEdDlg
= wxDynamicCast(dlg
, wxPGArrayStringEditorDialog
);
2516 strEdDlg
->SetCustomButton(cbt
, this);
2518 dlg
->SetDialogValue( useValue
);
2519 dlg
->Create(propGrid
, wxEmptyString
, m_label
);
2521 #if !wxPG_SMALL_SCREEN
2522 dlg
->Move( propGrid
->GetGoodEditorDialogPosition(this,dlg
->GetSize()) );
2531 int res
= dlg
->ShowModal();
2533 if ( res
== wxID_OK
&& dlg
->IsModified() )
2535 wxVariant value
= dlg
->GetDialogValue();
2536 if ( !value
.IsNull() )
2538 wxArrayString actualValue
= value
.GetArrayString();
2540 ARRSTRPROP_ARRAY_TO_STRING(tempStr
, actualValue
);
2541 #if wxUSE_VALIDATORS
2542 if ( dialogValidator
.DoValidate( propGrid
, validator
, tempStr
) )
2545 SetValueInEvent( actualValue
);
2562 bool wxArrayStringProperty::OnEvent( wxPropertyGrid
* propGrid
,
2566 if ( propGrid
->IsMainButtonEvent(event
) )
2567 return OnButtonClick(propGrid
,primary
,(const wxChar
*) NULL
);
2571 bool wxArrayStringProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int ) const
2575 WX_PG_TOKENIZER2_BEGIN(text
,wxS('"'))
2577 // Need to replace backslashes with empty characters
2578 // (opposite what is done in GenerateValueString).
2579 token
.Replace ( wxS("\\"), wxEmptyString
, true );
2583 WX_PG_TOKENIZER2_END()
2590 // -----------------------------------------------------------------------
2591 // wxPGInDialogValidator
2592 // -----------------------------------------------------------------------
2594 #if wxUSE_VALIDATORS
2595 bool wxPGInDialogValidator::DoValidate( wxPropertyGrid
* propGrid
,
2596 wxValidator
* validator
,
2597 const wxString
& value
)
2602 wxTextCtrl
* tc
= m_textCtrl
;
2607 tc
= new wxTextCtrl( propGrid
, wxPG_SUBID_TEMP1
, wxEmptyString
,
2608 wxPoint(30000,30000));
2615 tc
->SetValue(value
);
2617 validator
->SetWindow(tc
);
2618 bool res
= validator
->Validate(propGrid
);
2623 bool wxPGInDialogValidator::DoValidate( wxPropertyGrid
* WXUNUSED(propGrid
),
2624 wxValidator
* WXUNUSED(validator
),
2625 const wxString
& WXUNUSED(value
) )
2631 // -----------------------------------------------------------------------
2633 #endif // wxUSE_PROPGRID