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 GenerateComposedValue(s
, 0);
87 wxStringProperty::~wxStringProperty() { }
89 wxString
wxStringProperty::GetValueAsString( int argFlags
) const
91 wxString s
= m_value
.GetString();
93 if ( GetChildCount() && HasFlag(wxPG_PROP_COMPOSED_VALUE
) )
95 // Value stored in m_value is non-editable, non-full value
96 if ( (argFlags
& wxPG_FULL_VALUE
) || (argFlags
& wxPG_EDITABLE_VALUE
) )
97 GenerateComposedValue(s
, argFlags
);
102 // If string is password and value is for visual purposes,
103 // then return asterisks instead the actual string.
104 if ( (m_flags
& wxPG_PROP_PASSWORD
) && !(argFlags
& (wxPG_FULL_VALUE
|wxPG_EDITABLE_VALUE
)) )
105 return wxString(wxChar('*'), s
.Length());
110 bool wxStringProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int argFlags
) const
112 if ( GetChildCount() && HasFlag(wxPG_PROP_COMPOSED_VALUE
) )
113 return wxPGProperty::StringToValue(variant
, text
, argFlags
);
115 if ( m_value
.GetString() != text
)
124 bool wxStringProperty::DoSetAttribute( const wxString
& name
, wxVariant
& value
)
126 if ( name
== wxPG_STRING_PASSWORD
)
128 m_flags
&= ~(wxPG_PROP_PASSWORD
);
129 if ( wxPGVariantToInt(value
) ) m_flags
|= wxPG_PROP_PASSWORD
;
136 // -----------------------------------------------------------------------
138 // -----------------------------------------------------------------------
140 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxIntProperty
,wxPGProperty
,
143 wxIntProperty::wxIntProperty( const wxString
& label
, const wxString
& name
,
144 long value
) : wxPGProperty(label
,name
)
149 wxIntProperty::wxIntProperty( const wxString
& label
, const wxString
& name
,
150 const wxLongLong
& value
) : wxPGProperty(label
,name
)
152 SetValue(WXVARIANT(value
));
155 wxIntProperty::~wxIntProperty() { }
157 wxString
wxIntProperty::GetValueAsString( int ) const
159 if ( m_value
.GetType() == wxPG_VARIANT_TYPE_LONG
)
161 return wxString::Format(wxS("%li"),m_value
.GetLong());
163 else if ( m_value
.GetType() == wxLongLong_VariantType
)
167 return ll
.ToString();
170 return wxEmptyString
;
173 bool wxIntProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int argFlags
) const
178 if ( text
.length() == 0 )
184 // We know it is a number, but let's still check
186 if ( text
.IsNumber() )
188 // Remove leading zeroes, so that the number is not interpreted as octal
189 wxString::const_iterator i
= text
.begin();
190 wxString::const_iterator iMax
= text
.end() - 1; // Let's allow one, last zero though
192 int firstNonZeroPos
= 0;
194 for ( ; i
!= iMax
; i
++ )
197 if ( c
!= wxS('0') && c
!= wxS(' ') )
202 wxString useText
= text
.substr(firstNonZeroPos
, text
.length() - firstNonZeroPos
);
204 wxString variantType
= variant
.GetType();
205 bool isPrevLong
= variantType
== wxPG_VARIANT_TYPE_LONG
;
207 wxLongLong_t value64
= 0;
209 if ( useText
.ToLongLong(&value64
, 10) &&
210 ( value64
>= INT_MAX
|| value64
<= INT_MIN
)
213 bool doChangeValue
= isPrevLong
;
215 if ( !isPrevLong
&& variantType
== wxLongLong_VariantType
)
219 if ( oldValue
.GetValue() != value64
)
220 doChangeValue
= true;
225 wxLongLong
ll(value64
);
231 if ( useText
.ToLong( &value32
, 0 ) )
233 if ( !isPrevLong
|| m_value
.GetLong() != value32
)
240 else if ( argFlags
& wxPG_REPORT_ERROR
)
246 bool wxIntProperty::IntToValue( wxVariant
& variant
, int value
, int WXUNUSED(argFlags
) ) const
248 if ( variant
.GetType() != wxPG_VARIANT_TYPE_LONG
|| variant
.GetLong() != value
)
250 variant
= (long)value
;
256 bool wxIntProperty::DoValidation( const wxPGProperty
* property
, wxLongLong_t
& value
, wxPGValidationInfo
* pValidationInfo
, int mode
)
259 wxLongLong_t min
= wxINT64_MIN
;
260 wxLongLong_t max
= wxINT64_MAX
;
265 variant
= property
->GetAttribute(wxPGGlobalVars
->m_strMin
);
266 if ( !variant
.IsNull() )
268 wxPGVariantToLongLong(variant
, &min
);
272 variant
= property
->GetAttribute(wxPGGlobalVars
->m_strMax
);
273 if ( !variant
.IsNull() )
275 wxPGVariantToLongLong(variant
, &max
);
283 if ( mode
== wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE
)
284 pValidationInfo
->m_failureMessage
= wxString::Format(_("Value must be %lld or higher"),min
);
285 else if ( mode
== wxPG_PROPERTY_VALIDATION_SATURATE
)
288 value
= max
- (min
- value
);
297 if ( mode
== wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE
)
298 pValidationInfo
->m_failureMessage
= wxString::Format(_("Value must be %lld or higher"),min
);
299 else if ( mode
== wxPG_PROPERTY_VALIDATION_SATURATE
)
302 value
= min
+ (value
- max
);
309 bool wxIntProperty::ValidateValue( wxVariant
& value
, wxPGValidationInfo
& validationInfo
) const
312 if ( wxPGVariantToLongLong(value
, &ll
) )
313 return DoValidation(this, ll
, &validationInfo
, wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE
);
317 wxValidator
* wxIntProperty::GetClassValidator()
320 WX_PG_DOGETVALIDATOR_ENTRY()
322 // Atleast wxPython 2.6.2.1 required that the string argument is given
324 wxTextValidator
* validator
= new wxTextValidator(wxFILTER_NUMERIC
,&v
);
326 WX_PG_DOGETVALIDATOR_EXIT(validator
)
332 wxValidator
* wxIntProperty::DoGetValidator() const
334 return GetClassValidator();
337 // -----------------------------------------------------------------------
339 // -----------------------------------------------------------------------
342 #define wxPG_UINT_TEMPLATE_MAX 8
344 static const wxChar
* gs_uintTemplates32
[wxPG_UINT_TEMPLATE_MAX
] = {
345 wxT("%x"),wxT("0x%x"),wxT("$%x"),
346 wxT("%X"),wxT("0x%X"),wxT("$%X"),
350 static const wxChar
* gs_uintTemplates64
[wxPG_UINT_TEMPLATE_MAX
] = {
351 wxT("%") wxLongLongFmtSpec
wxT("x"),
352 wxT("0x%") wxLongLongFmtSpec
wxT("x"),
353 wxT("$%") wxLongLongFmtSpec
wxT("x"),
354 wxT("%") wxLongLongFmtSpec
wxT("X"),
355 wxT("0x%") wxLongLongFmtSpec
wxT("X"),
356 wxT("$%") wxLongLongFmtSpec
wxT("X"),
357 wxT("%") wxLongLongFmtSpec
wxT("u"),
358 wxT("%") wxLongLongFmtSpec
wxT("o")
361 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxUIntProperty
,wxPGProperty
,
362 long,unsigned long,TextCtrl
)
364 void wxUIntProperty::Init()
366 m_base
= 6; // This is magic number for dec base (must be same as in setattribute)
368 m_prefix
= wxPG_PREFIX_NONE
;
371 wxUIntProperty::wxUIntProperty( const wxString
& label
, const wxString
& name
,
372 unsigned long value
) : wxPGProperty(label
,name
)
375 SetValue((long)value
);
378 wxUIntProperty::wxUIntProperty( const wxString
& label
, const wxString
& name
,
379 const wxULongLong
& value
) : wxPGProperty(label
,name
)
382 SetValue(WXVARIANT(value
));
385 wxUIntProperty::~wxUIntProperty() { }
387 wxString
wxUIntProperty::GetValueAsString( int ) const
389 size_t index
= m_base
+ m_prefix
;
390 if ( index
>= wxPG_UINT_TEMPLATE_MAX
)
391 index
= wxPG_BASE_DEC
;
393 if ( m_value
.GetType() == wxPG_VARIANT_TYPE_LONG
)
395 return wxString::Format(gs_uintTemplates32
[index
], (unsigned long)m_value
.GetLong());
401 return wxString::Format(gs_uintTemplates64
[index
], ull
.GetValue());
404 bool wxUIntProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int WXUNUSED(argFlags
) ) const
406 wxString variantType
= variant
.GetType();
407 bool isPrevLong
= variantType
== wxPG_VARIANT_TYPE_LONG
;
409 if ( text
.length() == 0 )
416 if ( text
[0] == wxS('$') )
419 wxULongLong_t value64
= 0;
420 wxString s
= text
.substr(start
, text
.length() - start
);
422 if ( s
.ToULongLong(&value64
, (unsigned int)m_realBase
) )
424 if ( value64
>= LONG_MAX
)
426 bool doChangeValue
= isPrevLong
;
428 if ( !isPrevLong
&& variantType
== wxULongLong_VariantType
)
430 wxULongLong oldValue
;
432 if ( oldValue
.GetValue() != value64
)
433 doChangeValue
= true;
438 wxULongLong
ull(value64
);
445 unsigned long value32
= wxLongLong(value64
).GetLo();
446 if ( !isPrevLong
|| m_value
.GetLong() != (long)value32
)
448 variant
= (long)value32
;
457 bool wxUIntProperty::IntToValue( wxVariant
& variant
, int number
, int WXUNUSED(argFlags
) ) const
459 if ( m_value
!= (long)number
)
461 variant
= (long)number
;
468 #define wxUINT64_MAX ULLONG_MAX
469 #define wxUINT64_MIN wxULL(0)
471 #define wxUINT64_MAX wxULL(0xFFFFFFFFFFFFFFFF)
472 #define wxUINT64_MIN wxULL(0)
475 bool wxUIntProperty::ValidateValue( wxVariant
& value
, wxPGValidationInfo
& validationInfo
) const
479 if ( wxPGVariantToULongLong(value
, &ll
) )
481 wxULongLong_t min
= wxUINT64_MIN
;
482 wxULongLong_t max
= wxUINT64_MAX
;
485 variant
= GetAttribute(wxPGGlobalVars
->m_strMin
);
486 if ( !variant
.IsNull() )
488 wxPGVariantToULongLong(variant
, &min
);
491 validationInfo
.m_failureMessage
= wxString::Format(_("Value must be %llu or higher"),min
);
495 variant
= GetAttribute(wxPGGlobalVars
->m_strMax
);
496 if ( !variant
.IsNull() )
498 wxPGVariantToULongLong(variant
, &max
);
501 validationInfo
.m_failureMessage
= wxString::Format(_("Value must be %llu or less"),max
);
509 bool wxUIntProperty::DoSetAttribute( const wxString
& name
, wxVariant
& value
)
511 if ( name
== wxPG_UINT_BASE
)
513 int val
= value
.GetLong();
515 m_realBase
= (wxByte
) val
;
516 if ( m_realBase
> 16 )
520 // Translate logical base to a template array index
522 if ( val
== wxPG_BASE_HEX
)
524 else if ( val
== wxPG_BASE_DEC
)
526 else if ( val
== wxPG_BASE_HEXL
)
530 else if ( name
== wxPG_UINT_PREFIX
)
532 m_prefix
= (wxByte
) value
.GetLong();
538 // -----------------------------------------------------------------------
540 // -----------------------------------------------------------------------
542 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxFloatProperty
,wxPGProperty
,
543 double,double,TextCtrl
)
545 wxFloatProperty::wxFloatProperty( const wxString
& label
,
546 const wxString
& name
,
548 : wxPGProperty(label
,name
)
554 wxFloatProperty::~wxFloatProperty() { }
556 // This helper method provides standard way for floating point-using
557 // properties to convert values to string.
558 void wxPropertyGrid::DoubleToString(wxString
& target
,
562 wxString
* precTemplate
)
564 if ( precision
>= 0 )
568 precTemplate
= &text1
;
570 if ( !precTemplate
->length() )
572 *precTemplate
= wxS("%.");
573 *precTemplate
<< wxString::Format( wxS("%i"), precision
);
574 *precTemplate
<< wxS('f');
577 target
.Printf( precTemplate
->c_str(), value
);
581 target
.Printf( wxS("%f"), value
);
584 if ( removeZeroes
&& precision
!= 0 && target
.length() )
586 // Remove excess zeroes (do not remove this code just yet,
587 // since sprintf can't do the same consistently across platforms).
588 wxString::const_iterator i
= target
.end() - 1;
589 size_t new_len
= target
.length() - 1;
591 for ( ; i
!= target
.begin(); i
-- )
593 if ( *i
!= wxS('0') )
598 wxChar cur_char
= *i
;
599 if ( cur_char
!= wxS('.') && cur_char
!= wxS(',') )
602 if ( new_len
!= target
.length() )
603 target
.resize(new_len
);
607 wxString
wxFloatProperty::GetValueAsString( int argFlags
) const
610 if ( !m_value
.IsNull() )
612 wxPropertyGrid::DoubleToString(text
,
615 !(argFlags
& wxPG_FULL_VALUE
),
621 bool wxFloatProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int argFlags
) const
626 if ( text
.length() == 0 )
632 bool res
= text
.ToDouble(&value
);
635 if ( m_value
!= value
)
641 else if ( argFlags
& wxPG_REPORT_ERROR
)
647 bool wxFloatProperty::DoValidation( const wxPGProperty
* property
, double& value
, wxPGValidationInfo
* pValidationInfo
, int mode
)
650 double min
= (double)wxINT64_MIN
;
651 double max
= (double)wxINT64_MAX
;
656 variant
= property
->GetAttribute(wxPGGlobalVars
->m_strMin
);
657 if ( !variant
.IsNull() )
659 wxPGVariantToDouble(variant
, &min
);
663 variant
= property
->GetAttribute(wxPGGlobalVars
->m_strMax
);
664 if ( !variant
.IsNull() )
666 wxPGVariantToDouble(variant
, &max
);
674 if ( mode
== wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE
)
675 pValidationInfo
->m_failureMessage
= wxString::Format(_("Value must be %f or higher"),min
);
676 else if ( mode
== wxPG_PROPERTY_VALIDATION_SATURATE
)
679 value
= max
- (min
- value
);
686 wxPGVariantToDouble(variant
, &max
);
689 if ( mode
== wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE
)
690 pValidationInfo
->m_failureMessage
= wxString::Format(_("Value must be %f or less"),max
);
691 else if ( mode
== wxPG_PROPERTY_VALIDATION_SATURATE
)
694 value
= min
+ (value
- max
);
701 bool wxFloatProperty::ValidateValue( wxVariant
& value
, wxPGValidationInfo
& validationInfo
) const
704 if ( wxPGVariantToDouble(value
, &fpv
) )
705 return DoValidation(this, fpv
, &validationInfo
, wxPG_PROPERTY_VALIDATION_ERROR_MESSAGE
);
709 bool wxFloatProperty::DoSetAttribute( const wxString
& name
, wxVariant
& value
)
711 if ( name
== wxPG_FLOAT_PRECISION
)
713 m_precision
= value
.GetLong();
719 wxValidator
* wxFloatProperty::DoGetValidator() const
721 return wxIntProperty::GetClassValidator();
724 // -----------------------------------------------------------------------
726 // -----------------------------------------------------------------------
728 // We cannot use standard WX_PG_IMPLEMENT_PROPERTY_CLASS macro, since
729 // there is a custom GetEditorClass.
731 IMPLEMENT_DYNAMIC_CLASS(wxBoolProperty
, wxPGProperty
)
733 const wxPGEditor
* wxBoolProperty::DoGetEditorClass() const
735 // Select correct editor control.
736 #if wxPG_INCLUDE_CHECKBOX
737 if ( !(m_flags
& wxPG_PROP_USE_CHECKBOX
) )
738 return wxPG_EDITOR(Choice
);
739 return wxPG_EDITOR(CheckBox
);
741 return wxPG_EDITOR(Choice
);
745 wxBoolProperty::wxBoolProperty( const wxString
& label
, const wxString
& name
, bool value
) :
746 wxPGProperty(label
,name
)
748 m_choices
.Assign(wxPGGlobalVars
->m_boolChoices
);
750 SetValue(wxPGVariant_Bool(value
));
752 m_flags
|= wxPG_PROP_USE_DCC
;
755 wxBoolProperty::~wxBoolProperty() { }
757 wxString
wxBoolProperty::GetValueAsString( int argFlags
) const
759 bool value
= m_value
.GetBool();
761 // As a fragment of composite string value,
762 // make it a little more readable.
763 if ( argFlags
& wxPG_COMPOSITE_FRAGMENT
)
771 if ( argFlags
& wxPG_UNEDITABLE_COMPOSITE_FRAGMENT
)
772 return wxEmptyString
;
775 if ( wxPGGlobalVars
->m_autoGetTranslation
)
776 notFmt
= _("Not %s");
778 notFmt
= wxS("Not %s");
780 return wxString::Format(notFmt
.c_str(), m_label
.c_str());
784 if ( !(argFlags
& wxPG_FULL_VALUE
) )
786 return wxPGGlobalVars
->m_boolChoices
[value
?1:0].GetText();
791 if (value
) text
= wxS("true");
792 else text
= wxS("false");
797 bool wxBoolProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int WXUNUSED(argFlags
) ) const
800 if ( text
.CmpNoCase(wxPGGlobalVars
->m_boolChoices
[1].GetText()) == 0 ||
801 text
.CmpNoCase(wxS("true")) == 0 ||
802 text
.CmpNoCase(m_label
) == 0 )
805 if ( text
.length() == 0 )
811 bool oldValue
= m_value
.GetBool();
813 if ( (oldValue
&& !value
) || (!oldValue
&& value
) )
815 variant
= wxPGVariant_Bool(value
);
821 bool wxBoolProperty::IntToValue( wxVariant
& variant
, int value
, int ) const
823 bool boolValue
= value
? true : false;
824 bool oldValue
= m_value
.GetBool();
826 if ( oldValue
!= boolValue
)
828 variant
= wxPGVariant_Bool(boolValue
);
834 bool wxBoolProperty::DoSetAttribute( const wxString
& name
, wxVariant
& value
)
836 #if wxPG_INCLUDE_CHECKBOX
837 if ( name
== wxPG_BOOL_USE_CHECKBOX
)
839 int ival
= wxPGVariantToInt(value
);
841 m_flags
|= wxPG_PROP_USE_CHECKBOX
;
843 m_flags
&= ~(wxPG_PROP_USE_CHECKBOX
);
847 if ( name
== wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING
)
849 int ival
= wxPGVariantToInt(value
);
851 m_flags
|= wxPG_PROP_USE_DCC
;
853 m_flags
&= ~(wxPG_PROP_USE_DCC
);
859 // -----------------------------------------------------------------------
860 // wxBaseEnumProperty
861 // -----------------------------------------------------------------------
863 int wxBaseEnumProperty::ms_nextIndex
= -2;
865 wxBaseEnumProperty::wxBaseEnumProperty( const wxString
& label
, const wxString
& name
)
866 : wxPGProperty(label
,name
)
868 m_value
= wxPGVariant_Zero
;
871 /** If has values array, then returns number at index with value -
872 otherwise just returns the value.
874 int wxBaseEnumProperty::GetIndexForValue( int value
) const
879 void wxBaseEnumProperty::OnSetValue()
881 wxString variantType
= m_value
.GetType();
883 if ( variantType
== wxPG_VARIANT_TYPE_LONG
)
884 ValueFromInt_( m_value
, m_value
.GetLong(), wxPG_FULL_VALUE
);
885 else if ( variantType
== wxPG_VARIANT_TYPE_STRING
)
886 ValueFromString_( m_value
, m_value
.GetString(), 0 );
890 if ( ms_nextIndex
!= -2 )
892 m_index
= ms_nextIndex
;
897 bool wxBaseEnumProperty::ValidateValue( wxVariant
& value
, wxPGValidationInfo
& WXUNUSED(validationInfo
) ) const
899 // Make sure string value is in the list,
900 // unless property has string as preferred value type
901 // To reduce code size, use conversion here as well
902 if ( value
.GetType() == wxPG_VARIANT_TYPE_STRING
&&
903 !this->IsKindOf(CLASSINFO(wxEditEnumProperty
)) )
904 return ValueFromString_( value
, value
.GetString(), wxPG_PROPERTY_SPECIFIC
);
909 wxString
wxBaseEnumProperty::GetValueAsString( int ) const
911 if ( m_value
.GetType() == wxPG_VARIANT_TYPE_STRING
)
912 return m_value
.GetString();
917 const wxString
* pstr
= GetEntry( m_index
, &unusedVal
);
922 return wxEmptyString
;
925 bool wxBaseEnumProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int argFlags
) const
927 return ValueFromString_( variant
, text
, argFlags
);
930 bool wxBaseEnumProperty::IntToValue( wxVariant
& variant
, int intVal
, int argFlags
) const
932 return ValueFromInt_( variant
, intVal
, argFlags
);
935 bool wxBaseEnumProperty::ValueFromString_( wxVariant
& value
, const wxString
& text
, int argFlags
) const
938 const wxString
* entryLabel
;
943 entryLabel
= GetEntry(i
, &entryValue
);
946 if ( text
.CmpNoCase(*entryLabel
) == 0 )
949 useValue
= (long)entryValue
;
954 entryLabel
= GetEntry(i
, &entryValue
);
959 bool isEdit
= this->IsKindOf(CLASSINFO(wxEditEnumProperty
));
961 // If text not any of the choices, store as text instead
962 // (but only if we are wxEditEnumProperty)
963 if ( useIndex
== -1 &&
964 (value
.GetType() != wxPG_VARIANT_TYPE_STRING
|| (m_value
.GetString() != text
)) &&
970 int setAsNextIndex
= -2;
977 else if ( m_index
!= useIndex
)
979 if ( useIndex
!= -1 )
981 setAsNextIndex
= useIndex
;
982 value
= (long)useValue
;
987 value
= wxPGVariant_MinusOne
;
991 if ( setAsNextIndex
!= -2 )
993 // If wxPG_PROPERTY_SPECIFIC is set, then this is done for
994 // validation purposes only, and index must not be changed
995 if ( !(argFlags
& wxPG_PROPERTY_SPECIFIC
) )
996 ms_nextIndex
= setAsNextIndex
;
998 if ( isEdit
|| setAsNextIndex
!= -1 )
1006 bool wxBaseEnumProperty::ValueFromInt_( wxVariant
& variant
, int intVal
, int argFlags
) const
1008 // If wxPG_FULL_VALUE is *not* in argFlags, then intVal is index from combo box.
1012 if ( argFlags
& wxPG_FULL_VALUE
)
1014 ms_nextIndex
= GetIndexForValue( intVal
);
1018 if ( m_index
!= intVal
)
1020 ms_nextIndex
= intVal
;
1024 if ( ms_nextIndex
!= -2 )
1026 if ( !(argFlags
& wxPG_FULL_VALUE
) )
1027 GetEntry(intVal
, &intVal
);
1029 variant
= (long)intVal
;
1037 void wxBaseEnumProperty::SetIndex( int index
)
1043 int wxBaseEnumProperty::GetIndex() const
1045 if ( ms_nextIndex
!= -2 )
1046 return ms_nextIndex
;
1050 // -----------------------------------------------------------------------
1052 // -----------------------------------------------------------------------
1054 IMPLEMENT_DYNAMIC_CLASS(wxEnumProperty
, wxPGProperty
)
1056 WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxEnumProperty
,long,Choice
)
1058 wxEnumProperty::wxEnumProperty( const wxString
& label
, const wxString
& name
, const wxChar
** labels
,
1059 const long* values
, int value
) : wxBaseEnumProperty(label
,name
)
1065 m_choices
.Add(labels
,values
);
1067 if ( GetItemCount() )
1068 SetValue( (long)value
);
1072 wxEnumProperty::wxEnumProperty( const wxString
& label
, const wxString
& name
, const wxChar
** labels
,
1073 const long* values
, wxPGChoices
* choicesCache
, int value
)
1074 : wxBaseEnumProperty(label
,name
)
1078 wxASSERT( choicesCache
);
1080 if ( choicesCache
->IsOk() )
1082 m_choices
.Assign( *choicesCache
);
1083 m_value
= wxPGVariant_Zero
;
1087 m_choices
.Add(labels
,values
);
1089 if ( GetItemCount() )
1090 SetValue( (long)value
);
1094 wxEnumProperty::wxEnumProperty( const wxString
& label
, const wxString
& name
,
1095 const wxArrayString
& labels
, const wxArrayInt
& values
, int value
) : wxBaseEnumProperty(label
,name
)
1099 if ( &labels
&& labels
.size() )
1101 m_choices
.Set(labels
, values
);
1103 if ( GetItemCount() )
1104 SetValue( (long)value
);
1108 wxEnumProperty::wxEnumProperty( const wxString
& label
, const wxString
& name
,
1109 wxPGChoices
& choices
, int value
)
1110 : wxBaseEnumProperty(label
,name
)
1112 m_choices
.Assign( choices
);
1114 if ( GetItemCount() )
1115 SetValue( (long)value
);
1118 int wxEnumProperty::GetIndexForValue( int value
) const
1120 if ( !m_choices
.IsOk() )
1123 if ( m_choices
.HasValues() )
1125 int intVal
= m_choices
.Index(value
);
1133 wxEnumProperty::~wxEnumProperty ()
1137 const wxString
* wxEnumProperty::GetEntry( size_t index
, int* pvalue
) const
1139 if ( m_choices
.IsOk() && index
< m_choices
.GetCount() )
1141 int value
= (int)index
;
1142 if ( m_choices
.HasValue(index
) )
1143 value
= m_choices
.GetValue(index
);
1148 return &m_choices
.GetLabel(index
);
1150 return (const wxString
*) NULL
;
1153 // -----------------------------------------------------------------------
1154 // wxEditEnumProperty
1155 // -----------------------------------------------------------------------
1157 IMPLEMENT_DYNAMIC_CLASS(wxEditEnumProperty
, wxPGProperty
)
1159 WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxEditEnumProperty
,wxString
,ComboBox
)
1161 wxEditEnumProperty::wxEditEnumProperty( const wxString
& label
, const wxString
& name
, const wxChar
** labels
,
1162 const long* values
, const wxString
& value
)
1163 : wxEnumProperty(label
,name
,labels
,values
,0)
1168 wxEditEnumProperty::wxEditEnumProperty( const wxString
& label
, const wxString
& name
, const wxChar
** labels
,
1169 const long* values
, wxPGChoices
* choicesCache
, const wxString
& value
)
1170 : wxEnumProperty(label
,name
,labels
,values
,choicesCache
,0)
1175 wxEditEnumProperty::wxEditEnumProperty( const wxString
& label
, const wxString
& name
,
1176 const wxArrayString
& labels
, const wxArrayInt
& values
, const wxString
& value
)
1177 : wxEnumProperty(label
,name
,labels
,values
,0)
1182 wxEditEnumProperty::wxEditEnumProperty( const wxString
& label
, const wxString
& name
,
1183 wxPGChoices
& choices
, const wxString
& value
)
1184 : wxEnumProperty(label
,name
,choices
,0)
1189 wxEditEnumProperty::~wxEditEnumProperty()
1193 // -----------------------------------------------------------------------
1195 // -----------------------------------------------------------------------
1197 IMPLEMENT_DYNAMIC_CLASS(wxFlagsProperty
,wxPGProperty
)
1199 WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxFlagsProperty
,long,TextCtrl
)
1201 void wxFlagsProperty::Init()
1203 SetFlag(wxPG_PROP_AGGREGATE
); // This is must be done here to support flag props
1204 // with inital zero children.
1206 long value
= m_value
;
1209 // Generate children
1213 unsigned int prevChildCount
= m_children
.GetCount();
1216 if ( prevChildCount
)
1218 wxPropertyGridPageState
* state
= GetParentState();
1220 // State safety check (it may be NULL in immediate parent)
1225 wxPGProperty
* selected
= state
->GetSelection();
1228 if ( selected
->GetParent() == this )
1229 oldSel
= selected
->GetArrIndex();
1230 else if ( selected
== this )
1234 state
->DoClearSelection();
1237 // Delete old children
1238 for ( i
=0; i
<prevChildCount
; i
++ )
1239 delete ( (wxPGProperty
*) m_children
[i
] );
1243 if ( m_choices
.IsOk() )
1245 const wxPGChoices
& choices
= m_choices
;
1247 for ( i
=0; i
<GetItemCount(); i
++ )
1250 if ( choices
.HasValue(i
) )
1251 child_val
= ( value
& choices
.GetValue(i
) )?true:false;
1253 child_val
= ( value
& (1<<i
) )?true:false;
1255 wxPGProperty
* boolProp
;
1256 wxString label
= GetLabel(i
);
1259 if ( wxPGGlobalVars
->m_autoGetTranslation
)
1261 boolProp
= new wxBoolProperty( ::wxGetTranslation(label
), label
, child_val
);
1266 boolProp
= new wxBoolProperty( label
, label
, child_val
);
1271 m_oldChoicesData
= m_choices
.GetDataPtr();
1274 m_oldValue
= m_value
;
1276 if ( prevChildCount
)
1277 SubPropsChanged(oldSel
);
1280 wxFlagsProperty::wxFlagsProperty( const wxString
& label
, const wxString
& name
,
1281 const wxChar
** labels
, const long* values
, long value
) : wxPGProperty(label
,name
)
1283 m_oldChoicesData
= (wxPGChoicesData
*) NULL
;
1287 m_choices
.Set(labels
,values
);
1289 wxASSERT( GetItemCount() );
1295 m_value
= wxPGVariant_Zero
;
1299 wxFlagsProperty::wxFlagsProperty( const wxString
& label
, const wxString
& name
,
1300 const wxArrayString
& labels
, const wxArrayInt
& values
, int value
)
1301 : wxPGProperty(label
,name
)
1303 m_oldChoicesData
= (wxPGChoicesData
*) NULL
;
1305 if ( &labels
&& labels
.size() )
1307 m_choices
.Set(labels
,values
);
1309 wxASSERT( GetItemCount() );
1311 SetValue( (long)value
);
1315 m_value
= wxPGVariant_Zero
;
1319 wxFlagsProperty::wxFlagsProperty( const wxString
& label
, const wxString
& name
,
1320 wxPGChoices
& choices
, long value
)
1321 : wxPGProperty(label
,name
)
1323 m_oldChoicesData
= (wxPGChoicesData
*) NULL
;
1325 if ( choices
.IsOk() )
1327 m_choices
.Assign(choices
);
1329 wxASSERT( GetItemCount() );
1335 m_value
= wxPGVariant_Zero
;
1339 wxFlagsProperty::~wxFlagsProperty()
1343 void wxFlagsProperty::OnSetValue()
1345 if ( !m_choices
.IsOk() || !GetItemCount() )
1347 m_value
= wxPGVariant_Zero
;
1351 long val
= m_value
.GetLong();
1355 // normalize the value (i.e. remove extra flags)
1357 const wxPGChoices
& choices
= m_choices
;
1358 for ( i
= 0; i
< GetItemCount(); i
++ )
1360 if ( choices
.HasValue(i
) )
1361 fullFlags
|= choices
.GetValue(i
);
1363 fullFlags
|= (1<<i
);
1370 // Need to (re)init now?
1371 if ( GetChildCount() != GetItemCount() ||
1372 m_choices
.GetDataPtr() != m_oldChoicesData
)
1378 long newFlags
= m_value
;
1380 if ( newFlags
!= m_oldValue
)
1382 // Set child modified states
1384 const wxPGChoices
& choices
= m_choices
;
1385 for ( i
= 0; i
<GetItemCount(); i
++ )
1389 if ( choices
.HasValue(i
) )
1390 flag
= choices
.GetValue(i
);
1394 if ( (newFlags
& flag
) != (m_oldValue
& flag
) )
1395 Item(i
)->SetFlag( wxPG_PROP_MODIFIED
);
1398 m_oldValue
= newFlags
;
1402 wxString
wxFlagsProperty::GetValueAsString( int ) const
1406 if ( !m_choices
.IsOk() )
1409 long flags
= m_value
;
1411 const wxPGChoices
& choices
= m_choices
;
1413 for ( i
= 0; i
< GetItemCount(); i
++ )
1416 if ( choices
.HasValue(i
) )
1417 doAdd
= ( flags
& choices
.GetValue(i
) );
1419 doAdd
= ( flags
& (1<<i
) );
1423 text
+= choices
.GetLabel(i
);
1428 // remove last comma
1429 if ( text
.Len() > 1 )
1430 text
.Truncate ( text
.Len() - 2 );
1435 // Translate string into flag tokens
1436 bool wxFlagsProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int ) const
1438 if ( !m_choices
.IsOk() )
1442 long oldValue
= m_value
;
1444 // semicolons are no longer valid delimeters
1445 WX_PG_TOKENIZER1_BEGIN(text
,wxS(','))
1447 if ( token
.length() )
1449 // Determine which one it is
1450 long bit
= IdToBit( token
);
1463 WX_PG_TOKENIZER1_END()
1467 if ( newFlags
!= oldValue
)
1473 // Converts string id to a relevant bit.
1474 long wxFlagsProperty::IdToBit( const wxString
& id
) const
1477 for ( i
= 0; i
< GetItemCount(); i
++ )
1479 if ( id
== GetLabel(i
) )
1481 if ( m_choices
.HasValue(i
) )
1482 return m_choices
.GetValue(i
);
1489 void wxFlagsProperty::RefreshChildren()
1491 if ( !m_choices
.IsOk() || !GetChildCount() ) return;
1493 int flags
= m_value
.GetLong();
1495 const wxPGChoices
& choices
= m_choices
;
1497 for ( i
= 0; i
< GetItemCount(); i
++ )
1501 if ( choices
.HasValue(i
) )
1502 flag
= choices
.GetValue(i
);
1506 long subVal
= flags
& flag
;
1507 wxPGProperty
* p
= Item(i
);
1509 if ( subVal
!= (m_oldValue
& flag
) )
1510 p
->SetFlag( wxPG_PROP_MODIFIED
);
1512 p
->SetValue( subVal
?true:false );
1518 void wxFlagsProperty::ChildChanged( wxVariant
& thisValue
, int childIndex
, wxVariant
& childValue
) const
1520 long oldValue
= thisValue
.GetLong();
1521 long val
= childValue
.GetLong();
1522 unsigned long vi
= (1<<childIndex
);
1523 if ( m_choices
.HasValue(childIndex
) ) vi
= m_choices
.GetValue(childIndex
);
1525 thisValue
= (long)(oldValue
| vi
);
1527 thisValue
= (long)(oldValue
& ~(vi
));
1530 // -----------------------------------------------------------------------
1532 // -----------------------------------------------------------------------
1534 IMPLEMENT_DYNAMIC_CLASS(wxDirProperty
, wxLongStringProperty
)
1536 wxDirProperty::wxDirProperty( const wxString
& name
, const wxString
& label
, const wxString
& value
)
1537 : wxLongStringProperty(name
,label
,value
)
1539 m_flags
|= wxPG_NO_ESCAPE
;
1541 wxDirProperty::~wxDirProperty() { }
1543 wxValidator
* wxDirProperty::DoGetValidator() const
1545 return wxFileProperty::GetClassValidator();
1548 bool wxDirProperty::OnButtonClick( wxPropertyGrid
* propGrid
, wxString
& value
)
1550 wxSize
dlg_sz(300,400);
1552 wxDirDialog
dlg( propGrid
,
1553 m_dlgMessage
.length() ? m_dlgMessage
: wxString(_("Choose a directory:")),
1556 #if !wxPG_SMALL_SCREEN
1557 propGrid
->GetGoodEditorDialogPosition(this,dlg_sz
),
1564 if ( dlg
.ShowModal() == wxID_OK
)
1566 value
= dlg
.GetPath();
1572 bool wxDirProperty::DoSetAttribute( const wxString
& name
, wxVariant
& value
)
1574 if ( name
== wxPG_DIR_DIALOG_MESSAGE
)
1576 m_dlgMessage
= value
.GetString();
1582 // -----------------------------------------------------------------------
1583 // wxPGFileDialogAdapter
1584 // -----------------------------------------------------------------------
1586 bool wxPGFileDialogAdapter::DoShowDialog( wxPropertyGrid
* propGrid
, wxPGProperty
* property
)
1588 wxFileProperty
* fileProp
= NULL
;
1592 if ( property
->IsKindOf(CLASSINFO(wxFileProperty
)) )
1594 fileProp
= ((wxFileProperty
*)property
);
1595 path
= fileProp
->m_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();
1683 if ( !m_filename
.HasName() )
1685 m_value
= wxPGVariant_EmptyString
;
1689 // Find index for extension.
1690 if ( m_indFilter
< 0 && fnstr
.length() )
1692 wxString ext
= m_filename
.GetExt();
1695 size_t len
= m_wildcard
.length();
1697 pos
= m_wildcard
.find(wxS("|"), pos
);
1698 while ( pos
!= wxString::npos
&& pos
< (len
-3) )
1700 size_t ext_begin
= pos
+ 3;
1702 pos
= m_wildcard
.find(wxS("|"), ext_begin
);
1703 if ( pos
== wxString::npos
)
1705 wxString found_ext
= m_wildcard
.substr(ext_begin
, pos
-ext_begin
);
1707 if ( found_ext
.length() > 0 )
1709 if ( found_ext
[0] == wxS('*') )
1711 m_indFilter
= curind
;
1714 if ( ext
.CmpNoCase(found_ext
) == 0 )
1716 m_indFilter
= curind
;
1722 pos
= m_wildcard
.find(wxS("|"), pos
+1);
1729 wxString
wxFileProperty::GetValueAsString( int argFlags
) const
1731 // Always return empty string when name component is empty
1732 wxString fullName
= m_filename
.GetFullName();
1733 if ( !fullName
.length() )
1736 if ( argFlags
& wxPG_FULL_VALUE
)
1738 return m_filename
.GetFullPath();
1740 else if ( m_flags
& wxPG_PROP_SHOW_FULL_FILENAME
)
1742 if ( m_basePath
.Length() )
1744 wxFileName
fn2(m_filename
);
1745 fn2
.MakeRelativeTo(m_basePath
);
1746 return fn2
.GetFullPath();
1748 return m_filename
.GetFullPath();
1751 return m_filename
.GetFullName();
1754 wxPGEditorDialogAdapter
* wxFileProperty::GetEditorDialog() const
1756 return new wxPGFileDialogAdapter();
1759 bool wxFileProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int argFlags
) const
1761 if ( (m_flags
& wxPG_PROP_SHOW_FULL_FILENAME
) || (argFlags
& wxPG_FULL_VALUE
) )
1763 if ( m_filename
!= text
)
1771 if ( m_filename
.GetFullName() != text
)
1773 wxFileName fn
= m_filename
;
1774 fn
.SetFullName(text
);
1775 variant
= fn
.GetFullPath();
1783 bool wxFileProperty::DoSetAttribute( const wxString
& name
, wxVariant
& value
)
1785 // Return false on some occasions to make sure those attribs will get
1786 // stored in m_attributes.
1787 if ( name
== wxPG_FILE_SHOW_FULL_PATH
)
1789 if ( wxPGVariantToInt(value
) )
1790 m_flags
|= wxPG_PROP_SHOW_FULL_FILENAME
;
1792 m_flags
&= ~(wxPG_PROP_SHOW_FULL_FILENAME
);
1795 else if ( name
== wxPG_FILE_WILDCARD
)
1797 m_wildcard
= value
.GetString();
1799 else if ( name
== wxPG_FILE_SHOW_RELATIVE_PATH
)
1801 m_basePath
= value
.GetString();
1803 // Make sure wxPG_FILE_SHOW_FULL_PATH is also set
1804 m_flags
|= wxPG_PROP_SHOW_FULL_FILENAME
;
1806 else if ( name
== wxPG_FILE_INITIAL_PATH
)
1808 m_initialPath
= value
.GetString();
1811 else if ( name
== wxPG_FILE_DIALOG_TITLE
)
1813 m_dlgTitle
= value
.GetString();
1819 // -----------------------------------------------------------------------
1820 // wxPGLongStringDialogAdapter
1821 // -----------------------------------------------------------------------
1823 bool wxPGLongStringDialogAdapter::DoShowDialog( wxPropertyGrid
* propGrid
, wxPGProperty
* property
)
1825 wxString val1
= property
->GetValueAsString(0);
1826 wxString val_orig
= val1
;
1829 if ( !property
->HasFlag(wxPG_PROP_NO_ESCAPE
) )
1830 wxPropertyGrid::ExpandEscapeSequences(value
, val1
);
1832 value
= wxString(val1
);
1834 // Run editor dialog.
1835 if ( wxLongStringProperty::DisplayEditorDialog(property
, propGrid
, value
) )
1837 if ( !property
->HasFlag(wxPG_PROP_NO_ESCAPE
) )
1838 wxPropertyGrid::CreateEscapeSequences(val1
,value
);
1842 if ( val1
!= val_orig
)
1851 // -----------------------------------------------------------------------
1852 // wxLongStringProperty
1853 // -----------------------------------------------------------------------
1855 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxLongStringProperty
,wxPGProperty
,
1856 wxString
,const wxString
&,TextCtrlAndButton
)
1858 wxLongStringProperty::wxLongStringProperty( const wxString
& label
, const wxString
& name
,
1859 const wxString
& value
) : wxPGProperty(label
,name
)
1864 wxLongStringProperty::~wxLongStringProperty() {}
1866 wxString
wxLongStringProperty::GetValueAsString( int ) const
1871 bool wxLongStringProperty::OnEvent( wxPropertyGrid
* propGrid
, wxWindow
* WXUNUSED(primary
),
1874 if ( propGrid
->IsMainButtonEvent(event
) )
1877 PrepareValueForDialogEditing(propGrid
);
1879 wxString val1
= GetValueAsString(0);
1880 wxString val_orig
= val1
;
1883 if ( !(m_flags
& wxPG_PROP_NO_ESCAPE
) )
1884 wxPropertyGrid::ExpandEscapeSequences(value
,val1
);
1886 value
= wxString(val1
);
1888 // Run editor dialog.
1889 if ( OnButtonClick(propGrid
,value
) )
1891 if ( !(m_flags
& wxPG_PROP_NO_ESCAPE
) )
1892 wxPropertyGrid::CreateEscapeSequences(val1
,value
);
1896 if ( val1
!= val_orig
)
1898 SetValueInEvent( val1
);
1906 bool wxLongStringProperty::OnButtonClick( wxPropertyGrid
* propGrid
, wxString
& value
)
1908 return DisplayEditorDialog(this, propGrid
, value
);
1911 bool wxLongStringProperty::DisplayEditorDialog( wxPGProperty
* prop
, wxPropertyGrid
* propGrid
, wxString
& value
)
1914 // launch editor dialog
1915 wxDialog
* dlg
= new wxDialog(propGrid
,-1,prop
->GetLabel(),wxDefaultPosition
,wxDefaultSize
,
1916 wxDEFAULT_DIALOG_STYLE
|wxRESIZE_BORDER
|wxCLIP_CHILDREN
);
1918 dlg
->SetFont(propGrid
->GetFont()); // To allow entering chars of the same set as the propGrid
1920 // Multi-line text editor dialog.
1921 #if !wxPG_SMALL_SCREEN
1922 const int spacing
= 8;
1924 const int spacing
= 4;
1926 wxBoxSizer
* topsizer
= new wxBoxSizer( wxVERTICAL
);
1927 wxBoxSizer
* rowsizer
= new wxBoxSizer( wxHORIZONTAL
);
1928 wxTextCtrl
* ed
= new wxTextCtrl(dlg
,11,value
,
1929 wxDefaultPosition
,wxDefaultSize
,wxTE_MULTILINE
);
1931 rowsizer
->Add( ed
, 1, wxEXPAND
|wxALL
, spacing
);
1932 topsizer
->Add( rowsizer
, 1, wxEXPAND
, 0 );
1933 rowsizer
= new wxBoxSizer( wxHORIZONTAL
);
1934 const int but_sz_flags
=
1935 wxALIGN_RIGHT
|wxALIGN_CENTRE_VERTICAL
|wxBOTTOM
|wxLEFT
|wxRIGHT
;
1936 rowsizer
->Add( new wxButton(dlg
,wxID_OK
,_("Ok")),
1937 0, but_sz_flags
, spacing
);
1938 rowsizer
->Add( new wxButton(dlg
,wxID_CANCEL
,_("Cancel")),
1939 0, but_sz_flags
, spacing
);
1940 topsizer
->Add( rowsizer
, 0, wxALIGN_RIGHT
|wxALIGN_CENTRE_VERTICAL
, 0 );
1942 dlg
->SetSizer( topsizer
);
1943 topsizer
->SetSizeHints( dlg
);
1945 #if !wxPG_SMALL_SCREEN
1946 dlg
->SetSize(400,300);
1948 dlg
->Move( propGrid
->GetGoodEditorDialogPosition(prop
,dlg
->GetSize()) );
1951 int res
= dlg
->ShowModal();
1953 if ( res
== wxID_OK
)
1955 value
= ed
->GetValue();
1963 bool wxLongStringProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int ) const
1965 if ( m_value
!= text
)
1973 // -----------------------------------------------------------------------
1974 // wxArrayEditorDialog
1975 // -----------------------------------------------------------------------
1977 BEGIN_EVENT_TABLE(wxArrayEditorDialog
, wxDialog
)
1978 EVT_IDLE(wxArrayEditorDialog::OnIdle
)
1979 EVT_LISTBOX(24, wxArrayEditorDialog::OnListBoxClick
)
1980 EVT_TEXT_ENTER(21, wxArrayEditorDialog::OnAddClick
)
1981 EVT_BUTTON(22, wxArrayEditorDialog::OnAddClick
)
1982 EVT_BUTTON(23, wxArrayEditorDialog::OnDeleteClick
)
1983 EVT_BUTTON(25, wxArrayEditorDialog::OnUpClick
)
1984 EVT_BUTTON(26, wxArrayEditorDialog::OnDownClick
)
1985 EVT_BUTTON(27, wxArrayEditorDialog::OnUpdateClick
)
1986 //EVT_BUTTON(28, wxArrayEditorDialog::OnCustomEditClick)
1989 IMPLEMENT_ABSTRACT_CLASS(wxArrayEditorDialog
, wxDialog
)
1991 #include <wx/statline.h>
1993 // -----------------------------------------------------------------------
1995 void wxArrayEditorDialog::OnIdle(wxIdleEvent
& event
)
1998 // Do control focus detection here.
2001 wxWindow
* focused
= FindFocus();
2003 // This strange focus thing is a workaround for wxGTK wxListBox focus
2005 if ( m_curFocus
== 0 && focused
!= m_edValue
&&
2006 focused
!= m_butAdd
&& focused
!= m_butUpdate
&&
2007 m_lbStrings
->GetSelection() >= 0 )
2009 // ListBox was just focused.
2010 m_butAdd
->Enable(false);
2011 m_butUpdate
->Enable(false);
2012 m_butRemove
->Enable(true);
2013 m_butUp
->Enable(true);
2014 m_butDown
->Enable(true);
2017 else if ( (m_curFocus
== 1 && focused
== m_edValue
) /*|| m_curFocus == 2*/ )
2019 // TextCtrl was just focused.
2020 m_butAdd
->Enable(true);
2021 bool upd_enable
= false;
2022 if ( m_lbStrings
->GetCount() && m_lbStrings
->GetSelection() >= 0 )
2024 m_butUpdate
->Enable(upd_enable
);
2025 m_butRemove
->Enable(false);
2026 m_butUp
->Enable(false);
2027 m_butDown
->Enable(false);
2034 // -----------------------------------------------------------------------
2036 wxArrayEditorDialog::wxArrayEditorDialog()
2042 // -----------------------------------------------------------------------
2044 void wxArrayEditorDialog::Init()
2046 m_custBtText
= (const wxChar
*) NULL
;
2049 // -----------------------------------------------------------------------
2051 wxArrayEditorDialog::wxArrayEditorDialog( wxWindow
*parent
,
2052 const wxString
& message
,
2053 const wxString
& caption
,
2060 Create(parent
,message
,caption
,style
,pos
,sz
);
2063 // -----------------------------------------------------------------------
2065 bool wxArrayEditorDialog::Create( wxWindow
*parent
,
2066 const wxString
& message
,
2067 const wxString
& caption
,
2072 // On wxMAC the dialog shows incorrectly if style is not exactly wxCAPTION
2073 // FIXME: This should be only a temporary fix.
2075 int useStyle
= wxCAPTION
;
2077 int useStyle
= style
;
2080 bool res
= wxDialog::Create(parent
, wxID_ANY
, caption
, pos
, sz
, useStyle
);
2082 SetFont(parent
->GetFont()); // To allow entering chars of the same set as the propGrid
2084 #if !wxPG_SMALL_SCREEN
2085 const int spacing
= 4;
2087 const int spacing
= 3;
2094 const int but_sz_flags
=
2095 wxALIGN_RIGHT
|wxALIGN_CENTRE_VERTICAL
|wxALL
; //wxBOTTOM|wxLEFT|wxRIGHT;
2097 wxBoxSizer
* topsizer
= new wxBoxSizer( wxVERTICAL
);
2100 if ( message
.length() )
2101 topsizer
->Add( new wxStaticText(this,-1,message
),
2102 0, wxALIGN_LEFT
|wxALIGN_CENTRE_VERTICAL
|wxALL
, spacing
);
2105 wxBoxSizer
* rowsizer
= new wxBoxSizer( wxHORIZONTAL
);
2106 m_edValue
= new wxTextCtrl(this,21,wxEmptyString
,
2107 wxDefaultPosition
,wxDefaultSize
,wxTE_PROCESS_ENTER
);
2108 wxValidator
* validator
= GetTextCtrlValidator();
2111 m_edValue
->SetValidator( *validator
);
2114 rowsizer
->Add( m_edValue
,
2115 1, wxALIGN_LEFT
|wxALIGN_CENTRE_VERTICAL
|wxALL
, spacing
);
2118 m_butAdd
= new wxButton(this,22,_("Add"));
2119 rowsizer
->Add( m_butAdd
,
2120 0, wxALIGN_LEFT
|wxALIGN_CENTRE_VERTICAL
|wxTOP
|wxBOTTOM
|wxRIGHT
, spacing
);
2121 topsizer
->Add( rowsizer
, 0, wxEXPAND
, spacing
);
2124 topsizer
->Add( new wxStaticLine(this,-1),
2125 0, wxEXPAND
|wxBOTTOM
|wxLEFT
|wxRIGHT
, spacing
);
2127 rowsizer
= new wxBoxSizer( wxHORIZONTAL
);
2130 m_lbStrings
= new wxListBox(this, 24, wxDefaultPosition
, wxDefaultSize
);
2132 for ( i
=0; i
<ArrayGetCount(); i
++ )
2133 m_lbStrings
->Append( ArrayGet(i
) );
2134 rowsizer
->Add( m_lbStrings
, 1, wxEXPAND
|wxRIGHT
, spacing
);
2136 // Manipulator buttons
2137 wxBoxSizer
* colsizer
= new wxBoxSizer( wxVERTICAL
);
2138 m_butCustom
= (wxButton
*) NULL
;
2141 m_butCustom
= new wxButton(this,28,::wxGetTranslation(m_custBtText
));
2142 colsizer
->Add( m_butCustom
,
2143 0, wxALIGN_CENTER
|wxTOP
/*wxALIGN_LEFT|wxALIGN_CENTRE_VERTICAL|wxTOP|wxBOTTOM|wxRIGHT*/,
2146 m_butUpdate
= new wxButton(this,27,_("Update"));
2147 colsizer
->Add( m_butUpdate
,
2148 0, wxALIGN_CENTER
|wxTOP
, spacing
);
2149 m_butRemove
= new wxButton(this,23,_("Remove"));
2150 colsizer
->Add( m_butRemove
,
2151 0, wxALIGN_CENTER
|wxTOP
, spacing
);
2152 m_butUp
= new wxButton(this,25,_("Up"));
2153 colsizer
->Add( m_butUp
,
2154 0, wxALIGN_CENTER
|wxTOP
, spacing
);
2155 m_butDown
= new wxButton(this,26,_("Down"));
2156 colsizer
->Add( m_butDown
,
2157 0, wxALIGN_CENTER
|wxTOP
, spacing
);
2158 rowsizer
->Add( colsizer
, 0, 0, spacing
);
2160 topsizer
->Add( rowsizer
, 1, wxLEFT
|wxRIGHT
|wxEXPAND
, spacing
);
2163 topsizer
->Add( new wxStaticLine(this,-1),
2164 0, wxEXPAND
|wxTOP
|wxLEFT
|wxRIGHT
, spacing
);
2167 rowsizer
= new wxBoxSizer( wxHORIZONTAL
);
2169 const int but_sz_flags =
2170 wxALIGN_RIGHT|wxALIGN_CENTRE_VERTICAL|wxBOTTOM|wxLEFT|wxRIGHT;
2172 rowsizer
->Add( new wxButton(this,wxID_OK
,_("Ok")),
2173 0, but_sz_flags
, spacing
);
2174 rowsizer
->Add( new wxButton(this,wxID_CANCEL
,_("Cancel")),
2175 0, but_sz_flags
, spacing
);
2176 topsizer
->Add( rowsizer
, 0, wxALIGN_RIGHT
|wxALIGN_CENTRE_VERTICAL
, 0 );
2178 m_edValue
->SetFocus();
2180 SetSizer( topsizer
);
2181 topsizer
->SetSizeHints( this );
2183 #if !wxPG_SMALL_SCREEN
2184 if ( sz
.x
== wxDefaultSize
.x
&&
2185 sz
.y
== wxDefaultSize
.y
)
2186 SetSize( wxSize(275,360) );
2194 // -----------------------------------------------------------------------
2196 void wxArrayEditorDialog::OnAddClick(wxCommandEvent
& )
2198 wxString text
= m_edValue
->GetValue();
2199 if ( text
.length() )
2201 if ( ArrayInsert( text
, -1 ) )
2203 m_lbStrings
->Append( text
);
2210 // -----------------------------------------------------------------------
2212 void wxArrayEditorDialog::OnDeleteClick(wxCommandEvent
& )
2214 int index
= m_lbStrings
->GetSelection();
2217 ArrayRemoveAt( index
);
2218 m_lbStrings
->Delete ( index
);
2223 // -----------------------------------------------------------------------
2225 void wxArrayEditorDialog::OnUpClick(wxCommandEvent
& )
2227 int index
= m_lbStrings
->GetSelection();
2230 ArraySwap(index
-1,index
);
2231 /*wxString old_str = m_array[index-1];
2232 wxString new_str = m_array[index];
2233 m_array[index-1] = new_str;
2234 m_array[index] = old_str;*/
2235 m_lbStrings
->SetString ( index
-1, ArrayGet(index
-1) );
2236 m_lbStrings
->SetString ( index
, ArrayGet(index
) );
2237 m_lbStrings
->SetSelection ( index
-1 );
2242 // -----------------------------------------------------------------------
2244 void wxArrayEditorDialog::OnDownClick(wxCommandEvent
& )
2246 int index
= m_lbStrings
->GetSelection();
2247 int lastStringIndex
= ((int) m_lbStrings
->GetCount()) - 1;
2248 if ( index
>= 0 && index
< lastStringIndex
)
2250 ArraySwap(index
,index
+1);
2251 /*wxString old_str = m_array[index+1];
2252 wxString new_str = m_array[index];
2253 m_array[index+1] = new_str;
2254 m_array[index] = old_str;*/
2255 m_lbStrings
->SetString ( index
+1, ArrayGet(index
+1) );
2256 m_lbStrings
->SetString ( index
, ArrayGet(index
) );
2257 m_lbStrings
->SetSelection ( index
+1 );
2262 // -----------------------------------------------------------------------
2264 void wxArrayEditorDialog::OnUpdateClick(wxCommandEvent
& )
2266 int index
= m_lbStrings
->GetSelection();
2269 wxString str
= m_edValue
->GetValue();
2270 if ( ArraySet(index
,str
) )
2272 m_lbStrings
->SetString ( index
, str
);
2273 //m_array[index] = str;
2279 // -----------------------------------------------------------------------
2281 void wxArrayEditorDialog::OnListBoxClick(wxCommandEvent
& )
2283 int index
= m_lbStrings
->GetSelection();
2286 m_edValue
->SetValue( m_lbStrings
->GetString(index
) );
2290 // -----------------------------------------------------------------------
2291 // wxPGArrayStringEditorDialog
2292 // -----------------------------------------------------------------------
2294 IMPLEMENT_DYNAMIC_CLASS(wxPGArrayStringEditorDialog
, wxArrayEditorDialog
)
2296 BEGIN_EVENT_TABLE(wxPGArrayStringEditorDialog
, wxArrayEditorDialog
)
2297 EVT_BUTTON(28, wxPGArrayStringEditorDialog::OnCustomEditClick
)
2300 // -----------------------------------------------------------------------
2302 wxString
wxPGArrayStringEditorDialog::ArrayGet( size_t index
)
2304 return m_array
[index
];
2307 size_t wxPGArrayStringEditorDialog::ArrayGetCount()
2309 return m_array
.size();
2312 bool wxPGArrayStringEditorDialog::ArrayInsert( const wxString
& str
, int index
)
2317 m_array
.Insert(str
,index
);
2321 bool wxPGArrayStringEditorDialog::ArraySet( size_t index
, const wxString
& str
)
2323 m_array
[index
] = str
;
2327 void wxPGArrayStringEditorDialog::ArrayRemoveAt( int index
)
2329 m_array
.RemoveAt(index
);
2332 void wxPGArrayStringEditorDialog::ArraySwap( size_t first
, size_t second
)
2334 wxString old_str
= m_array
[first
];
2335 wxString new_str
= m_array
[second
];
2336 m_array
[first
] = new_str
;
2337 m_array
[second
] = old_str
;
2340 wxPGArrayStringEditorDialog::wxPGArrayStringEditorDialog()
2341 : wxArrayEditorDialog()
2346 void wxPGArrayStringEditorDialog::Init()
2348 m_pCallingClass
= (wxArrayStringProperty
*) NULL
;
2351 void wxPGArrayStringEditorDialog::OnCustomEditClick(wxCommandEvent
& )
2353 wxASSERT( m_pCallingClass
);
2354 wxString str
= m_edValue
->GetValue();
2355 if ( m_pCallingClass
->OnCustomStringEdit(m_parent
,str
) )
2357 //m_edValue->SetValue ( str );
2358 m_lbStrings
->Append ( str
);
2359 m_array
.Add ( str
);
2364 // -----------------------------------------------------------------------
2365 // wxArrayStringProperty
2366 // -----------------------------------------------------------------------
2368 WX_PG_IMPLEMENT_PROPERTY_CLASS(wxArrayStringProperty
, // Property name
2369 wxPGProperty
, // Property we inherit from
2370 wxArrayString
, // Value type name
2371 const wxArrayString
&, // Value type, as given in constructor
2372 TextCtrlAndButton
) // Initial editor
2374 wxArrayStringProperty::wxArrayStringProperty( const wxString
& label
,
2375 const wxString
& name
,
2376 const wxArrayString
& array
)
2377 : wxPGProperty(label
,name
)
2382 wxArrayStringProperty::~wxArrayStringProperty() { }
2384 void wxArrayStringProperty::OnSetValue()
2386 GenerateValueAsString();
2389 wxString
wxArrayStringProperty::GetValueAsString( int WXUNUSED(argFlags
) ) const
2394 // Converts wxArrayString to a string separated by delimeters and spaces.
2395 // preDelim is useful for "str1" "str2" style. Set flags to 1 to do slash
2397 void wxPropertyGrid::ArrayStringToString( wxString
& dst
, const wxArrayString
& src
,
2398 wxChar preDelim
, wxChar postDelim
,
2404 unsigned int itemCount
= src
.size();
2412 else if ( (flags
& 1) )
2414 preas
[0] = preDelim
;
2421 dst
.append( preas
);
2423 wxASSERT( postDelim
);
2424 wxString
postDelimStr(postDelim
);
2425 //wxString preDelimStr(preDelim);
2427 for ( i
= 0; i
< itemCount
; i
++ )
2429 wxString
str( src
.Item(i
) );
2431 // Do some character conversion.
2432 // Convertes \ to \\ and <preDelim> to \<preDelim>
2433 // Useful when preDelim and postDelim are "\"".
2436 str
.Replace( wxS("\\"), wxS("\\\\"), true );
2438 str
.Replace( preas
, pdr
, true );
2443 if ( i
< (itemCount
-1) )
2445 dst
.append( postDelimStr
);
2446 dst
.append( wxS(" ") );
2447 dst
.append( preas
);
2449 else if ( preDelim
)
2450 dst
.append( postDelimStr
);
2454 #define ARRSTRPROP_ARRAY_TO_STRING(STRING,ARRAY) \
2455 wxPropertyGrid::ArrayStringToString(STRING,ARRAY,wxS('"'),wxS('"'),1);
2457 void wxArrayStringProperty::GenerateValueAsString()
2459 wxArrayString arr
= m_value
.GetArrayString();
2460 ARRSTRPROP_ARRAY_TO_STRING(m_display
, arr
)
2463 // Default implementation doesn't do anything.
2464 bool wxArrayStringProperty::OnCustomStringEdit( wxWindow
*, wxString
& )
2469 wxArrayEditorDialog
* wxArrayStringProperty::CreateEditorDialog()
2471 return new wxPGArrayStringEditorDialog();
2474 bool wxArrayStringProperty::OnButtonClick( wxPropertyGrid
* propGrid
,
2475 wxWindow
* WXUNUSED(primaryCtrl
),
2479 PrepareValueForDialogEditing(propGrid
);
2481 if ( !propGrid
->EditorValidate() )
2484 // Create editor dialog.
2485 wxArrayEditorDialog
* dlg
= CreateEditorDialog();
2486 #if wxUSE_VALIDATORS
2487 wxValidator
* validator
= GetValidator();
2488 wxPGInDialogValidator dialogValidator
;
2491 wxPGArrayStringEditorDialog
* strEdDlg
= wxDynamicCast(dlg
, wxPGArrayStringEditorDialog
);
2494 strEdDlg
->SetCustomButton(cbt
, this);
2496 dlg
->SetDialogValue( wxVariant(m_value
) );
2497 dlg
->Create(propGrid
, wxEmptyString
, m_label
);
2499 #if !wxPG_SMALL_SCREEN
2500 dlg
->Move( propGrid
->GetGoodEditorDialogPosition(this,dlg
->GetSize()) );
2509 int res
= dlg
->ShowModal();
2511 if ( res
== wxID_OK
&& dlg
->IsModified() )
2513 wxVariant value
= dlg
->GetDialogValue();
2514 if ( !value
.IsNull() )
2516 wxArrayString actualValue
= value
.GetArrayString();
2518 ARRSTRPROP_ARRAY_TO_STRING(tempStr
, actualValue
)
2519 #if wxUSE_VALIDATORS
2520 if ( dialogValidator
.DoValidate( propGrid
, validator
, tempStr
) )
2523 SetValueInEvent( actualValue
);
2540 bool wxArrayStringProperty::OnEvent( wxPropertyGrid
* propGrid
,
2544 if ( propGrid
->IsMainButtonEvent(event
) )
2545 return OnButtonClick(propGrid
,primary
,(const wxChar
*) NULL
);
2549 bool wxArrayStringProperty::StringToValue( wxVariant
& variant
, const wxString
& text
, int ) const
2553 WX_PG_TOKENIZER2_BEGIN(text
,wxS('"'))
2555 // Need to replace backslashes with empty characters
2556 // (opposite what is done in GenerateValueString).
2557 token
.Replace ( wxS("\\"), wxEmptyString
, true );
2561 WX_PG_TOKENIZER2_END()
2568 // -----------------------------------------------------------------------
2569 // wxPGInDialogValidator
2570 // -----------------------------------------------------------------------
2572 #if wxUSE_VALIDATORS
2573 bool wxPGInDialogValidator::DoValidate( wxPropertyGrid
* propGrid
,
2574 wxValidator
* validator
,
2575 const wxString
& value
)
2580 wxTextCtrl
* tc
= m_textCtrl
;
2585 tc
= new wxTextCtrl( propGrid
, wxPG_SUBID_TEMP1
, wxEmptyString
,
2586 wxPoint(30000,30000));
2593 tc
->SetValue(value
);
2595 validator
->SetWindow(tc
);
2596 bool res
= validator
->Validate(propGrid
);
2601 bool wxPGInDialogValidator::DoValidate( wxPropertyGrid
* WXUNUSED(propGrid
),
2602 wxValidator
* WXUNUSED(validator
),
2603 const wxString
& WXUNUSED(value
) )
2609 // -----------------------------------------------------------------------
2611 #endif // wxUSE_PROPGRID