solemnwarning/wxwidgets
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 4

Use enum class to implement wxPGPropValFormatFlags as bitmask

Browse source 
This is for better type safety of the flags.
This commit is contained in:
Artur Wieczorek 2024-01-06 17:26:12 +01:00
parent 031435bd39
commit ca3acd7a03
21 changed files with 1155 additions and 431 deletions
Download patch file Download diff file Expand all files Collapse all files

138
include/wx/propgrid/advprops.h
View file

@ -136,7 +136,16 @@ public:
const wxFont& value = wxFont());
virtual ~wxFontProperty() = default;
virtual void OnSetValue() override;
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const override
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
virtual wxVariant ChildChanged( wxVariant& thisValue,
int childIndex,
wxVariant& childValue ) const override;
@ -168,23 +177,60 @@ public:
virtual ~wxSystemColourProperty() = default;
virtual void OnSetValue() override;
virtual bool IntToValue(wxVariant& variant,
int number,
int argFlags = 0) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use IntToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool IntToValue(wxVariant& variant, int number,
int flags) const override
{
m_oldIntToValueCalled = true;
return IntToValue(variant, number, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool IntToValue(wxVariant& variant, int number,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
// Override in derived class to customize how colours are printed as
// strings.
virtual wxString ColourToString( const wxColour& col, int index,
int argFlags = 0 ) const;
#if WXWIN_COMPATIBILITY_3_2
mutable bool m_oldColourToStringCalled = false;
wxString ColourToStringWithCheck(const wxColour& col, int index,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
wxDEPRECATED_BUT_USED_INTERNALLY_MSG("use ColourToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ColourToString(const wxColour& col, int index,
int flags) const
{
m_oldColourToStringCalled = true;
return ColourToString(col, index, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ColourToString(const wxColour& col, int index,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
// Returns index of entry that triggers colour picker dialog
// (default is last).
virtual int GetCustomColourIndex() const;
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const override;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const override
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use StringToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool StringToValue(wxVariant& variant, const wxString& text,
int flags) const override
{
m_oldStringToValueCalled = true;
return StringToValue(variant, text, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
virtual bool OnEvent( wxPropertyGrid* propgrid,
wxWindow* primary, wxEvent& event ) override;
virtual bool DoSetAttribute( const wxString& name, wxVariant& value ) override;
@ -240,7 +286,16 @@ public:
const wxColour& value = *wxWHITE );
virtual ~wxColourProperty() = default;
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const override
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
virtual wxColour GetColour( int index ) const override;
protected:
@ -262,7 +317,16 @@ class WXDLLIMPEXP_PROPGRID wxCursorProperty : public wxEnumProperty
int value = 0 );
virtual ~wxCursorProperty() = default;
virtual wxString ValueToString(wxVariant& value, int argFlags = 0) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const override
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
virtual wxSize OnMeasureImage( int item ) const override;
virtual void OnCustomPaint( wxDC& dc,
const wxRect& rect, wxPGPaintData& paintdata ) override;
@ -332,10 +396,27 @@ public:
virtual ~wxMultiChoiceProperty() = default;
virtual void OnSetValue() override;
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const override;
virtual bool StringToValue(wxVariant& variant,
const wxString& text,
int argFlags = 0) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const override
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use StringToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool StringToValue(wxVariant& variant, const wxString& text,
int flags) const override
{
m_oldStringToValueCalled = true;
return StringToValue(variant, text, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
virtual bool DoSetAttribute( const wxString& name, wxVariant& value ) override;
wxArrayInt GetValueAsArrayInt() const
@ -382,10 +463,27 @@ public:
virtual ~wxDateProperty() = default;
virtual void OnSetValue() override;
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const override;
virtual bool StringToValue(wxVariant& variant,
const wxString& text,
int argFlags = 0) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const override
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual bool StringToValue(wxVariant& variant, const wxString& text,
int flags) const override
{
m_oldStringToValueCalled = true;
return StringToValue(variant, text, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
virtual bool DoSetAttribute( const wxString& name, wxVariant& value ) override;

149
include/wx/propgrid/property.h
View file

@ -1088,9 +1088,9 @@ public:
// null wxVariant in normal cases). Translated value must be assigned
// back to it.
// text - Text to be translated into variant.
// argFlags - If wxPG_FULL_VALUE is set, returns complete, storable value instead
// flags - If wxPGPropValFormatFlags::FullValue is set, returns complete, storable value instead
// of displayable one (they may be different).
// If wxPG_COMPOSITE_FRAGMENT is set, text is interpreted as a part of
// If wxPGPropValFormatFlags::CompositeFragment is set, text is interpreted as a part of
// composite property string value (as generated by ValueToString()
// called with this same flag).
// Returns true if resulting wxVariant value was different.
@ -1099,9 +1099,19 @@ public:
// You might want to take into account that m_value is Null variant
// if property value is unspecified (which is usually only case if
// you explicitly enabled that sort behaviour).
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const;
#if WXWIN_COMPATIBILITY_3_2
mutable bool m_oldStringToValueCalled = false;
bool StringToValueWithCheck(wxVariant& variant, const wxString& text, wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
wxDEPRECATED_BUT_USED_INTERNALLY_MSG("use StringToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool StringToValue( wxVariant& variant, const wxString& text,
int flags ) const
{
m_oldStringToValueCalled = true;
return StringToValue(variant, text, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
// Converts integer (possibly a choice selection) into wxVariant value
// appropriate for this property.
@ -1109,7 +1119,7 @@ public:
// variant - On function entry this is the old value (should not be null wxVariant
// in normal cases). Translated value must be assigned back to it.
// number - Integer to be translated into variant.
// argFlags - If wxPG_FULL_VALUE is set, returns complete, storable value
// flags - If wxPGPropValFormatFlags::FullValue is set, returns complete, storable value
// instead of displayable one.
// Returns true if resulting wxVariant value was different.
// Remarks
@ -1122,36 +1132,69 @@ public:
// - You might want to take into account that m_value is Null variant
// if property value is unspecified (which is usually only case if
// you explicitly enabled that sort behaviour).
virtual bool IntToValue( wxVariant& value,
int number,
int argFlags = 0 ) const;
#if WXWIN_COMPATIBILITY_3_2
mutable bool m_oldIntToValueCalled = false;
bool IntToValueWithCheck(wxVariant& variant, int number, wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
wxDEPRECATED_BUT_USED_INTERNALLY_MSG("use IntToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool IntToValue(wxVariant& value, int number, int flags) const
{
m_oldIntToValueCalled = true;
return IntToValue(value, number, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool IntToValue(wxVariant& value, int number,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
// Converts property value into a text representation.
// Parameters:
// value - Value to be converted.
// argFlags - If 0 (default value), then displayed string is returned.
// If wxPG_FULL_VALUE is set, returns complete, storable string value
// instead of displayable. If wxPG_EDITABLE_VALUE is set, returns
// flags - If wxPGPropValFormatFlags::Null (default value), then displayed string is returned.
// If wxPGPropValFormatFlags::FullValue is set, returns complete, storable string value
// instead of displayable. If wxPGPropValFormatFlags::EditableValue is set, returns
// string value that must be editable in textctrl. If
// wxPG_COMPOSITE_FRAGMENT is set, returns text that is appropriate to
// wxPGPropValFormatFlags::CompositeFragment is set, returns text that is appropriate to
// display as a part of string property's composite text
// representation.
// Default implementation calls GenerateComposedValue().
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
#if WXWIN_COMPATIBILITY_3_2
mutable bool m_oldValueToStringCalled = false;
wxString ValueToStringWithCheck(wxVariant& variant, wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
wxDEPRECATED_BUT_USED_INTERNALLY_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value, wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
// Converts string to a value, and if successful, calls SetValue() on it.
// Default behaviour is to do nothing.
// Returns true if value was changed.
bool SetValueFromString( const wxString& text, int flags = wxPG_PROGRAMMATIC_VALUE );
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use SetValueFromString with 'flags' argument as wxPGPropValFormatFlags")
bool SetValueFromString(const wxString& text, int flags)
{
return SetValueFromString(text, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
bool SetValueFromString(const wxString& text, wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::ProgrammaticValue);
// Converts integer to a value, and if successful, calls SetValue() on it.
// Default behaviour is to do nothing.
// Parameters:
// value - Int to get the value from.
// flags - If has wxPG_FULL_VALUE, then the value given is a actual value
// flags - If has wxPGPropValFormatFlags::FullValue, then the value given is a actual value
// and not an index.
// Returns true if value was changed.
bool SetValueFromInt( long value, int flags = 0 );
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use SetValueFromInt with 'flags' argument as wxPGPropValFormatFlags")
bool SetValueFromInt(long value, int flags)
{
return SetValueFromInt(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
bool SetValueFromInt(long value, wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null);
// Returns size of the custom painted image in front of property.
// This method must be overridden to return non-default value if
@ -1382,18 +1425,28 @@ public:
}
// Returns text representation of property's value.
// argFlags - If 0 (default value), then displayed string is returned.
// If wxPG_FULL_VALUE is set, returns complete, storable string value
// instead of displayable. If wxPG_EDITABLE_VALUE is set, returns
// flags - If wxPGPropValFormatFlags::Null (default value), then displayed string is returned.
// If wxPGPropValFormatFlags::FullValue is set, returns complete, storable string value
// instead of displayable. If wxPGPropValFormatFlags::EditableValue is set, returns
// string value that must be editable in textctrl. If
// wxPG_COMPOSITE_FRAGMENT is set, returns text that is appropriate to
// wxPGPropValFormatFlags::CompositeFragment is set, returns text that is appropriate to
// display as a part of string property's composite text
// representation.
// In older versions, this function used to be overridden to convert
// property's value into a string representation. This function is
// now handled by ValueToString(), and overriding this function now
// will result in run-time assertion failure.
virtual wxString GetValueAsString( int argFlags = 0 ) const;
#if WXWIN_COMPATIBILITY_3_2
mutable bool m_oldGetValueAsString = false;
wxString GetValueAsStringWithCheck(wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
wxDEPRECATED_BUT_USED_INTERNALLY_MSG("use GetValueAsString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString GetValueAsString(int flags) const
{
m_oldGetValueAsString = true;
return GetValueAsString(static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString GetValueAsString(wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
// Returns wxPGCell of given column.
// Const version of this member function returns 'default'
@ -1416,7 +1469,12 @@ public:
// Returns property's displayed text.
wxString GetDisplayedString() const
{
return GetValueAsString(0);
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
return GetValueAsStringWithCheck(wxPGPropValFormatFlags::Null);
#else
return GetValueAsString(wxPGPropValFormatFlags::Null);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
}
// Returns property's hint text (shown in empty value cell).
@ -2087,10 +2145,20 @@ protected:
int index = -1,
bool correct_mode = true );
void DoGenerateComposedValue( wxString& text,
int argFlags = wxPG_VALUE_IS_CURRENT,
const wxVariantList* valueOverrides = nullptr,
wxPGHashMapS2S* childResults = nullptr ) const;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use DoGenerateComposedValue with 'flags' argument as wxPGPropValFormatFlags")
void DoGenerateComposedValue(wxString& text, int flags,
const wxVariantList* valueOverrides,
wxPGHashMapS2S* childResults) const
{
DoGenerateComposedValue(text, static_cast<wxPGPropValFormatFlags>(flags),
valueOverrides, childResults);
}
#endif // WXWIN_COMPATIBILITY_3_2
void DoGenerateComposedValue(wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::ValueIsCurrent,
const wxVariantList* valueOverrides = nullptr,
wxPGHashMapS2S* childResults = nullptr) const;
bool DoHide( bool hide, wxPGPropertyValuesFlags flags );
@ -2266,10 +2334,17 @@ public:
wxPGRootProperty( const wxString& name = wxS("<Root>") );
virtual ~wxPGRootProperty() = default;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use StringToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool StringToValue( wxVariant&, const wxString&, int ) const override
{
return false;
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool StringToValue( wxVariant&, const wxString&, wxPGPropValFormatFlags ) const override
{
return false;
}
protected:
};
@ -2292,8 +2367,24 @@ public:
int GetTextExtent( const wxWindow* wnd, const wxFont& font ) const;
virtual wxString ValueToString( wxVariant& value, int argFlags ) const override;
virtual wxString GetValueAsString( int argFlags = 0 ) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const override
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value, wxPGPropValFormatFlags flags) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use GetValueAsString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString GetValueAsString(int flags) const override
{
m_oldGetValueAsString = true;
return GetValueAsString(static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString GetValueAsString(wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
protected:
void SetTextColIndex( unsigned int colInd )

11
include/wx/propgrid/propgrid.h
View file

@ -1032,8 +1032,15 @@ public:
// Returns (visual) text representation of the unspecified
// property value.
// argFlags - For internal use only.
wxString GetUnspecifiedValueText( int argFlags = 0 ) const;
// flags - For internal use only.
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use GetUnspecifiedValueText with 'flags' argument as wxPGPropValFormatFlags")
wxString GetUnspecifiedValueText(int flags) const
{
return GetUnspecifiedValueText(static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
wxString GetUnspecifiedValueText(wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
// Set virtual width for this particular page. Width -1 indicates that the
// virtual width should be disabled.

77
include/wx/propgrid/propgriddefs.h
View file

@ -212,36 +212,93 @@ constexpr bool operator!=(wxPGPropertyValuesFlags a, int b)
// -----------------------------------------------------------------------
// Misc. argument flags.
enum wxPG_MISC_ARG_FLAGS
// Miscellaneous property value format flags
enum class wxPGPropValFormatFlags : int
{
// No flags.
Null = 0,
// Get/Store full value instead of displayed value.
wxPG_FULL_VALUE = 0x00000001,
FullValue = 0x00000001,
// Perform special action in case of unsuccessful conversion.
wxPG_REPORT_ERROR = 0x00000002,
ReportError = 0x00000002,
wxPG_PROPERTY_SPECIFIC = 0x00000004,
PropertySpecific = 0x00000004,
// Get/Store editable value instead of displayed one (should only be
// different in the case of common values)
wxPG_EDITABLE_VALUE = 0x00000008,
EditableValue = 0x00000008,
// Used when dealing with fragments of composite string value
wxPG_COMPOSITE_FRAGMENT = 0x00000010,
CompositeFragment = 0x00000010,
// Means property for which final string value is for cannot really be
// edited.
wxPG_UNEDITABLE_COMPOSITE_FRAGMENT = 0x00000020,
UneditableCompositeFragment = 0x00000020,
// ValueToString() called from GetValueAsString()
// (guarantees that input wxVariant value is current own value)
wxPG_VALUE_IS_CURRENT = 0x00000040,
ValueIsCurrent = 0x00000040,
// Value is being set programmatically (i.e. not by user)
wxPG_PROGRAMMATIC_VALUE = 0x00000080
ProgrammaticValue = 0x00000080
};
constexpr wxPGPropValFormatFlags operator&(wxPGPropValFormatFlags a, wxPGPropValFormatFlags b)
{
return static_cast<wxPGPropValFormatFlags>(static_cast<int>(a) & static_cast<int>(b));
}
constexpr wxPGPropValFormatFlags operator|(wxPGPropValFormatFlags a, wxPGPropValFormatFlags b)
{
return static_cast<wxPGPropValFormatFlags>(static_cast<int>(a) | static_cast<int>(b));
}
inline wxPGPropValFormatFlags operator|=(wxPGPropValFormatFlags& a, wxPGPropValFormatFlags b)
{
return a = a | b;
}
constexpr bool operator!(wxPGPropValFormatFlags a)
{
return static_cast<int>(a) == 0;
}
#if WXWIN_COMPATIBILITY_3_2
constexpr int operator&(int a, wxPGPropValFormatFlags b)
{
return a & static_cast<int>(b);
}
constexpr int operator|(int a, wxPGPropValFormatFlags b)
{
return a | static_cast<int>(b);
}
inline int operator|=(int& a, wxPGPropValFormatFlags b)
{
return a = a | static_cast<int>(b);
}
wxDEPRECATED_MSG("use wxPGPropValFormatFlags::FullValue instead")
constexpr wxPGPropValFormatFlags wxPG_FULL_VALUE { wxPGPropValFormatFlags::FullValue };
wxDEPRECATED_MSG("use wxPGPropValFormatFlags::ReportError instead")
constexpr wxPGPropValFormatFlags wxPG_REPORT_ERROR { wxPGPropValFormatFlags::ReportError };
wxDEPRECATED_MSG("use wxPGPropValFormatFlags::PropertySpecific instead")
constexpr wxPGPropValFormatFlags wxPG_PROPERTY_SPECIFIC { wxPGPropValFormatFlags::PropertySpecific };
wxDEPRECATED_MSG("use wxPGPropValFormatFlags::EditableValue instead")
constexpr wxPGPropValFormatFlags wxPG_EDITABLE_VALUE { wxPGPropValFormatFlags::EditableValue };
wxDEPRECATED_MSG("use wxPGPropValFormatFlags::CompositeFragment instead")
constexpr wxPGPropValFormatFlags wxPG_COMPOSITE_FRAGMENT { wxPGPropValFormatFlags::CompositeFragment };
wxDEPRECATED_MSG("use wxPGPropValFormatFlags::UneditableCompositeFragment instead")
constexpr wxPGPropValFormatFlags wxPG_UNEDITABLE_COMPOSITE_FRAGMENT { wxPGPropValFormatFlags::UneditableCompositeFragment };
wxDEPRECATED_MSG("use wxPGPropValFormatFlags::ValueIsCurrent instead")
constexpr wxPGPropValFormatFlags wxPG_VALUE_IS_CURRENT { wxPGPropValFormatFlags::ValueIsCurrent };
wxDEPRECATED_MSG("use wxPGPropValFormatFlags::ProgrammaticValue instead")
constexpr wxPGPropValFormatFlags wxPG_PROGRAMMATIC_VALUE { wxPGPropValFormatFlags::ProgrammaticValue };
#endif // WXWIN_COMPATIBILITY_3_2
// -----------------------------------------------------------------------
// wxPGProperty::SetValue() flags

14
include/wx/propgrid/propgridiface.h
View file

@ -797,22 +797,22 @@ public:
// Sets an attribute for this property.
// name - Text identifier of attribute. See @ref propgrid_property_attributes.
// value - Value of attribute.
// argFlags - Optional. Use wxPGPropertyValuesFlags::Recurse to set the attribute to child
// flags - Optional. Use wxPGPropertyValuesFlags::Recurse to set the attribute to child
// properties recursively.
// Setting attribute's value to null wxVariant will simply remove it
// from property's set of attributes.
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use SetPropertyAttribute with argFlags argument as wxPGPropertyValuesFlags")
wxDEPRECATED_MSG("use SetPropertyAttribute with 'flags' argument as wxPGPropertyValuesFlags")
void SetPropertyAttribute(wxPGPropArg id, const wxString& attrName,
wxVariant value, long argFlags)
wxVariant value, long flags)
{
DoSetPropertyAttribute(id, attrName, value, static_cast<wxPGPropertyValuesFlags>(argFlags));
DoSetPropertyAttribute(id, attrName, value, static_cast<wxPGPropertyValuesFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
void SetPropertyAttribute(wxPGPropArg id, const wxString& attrName, wxVariant value,
wxPGPropertyValuesFlags argFlags = wxPGPropertyValuesFlags::DontRecurse)
wxPGPropertyValuesFlags flags = wxPGPropertyValuesFlags::DontRecurse)
{
DoSetPropertyAttribute(id, attrName, value, argFlags);
DoSetPropertyAttribute(id, attrName, value, flags);
}
// Sets property attribute for all applicable properties.
// Be sure to use this method only after all properties have been
@ -1236,7 +1236,7 @@ protected:
// Intermediate version needed due to wxVariant copying inefficiency
void DoSetPropertyAttribute( wxPGPropArg id,
const wxString& name,
wxVariant& value, wxPGPropertyValuesFlags argFlags );
wxVariant& value, wxPGPropertyValuesFlags flags );
// Empty string object to return from member functions returning const
// wxString&.

370
include/wx/propgrid/props.h
View file

@ -99,10 +99,28 @@ public:
const wxString& value = wxString() );
virtual ~wxStringProperty() = default;
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const override;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const override
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use StringToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool StringToValue( wxVariant& variant, const wxString& text,
int flags ) const override
{
m_oldStringToValueCalled = true;
return StringToValue(variant, text, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
virtual bool DoSetAttribute( const wxString& name, wxVariant& value ) override;
@ -194,15 +212,39 @@ public:
const wxString& name,
const wxLongLong& value );
#endif
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const override;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const override
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual bool StringToValue(wxVariant& variant, const wxString& text,
int flags) const override
{
m_oldStringToValueCalled = true;
return StringToValue(variant, text, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
virtual bool ValidateValue( wxVariant& value,
wxPGValidationInfo& validationInfo ) const override;
virtual bool IntToValue( wxVariant& variant,
int number,
int argFlags = 0 ) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use IntToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool IntToValue(wxVariant& variant, int number, int flags) const override
{
m_oldIntToValueCalled = true;
return IntToValue(variant, number, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool IntToValue(wxVariant& variant, int number,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
static wxValidator* GetClassValidator();
virtual wxValidator* DoGetValidator() const override;
virtual wxVariant AddSpinStepValue(long stepScale) const override;
@ -240,17 +282,42 @@ public:
const wxString& name,
const wxULongLong& value );
#endif
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const override;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const override
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use StringToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool StringToValue(wxVariant& variant, const wxString& text,
int flags) const override
{
m_oldStringToValueCalled = true;
return StringToValue(variant, text, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
virtual bool DoSetAttribute( const wxString& name, wxVariant& value ) override;
virtual bool ValidateValue( wxVariant& value,
wxPGValidationInfo& validationInfo ) const override;
virtual wxValidator* DoGetValidator () const override;
virtual bool IntToValue( wxVariant& variant,
int number,
int argFlags = 0 ) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use IntToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool IntToValue(wxVariant& variant, int number,
int flags) const override
{
m_oldIntToValueCalled = true;
return IntToValue(variant, number, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool IntToValue(wxVariant& variant, int number,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
virtual wxVariant AddSpinStepValue(long stepScale) const override;
protected:
@ -285,10 +352,27 @@ public:
double value = 0.0 );
virtual ~wxFloatProperty() = default;
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const override;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const override
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use StringToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool StringToValue(wxVariant& variant, const wxString& text,
int flags) const override
{
m_oldStringToValueCalled = true;
return StringToValue(variant, text, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
virtual bool DoSetAttribute( const wxString& name, wxVariant& value ) override;
virtual bool ValidateValue( wxVariant& value,
@ -321,12 +405,37 @@ public:
bool value = false );
virtual ~wxBoolProperty() = default;
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const override;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const override;
virtual bool IntToValue( wxVariant& variant,
int number, int argFlags = 0 ) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const override
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use StringToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool StringToValue(wxVariant& variant, const wxString& text,
int flags) const override
{
m_oldStringToValueCalled = true;
return StringToValue(variant, text, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use IntToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool IntToValue(wxVariant& variant, int number, int flags) const override
{
m_oldIntToValueCalled = true;
return IntToValue(variant, number, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool IntToValue(wxVariant& variant, int number,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
virtual bool DoSetAttribute( const wxString& name, wxVariant& value ) override;
};
@ -387,18 +496,41 @@ public:
size_t GetItemCount() const { return m_choices.GetCount(); }
virtual void OnSetValue() override;
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const override;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const override
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value, wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use StringToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool StringToValue(wxVariant& variant, const wxString& text,
int flags) const override
{
m_oldStringToValueCalled = true;
return StringToValue(variant, text, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
virtual bool ValidateValue( wxVariant& value,
wxPGValidationInfo& validationInfo ) const override;
// If wxPG_FULL_VALUE is not set in flags, then the value is interpreted
// If wxPGPropValFormatFlags::FullValue is not set in flags, then the value is interpreted
// as index to choices list. Otherwise, it is actual value.
virtual bool IntToValue( wxVariant& variant,
int number,
int argFlags = 0 ) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use IntToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool IntToValue(wxVariant& variant, int number, int flags) const override
{
m_oldIntToValueCalled = true;
return IntToValue(variant, number, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool IntToValue(wxVariant& variant, int number,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
//
// Additional virtuals
@ -420,25 +552,38 @@ protected:
wxDEPRECATED_MSG("use ValueFromString_(wxVariant&, int*, const wxString&, int) function instead")
bool ValueFromString_( wxVariant& value,
const wxString& text,
int argFlags ) const
int flags ) const
{
return ValueFromString_(value, nullptr, text, argFlags);
return ValueFromString_(value, nullptr, text, static_cast<wxPGPropValFormatFlags>(flags));
}
wxDEPRECATED_MSG("use ValueFromInt_(wxVariant&, int*, int, int) function instead")
bool ValueFromInt_( wxVariant& value, int intVal, int argFlags ) const
bool ValueFromInt_( wxVariant& value, int intVal, int flags ) const
{
return ValueFromInt_(value, nullptr, intVal, argFlags);
return ValueFromInt_(value, nullptr, intVal, static_cast<wxPGPropValFormatFlags>(flags));
}
wxDEPRECATED_MSG("don't use ResetNextIndex() function")
static void ResetNextIndex() { }
#endif
// Converts text to value and returns corresponding index in the collection
bool ValueFromString_(wxVariant& value,
int* pIndex,
const wxString& text,
int argFlags) const;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueFromString_ with 'flags' argument as wxPGPropValFormatFlags")
bool ValueFromString_(wxVariant& value, int* pIndex,
const wxString& text, int flags) const
{
return ValueFromString_(value, pIndex, text, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
bool ValueFromString_(wxVariant& value, int* pIndex,
const wxString& text, wxPGPropValFormatFlags flags) const;
// Converts number to value and returns corresponding index in the collection
bool ValueFromInt_(wxVariant& value, int* pIndex, int intVal, int argFlags) const;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueFromInt_ with 'flags' argument as wxPGPropValFormatFlags")
bool ValueFromInt_(wxVariant& value, int* pIndex, int intVal, int flags) const
{
return ValueFromInt_(value, pIndex, intVal, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
bool ValueFromInt_(wxVariant& value, int* pIndex, int intVal, wxPGPropValFormatFlags flags) const;
private:
// This is private so that classes are guaranteed to use GetIndex
@ -482,9 +627,17 @@ public:
virtual ~wxEditEnumProperty() = default;
void OnSetValue() override;
bool StringToValue(wxVariant& variant,
const wxString& text,
int argFlags = 0) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use StringToValue with 'flags' argument as wxPGPropValFormatFlags")
bool StringToValue(wxVariant& variant, const wxString& text,
int flags) const override
{
m_oldStringToValueCalled = true;
return StringToValue(variant, text, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
bool ValidateValue(wxVariant& value,
wxPGValidationInfo& validationInfo) const override;
@ -524,10 +677,27 @@ public:
virtual ~wxFlagsProperty () = default;
virtual void OnSetValue() override;
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const override;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int flags ) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const override
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use StringToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool StringToValue(wxVariant& variant, const wxString& text,
int flags) const override
{
m_oldStringToValueCalled = true;
return StringToValue(variant, text, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags) const override;
virtual wxVariant ChildChanged( wxVariant& thisValue,
int childIndex,
wxVariant& childValue ) const override;
@ -597,10 +767,26 @@ public:
virtual ~wxFileProperty() = default;
virtual void OnSetValue() override;
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const override;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const override
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value, wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use StringToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool StringToValue(wxVariant& variant, const wxString& text,
int flags) const override
{
m_oldStringToValueCalled = true;
return StringToValue(variant, text, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
virtual bool DoSetAttribute( const wxString& name, wxVariant& value ) override;
static wxValidator* GetClassValidator();
@ -639,10 +825,27 @@ public:
const wxString& value = wxString() );
virtual ~wxLongStringProperty() = default;
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const override;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const override
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use StringToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool StringToValue(wxVariant& variant, const wxString& text,
int flags) const override
{
m_oldStringToValueCalled = true;
return StringToValue(variant, text, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
protected:
virtual bool DisplayEditorDialog(wxPropertyGrid* pg, wxVariant& value) override;
@ -661,9 +864,27 @@ public:
const wxString& value = wxString() );
virtual ~wxDirProperty() = default;
virtual wxString ValueToString(wxVariant& value, int argFlags = 0) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const override
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use StringToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool StringToValue(wxVariant& variant, const wxString& text,
int argFlags = 0) const override;
int flags) const override
{
m_oldStringToValueCalled = true;
return StringToValue(variant, text, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
#if WXWIN_COMPATIBILITY_3_0
virtual bool DoSetAttribute(const wxString& name, wxVariant& value) override;
#endif // WXWIN_COMPATIBILITY_3_0
@ -686,10 +907,27 @@ public:
virtual ~wxArrayStringProperty() = default;
virtual void OnSetValue() override;
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const override;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use ValueToString with 'flags' argument as wxPGPropValFormatFlags")
virtual wxString ValueToString(wxVariant& value, int flags) const override
{
m_oldValueToStringCalled = true;
return ValueToString(value, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
#if WXWIN_COMPATIBILITY_3_2
wxDEPRECATED_MSG("use StringToValue with 'flags' argument as wxPGPropValFormatFlags")
virtual bool StringToValue(wxVariant& variant, const wxString& text,
int flags) const override
{
m_oldStringToValueCalled = true;
return StringToValue(variant, text, static_cast<wxPGPropValFormatFlags>(flags));
}
#endif // WXWIN_COMPATIBILITY_3_2
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
virtual bool DoSetAttribute( const wxString& name, wxVariant& value ) override;
// Implement in derived class for custom array-to-string conversion.

47
interface/wx/propgrid/advprops.h
View file

@ -77,7 +77,8 @@ public:
const wxFont& value = wxFont());
virtual ~wxFontProperty();
virtual void OnSetValue();
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual wxVariant ChildChanged( wxVariant& thisValue,
int childIndex,
wxVariant& childValue ) const;
@ -107,26 +108,24 @@ public:
virtual ~wxSystemColourProperty();
virtual void OnSetValue();
virtual bool IntToValue(wxVariant& variant,
int number,
int argFlags = 0) const;
virtual bool IntToValue(wxVariant& variant, int number,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
/**
Override in derived class to customize how colours are printed as
/** Override in derived class to customize how colours are printed as
strings.
*/
virtual wxString ColourToString( const wxColour& col, int index,
int argFlags = 0 ) const;
virtual wxString ColourToString(const wxColour& col, int index,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
/** Returns index of entry that triggers colour picker dialog
(default is last).
*/
virtual int GetCustomColourIndex() const;
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const;
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool OnEvent( wxPropertyGrid* propgrid,
wxWindow* primary, wxEvent& event );
virtual bool DoSetAttribute( const wxString& name, wxVariant& value );
@ -134,7 +133,8 @@ public:
virtual void OnCustomPaint( wxDC& dc,
const wxRect& rect, wxPGPaintData& paintdata );
// Helper function to show the colour dialog
/** Helper function to show the colour dialog
*/
bool QueryColourFromUser( wxVariant& variant ) const;
/** Default is to use wxSystemSettings::GetColour(index). Override to use
@ -184,7 +184,8 @@ public:
const wxColour& value = *wxWHITE );
virtual ~wxColourProperty();
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual wxColour GetColour( int index ) const;
protected:
@ -205,6 +206,8 @@ public:
int value = 0 );
virtual ~wxCursorProperty();
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual wxSize OnMeasureImage( int item ) const;
virtual void OnCustomPaint( wxDC& dc,
const wxRect& rect, wxPGPaintData& paintdata );
@ -279,10 +282,10 @@ public:
virtual ~wxMultiChoiceProperty();
virtual void OnSetValue();
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
virtual bool StringToValue(wxVariant& variant,
const wxString& text,
int argFlags = 0) const;
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
wxArrayInt GetValueAsArrayInt() const;
@ -322,10 +325,10 @@ public:
virtual ~wxDateProperty();
virtual void OnSetValue();
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
virtual bool StringToValue(wxVariant& variant,
const wxString& text,
int argFlags = 0) const;
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool DoSetAttribute( const wxString& name, wxVariant& value );

81
interface/wx/propgrid/property.h
View file

@ -822,12 +822,12 @@ enum class wxPGPropertyFlags : int
}
virtual wxString ValueToString( wxVariant& value,
int argFlags ) const
int flags ) const
{
// TODO: Convert given property value to a string
}
virtual bool StringToValue( wxVariant& variant, const wxString& text, int argFlags )
virtual bool StringToValue( wxVariant& variant, const wxString& text, int flags )
{
// TODO: Adapt string to property value.
}
@ -909,12 +909,12 @@ public:
@param text
Text to be translated into variant.
@param argFlags
If ::wxPG_FULL_VALUE is set, returns complete, storable value instead
of displayable one (they may be different).
If ::wxPG_COMPOSITE_FRAGMENT is set, text is interpreted as a part of
composite property string value (as generated by ValueToString()
called with this same flag).
@param flags
If wxPGPropValFormatFlags::FullValue is set, returns complete, storable value
instead of displayable one (they may be different).
If wxPGPropValFormatFlags::CompositeFragment is set, text is interpreted as
a part of composite property string value (as generated by
ValueToString() called with this same flag).
@return Returns @true if resulting wxVariant value was different.
@ -925,7 +925,8 @@ public:
if property value is unspecified (which is usually only case if
you explicitly enabled that sort behaviour).
*/
virtual bool StringToValue( wxVariant& variant, const wxString& text, int argFlags = 0 ) const;
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
/**
Converts integer (possibly a choice selection) into wxVariant value
@ -936,9 +937,9 @@ public:
in normal cases). Translated value must be assigned back to it.
@param number
Integer to be translated into variant.
@param argFlags
If ::wxPG_FULL_VALUE is set, returns complete, storable value instead
of displayable one.
@param flags
If wxPGPropValFormatFlags::FullValue is set, returns complete, storable value
instead of displayable one.
@return Returns @true if resulting wxVariant value was different.
@ -953,24 +954,25 @@ public:
property value is unspecified (which is usually only case if you
explicitly enabled that sort behaviour).
*/
virtual bool IntToValue( wxVariant& variant, int number, int argFlags = 0 ) const;
virtual bool IntToValue(wxVariant& variant, int number,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
/**
Converts property value into a text representation.
@param value
Value to be converted.
@param argFlags
If 0 (default value), then displayed string is returned.
If ::wxPG_FULL_VALUE is set, returns complete, storable string value
instead of displayable. If ::wxPG_EDITABLE_VALUE is set, returns
@param flags
If wxPGPropValFormatFlags::Null (default value), then displayed string is returned.
If wxPGPropValFormatFlags::FullValue is set, returns complete, storable string value
instead of displayable. If wxPGPropValFormatFlags::EditableValue is set, returns
string value that must be editable in textctrl.
If ::wxPG_COMPOSITE_FRAGMENT is set, returns text that is appropriate to
If wxPGPropValFormatFlags::CompositeFragment is set, returns text that is appropriate to
display as a part of string property's composite text representation.
@remarks Default implementation calls GenerateComposedValue().
*/
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
virtual wxString ValueToString(wxVariant& value, wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
/**
Converts string to a value, and if successful, calls SetValue() on it.
@ -979,18 +981,19 @@ public:
@param text
String to get the value from.
@param flags
If ::wxPG_FULL_VALUE is set, the function sets complete, storable
If wxPGPropValFormatFlags::FullValue is set, the function sets complete, storable
value instead of displayable one (they may be different).
::wxPG_PROGRAMMATIC_VALUE flag is used to indicate that value is
wxPGPropValFormatFlags::ProgrammaticValue flag is used to indicate that value is
being set programmatically (i.e. operation is not caused by user
input).
If ::wxPG_REPORT_ERROR is set, a special action should be
If wxPGPropValFormatFlags::ReportError is set, a special action should be
performed if string couldn't have been successfully converted
to the valid value (e.g. a special value can be set in this case).
@return @true if value was changed.
*/
bool SetValueFromString( const wxString& text, int flags = wxPG_PROGRAMMATIC_VALUE );
bool SetValueFromString(const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::ProgrammaticValue);
/**
Converts integer to a value, and if successful, calls SetValue() on it.
@ -999,11 +1002,11 @@ public:
@param value
Int to get the value from.
@param flags
If has ::wxPG_FULL_VALUE, then the value given is an actual value and not an index.
If has wxPGPropValFormatFlags::FullValue, then the value given is an actual value and not an index.
@return @true if value was changed.
*/
bool SetValueFromInt( long value, int flags = 0 );
bool SetValueFromInt(long value, wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null);
/**
Returns size of the custom painted image in front of property. This method
@ -1613,12 +1616,12 @@ public:
/** Returns text representation of property's value.
@param argFlags
If 0 (default value), then displayed string is returned.
If ::wxPG_FULL_VALUE is set, returns complete, storable string value
instead of displayable. If ::wxPG_EDITABLE_VALUE is set, returns
@param flags
If wxPGPropValFormatFlags::Null (default value), then displayed string is returned.
If wxPGPropValFormatFlags::FullValue is set, returns complete, storable string value
instead of displayable. If wxPGPropValFormatFlags::EditableValue is set, returns
string value that must be editable in textctrl. If
::wxPG_COMPOSITE_FRAGMENT is set, returns text that is appropriate to
wxPGPropValFormatFlags::CompositeFragment is set, returns text that is appropriate to
display as a part of string property's composite text
representation.
@ -1627,15 +1630,7 @@ public:
now handled by ValueToString(), and overriding this function now
will result in run-time assertion failure.
*/
virtual wxString GetValueAsString( int argFlags = 0 ) const;
/** Synonymous to GetValueAsString().
@deprecated Use GetValueAsString() instead.
@see GetValueAsString()
*/
wxString GetValueString( int argFlags = 0 ) const;
virtual wxString GetValueAsString(wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
/**
Returns value type used by this property.
@ -2923,7 +2918,7 @@ public:
wxPGRootProperty( const wxString& name = wxS("<Root>") );
virtual ~wxPGRootProperty();
virtual bool StringToValue( wxVariant&, const wxString&, int ) const;
virtual bool StringToValue( wxVariant&, const wxString&, wxPGPropValFormatFlags ) const;
};
// -----------------------------------------------------------------------
@ -2942,10 +2937,10 @@ public:
wxPropertyCategory( const wxString& label,
const wxString& name = wxPG_LABEL );
~wxPropertyCategory();
virtual ~wxPropertyCategory();
int GetTextExtent( const wxWindow* wnd, const wxFont& font ) const;
virtual wxString ValueToString( wxVariant& value, int argFlags ) const;
virtual wxString GetValueAsString( int argFlags = 0 ) const;
virtual wxString ValueToString(wxVariant& value, wxPGPropValFormatFlags flags) const;
virtual wxString GetValueAsString(wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
};

4
interface/wx/propgrid/propgrid.h
View file

@ -851,9 +851,9 @@ public:
Returns (visual) text representation of the unspecified
property value.
@param argFlags For internal use only.
@param flags For internal use only.
*/
wxString GetUnspecifiedValueText( int argFlags = 0 ) const;
wxString GetUnspecifiedValueText(wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
/**
Returns current vertical spacing.

25
interface/wx/propgrid/propgriddefs.h
View file

@ -105,52 +105,57 @@ enum class wxPGPropertyValuesFlags : int
// -----------------------------------------------------------------------
/** Misc argument flags.
/** Miscellaneous property value format flags.
*/
enum wxPG_MISC_ARG_FLAGS
enum class wxPGPropValFormatFlags : int
{
/** No flags.
@hideinitializer
*/
Null = 0,
/** Get/Store full value instead of displayed value.
@hideinitializer
*/
wxPG_FULL_VALUE = 0x00000001,
FullValue = 0x00000001,
/** Perform special action in case of unsuccessful conversion.
@hideinitializer
*/
wxPG_REPORT_ERROR = 0x00000002,
ReportError = 0x00000002,
/**
@hideinitializer
*/
wxPG_PROPERTY_SPECIFIC = 0x00000004,
PropertySpecific = 0x00000004,
/** Get/Store editable value instead of displayed one (should only be
different in the case of common values).
@hideinitializer
*/
wxPG_EDITABLE_VALUE = 0x00000008,
EditableValue = 0x00000008,
/** Used when dealing with fragments of composite string value
@hideinitializer
*/
wxPG_COMPOSITE_FRAGMENT = 0x00000010,
CompositeFragment = 0x00000010,
/** Means property for which final string value is for cannot really be
edited.
@hideinitializer
*/
wxPG_UNEDITABLE_COMPOSITE_FRAGMENT = 0x00000020,
UneditableCompositeFragment = 0x00000020,
/** wxPGProperty::ValueToString() called from wxPGProperty::GetValueAsString()
(guarantees that input wxVariant value is current own value)
@hideinitializer
*/
wxPG_VALUE_IS_CURRENT = 0x00000040,
ValueIsCurrent = 0x00000040,
/** Value is being set programmatically (i.e. not by user)
@hideinitializer
*/
wxPG_PROGRAMMATIC_VALUE = 0x00000080
ProgrammaticValue = 0x00000080
};
// -----------------------------------------------------------------------

4
interface/wx/propgrid/propgridiface.h
View file

@ -844,7 +844,7 @@ public:
Text identifier of attribute. See @ref propgrid_property_attributes.
@param value
Value of attribute.
@param argFlags
@param flags
Optional.
Use wxPGPropertyValuesFlags::Recurse to set the attribute to child
properties recursively.
@ -855,7 +855,7 @@ public:
- Property is refreshed with new settings.
*/
void SetPropertyAttribute(wxPGPropArg id, const wxString& attrName, wxVariant value,
wxPGPropertyValuesFlags argFlags = wxPGPropertyValuesFlags::DontRecurse);
wxPGPropertyValuesFlags flags = wxPGPropertyValuesFlags::DontRecurse);
/**
Sets property attribute for all applicable properties.

125
interface/wx/propgrid/props.h
View file

@ -48,10 +48,10 @@ public:
const wxString& value = wxString() );
virtual ~wxStringProperty();
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const;
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool DoSetAttribute( const wxString& name, wxVariant& value );
@ -215,15 +215,14 @@ public:
wxIntProperty( const wxString& label,
const wxString& name,
const wxLongLong& value );
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const;
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlagsflags = wxPGPropValFormatFlags::Null) const;
virtual bool ValidateValue( wxVariant& value,
wxPGValidationInfo& validationInfo ) const;
virtual bool IntToValue( wxVariant& variant,
int number,
int argFlags = 0 ) const;
virtual bool IntToValue(wxVariant& variant, int number,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
static wxValidator* GetClassValidator();
virtual wxValidator* DoGetValidator() const;
virtual wxVariant AddSpinStepValue(long stepScale) const;
@ -260,17 +259,16 @@ public:
wxUIntProperty( const wxString& label,
const wxString& name,
const wxULongLong& value );
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const;
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool DoSetAttribute( const wxString& name, wxVariant& value );
virtual bool ValidateValue( wxVariant& value,
wxPGValidationInfo& validationInfo ) const;
virtual wxValidator* DoGetValidator () const;
virtual bool IntToValue( wxVariant& variant,
int number,
int argFlags = 0 ) const;
virtual bool IntToValue(wxVariant& variant, int number,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual wxVariant AddSpinStepValue(long stepScale) const;
protected:
@ -299,10 +297,10 @@ public:
double value = 0.0 );
virtual ~wxFloatProperty();
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const;
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool DoSetAttribute( const wxString& name, wxVariant& value );
virtual bool ValidateValue( wxVariant& value,
wxPGValidationInfo& validationInfo ) const;
@ -335,12 +333,12 @@ public:
bool value = false );
virtual ~wxBoolProperty();
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const;
virtual bool IntToValue( wxVariant& variant,
int number, int argFlags = 0 ) const;
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool IntToValue(wxVariant& variant, int number,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool DoSetAttribute( const wxString& name, wxVariant& value );
};
@ -389,18 +387,18 @@ public:
size_t GetItemCount() const;
virtual void OnSetValue();
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const;
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool ValidateValue( wxVariant& value,
wxPGValidationInfo& validationInfo ) const;
// If wxPG_FULL_VALUE is not set in flags, then the value is interpreted
// as index to choices list. Otherwise, it is actual value.
virtual bool IntToValue( wxVariant& variant,
int number,
int argFlags = 0 ) const;
/** If wxPGPropValFormatFlags::FullValue is not set in flags, then the value is interpreted
as index to choices list. Otherwise, it is actual value.
*/
virtual bool IntToValue(wxVariant& variant, int number,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
//
// Additional virtuals
@ -418,13 +416,10 @@ protected:
int GetIndex() const;
void SetIndex( int index );
bool ValueFromString_( wxVariant& value,
const wxString& text,
int argFlags ) const;
bool ValueFromInt_( wxVariant& value, int intVal, int argFlags ) const;
static void ResetNextIndex();
bool ValueFromString_(wxVariant& value, int* pIndex, const wxString& text,
wxPGPropValFormatFlags flags) const;
bool ValueFromInt_(wxVariant& value, int* pIndex, int intVal,
wxPGPropValFormatFlags flags) const;
};
@ -468,6 +463,11 @@ public:
virtual ~wxEditEnumProperty();
void OnSetValue() override;
bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
bool ValidateValue(wxVariant& value,
wxPGValidationInfo& validationInfo) const;
};
@ -506,10 +506,10 @@ public:
virtual ~wxFlagsProperty ();
virtual void OnSetValue();
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int flags ) const;
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags) const;
virtual wxVariant ChildChanged( wxVariant& thisValue,
int childIndex,
wxVariant& childValue ) const;
@ -602,10 +602,10 @@ public:
virtual ~wxFileProperty ();
virtual void OnSetValue();
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const;
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool DoSetAttribute( const wxString& name, wxVariant& value );
static wxValidator* GetClassValidator();
@ -643,10 +643,10 @@ public:
const wxString& value = wxString() );
virtual ~wxLongStringProperty();
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const;
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
protected:
virtual bool DisplayEditorDialog(wxPropertyGrid* pg, wxVariant& value);
@ -669,9 +669,10 @@ public:
const wxString& value = wxString() );
virtual ~wxDirProperty();
virtual wxString ValueToString(wxVariant& value, int argFlags = 0) const;
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool StringToValue(wxVariant& variant, const wxString& text,
int argFlags = 0) const;
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual wxValidator* DoGetValidator() const;
protected:
@ -696,10 +697,10 @@ public:
virtual ~wxArrayStringProperty();
virtual void OnSetValue();
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const;
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool StringToValue(wxVariant& variant, const wxString& text,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const;
virtual bool DoSetAttribute( const wxString& name, wxVariant& value );
/**

10
samples/propgrid/sampleprops.cpp
View file

@ -505,11 +505,11 @@ void wxArrayDoubleProperty::OnSetValue()
}
wxString wxArrayDoubleProperty::ValueToString( wxVariant& value,
int argFlags ) const
wxPGPropValFormatFlags flags ) const
{
wxString s;
if ( argFlags & wxPG_FULL_VALUE )
if ( !!(flags & wxPGPropValFormatFlags::FullValue) )
{
GenerateValueAsString(s,-1,false);
}
@ -571,7 +571,7 @@ bool wxArrayDoubleProperty::DisplayEditorDialog(wxPropertyGrid* pg, wxVariant& v
return false;
}
bool wxArrayDoubleProperty::StringToValue( wxVariant& variant, const wxString& text, int ) const
bool wxArrayDoubleProperty::StringToValue( wxVariant& variant, const wxString& text, wxPGPropValFormatFlags ) const
{
// Add values to a temporary array so that in case
// of error we can opt not to use them.
@ -707,12 +707,12 @@ wxColour MyColourProperty::GetColour(int index) const
return wxColour();
}
wxString MyColourProperty::ColourToString(const wxColour& col, int index, int argFlags) const
wxString MyColourProperty::ColourToString(const wxColour& col, int index, wxPGPropValFormatFlags flags) const
{
if ( index == (int)(m_choices.GetCount() - 1) )
return wxEmptyString;
return wxColourProperty::ColourToString(col, index, argFlags);
return wxColourProperty::ColourToString(col, index, flags);
}
int MyColourProperty::GetCustomColourIndex() const

18
samples/propgrid/sampleprops.h
View file

@ -116,10 +116,16 @@ public:
virtual ~wxArrayDoubleProperty() = default;
virtual void OnSetValue() override;
virtual wxString ValueToString( wxVariant& value, int argFlags = 0 ) const override;
#if WXWIN_COMPATIBILITY_3_2
// To prevent warnings that obsolete methods are hidden by overloads with new signature.
using wxEditorDialogProperty::ValueToString;
using wxEditorDialogProperty::StringToValue;
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ValueToString(wxVariant& value,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
virtual bool StringToValue( wxVariant& variant,
const wxString& text,
int argFlags = 0 ) const override;
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null ) const override;
virtual bool DoSetAttribute( const wxString& name, wxVariant& value ) override;
// Generates cache for displayed text
@ -150,8 +156,12 @@ public:
virtual wxColour GetColour(int index) const override;
virtual wxString ColourToString(const wxColour& col,
int index, int argFlags = 0) const override;
#if WXWIN_COMPATIBILITY_3_2
// To prevent warning that obsolete method is hidden by overload with new signature.
using wxColourProperty::ColourToString;
#endif // WXWIN_COMPATIBILITY_3_2
virtual wxString ColourToString(const wxColour& col, int index,
wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override;
virtual int GetCustomColourIndex() const override;
};

84
src/propgrid/advprops.cpp
View file

@ -334,7 +334,12 @@ bool wxPGSpinCtrlEditor::OnEvent(wxPropertyGrid* propgrid, wxPGProperty* propert
stepScale *= spins;
wxVariant v = prop->AddSpinStepValue(stepScale);
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
SetControlStringValue(prop, propgrid->GetEditorControl(), prop->ValueToStringWithCheck(v));
#else
SetControlStringValue(prop, propgrid->GetEditorControl(), prop->ValueToString(v));
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
return true;
}
}
@ -579,7 +584,7 @@ wxFontProperty::wxFontProperty( const wxString& label, const wxString& name,
wxPGProperty* p = new wxEnumProperty(_("Face Name"), wxS("Face Name"),
*wxPGGlobalVars->m_fontFamilyChoices);
p->SetValueFromString(faceName, wxPG_FULL_VALUE);
p->SetValueFromString(faceName, wxPGPropValFormatFlags::FullValue);
AddPrivateChild( p );
@ -615,9 +620,9 @@ void wxFontProperty::OnSetValue()
}
wxString wxFontProperty::ValueToString( wxVariant& value,
int argFlags ) const
wxPGPropValFormatFlags flags ) const
{
return wxEditorDialogProperty::ValueToString(value, argFlags);
return wxEditorDialogProperty::ValueToString(value, flags);
}
bool wxFontProperty::DisplayEditorDialog(wxPropertyGrid* pg, wxVariant& value)
@ -652,7 +657,7 @@ void wxFontProperty::RefreshChildren()
wxFont font;
font << m_value;
Item(0)->SetValue( (long)font.GetPointSize() );
Item(1)->SetValueFromString( font.GetFaceName(), wxPG_FULL_VALUE );
Item(1)->SetValueFromString( font.GetFaceName(), wxPGPropValFormatFlags::FullValue );
Item(2)->SetValue( (long)font.GetStyle() );
Item(3)->SetValue( (long)font.GetWeight() );
Item(4)->SetValue( font.GetUnderlined() );
@ -1054,15 +1059,35 @@ wxColour wxSystemColourProperty::GetColour( int index ) const
return wxSystemSettings::GetColour( (wxSystemColour)index );
}
#if WXWIN_COMPATIBILITY_3_2
// By call to obsolete function we want to check if user-overriden function is still in use
wxString wxSystemColourProperty::ColourToStringWithCheck(const wxColour& col, int index,
wxPGPropValFormatFlags flags) const
{
m_oldColourToStringCalled = false;
wxString res = ColourToString(col, index, static_cast<int>(flags));
if ( m_oldColourToStringCalled )
{
// Our own function was called - this implies that call was forwarded to the new overriding
// function and there is no need to call it explicitly.
}
else
{ // User-overriden obsolete function was called
wxFAIL_MSG(wxString::Format("in %s use ColourToString with 'flags' argument as wxPGPropValFormatFlags", GetClassInfo()->GetClassName()));
}
return res;
}
#endif // WXWIN_COMPATIBILITY_3_2
wxString wxSystemColourProperty::ColourToString( const wxColour& col,
int index,
int argFlags ) const
wxPGPropValFormatFlags flags ) const
{
if ( index == wxNOT_FOUND )
{
if ( (argFlags & wxPG_FULL_VALUE) || !!(m_flags & wxPGPropertyFlags_ColourHasAlpha) )
if ( !!(flags & wxPGPropValFormatFlags::FullValue) || !!(m_flags & wxPGPropertyFlags_ColourHasAlpha) )
{
return wxString::Format(wxS("(%i,%i,%i,%i)"),
(int)col.Red(),
@ -1085,15 +1110,15 @@ wxString wxSystemColourProperty::ColourToString( const wxColour& col,
}
wxString wxSystemColourProperty::ValueToString( wxVariant& value,
int argFlags ) const
wxPGPropValFormatFlags flags ) const
{
wxColourPropertyValue val = GetVal(&value);
int index;
if ( argFlags & wxPG_VALUE_IS_CURRENT )
if ( !!(flags & wxPGPropValFormatFlags::ValueIsCurrent) )
{
// GetIndex() only works reliably if wxPG_VALUE_IS_CURRENT flag is set,
// GetIndex() only works reliably if wxPGPropValFormatFlags::ValueIsCurrent flag is set,
// but we should use it whenever possible.
index = GetIndex();
@ -1108,7 +1133,12 @@ wxString wxSystemColourProperty::ValueToString( wxVariant& value,
index = m_choices.Index(val.m_type);
}
return ColourToString(val.m_colour, index, argFlags);
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
return ColourToStringWithCheck(val.m_colour, index, flags);
#else
return ColourToString(val.m_colour, index, flags);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
}
@ -1167,14 +1197,14 @@ bool wxSystemColourProperty::QueryColourFromUser( wxVariant& variant ) const
}
bool wxSystemColourProperty::IntToValue( wxVariant& variant, int number, int argFlags ) const
bool wxSystemColourProperty::IntToValue( wxVariant& variant, int number, wxPGPropValFormatFlags flags ) const
{
int index = number;
const int type = m_choices.GetValue(index);
if ( type == wxPG_COLOUR_CUSTOM )
{
if ( !(argFlags & wxPG_PROPERTY_SPECIFIC) )
if ( !(flags & wxPGPropValFormatFlags::PropertySpecific) )
return QueryColourFromUser(variant);
// Call from event handler.
@ -1341,7 +1371,7 @@ void wxSystemColourProperty::OnCustomPaint( wxDC& dc, const wxRect& rect,
}
bool wxSystemColourProperty::StringToValue( wxVariant& value, const wxString& text, int argFlags ) const
bool wxSystemColourProperty::StringToValue( wxVariant& value, const wxString& text, wxPGPropValFormatFlags flags ) const
{
const int custIndex = GetCustomColourIndex();
wxString custColName;
@ -1391,7 +1421,7 @@ bool wxSystemColourProperty::StringToValue( wxVariant& value, const wxString& te
!(m_flags & wxPGPropertyFlags_HideCustomColour) &&
isCustomColour )
{
if ( !(argFlags & wxPG_EDITABLE_VALUE ))
if ( !(flags & wxPGPropValFormatFlags::EditableValue ))
{
// This really should not occur...
// wxASSERT(false);
@ -1400,7 +1430,7 @@ bool wxSystemColourProperty::StringToValue( wxVariant& value, const wxString& te
if ( !QueryColourFromUser(value) )
{
if ( !(argFlags & wxPG_PROPERTY_SPECIFIC) )
if ( !(flags & wxPGPropValFormatFlags::PropertySpecific) )
return false;
// If query for value comes from the event handler
// use current pending value to be processed later on in OnEvent().
@ -1417,7 +1447,7 @@ bool wxSystemColourProperty::StringToValue( wxVariant& value, const wxString& te
{
// Try predefined colour first
int index;
bool res = ValueFromString_(value, &index, colStr, argFlags);
bool res = ValueFromString_(value, &index, colStr, flags);
if ( res && index >= 0 )
{
val.m_type = index;
@ -1601,15 +1631,15 @@ void wxColourProperty::Init( wxColour colour )
}
wxString wxColourProperty::ValueToString( wxVariant& value,
int argFlags ) const
wxPGPropValFormatFlags flags ) const
{
const wxPGEditor* editor = GetEditorClass();
if ( editor != wxPGEditor_Choice &&
editor != wxPGEditor_ChoiceAndButton &&
editor != wxPGEditor_ComboBox )
argFlags |= wxPG_PROPERTY_SPECIFIC;
flags |= wxPGPropValFormatFlags::PropertySpecific;
return wxSystemColourProperty::ValueToString(value, argFlags);
return wxSystemColourProperty::ValueToString(value, flags);
}
wxColour wxColourProperty::GetColour( int index ) const
@ -1711,9 +1741,9 @@ wxCursorProperty::wxCursorProperty( const wxString& label, const wxString& name,
m_flags |= wxPGPropertyFlags_StaticChoices; // Cursor selection cannot be changed.
}
wxString wxCursorProperty::ValueToString(wxVariant& value, int argFlags) const
wxString wxCursorProperty::ValueToString(wxVariant& value, wxPGPropValFormatFlags flags) const
{
return wxGetTranslation(wxEnumProperty::ValueToString(value, argFlags),
return wxGetTranslation(wxEnumProperty::ValueToString(value, flags),
wxString(), "system cursor name");
}
@ -1945,10 +1975,10 @@ void wxMultiChoiceProperty::OnSetValue()
}
wxString wxMultiChoiceProperty::ValueToString( wxVariant& value,
int argFlags ) const
wxPGPropValFormatFlags flags ) const
{
// If possible, use cached string
if ( argFlags & wxPG_VALUE_IS_CURRENT )
if ( !!(flags & wxPGPropValFormatFlags::ValueIsCurrent) )
return m_display;
return GenerateValueAsString(value);
@ -2058,7 +2088,7 @@ bool wxMultiChoiceProperty::DisplayEditorDialog(wxPropertyGrid* pg, wxVariant& v
return false;
}
bool wxMultiChoiceProperty::StringToValue( wxVariant& variant, const wxString& text, int ) const
bool wxMultiChoiceProperty::StringToValue( wxVariant& variant, const wxString& text, wxPGPropValFormatFlags ) const
{
wxArrayString arr;
@ -2135,7 +2165,7 @@ void wxDateProperty::OnSetValue()
}
bool wxDateProperty::StringToValue( wxVariant& variant, const wxString& text,
int WXUNUSED(argFlags) ) const
wxPGPropValFormatFlags WXUNUSED(flags) ) const
{
wxDateTime dt;
@ -2153,7 +2183,7 @@ bool wxDateProperty::StringToValue( wxVariant& variant, const wxString& text,
}
wxString wxDateProperty::ValueToString( wxVariant& value,
int argFlags ) const
wxPGPropValFormatFlags flags ) const
{
wxDateTime dateTime = value.GetDateTime();
@ -2172,7 +2202,7 @@ wxString wxDateProperty::ValueToString( wxVariant& value,
wxString format;
if ( !m_format.empty() &&
!(argFlags & wxPG_FULL_VALUE) )
!(flags & wxPGPropValFormatFlags::FullValue) )
format = m_format;
// Determine default from locale

96
src/propgrid/editors.cpp
View file

@ -191,8 +191,13 @@ void wxPGEditor::SetControlAppearance( wxPropertyGrid* pg,
}
else if ( oCell.HasText() )
{
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
tcText = property->GetValueAsStringWithCheck(
#else
tcText = property->GetValueAsString(
property->HasFlag(wxPGPropertyFlags::ReadOnly)?0:wxPG_EDITABLE_VALUE);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
property->HasFlag(wxPGPropertyFlags::ReadOnly)?wxPGPropValFormatFlags::Null:wxPGPropValFormatFlags::EditableValue);
changeText = true;
}
@ -284,11 +289,16 @@ wxPGWindowList wxPGTextCtrlEditor::CreateControls( wxPropertyGrid* propGrid,
property->HasAnyChild() )
return nullptr;
int argFlags = 0;
wxPGPropValFormatFlags fmtFlags = wxPGPropValFormatFlags::Null;
if ( !property->HasFlag(wxPGPropertyFlags::ReadOnly) &&
!property->IsValueUnspecified() )
argFlags |= wxPG_EDITABLE_VALUE;
text = property->GetValueAsString(argFlags);
fmtFlags |= wxPGPropValFormatFlags::EditableValue;
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
text = property->GetValueAsStringWithCheck(fmtFlags);
#else
text = property->GetValueAsString(fmtFlags);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
int flags = 0;
if ( property->HasFlag(wxPGPropertyFlags_Password) &&
@ -330,7 +340,12 @@ void wxPGTextCtrlEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl )
wxString s;
if ( tc->HasFlag(wxTE_PASSWORD) )
s = property->GetValueAsString(wxPG_FULL_VALUE);
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
s = property->GetValueAsStringWithCheck(wxPGPropValFormatFlags::FullValue);
#else
s = property->GetValueAsString(wxPGPropValFormatFlags::FullValue);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
else
s = property->GetDisplayedString();
@ -397,7 +412,12 @@ bool wxPGTextCtrlEditor::GetTextCtrlValueFromControl( wxVariant& variant, wxPGPr
return true;
}
bool res = property->StringToValue(variant, textVal, wxPG_EDITABLE_VALUE);
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
bool res = property->StringToValueWithCheck(variant, textVal, wxPGPropValFormatFlags::EditableValue);
#else
bool res = property->StringToValue(variant, textVal, wxPGPropValFormatFlags::EditableValue);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
// Changing unspecified always causes event (returning
// true here should be enough to trigger it).
@ -435,9 +455,14 @@ void wxPGTextCtrlEditor_OnFocus( wxPGProperty* property,
{
// Make sure there is correct text (instead of unspecified value
// indicator or hint text)
int flags = property->HasFlag(wxPGPropertyFlags::ReadOnly) ?
0 : wxPG_EDITABLE_VALUE;
wxString correctText = property->GetValueAsString(flags);
wxPGPropValFormatFlags fmtFlags = property->HasFlag(wxPGPropertyFlags::ReadOnly) ?
wxPGPropValFormatFlags::Null : wxPGPropValFormatFlags::EditableValue;
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
wxString correctText = property->GetValueAsStringWithCheck(fmtFlags);
#else
wxString correctText = property->GetValueAsString(fmtFlags);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
if ( tc->GetValue() != correctText )
{
@ -726,7 +751,12 @@ void wxPropertyGrid::OnComboItemPaint( const wxPGComboBox* pCb,
else
{
if ( !p->IsValueUnspecified() )
text = p->GetValueAsString(0);
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
text = p->GetValueAsStringWithCheck(wxPGPropValFormatFlags::Null);
#else
text = p->GetValueAsString(wxPGPropValFormatFlags::Null);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
}
}
@ -948,11 +978,16 @@ wxWindow* wxPGChoiceEditor::CreateControlsBase( wxPropertyGrid* propGrid,
wxString defString;
int index = property->GetChoiceSelection();
int argFlags = 0;
wxPGPropValFormatFlags fmtFlags = wxPGPropValFormatFlags::Null;
if ( !property->HasFlag(wxPGPropertyFlags::ReadOnly) &&
!property->IsValueUnspecified() )
argFlags |= wxPG_EDITABLE_VALUE;
defString = property->GetValueAsString(argFlags);
fmtFlags |= wxPGPropValFormatFlags::EditableValue;
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
defString = property->GetValueAsStringWithCheck(fmtFlags);
#else
defString = property->GetValueAsString(fmtFlags);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
wxArrayString labels = choices.GetLabels();
@ -1135,7 +1170,12 @@ bool wxPGChoiceEditor::GetValueFromControl( wxVariant& variant, wxPGProperty* pr
property->IsValueUnspecified()
)
{
return property->IntToValue(variant, index, wxPG_PROPERTY_SPECIFIC);
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
return property->IntToValueWithCheck(variant, index, wxPGPropValFormatFlags::PropertySpecific);
#else
return property->IntToValue(variant, index, wxPGPropValFormatFlags::PropertySpecific);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
}
return false;
}
@ -1199,7 +1239,12 @@ void wxPGComboBoxEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl )
{
wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
const int index = property->GetChoiceSelection();
wxString s = property->GetValueAsString(wxPG_EDITABLE_VALUE);
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
wxString s = property->GetValueAsStringWithCheck(wxPGPropValFormatFlags::EditableValue);
#else
wxString s = property->GetValueAsString(wxPGPropValFormatFlags::EditableValue);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
cb->SetSelection(index);
property->GetGrid()->SetupTextCtrlValue(s);
cb->SetValue(s);
@ -1247,7 +1292,12 @@ bool wxPGComboBoxEditor::GetValueFromControl( wxVariant& variant, wxPGProperty*
return true;
}
bool res = property->StringToValue(variant, textVal, wxPG_EDITABLE_VALUE|wxPG_PROPERTY_SPECIFIC);
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
bool res = property->StringToValueWithCheck(variant, textVal, wxPGPropValFormatFlags::EditableValue|wxPGPropValFormatFlags::PropertySpecific);
#else
bool res = property->StringToValue(variant, textVal, wxPGPropValFormatFlags::EditableValue | wxPGPropValFormatFlags::PropertySpecific);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
// Changing unspecified always causes event (returning
// true here should be enough to trigger it).
@ -1724,7 +1774,12 @@ bool wxPGCheckBoxEditor::GetValueFromControl( wxVariant& variant, wxPGProperty*
property->IsValueUnspecified()
)
{
return property->IntToValue(variant, index, wxPG_PROPERTY_SPECIFIC);
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
return property->IntToValueWithCheck(variant, index, wxPGPropValFormatFlags::PropertySpecific);
#else
return property->IntToValue(variant, index, wxPGPropValFormatFlags::PropertySpecific);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
}
return false;
}
@ -2048,7 +2103,12 @@ wxWindow* wxPropertyGrid::GenerateEditorTextCtrlAndButton( const wxPoint& pos,
wxString text;
if ( !property->IsValueUnspecified() )
text = property->GetValueAsString(property->HasFlag(wxPGPropertyFlags::ReadOnly)?0:wxPG_EDITABLE_VALUE);
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
text = property->GetValueAsStringWithCheck(property->HasFlag(wxPGPropertyFlags::ReadOnly)?wxPGPropValFormatFlags::Null : wxPGPropValFormatFlags::EditableValue);
#else
text = property->GetValueAsString(property->HasFlag(wxPGPropertyFlags::ReadOnly) ? wxPGPropValFormatFlags::Null : wxPGPropValFormatFlags::EditableValue);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
return GenerateEditorTextCtrl(pos, sz, text, but, 0, property->GetMaxLength());
}

168
src/propgrid/property.cpp
View file

@ -273,7 +273,12 @@ bool wxPGDefaultRenderer::Render( wxDC& dc, const wxRect& rect,
imageWidth = paintdata.m_drawnWidth;
}
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
text = property->GetValueAsStringWithCheck();
#else
text = property->GetValueAsString();
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
// Add units string?
if ( propertyGrid->GetColumnCount() <= 2 )
@ -978,7 +983,7 @@ wxString wxPGProperty::GetColumnText( unsigned int col, int choiceIndex ) const
*/
void wxPGProperty::DoGenerateComposedValue( wxString& text,
int argFlags,
wxPGPropValFormatFlags flags,
const wxVariantList* valueOverrides,
wxPGHashMapS2S* childResults ) const
{
@ -989,13 +994,13 @@ void wxPGProperty::DoGenerateComposedValue( wxString& text,
return;
if ( iMax > PWC_CHILD_SUMMARY_LIMIT &&
!(argFlags & wxPG_FULL_VALUE) )
!(flags & wxPGPropValFormatFlags::FullValue) )
iMax = PWC_CHILD_SUMMARY_LIMIT;
size_t iMaxMinusOne = iMax-1;
if ( !IsTextEditable() )
argFlags |= wxPG_UNEDITABLE_COMPOSITE_FRAGMENT;
flags |= wxPGPropValFormatFlags::UneditableCompositeFragment;
wxPGProperty* curChild = m_children[0];
@ -1046,13 +1051,19 @@ void wxPGProperty::DoGenerateComposedValue( wxString& text,
childValue.IsType(wxPG_VARIANT_TYPE_LIST) )
{
wxVariantList& childList = childValue.GetList();
DoGenerateComposedValue(s, argFlags|wxPG_COMPOSITE_FRAGMENT,
DoGenerateComposedValue(s, flags|wxPGPropValFormatFlags::CompositeFragment,
&childList, childResults);
}
else
{
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
s = curChild->ValueToStringWithCheck(childValue,
flags|wxPGPropValFormatFlags::CompositeFragment);
#else
s = curChild->ValueToString(childValue,
argFlags|wxPG_COMPOSITE_FRAGMENT);
flags|wxPGPropValFormatFlags::CompositeFragment);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
}
}
@ -1060,7 +1071,7 @@ void wxPGProperty::DoGenerateComposedValue( wxString& text,
(*childResults)[curChild->GetName()] = s;
bool skip = false;
if ( (argFlags & wxPG_UNEDITABLE_COMPOSITE_FRAGMENT) && s.empty() )
if ( !!(flags & wxPGPropValFormatFlags::UneditableCompositeFragment) && s.empty() )
skip = true;
if ( !curChild->HasAnyChild() || skip )
@ -1071,8 +1082,8 @@ void wxPGProperty::DoGenerateComposedValue( wxString& text,
if ( i < iMaxMinusOne )
{
if ( text.length() > PWC_CHILD_SUMMARY_CHAR_LIMIT &&
!(argFlags & wxPG_EDITABLE_VALUE) &&
!(argFlags & wxPG_FULL_VALUE) )
!(flags & wxPGPropValFormatFlags::EditableValue) &&
!(flags & wxPGPropValFormatFlags::FullValue) )
break;
if ( !skip )
@ -1096,8 +1107,27 @@ void wxPGProperty::DoGenerateComposedValue( wxString& text,
}
}
#if WXWIN_COMPATIBILITY_3_2
// By call to obsolete function we want to check if user-overriden function is still in use
wxString wxPGProperty::ValueToStringWithCheck(wxVariant& variant, wxPGPropValFormatFlags flags) const
{
m_oldValueToStringCalled = false;
wxString res = ValueToString(variant, static_cast<int>(flags));
if ( m_oldValueToStringCalled )
{
// Our own function was called - this implies that call was forwarded to the new overriding
// function and there is no need to call it explicitly.
}
else
{ // User-overriden obsolete function was called
wxFAIL_MSG(wxString::Format("in %s use ValueToString with 'flags' argument as wxPGPropValFormatFlags", GetClassInfo()->GetClassName()));
}
return res;
}
#endif // WXWIN_COMPATIBILITY_3_2
wxString wxPGProperty::ValueToString( wxVariant& WXUNUSED(value),
int argFlags ) const
wxPGPropValFormatFlags flags ) const
{
wxCHECK_MSG( HasAnyChild(),
wxString(),
@ -1105,39 +1135,63 @@ wxString wxPGProperty::ValueToString( wxVariant& WXUNUSED(value),
wxS("override GetValueAsString") );
// FIXME: Currently code below only works if value is actually m_value
wxASSERT_MSG( argFlags & wxPG_VALUE_IS_CURRENT,
wxASSERT_MSG( !!(flags & wxPGPropValFormatFlags::ValueIsCurrent),
wxS("Sorry, currently default wxPGProperty::ValueToString() ")
wxS("implementation only works if value is m_value.") );
wxString text;
DoGenerateComposedValue(text, argFlags);
DoGenerateComposedValue(text, flags);
return text;
}
wxString wxPGProperty::GetValueAsString( int argFlags ) const
#if WXWIN_COMPATIBILITY_3_2
// By call to obsolete function we want to check if user-overriden function is still in use
wxString wxPGProperty::GetValueAsStringWithCheck(wxPGPropValFormatFlags flags) const
{
m_oldGetValueAsString = false;
wxString res = GetValueAsString(static_cast<int>(flags));
if ( m_oldGetValueAsString )
{
// Our own function was called - this implies that call was forwarded to the new overriding
// function and there is no need to call it explicitly.
}
else
{ // User-overriden obsolete function was called
wxFAIL_MSG(wxString::Format("in %s use GetValueAsString with 'flags' argument as wxPGPropValFormatFlags", GetClassInfo()->GetClassName()));
}
return res;
}
#endif // WXWIN_COMPATIBILITY_3_2
wxString wxPGProperty::GetValueAsString(wxPGPropValFormatFlags flags) const
{
wxPropertyGrid* pg = GetGrid();
wxCHECK_MSG( pg, wxString(),
wxS("Cannot get valid value for detached property") );
if ( IsValueUnspecified() )
return pg->GetUnspecifiedValueText(argFlags);
return pg->GetUnspecifiedValueText(flags);
if ( m_commonValue == -1 )
{
wxVariant value(GetValue());
return ValueToString(value, argFlags|wxPG_VALUE_IS_CURRENT);
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
return ValueToStringWithCheck(value, flags|wxPGPropValFormatFlags::ValueIsCurrent);
#else
return ValueToString(value, flags|wxPGPropValFormatFlags::ValueIsCurrent);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
}
//
// Return common value's string representation
const wxPGCommonValue* cv = pg->GetCommonValue(m_commonValue);
if ( argFlags & wxPG_FULL_VALUE )
if ( !!(flags & wxPGPropValFormatFlags::FullValue) )
{
return cv->GetLabel();
}
else if ( argFlags & wxPG_EDITABLE_VALUE )
else if ( !!(flags & wxPGPropValFormatFlags::EditableValue) )
{
return cv->GetEditableText();
}
@ -1147,14 +1201,52 @@ wxString wxPGProperty::GetValueAsString( int argFlags ) const
}
}
bool wxPGProperty::IntToValue( wxVariant& variant, int number, int WXUNUSED(argFlags) ) const
#if WXWIN_COMPATIBILITY_3_2
// By call to obsolete function we want to check if user-overriden function is still in use
bool wxPGProperty::IntToValueWithCheck(wxVariant& variant, int number, wxPGPropValFormatFlags flags) const
{
m_oldIntToValueCalled = false;
bool res = IntToValue(variant, number, static_cast<int>(flags));
if ( m_oldIntToValueCalled )
{
// Our own function was called - this implies that call was forwarded to the new overriding
// function and there is no need to call it explicitly.
}
else
{ // User-overriden obsolete function was called
wxFAIL_MSG(wxString::Format("in %s use IntoToValue with 'flags' argument as wxPGPropValFormatFlags", GetClassInfo()->GetClassName()));
}
return res;
}
#endif // WXWIN_COMPATIBILITY_3_2
bool wxPGProperty::IntToValue( wxVariant& variant, int number, wxPGPropValFormatFlags WXUNUSED(flags) ) const
{
variant = (long)number;
return true;
}
#if WXWIN_COMPATIBILITY_3_2
// By call to obsolete function we want to check if user-overriden function is still in use#if WXWIN_COMPATIBILITY_3_2
bool wxPGProperty::StringToValueWithCheck(wxVariant& variant, const wxString& text, wxPGPropValFormatFlags flags) const
{
m_oldStringToValueCalled = false;
bool res = StringToValue(variant, text, static_cast<int>(flags));
if ( m_oldStringToValueCalled )
{
// Our own function was called - this implies that call was forwarded to the new overriding
// function and there is no need to call it explicitly.
}
else
{ // User-overriden obsolete function was called
wxFAIL_MSG(wxString::Format("in %s use StringToValue with 'flags' argument as wxPGPropValFormatFlags", GetClassInfo()->GetClassName()));
}
return res;
}
#endif // WXWIN_COMPATIBILITY_3_2
// Convert semicolon delimited tokens into child values.
bool wxPGProperty::StringToValue( wxVariant& v, const wxString& text, int argFlags ) const
bool wxPGProperty::StringToValue( wxVariant& v, const wxString& text, wxPGPropValFormatFlags flags ) const
{
if ( !HasAnyChild() )
return false;
@ -1164,7 +1256,7 @@ bool wxPGProperty::StringToValue( wxVariant& v, const wxString& text, int argFla
unsigned int iMax = m_children.size();
if ( iMax > PWC_CHILD_SUMMARY_LIMIT &&
!(argFlags & wxPG_FULL_VALUE) )
!(flags & wxPGPropValFormatFlags::FullValue) )
iMax = PWC_CHILD_SUMMARY_LIMIT;
bool changed = false;
@ -1181,7 +1273,7 @@ bool wxPGProperty::StringToValue( wxVariant& v, const wxString& text, int argFla
wxVariantList temp_list;
wxVariant list(temp_list);
int propagatedFlags = argFlags & (wxPG_REPORT_ERROR|wxPG_PROGRAMMATIC_VALUE);
wxPGPropValFormatFlags propagatedFlags = flags & (wxPGPropValFormatFlags::ReportError|wxPGPropValFormatFlags::ProgrammaticValue);
wxLogTrace("propgrid",
wxS(">> %s.StringToValue('%s')"), GetLabel(), text);
@ -1216,14 +1308,20 @@ bool wxPGProperty::StringToValue( wxVariant& v, const wxString& text, int argFla
token, childName);
// Add only if editable or setting programmatically
if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
if ( !!(flags & wxPGPropValFormatFlags::ProgrammaticValue) ||
(!child->HasFlag(wxPGPropertyFlags::Disabled) &&
!child->HasFlag(wxPGPropertyFlags::ReadOnly)) )
{
if ( len > 0 )
{
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
if ( child->StringToValueWithCheck(variant, token,
propagatedFlags | wxPGPropValFormatFlags::CompositeFragment) )
#else
if ( child->StringToValue(variant, token,
propagatedFlags|wxPG_COMPOSITE_FRAGMENT) )
propagatedFlags | wxPGPropValFormatFlags::CompositeFragment) )
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
{
// We really need to set the variant's name
// *after* child->StringToValue() has been
@ -1295,14 +1393,20 @@ bool wxPGProperty::StringToValue( wxVariant& v, const wxString& text, int argFla
wxVariant oldChildValue = child->GetValue();
wxVariant variant(oldChildValue);
if ( (argFlags & wxPG_PROGRAMMATIC_VALUE) ||
if ( !!(flags & wxPGPropValFormatFlags::ProgrammaticValue) ||
(!child->HasFlag(wxPGPropertyFlags::Disabled) &&
!child->HasFlag(wxPGPropertyFlags::ReadOnly)) )
{
wxString childName = child->GetBaseName();
bool stvRes = child->StringToValue( variant, token,
propagatedFlags );
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
bool stvRes = child->StringToValueWithCheck(variant, token,
propagatedFlags);
#else
bool stvRes = child->StringToValue(variant, token,
propagatedFlags);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
if ( stvRes || (variant != oldChildValue) )
{
variant.SetName(childName);
@ -1350,19 +1454,19 @@ bool wxPGProperty::StringToValue( wxVariant& v, const wxString& text, int argFla
return changed;
}
bool wxPGProperty::SetValueFromString( const wxString& text, int argFlags )
bool wxPGProperty::SetValueFromString( const wxString& text, wxPGPropValFormatFlags flags )
{
wxVariant variant(m_value);
bool res = StringToValue(variant, text, argFlags);
bool res = StringToValue(variant, text, flags);
if ( res )
SetValue(variant);
return res;
}
bool wxPGProperty::SetValueFromInt( long number, int argFlags )
bool wxPGProperty::SetValueFromInt( long number, wxPGPropValFormatFlags flags )
{
wxVariant variant(m_value);
bool res = IntToValue(variant, number, argFlags);
bool res = IntToValue(variant, number, flags);
if ( res )
SetValue(variant);
return res;
@ -2901,15 +3005,15 @@ wxPropertyCategory::wxPropertyCategory( const wxString &label, const wxString& n
}
wxString wxPropertyCategory::ValueToString( wxVariant& WXUNUSED(value),
int WXUNUSED(argFlags) ) const
wxPGPropValFormatFlags WXUNUSED(flags) ) const
{
return m_value.IsType(wxPG_VARIANT_TYPE_STRING) ? m_value.GetString() : wxString();
}
wxString wxPropertyCategory::GetValueAsString( int argFlags ) const
wxString wxPropertyCategory::GetValueAsString(wxPGPropValFormatFlags flags) const
{
// Unspecified value is always empty string
return IsValueUnspecified() ? wxString() : wxPGProperty::GetValueAsString(argFlags);
return IsValueUnspecified() ? wxString() : wxPGProperty::GetValueAsString(flags);
}
static int DoGetTextExtent(const wxWindow* wnd, const wxString& label, const wxFont& font)

20
src/propgrid/propgrid.cpp
View file

@ -3485,7 +3485,12 @@ wxVariant wxPropertyGrid::GetUncommittedPropertyValue()
if ( !tc || !IsEditorsValueModified() )
return value;
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
if ( !prop->StringToValueWithCheck(value, tc->GetValue()) )
#else
if ( !prop->StringToValue(value, tc->GetValue()) )
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
return value;
if ( !PerformValidation(prop, value, IsStandaloneValidation) )
@ -3865,13 +3870,13 @@ void wxPropertyGrid::CustomSetCursor( int type, bool override )
// -----------------------------------------------------------------------
wxString
wxPropertyGrid::GetUnspecifiedValueText( int argFlags ) const
wxPropertyGrid::GetUnspecifiedValueText(wxPGPropValFormatFlags flags) const
{
const wxPGCell& ua = GetUnspecifiedValueAppearance();
if ( ua.HasText() &&
!(argFlags & wxPG_FULL_VALUE) &&
!(argFlags & wxPG_EDITABLE_VALUE) )
!(flags & wxPGPropValFormatFlags::FullValue) &&
!(flags & wxPGPropValFormatFlags::EditableValue) )
return ua.GetText();
return wxString();
@ -5098,7 +5103,12 @@ bool wxPropertyGrid::HandleMouseMove( int x, unsigned int y,
wxSize imageSize = GetImageSize(m_propHover, -1);
if ( imageSize.x > 0 )
imageWidth = imageSize.x;
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
tipString = m_propHover->GetValueAsStringWithCheck();
#else
tipString = m_propHover->GetValueAsString();
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
if ( GetColumnCount() <= 2 )
{
wxString unitsString = m_propHover->GetAttribute(wxPG_ATTR_UNITS, wxString());
@ -6396,8 +6406,8 @@ wxPGProperty* wxPropertyGridPopulator::Add( const wxString& propClass,
m_state->DoInsert(parent, -1, property);
if ( propValue )
property->SetValueFromString( *propValue, wxPG_FULL_VALUE|
wxPG_PROGRAMMATIC_VALUE );
property->SetValueFromString( *propValue, wxPGPropValFormatFlags::FullValue|
wxPGPropValFormatFlags::ProgrammaticValue );
return property;
}

13
src/propgrid/propgridiface.cpp
View file

@ -424,16 +424,16 @@ wxPGProperty* wxPropertyGridInterface::GetPropertyByLabel( const wxString& label
// ----------------------------------------------------------------------------
void wxPropertyGridInterface::DoSetPropertyAttribute( wxPGPropArg id, const wxString& name,
wxVariant& value, wxPGPropertyValuesFlags argFlags )
wxVariant& value, wxPGPropertyValuesFlags flags )
{
wxPG_PROP_ARG_CALL_PROLOG()
p->SetAttribute( name, value ); // property is also refreshed here
if ( !!(argFlags & wxPGPropertyValuesFlags::Recurse) )
if ( !!(flags & wxPGPropertyValuesFlags::Recurse) )
{
for ( unsigned int i = 0; i < p->GetChildCount(); i++ )
DoSetPropertyAttribute(p->Item(i), name, value, argFlags);
DoSetPropertyAttribute(p->Item(i), name, value, flags);
}
}
@ -748,7 +748,12 @@ wxVariant wxPropertyGridInterface::GetPropertyValue(wxPGPropArg id)
wxString wxPropertyGridInterface::GetPropertyValueAsString( wxPGPropArg id ) const
{
wxPG_PROP_ARG_CALL_PROLOG_RETVAL(wxString())
return p->GetValueAsString(wxPG_FULL_VALUE);
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
return p->GetValueAsStringWithCheck(wxPGPropValFormatFlags::FullValue);
#else
return p->GetValueAsString(wxPGPropValFormatFlags::FullValue);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
}
bool wxPropertyGridInterface::GetPropertyValueAsBool( wxPGPropArg id ) const

7
src/propgrid/propgridpagestate.cpp
View file

@ -1220,11 +1220,16 @@ bool wxPropertyGridPageState::DoSetPropertyValueString( wxPGProperty* p, const w
{
if ( p )
{
int flags = wxPG_REPORT_ERROR|wxPG_FULL_VALUE|wxPG_PROGRAMMATIC_VALUE;
constexpr wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::ReportError|wxPGPropValFormatFlags::FullValue|wxPGPropValFormatFlags::ProgrammaticValue;
wxVariant variant = p->GetValueRef();
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
if ( p->StringToValueWithCheck(variant, value, flags) )
#else
if ( p->StringToValue(variant, value, flags) )
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
{
p->SetValue(variant);
if ( p == m_pPropGrid->GetSelection() && IsDisplayed() )

125
src/propgrid/props.cpp
View file

@ -70,23 +70,23 @@ void wxStringProperty::OnSetValue()
}
wxString wxStringProperty::ValueToString( wxVariant& value,
int argFlags ) const
wxPGPropValFormatFlags flags ) const
{
wxString s = value.GetString();
if ( HasAnyChild() && HasFlag(wxPGPropertyFlags::ComposedValue) )
{
// Value stored in m_value is non-editable, non-full value
if ( (argFlags & wxPG_FULL_VALUE) ||
(argFlags & wxPG_EDITABLE_VALUE) ||
if ( !!(flags & wxPGPropValFormatFlags::FullValue) ||
!!(flags & wxPGPropValFormatFlags::EditableValue) ||
s.empty() )
{
// Calling this under incorrect conditions will fail
wxASSERT_MSG( argFlags & wxPG_VALUE_IS_CURRENT,
wxASSERT_MSG( !!(flags & wxPGPropValFormatFlags::ValueIsCurrent),
wxS("Sorry, currently default wxPGProperty::ValueToString() ")
wxS("implementation only works if value is m_value.") );
DoGenerateComposedValue(s, argFlags);
DoGenerateComposedValue(s, flags);
}
return s;
@ -94,16 +94,16 @@ wxString wxStringProperty::ValueToString( wxVariant& value,
// If string is password and value is for visual purposes,
// then return asterisks instead the actual string.
if ( !!(m_flags & wxPGPropertyFlags_Password) && !(argFlags & (wxPG_FULL_VALUE|wxPG_EDITABLE_VALUE)) )
if ( !!(m_flags & wxPGPropertyFlags_Password) && !(flags & (wxPGPropValFormatFlags::FullValue|wxPGPropValFormatFlags::EditableValue)) )
return wxString(wxS('*'), s.length());
return s;
}
bool wxStringProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
bool wxStringProperty::StringToValue( wxVariant& variant, const wxString& text, wxPGPropValFormatFlags flags ) const
{
if ( HasAnyChild() && HasFlag(wxPGPropertyFlags::ComposedValue) )
return wxPGProperty::StringToValue(variant, text, argFlags);
return wxPGProperty::StringToValue(variant, text, flags);
if ( variant != text )
{
@ -251,7 +251,12 @@ namespace {
{
// Round value to the required precision.
wxVariant variant = value;
wxString strVal = prop->ValueToString(variant, wxPG_FULL_VALUE);
#if WXWIN_COMPATIBILITY_3_2
// Special implementation with check if user-overriden obsolete function is still in use
wxString strVal = prop->ValueToStringWithCheck(variant, wxPGPropValFormatFlags::FullValue);
#else
wxString strVal = prop->ValueToString(variant, wxPGPropValFormatFlags::FullValue);
#endif // WXWIN_COMPATIBILITY_3_2 | !WXWIN_COMPATIBILITY_3_2
wxNumberFormatter::FromString(strVal, &value);
return value;
}
@ -372,7 +377,7 @@ wxIntProperty::wxIntProperty( const wxString& label, const wxString& name,
#endif
wxString wxIntProperty::ValueToString( wxVariant& value,
int WXUNUSED(argFlags) ) const
wxPGPropValFormatFlags WXUNUSED(flags) ) const
{
const wxString valType(value.GetType());
if ( valType == wxPG_VARIANT_TYPE_LONG )
@ -390,7 +395,7 @@ wxString wxIntProperty::ValueToString( wxVariant& value,
return wxString();
}
bool wxIntProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
bool wxIntProperty::StringToValue( wxVariant& variant, const wxString& text, wxPGPropValFormatFlags flags ) const
{
if ( text.empty() )
{
@ -445,13 +450,13 @@ bool wxIntProperty::StringToValue( wxVariant& variant, const wxString& text, int
}
}
}
else if ( argFlags & wxPG_REPORT_ERROR )
else if ( !!(flags & wxPGPropValFormatFlags::ReportError) )
{
}
return false;
}
bool wxIntProperty::IntToValue( wxVariant& variant, int value, int WXUNUSED(argFlags) ) const
bool wxIntProperty::IntToValue( wxVariant& variant, int value, wxPGPropValFormatFlags WXUNUSED(flags) ) const
{
if ( !variant.IsType(wxPG_VARIANT_TYPE_LONG) || variant != (long)value )
{
@ -586,7 +591,7 @@ wxUIntProperty::wxUIntProperty( const wxString& label, const wxString& name,
}
#endif
wxString wxUIntProperty::ValueToString(wxVariant& value, int argFlags) const
wxString wxUIntProperty::ValueToString(wxVariant& value, wxPGPropValFormatFlags flags) const
{
static const wxStringCharType* const gs_uintTemplates32[wxPG_UINT_TEMPLATE_MAX] =
{
@ -639,7 +644,7 @@ wxString wxUIntProperty::ValueToString(wxVariant& value, int argFlags) const
const wxString valType(value.GetType());
if ( valType == wxPG_VARIANT_TYPE_LONG )
{
const wxStringCharType* fmt = argFlags & wxPG_EDITABLE_VALUE ?
const wxStringCharType* fmt = !!(flags & wxPGPropValFormatFlags::EditableValue) ?
gs_uintEditTemplates32[index] :
gs_uintTemplates32[index];
return wxString::Format(fmt, (unsigned long)value.GetLong());
@ -647,7 +652,7 @@ wxString wxUIntProperty::ValueToString(wxVariant& value, int argFlags) const
#if wxUSE_LONGLONG
else if ( valType == wxPG_VARIANT_TYPE_ULONGLONG )
{
const wxStringCharType* fmt = argFlags & wxPG_EDITABLE_VALUE ?
const wxStringCharType* fmt = !!(flags & wxPGPropValFormatFlags::EditableValue) ?
gs_uintEditTemplates64[index] :
gs_uintTemplates64[index];
wxULongLong ull = value.GetULongLong();
@ -657,7 +662,7 @@ wxString wxUIntProperty::ValueToString(wxVariant& value, int argFlags) const
return wxString();
}
bool wxUIntProperty::StringToValue(wxVariant& variant, const wxString& text, int argFlags) const
bool wxUIntProperty::StringToValue(wxVariant& variant, const wxString& text, wxPGPropValFormatFlags flags) const
{
if ( text.empty() )
{
@ -707,14 +712,14 @@ bool wxUIntProperty::StringToValue(wxVariant& variant, const wxString& text, int
return true;
}
}
else if ( argFlags & wxPG_REPORT_ERROR )
else if ( !!(flags & wxPGPropValFormatFlags::ReportError) )
{
}
return false;
}
bool wxUIntProperty::IntToValue( wxVariant& variant, int number, int WXUNUSED(argFlags) ) const
bool wxUIntProperty::IntToValue( wxVariant& variant, int number, wxPGPropValFormatFlags WXUNUSED(flags) ) const
{
if ( variant != (long)number )
{
@ -920,19 +925,19 @@ const wxString& wxPropertyGrid::DoubleToString(wxString& target,
#endif // WXWIN_COMPATIBILITY_3_0
wxString wxFloatProperty::ValueToString( wxVariant& value,
int argFlags ) const
wxPGPropValFormatFlags flags ) const
{
wxString text;
if ( !value.IsNull() )
{
text = wxNumberFormatter::ToString(value.GetDouble(), m_precision,
argFlags & wxPG_FULL_VALUE ? wxNumberFormatter::Style_None
: wxNumberFormatter::Style_NoTrailingZeroes);
!!(flags & wxPGPropValFormatFlags::FullValue) ? wxNumberFormatter::Style_None
: wxNumberFormatter::Style_NoTrailingZeroes);
}
return text;
}
bool wxFloatProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
bool wxFloatProperty::StringToValue( wxVariant& variant, const wxString& text, wxPGPropValFormatFlags flags ) const
{
if ( text.empty() )
{
@ -950,7 +955,7 @@ bool wxFloatProperty::StringToValue( wxVariant& variant, const wxString& text, i
return true;
}
}
else if ( argFlags & wxPG_REPORT_ERROR )
else if ( !!(flags & wxPGPropValFormatFlags::ReportError) )
{
}
return false;
@ -1050,13 +1055,13 @@ wxBoolProperty::wxBoolProperty( const wxString& label, const wxString& name, boo
}
wxString wxBoolProperty::ValueToString( wxVariant& value,
int argFlags ) const
wxPGPropValFormatFlags flags ) const
{
bool boolValue = value.GetBool();
// As a fragment of composite string value,
// make it a little more readable.
if ( argFlags & wxPG_COMPOSITE_FRAGMENT )
if ( !!(flags & wxPGPropValFormatFlags::CompositeFragment) )
{
if ( boolValue )
{
@ -1064,7 +1069,7 @@ wxString wxBoolProperty::ValueToString( wxVariant& value,
}
else
{
if ( argFlags & wxPG_UNEDITABLE_COMPOSITE_FRAGMENT )
if ( !!(flags & wxPGPropValFormatFlags::UneditableCompositeFragment) )
return wxString();
wxString notFmt;
@ -1077,7 +1082,7 @@ wxString wxBoolProperty::ValueToString( wxVariant& value,
}
}
if ( !(argFlags & wxPG_FULL_VALUE) )
if ( !(flags & wxPGPropValFormatFlags::FullValue) )
{
return wxPGGlobalVars->m_boolChoices[boolValue?1:0].GetText();
}
@ -1085,7 +1090,7 @@ wxString wxBoolProperty::ValueToString( wxVariant& value,
return boolValue? wxS("true"): wxS("false");
}
bool wxBoolProperty::StringToValue( wxVariant& variant, const wxString& text, int WXUNUSED(argFlags) ) const
bool wxBoolProperty::StringToValue( wxVariant& variant, const wxString& text, wxPGPropValFormatFlags WXUNUSED(flags) ) const
{
bool boolValue = false;
if ( text.CmpNoCase(wxPGGlobalVars->m_boolChoices[1].GetText()) == 0 ||
@ -1107,7 +1112,7 @@ bool wxBoolProperty::StringToValue( wxVariant& variant, const wxString& text, in
return false;
}
bool wxBoolProperty::IntToValue( wxVariant& variant, int value, int ) const
bool wxBoolProperty::IntToValue( wxVariant& variant, int value, wxPGPropValFormatFlags ) const
{
bool boolValue = (bool)value;
@ -1229,11 +1234,11 @@ void wxEnumProperty::OnSetValue()
int index = -1;
if ( valType == wxPG_VARIANT_TYPE_LONG )
{
ValueFromInt_(m_value, &index, m_value.GetLong(), wxPG_FULL_VALUE);
ValueFromInt_(m_value, &index, m_value.GetLong(), wxPGPropValFormatFlags::FullValue);
}
else if ( valType == wxPG_VARIANT_TYPE_STRING )
{
ValueFromString_(m_value, &index, m_value.GetString(), 0);
ValueFromString_(m_value, &index, m_value.GetString(), wxPGPropValFormatFlags::Null);
}
else
{
@ -1250,13 +1255,13 @@ bool wxEnumProperty::ValidateValue( wxVariant& value, wxPGValidationInfo& WXUNUS
// unless property has string as preferred value type
// To reduce code size, use conversion here as well
if ( value.IsType(wxPG_VARIANT_TYPE_STRING) )
return ValueFromString_(value, nullptr, value.GetString(), wxPG_PROPERTY_SPECIFIC);
return ValueFromString_(value, nullptr, value.GetString(), wxPGPropValFormatFlags::PropertySpecific);
return true;
}
wxString wxEnumProperty::ValueToString( wxVariant& value,
int WXUNUSED(argFlags) ) const
wxPGPropValFormatFlags WXUNUSED(flags) ) const
{
if ( value.IsType(wxPG_VARIANT_TYPE_STRING) )
return value.GetString();
@ -1268,17 +1273,17 @@ wxString wxEnumProperty::ValueToString( wxVariant& value,
return m_choices.GetLabel(index);
}
bool wxEnumProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
bool wxEnumProperty::StringToValue( wxVariant& variant, const wxString& text, wxPGPropValFormatFlags flags ) const
{
return ValueFromString_(variant, nullptr, text, argFlags);
return ValueFromString_(variant, nullptr, text, flags);
}
bool wxEnumProperty::IntToValue( wxVariant& variant, int intVal, int argFlags ) const
bool wxEnumProperty::IntToValue( wxVariant& variant, int intVal, wxPGPropValFormatFlags flags ) const
{
return ValueFromInt_(variant, nullptr, intVal, argFlags);
return ValueFromInt_(variant, nullptr, intVal, flags);
}
bool wxEnumProperty::ValueFromString_(wxVariant& value, int* pIndex, const wxString& text, int WXUNUSED(argFlags)) const
bool wxEnumProperty::ValueFromString_(wxVariant& value, int* pIndex, const wxString& text, wxPGPropValFormatFlags WXUNUSED(flags)) const
{
int useIndex = -1;
long useValue = 0;
@ -1313,13 +1318,13 @@ bool wxEnumProperty::ValueFromString_(wxVariant& value, int* pIndex, const wxStr
return false;
}
bool wxEnumProperty::ValueFromInt_(wxVariant& value, int* pIndex, int intVal, int argFlags) const
bool wxEnumProperty::ValueFromInt_(wxVariant& value, int* pIndex, int intVal, wxPGPropValFormatFlags flags) const
{
// If wxPG_FULL_VALUE is *not* in argFlags, then intVal is index from combo box.
// If wxPGPropValFormatFlags::FullValue is *not* in flags, then intVal is index from combo box.
//
int setAsNextIndex = -2;
if ( argFlags & wxPG_FULL_VALUE )
if ( !!(flags & wxPGPropValFormatFlags::FullValue) )
{
setAsNextIndex = GetIndexForValue( intVal );
}
@ -1333,7 +1338,7 @@ bool wxEnumProperty::ValueFromInt_(wxVariant& value, int* pIndex, int intVal, in
if ( setAsNextIndex != -2 )
{
if ( !(argFlags & wxPG_FULL_VALUE) )
if ( !(flags & wxPGPropValFormatFlags::FullValue) )
intVal = m_choices.GetValue(intVal);
value = (long)intVal;
@ -1406,12 +1411,12 @@ void wxEditEnumProperty::OnSetValue()
int index = -1;
if ( valType == wxPG_VARIANT_TYPE_LONG )
{
ValueFromInt_(m_value, &index, m_value.GetLong(), wxPG_FULL_VALUE);
ValueFromInt_(m_value, &index, m_value.GetLong(), wxPGPropValFormatFlags::FullValue);
}
else if ( valType == wxPG_VARIANT_TYPE_STRING )
{
wxString val = m_value.GetString();
ValueFromString_(m_value, &index, val, 0);
ValueFromString_(m_value, &index, val, wxPGPropValFormatFlags::Null);
// If text is not any of the choices, store as plain text instead.
if (index == -1)
{
@ -1428,10 +1433,10 @@ void wxEditEnumProperty::OnSetValue()
}
bool wxEditEnumProperty::StringToValue(wxVariant& variant,
const wxString& text, int argFlags) const
const wxString& text, wxPGPropValFormatFlags flags) const
{
int index;
bool res = ValueFromString_(variant, &index, text, argFlags);
bool res = ValueFromString_(variant, &index, text, flags);
// If text is not any of the choices, store as plain text instead.
if (index == -1)
{
@ -1588,7 +1593,7 @@ void wxFlagsProperty::OnSetValue()
}
wxString wxFlagsProperty::ValueToString( wxVariant& value,
int WXUNUSED(argFlags) ) const
wxPGPropValFormatFlags WXUNUSED(flags) ) const
{
wxString text;
@ -1616,7 +1621,7 @@ wxString wxFlagsProperty::ValueToString( wxVariant& value,
}
// Translate string into flag tokens
bool wxFlagsProperty::StringToValue( wxVariant& variant, const wxString& text, int ) const
bool wxFlagsProperty::StringToValue( wxVariant& variant, const wxString& text, wxPGPropValFormatFlags ) const
{
if ( !m_choices.IsOk() )
return false;
@ -1741,12 +1746,12 @@ wxDirProperty::wxDirProperty( const wxString& label, const wxString& name, const
SetValue(value);
}
wxString wxDirProperty::ValueToString(wxVariant& value, int WXUNUSED(argFlags)) const
wxString wxDirProperty::ValueToString(wxVariant& value, wxPGPropValFormatFlags WXUNUSED(flags)) const
{
return value;
}
bool wxDirProperty::StringToValue(wxVariant& variant, const wxString& text, int) const
bool wxDirProperty::StringToValue(wxVariant& variant, const wxString& text, wxPGPropValFormatFlags) const
{
if ( variant != text )
{
@ -1959,7 +1964,7 @@ wxFileName wxFileProperty::GetFileName() const
}
wxString wxFileProperty::ValueToString( wxVariant& value,
int argFlags ) const
wxPGPropValFormatFlags flags ) const
{
wxFileName filename = value.GetString();
@ -1970,7 +1975,7 @@ wxString wxFileProperty::ValueToString( wxVariant& value,
if ( fullName.empty() )
return wxString();
if ( argFlags & wxPG_FULL_VALUE )
if ( !!(flags & wxPGPropValFormatFlags::FullValue) )
{
return filename.GetFullPath();
}
@ -1988,11 +1993,11 @@ wxString wxFileProperty::ValueToString( wxVariant& value,
return filename.GetFullName();
}
bool wxFileProperty::StringToValue( wxVariant& variant, const wxString& text, int argFlags ) const
bool wxFileProperty::StringToValue( wxVariant& variant, const wxString& text, wxPGPropValFormatFlags flags ) const
{
wxFileName filename = variant.GetString();
if ( !!(m_flags & wxPGPropertyFlags::ShowFullFileName) || (argFlags & wxPG_FULL_VALUE) )
if ( !!(m_flags & wxPGPropertyFlags::ShowFullFileName) || !!(flags & wxPGPropValFormatFlags::FullValue) )
{
if ( filename != text )
{
@ -2101,7 +2106,7 @@ wxLongStringProperty::wxLongStringProperty( const wxString& label, const wxStrin
}
wxString wxLongStringProperty::ValueToString( wxVariant& value,
int WXUNUSED(argFlags) ) const
wxPGPropValFormatFlags WXUNUSED(flags) ) const
{
return value;
}
@ -2164,7 +2169,7 @@ bool wxLongStringProperty::DisplayEditorDialog(wxPropertyGrid* pg, wxVariant& va
return false;
}
bool wxLongStringProperty::StringToValue( wxVariant& variant, const wxString& text, int ) const
bool wxLongStringProperty::StringToValue( wxVariant& variant, const wxString& text, wxPGPropValFormatFlags ) const
{
if ( variant != text )
{
@ -2570,11 +2575,11 @@ wxString wxArrayStringProperty::ConvertArrayToString(const wxArrayString& arr,
}
wxString wxArrayStringProperty::ValueToString( wxVariant& WXUNUSED(value),
int argFlags ) const
wxPGPropValFormatFlags flags ) const
{
//
// If this is called from GetValueAsString(), return cached string
if ( argFlags & wxPG_VALUE_IS_CURRENT )
if ( !!(flags & wxPGPropValFormatFlags::ValueIsCurrent) )
{
return m_display;
}
@ -2723,7 +2728,7 @@ bool wxArrayStringProperty::DisplayEditorDialog(wxPropertyGrid* pg, wxVariant& v
}
bool wxArrayStringProperty::StringToValue( wxVariant& variant,
const wxString& text, int ) const
const wxString& text, wxPGPropValFormatFlags ) const
{
wxArrayString arr;