From ca3acd7a03ac9dce4f4195b717288cd96aa3ab8f Mon Sep 17 00:00:00 2001 From: Artur Wieczorek <7330332+a-wi@users.noreply.github.com> Date: Sat, 6 Jan 2024 17:26:12 +0100 Subject: [PATCH] Use enum class to implement wxPGPropValFormatFlags as bitmask This is for better type safety of the flags. --- include/wx/propgrid/advprops.h | 138 ++++++++-- include/wx/propgrid/property.h | 149 +++++++++-- include/wx/propgrid/propgrid.h | 11 +- include/wx/propgrid/propgriddefs.h | 77 +++++- include/wx/propgrid/propgridiface.h | 14 +- include/wx/propgrid/props.h | 370 +++++++++++++++++++++----- interface/wx/propgrid/advprops.h | 47 ++-- interface/wx/propgrid/property.h | 81 +++--- interface/wx/propgrid/propgrid.h | 4 +- interface/wx/propgrid/propgriddefs.h | 25 +- interface/wx/propgrid/propgridiface.h | 4 +- interface/wx/propgrid/props.h | 125 ++++----- samples/propgrid/sampleprops.cpp | 10 +- samples/propgrid/sampleprops.h | 18 +- src/propgrid/advprops.cpp | 84 ++++-- src/propgrid/editors.cpp | 96 +++++-- src/propgrid/property.cpp | 168 +++++++++--- src/propgrid/propgrid.cpp | 20 +- src/propgrid/propgridiface.cpp | 13 +- src/propgrid/propgridpagestate.cpp | 7 +- src/propgrid/props.cpp | 125 ++++----- 21 files changed, 1155 insertions(+), 431 deletions(-) diff --git a/include/wx/propgrid/advprops.h b/include/wx/propgrid/advprops.h index f5375997be..c27f7c5be2 100644 --- a/include/wx/propgrid/advprops.h +++ b/include/wx/propgrid/advprops.h @@ -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(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(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(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(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(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(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(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(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(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(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(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; diff --git a/include/wx/propgrid/property.h b/include/wx/propgrid/property.h index 076a0cc58e..0676e79c5f 100644 --- a/include/wx/propgrid/property.h +++ b/include/wx/propgrid/property.h @@ -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(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(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(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(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(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(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(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("") ); 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(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(flags)); + } +#endif // WXWIN_COMPATIBILITY_3_2 + virtual wxString GetValueAsString(wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null) const override; protected: void SetTextColIndex( unsigned int colInd ) diff --git a/include/wx/propgrid/propgrid.h b/include/wx/propgrid/propgrid.h index 0dd0a0da89..06b070675a 100644 --- a/include/wx/propgrid/propgrid.h +++ b/include/wx/propgrid/propgrid.h @@ -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(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. diff --git a/include/wx/propgrid/propgriddefs.h b/include/wx/propgrid/propgriddefs.h index 6febe05ce3..0ee66de466 100644 --- a/include/wx/propgrid/propgriddefs.h +++ b/include/wx/propgrid/propgriddefs.h @@ -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(static_cast(a) & static_cast(b)); +} + +constexpr wxPGPropValFormatFlags operator|(wxPGPropValFormatFlags a, wxPGPropValFormatFlags b) +{ + return static_cast(static_cast(a) | static_cast(b)); +} + +inline wxPGPropValFormatFlags operator|=(wxPGPropValFormatFlags& a, wxPGPropValFormatFlags b) +{ + return a = a | b; +} + +constexpr bool operator!(wxPGPropValFormatFlags a) +{ + return static_cast(a) == 0; +} + +#if WXWIN_COMPATIBILITY_3_2 +constexpr int operator&(int a, wxPGPropValFormatFlags b) +{ + return a & static_cast(b); +} + +constexpr int operator|(int a, wxPGPropValFormatFlags b) +{ + return a | static_cast(b); +} + +inline int operator|=(int& a, wxPGPropValFormatFlags b) +{ + return a = a | static_cast(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 diff --git a/include/wx/propgrid/propgridiface.h b/include/wx/propgrid/propgridiface.h index 40a6c48fc3..ff392782bf 100644 --- a/include/wx/propgrid/propgridiface.h +++ b/include/wx/propgrid/propgridiface.h @@ -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(argFlags)); + DoSetPropertyAttribute(id, attrName, value, static_cast(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&. diff --git a/include/wx/propgrid/props.h b/include/wx/propgrid/props.h index cdae89c8e0..29d4b6a0e6 100644 --- a/include/wx/propgrid/props.h +++ b/include/wx/propgrid/props.h @@ -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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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. diff --git a/interface/wx/propgrid/advprops.h b/interface/wx/propgrid/advprops.h index 15f3791282..38f07dc746 100644 --- a/interface/wx/propgrid/advprops.h +++ b/interface/wx/propgrid/advprops.h @@ -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 ); diff --git a/interface/wx/propgrid/property.h b/interface/wx/propgrid/property.h index 191a2fc729..e86656fd88 100644 --- a/interface/wx/propgrid/property.h +++ b/interface/wx/propgrid/property.h @@ -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("") ); 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; }; diff --git a/interface/wx/propgrid/propgrid.h b/interface/wx/propgrid/propgrid.h index 29c1e25cbb..c68fda75c8 100644 --- a/interface/wx/propgrid/propgrid.h +++ b/interface/wx/propgrid/propgrid.h @@ -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. diff --git a/interface/wx/propgrid/propgriddefs.h b/interface/wx/propgrid/propgriddefs.h index 23314b4411..259c5ff1d2 100644 --- a/interface/wx/propgrid/propgriddefs.h +++ b/interface/wx/propgrid/propgriddefs.h @@ -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 }; // ----------------------------------------------------------------------- diff --git a/interface/wx/propgrid/propgridiface.h b/interface/wx/propgrid/propgridiface.h index acbb9a4263..73eada045a 100644 --- a/interface/wx/propgrid/propgridiface.h +++ b/interface/wx/propgrid/propgridiface.h @@ -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. diff --git a/interface/wx/propgrid/props.h b/interface/wx/propgrid/props.h index c5ac027f96..34a8ff9426 100644 --- a/interface/wx/propgrid/props.h +++ b/interface/wx/propgrid/props.h @@ -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 ); /** diff --git a/samples/propgrid/sampleprops.cpp b/samples/propgrid/sampleprops.cpp index 986e4eafc2..442cd5e363 100644 --- a/samples/propgrid/sampleprops.cpp +++ b/samples/propgrid/sampleprops.cpp @@ -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 diff --git a/samples/propgrid/sampleprops.h b/samples/propgrid/sampleprops.h index 3fa44c1d6e..32927038d2 100644 --- a/samples/propgrid/sampleprops.h +++ b/samples/propgrid/sampleprops.h @@ -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; }; diff --git a/src/propgrid/advprops.cpp b/src/propgrid/advprops.cpp index 2085242197..2728a7f55d 100644 --- a/src/propgrid/advprops.cpp +++ b/src/propgrid/advprops.cpp @@ -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(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 diff --git a/src/propgrid/editors.cpp b/src/propgrid/editors.cpp index de9f230bf3..9dfc565e5f 100644 --- a/src/propgrid/editors.cpp +++ b/src/propgrid/editors.cpp @@ -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()); } diff --git a/src/propgrid/property.cpp b/src/propgrid/property.cpp index a78d89d078..d955683d8f 100644 --- a/src/propgrid/property.cpp +++ b/src/propgrid/property.cpp @@ -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(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(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(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(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) diff --git a/src/propgrid/propgrid.cpp b/src/propgrid/propgrid.cpp index 3ea759876c..202ee21929 100644 --- a/src/propgrid/propgrid.cpp +++ b/src/propgrid/propgrid.cpp @@ -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; } diff --git a/src/propgrid/propgridiface.cpp b/src/propgrid/propgridiface.cpp index fe95145514..d3b3d71714 100644 --- a/src/propgrid/propgridiface.cpp +++ b/src/propgrid/propgridiface.cpp @@ -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 diff --git a/src/propgrid/propgridpagestate.cpp b/src/propgrid/propgridpagestate.cpp index c45c1b1e65..dfb5543371 100644 --- a/src/propgrid/propgridpagestate.cpp +++ b/src/propgrid/propgridpagestate.cpp @@ -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() ) diff --git a/src/propgrid/props.cpp b/src/propgrid/props.cpp index 259e4e9d6c..fb0951d5b6 100644 --- a/src/propgrid/props.cpp +++ b/src/propgrid/props.cpp @@ -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;