initial commit

Signed-off-by: Peter Siegmund <mars3142@noreply.mars3142.dev>

libs/wxWidgets-3.3.1/include/wx/propgrid/propgridpagestate.h

@@ -0,0 +1,821 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/propgrid/propgridpagestate.h
+// Purpose:     wxPropertyGridPageState class
+// Author:      Jaakko Salli
+// Created:     2008-08-24
+// Copyright:   (c) Jaakko Salli
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_PROPGRID_PROPGRIDPAGESTATE_H_
+#define _WX_PROPGRID_PROPGRIDPAGESTATE_H_
+
+#include "wx/defs.h"
+
+#if wxUSE_PROPGRID
+
+#include "wx/propgrid/property.h"
+
+#include <set>
+#include <unordered_map>
+#include <vector>
+
+// -----------------------------------------------------------------------
+
+enum class wxPGSelectPropertyFlags : int
+{
+    // No flags
+    Null          = 0,
+    // Focuses to created editor
+    Focus         = 0x0001,
+    // Forces deletion and recreation of editor
+    Force         = 0x0002,
+    // For example, doesn't cause EnsureVisible
+    Nonvisible    = 0x0004,
+    // Do not validate editor's value before selecting
+    NoValidate    = 0x0008,
+    // Property being deselected is about to be deleted
+    Deleting      = 0x0010,
+    // Property's values was set to unspecified by the user
+    SetUnspec     = 0x0020,
+    // Property's event handler changed the value
+    DialogVal     = 0x0040,
+    // Set to disable sending of wxEVT_PG_SELECTED event
+    DontSendEvent = 0x0080,
+    // Don't make any graphics updates
+    NoRefresh     = 0x0100
+};
+
+#if WXWIN_COMPATIBILITY_3_2
+// These constants themselves intentionally don't use wxDEPRECATED_MSG()
+// because one will be given whenever they are used with any function now
+// taking wxPGSelectPropertyFlags anyhow and giving multiple deprecation
+// warnings for the same line of code is more annoying than helpful.
+enum wxPG_SELECT_PROPERTY_FLAGS
+{
+    wxPG_SEL_NONE = static_cast<int>(wxPGSelectPropertyFlags::Null),
+    wxPG_SEL_FOCUS = static_cast<int>(wxPGSelectPropertyFlags::Focus),
+    wxPG_SEL_FORCE = static_cast<int>(wxPGSelectPropertyFlags::Force),
+    wxPG_SEL_NONVISIBLE = static_cast<int>(wxPGSelectPropertyFlags::Nonvisible),
+    wxPG_SEL_NOVALIDATE = static_cast<int>(wxPGSelectPropertyFlags::NoValidate),
+    wxPG_SEL_DELETING = static_cast<int>(wxPGSelectPropertyFlags::Deleting),
+    wxPG_SEL_SETUNSPEC = static_cast<int>(wxPGSelectPropertyFlags::SetUnspec),
+    wxPG_SEL_DIALOGVAL = static_cast<int>(wxPGSelectPropertyFlags::DialogVal),
+    wxPG_SEL_DONT_SEND_EVENT = static_cast<int>(wxPGSelectPropertyFlags::DontSendEvent),
+    wxPG_SEL_NO_REFRESH = static_cast<int>(wxPGSelectPropertyFlags::NoRefresh),
+};
+
+wxDEPRECATED_MSG("use wxPGSelectPropertyFlags instead")
+constexpr bool operator==(wxPGSelectPropertyFlags a, int b)
+{
+    return static_cast<int>(a) == b;
+}
+
+wxDEPRECATED_MSG("use wxPGSelectPropertyFlags instead")
+constexpr bool operator!=(wxPGSelectPropertyFlags a, int b)
+{
+    return static_cast<int>(a) != b;
+}
+#endif // WXWIN_COMPATIBILITY_3_2
+
+constexpr wxPGSelectPropertyFlags operator|(wxPGSelectPropertyFlags a, wxPGSelectPropertyFlags b)
+{
+    return static_cast<wxPGSelectPropertyFlags>(static_cast<int>(a) | static_cast<int>(b));
+}
+
+inline wxPGSelectPropertyFlags operator|=(wxPGSelectPropertyFlags& a, wxPGSelectPropertyFlags b)
+{
+    return a = a | b;
+}
+
+constexpr wxPGSelectPropertyFlags operator&(wxPGSelectPropertyFlags a, wxPGSelectPropertyFlags b)
+{
+    return static_cast<wxPGSelectPropertyFlags>(static_cast<int>(a) & static_cast<int>(b));
+}
+
+constexpr bool operator!(wxPGSelectPropertyFlags a)
+{
+    return static_cast<int>(a) == 0;
+}
+
+// -----------------------------------------------------------------------
+
+// DoSetSplitter() flags
+
+enum class wxPGSplitterPositionFlags : int
+{
+    Null           = 0,
+    Refresh        = 0x0001,
+    AllPages       = 0x0002,
+    FromEvent      = 0x0004,
+    FromAutoCenter = 0x0008
+};
+
+constexpr wxPGSplitterPositionFlags operator&(wxPGSplitterPositionFlags a, wxPGSplitterPositionFlags b)
+{
+    return static_cast<wxPGSplitterPositionFlags>(static_cast<int>(a) & static_cast<int>(b));
+}
+
+constexpr wxPGSplitterPositionFlags operator|(wxPGSplitterPositionFlags a, wxPGSplitterPositionFlags b)
+{
+    return static_cast<wxPGSplitterPositionFlags>(static_cast<int>(a) | static_cast<int>(b));
+}
+
+constexpr bool operator!(wxPGSplitterPositionFlags a)
+{
+    return static_cast<int>(a) == 0;
+}
+
+#if WXWIN_COMPATIBILITY_3_2
+// See comment before wxPG_SEL_NONE above.
+enum wxPG_SET_SPLITTER_POSITION_SPLITTER_FLAGS
+{
+    wxPG_SPLITTER_REFRESH = static_cast<int>(wxPGSplitterPositionFlags::Refresh),
+    wxPG_SPLITTER_ALL_PAGES = static_cast<int>(wxPGSplitterPositionFlags::AllPages),
+    wxPG_SPLITTER_FROM_EVENT = static_cast<int>(wxPGSplitterPositionFlags::FromEvent),
+    wxPG_SPLITTER_FROM_AUTO_CENTER = static_cast<int>(wxPGSplitterPositionFlags::FromAutoCenter),
+};
+
+wxDEPRECATED_MSG("use wxPGSplitterPositionFlags instead")
+constexpr bool operator==(wxPGSplitterPositionFlags a, int b)
+{
+    return static_cast<int>(a) == b;
+}
+
+wxDEPRECATED_MSG("use wxPGSplitterPositionFlags instead")
+constexpr bool operator!=(wxPGSplitterPositionFlags a, int b)
+{
+    return static_cast<int>(a) != b;
+}
+#endif // WXWIN_COMPATIBILITY_3_2
+
+// -----------------------------------------------------------------------
+
+// A return value from wxPropertyGrid::HitTest(),
+// contains all you need to know about an arbitrary location on the grid.
+class WXDLLIMPEXP_PROPGRID wxPropertyGridHitTestResult
+{
+    friend class wxPropertyGridPageState;
+public:
+    wxPropertyGridHitTestResult()
+        : m_property(nullptr)
+        , m_column(-1)
+        , m_splitter(-1)
+        , m_splitterHitOffset(0)
+    {
+    }
+
+    ~wxPropertyGridHitTestResult() = default;
+
+    // Returns column hit. -1 for margin.
+    int GetColumn() const { return m_column; }
+
+    // Returns property hit. nullptr if empty space below
+    // properties was hit instead.
+    wxPGProperty* GetProperty() const
+    {
+        return m_property;
+    }
+
+    // Returns index of splitter hit, -1 for none.
+    int GetSplitter() const { return m_splitter; }
+
+    // If splitter hit, then this member function
+    // returns offset to the exact splitter position.
+    int GetSplitterHitOffset() const { return m_splitterHitOffset; }
+
+private:
+    // Property. nullptr if empty space below properties was hit.
+    wxPGProperty*   m_property;
+
+    // Column. -1 for margin.
+    int             m_column;
+
+    // Index of splitter hit, -1 for none.
+    int             m_splitter;
+
+    // If splitter hit, offset to that.
+    int             m_splitterHitOffset;
+};
+
+// -----------------------------------------------------------------------
+
+#define wxPG_IT_CHILDREN(A)         ((A)<<16)
+
+// NOTES: At lower 16-bits, there are flags to check if item will be included.
+// At higher 16-bits, there are same flags, but to instead check if children
+// will be included.
+enum wxPG_ITERATOR_FLAGS
+{
+
+// Iterate through 'normal' property items (does not include children of
+// aggregate or hidden items by default).
+wxPG_ITERATE_PROPERTIES = wxPGFlags::Property |
+                          wxPGFlags::MiscParent |
+                          wxPGFlags::Aggregate |
+                          wxPGFlags::Collapsed |
+                          wxPG_IT_CHILDREN(wxPGFlags::MiscParent) |
+                          wxPG_IT_CHILDREN(wxPGFlags::Category),
+
+// Iterate children of collapsed parents, and individual items that are hidden.
+wxPG_ITERATE_HIDDEN = wxPGFlags::Hidden |
+                      wxPG_IT_CHILDREN(wxPGFlags::Collapsed),
+
+// Iterate children of parent that is an aggregate property (ie has fixed
+// children).
+wxPG_ITERATE_FIXED_CHILDREN = wxPG_IT_CHILDREN(wxPGFlags::Aggregate) |
+                              wxPG_ITERATE_PROPERTIES,
+
+// Iterate categories.
+// Note that even without this flag, children of categories are still iterated
+// through.
+wxPG_ITERATE_CATEGORIES = wxPGFlags::Category |
+                          wxPG_IT_CHILDREN(wxPGFlags::Category) |
+                          wxPGFlags::Collapsed,
+
+wxPG_ITERATE_ALL_PARENTS = static_cast<int>(wxPGFlags::MiscParent |
+                           wxPGFlags::Aggregate |
+                           wxPGFlags::Category),
+
+wxPG_ITERATE_ALL_PARENTS_RECURSIVELY = wxPG_ITERATE_ALL_PARENTS |
+                                       wxPG_IT_CHILDREN(
+                                                wxPG_ITERATE_ALL_PARENTS),
+
+wxPG_ITERATOR_FLAGS_ALL = static_cast<int>(wxPGFlags::Property |
+                          wxPGFlags::MiscParent |
+                          wxPGFlags::Aggregate |
+                          wxPGFlags::Hidden |
+                          wxPGFlags::Category |
+                          wxPGFlags::Collapsed),
+
+wxPG_ITERATOR_MASK_OP_ITEM = wxPG_ITERATOR_FLAGS_ALL,
+
+// (wxPGFlags::MiscParent|wxPGFlags::Aggregate|wxPGFlags::Category)
+wxPG_ITERATOR_MASK_OP_PARENT = wxPG_ITERATOR_FLAGS_ALL,
+
+// Combines all flags needed to iterate through visible properties
+// (ie. hidden properties and children of collapsed parents are skipped).
+wxPG_ITERATE_VISIBLE = wxPG_ITERATE_PROPERTIES |
+                       wxPGFlags::Category |
+                       wxPG_IT_CHILDREN(wxPGFlags::Aggregate),
+
+// Iterate all items.
+wxPG_ITERATE_ALL = wxPG_ITERATE_VISIBLE |
+                   wxPG_ITERATE_HIDDEN,
+
+// Iterate through individual properties (ie categories and children of
+// aggregate properties are skipped).
+wxPG_ITERATE_NORMAL = wxPG_ITERATE_PROPERTIES |
+                      wxPG_ITERATE_HIDDEN,
+
+// Default iterator flags.
+wxPG_ITERATE_DEFAULT = wxPG_ITERATE_NORMAL
+
+};
+
+inline void wxPGCreateIteratorMasks(int flags, wxPGFlags& itemExMask, wxPGFlags& parentExMask)
+{
+    itemExMask = static_cast<wxPGFlags>((flags ^ wxPG_ITERATOR_MASK_OP_ITEM) &
+        wxPG_ITERATOR_MASK_OP_ITEM & 0xFFFF);
+    parentExMask = static_cast<wxPGFlags>(((flags >> 16) ^ wxPG_ITERATOR_MASK_OP_PARENT) &
+        wxPG_ITERATOR_MASK_OP_PARENT & 0xFFFF);
+}
+
+#if WXWIN_COMPATIBILITY_3_2
+#ifdef wxPG_MUST_DEPRECATE_MACRO_NAME
+#pragma deprecated(wxPG_ITERATOR_CREATE_MASKS)
+#endif
+#define wxPG_ITERATOR_CREATE_MASKS wxPG_DEPRECATED_MACRO_VALUE(wxPGCreateIteratorMasks,\
+                 "wxPG_ITERATOR_CREATE_MASKS is deprecated. Call wxPGCreateIteratorMasks instead.")
+#endif // WXWIN_COMPATIBILITY_3_2
+
+// Base for wxPropertyGridIterator classes.
+class WXDLLIMPEXP_PROPGRID wxPropertyGridIteratorBase
+{
+protected:
+    wxPropertyGridIteratorBase() = default;
+
+public:
+    void Assign( const wxPropertyGridIteratorBase& it );
+
+    bool AtEnd() const { return m_property == nullptr; }
+
+    // Get current property.
+    wxPGProperty* GetProperty() const { return m_property; }
+
+    void Init( wxPropertyGridPageState* state,
+               int flags,
+               wxPGProperty* property,
+               int dir = 1 );
+
+    void Init( wxPropertyGridPageState* state,
+               int flags,
+               int startPos = wxTOP,
+               int dir = 0 );
+
+    // Iterate to the next property.
+    void Next( bool iterateChildren = true );
+
+    // Iterate to the previous property.
+    void Prev();
+
+    // Set base parent, i.e. a property when, in which iteration returns, it
+    // ends.
+    // Default base parent is the root of the used wxPropertyGridPageState.
+    void SetBaseParent( wxPGProperty* baseParent )
+        { m_baseParent = baseParent; }
+
+protected:
+
+    wxPGProperty*               m_property;
+
+private:
+    wxPropertyGridPageState*        m_state;
+    wxPGProperty*               m_baseParent;
+
+    // Masks are used to quickly exclude items
+    wxPGFlags           m_itemExMask;
+    wxPGFlags           m_parentExMask;
+};
+
+template <typename PROPERTY, typename STATE>
+class wxPGIterator : public wxPropertyGridIteratorBase
+{
+public:
+    wxPGIterator(STATE* state, int flags = wxPG_ITERATE_DEFAULT,
+                 PROPERTY* property = nullptr, int dir = 1)
+        : wxPropertyGridIteratorBase()
+    {
+        Init(const_cast<wxPropertyGridPageState*>(state), flags, const_cast<wxPGProperty*>(property), dir);
+    }
+    wxPGIterator(STATE* state, int flags, int startPos, int dir = 0)
+        : wxPropertyGridIteratorBase()
+    {
+        Init(const_cast<wxPropertyGridPageState*>(state), flags, startPos, dir);
+    }
+    wxPGIterator()
+        : wxPropertyGridIteratorBase()
+    {
+        m_property = nullptr;
+    }
+    wxPGIterator(const wxPGIterator& it)
+        : wxPropertyGridIteratorBase()
+    {
+        Assign(it);
+    }
+    ~wxPGIterator() = default;
+
+    wxPGIterator& operator=(const wxPGIterator& it)
+    {
+        if ( this != &it )
+            Assign(it);
+        return *this;
+    }
+
+    wxPGIterator& operator++() { Next(); return *this; }
+    wxPGIterator operator++(int) { wxPGIterator it = *this; Next(); return it; }
+    wxPGIterator& operator--() { Prev(); return *this; }
+    wxPGIterator operator--(int) { wxPGIterator it = *this; Prev(); return it; }
+    PROPERTY* operator *() const { return const_cast<PROPERTY*>(m_property); }
+    static PROPERTY* OneStep(STATE* state, int flags = wxPG_ITERATE_DEFAULT,
+                             PROPERTY* property = nullptr, int dir = 1)
+    {
+        wxPGIterator it(state, flags, property, dir);
+        if ( property )
+        {
+            if ( dir == 1 )
+                it.Next();
+            else
+                it.Prev();
+        }
+        return *it;
+    }
+};
+
+// Preferable way to iterate through contents of wxPropertyGrid,
+// wxPropertyGridManager, and wxPropertyGridPage.
+// See wxPropertyGridInterface::GetIterator() for more information about usage.
+typedef wxPGIterator<wxPGProperty, wxPropertyGridPageState> wxPropertyGridIterator;
+typedef wxPGIterator<const wxPGProperty, const wxPropertyGridPageState> wxPropertyGridConstIterator;
+
+// -----------------------------------------------------------------------
+
+// Base class to derive new viterators.
+class WXDLLIMPEXP_PROPGRID wxPGVIteratorBase : public wxObjectRefData
+{
+    friend class wxPGVIterator;
+public:
+    wxPGVIteratorBase() = default;
+    virtual void Next() = 0;
+    virtual bool AtEnd() const = 0;
+protected:
+    virtual ~wxPGVIteratorBase() = default;
+
+    wxPropertyGridIterator  m_it;
+};
+
+// Abstract implementation of a simple iterator. Can only be used
+// to iterate in forward order, and only through the entire container.
+// Used to have functions dealing with all properties work with both
+// wxPropertyGrid and wxPropertyGridManager.
+class WXDLLIMPEXP_PROPGRID wxPGVIterator
+{
+public:
+    wxPGVIterator() { m_pIt = nullptr; }
+    wxPGVIterator( wxPGVIteratorBase* obj ) { m_pIt = obj; }
+    ~wxPGVIterator() { UnRef(); }
+    void UnRef() { if (m_pIt) m_pIt->DecRef(); }
+    wxPGVIterator( const wxPGVIterator& it )
+    {
+        m_pIt = it.m_pIt;
+        m_pIt->IncRef();
+    }
+    const wxPGVIterator& operator=( const wxPGVIterator& it )
+    {
+        if (this != &it)
+        {
+            UnRef();
+            m_pIt = it.m_pIt;
+            m_pIt->IncRef();
+        }
+        return *this;
+    }
+    void Next() { m_pIt->Next(); }
+    bool AtEnd() const { return m_pIt->AtEnd(); }
+    wxPGProperty* GetProperty() const { return m_pIt->m_it.GetProperty(); }
+protected:
+    wxPGVIteratorBase*  m_pIt;
+};
+
+// -----------------------------------------------------------------------
+
+// Contains low-level property page information (properties, column widths,
+// etc.) of a single wxPropertyGrid or single wxPropertyGridPage. Generally you
+// should not use this class directly, but instead member functions in
+// wxPropertyGridInterface, wxPropertyGrid, wxPropertyGridPage, and
+// wxPropertyGridManager.
+// - Currently this class is not implemented in wxPython.
+class WXDLLIMPEXP_PROPGRID wxPropertyGridPageState
+{
+    friend class wxPropertyGrid;
+    friend class wxPropertyGridInterface;
+    friend class wxPropertyGridPage;
+    friend class wxPropertyGridManager;
+    friend class wxPGProperty;
+    friend class wxFlagsProperty;
+    friend class wxPropertyGridIteratorBase;
+    friend class wxPropertyGridXmlHandler;
+public:
+
+    // Default constructor.
+    wxPropertyGridPageState();
+
+    // Destructor.
+    virtual ~wxPropertyGridPageState();
+
+    // Makes sure all columns have minimum width.
+    void CheckColumnWidths( int widthChange = 0 );
+
+    // Override this member function to add custom behaviour on property
+    // deletion.
+    virtual void DoDelete( wxPGProperty* item, bool doDelete = true );
+
+    // Override this member function to add custom behaviour on property
+    // insertion.
+    virtual wxPGProperty* DoInsert( wxPGProperty* parent,
+                                    int index,
+                                    wxPGProperty* property );
+
+    // This needs to be overridden in grid used the manager so that splitter
+    // changes can be propagated to other pages.
+    virtual void DoSetSplitter(int pos,
+                               int splitterColumn = 0,
+                               wxPGSplitterPositionFlags
+                                flags = wxPGSplitterPositionFlags::Null);
+
+#if WXWIN_COMPATIBILITY_3_2
+    wxDEPRECATED_MSG("use DoSetSplitter() taking wxPGSplitterPositionFlags")
+    virtual void DoSetSplitterPosition(int pos, int splitterColumn, int flags)
+    {
+        DoSetSplitter(pos, splitterColumn, static_cast<wxPGSplitterPositionFlags>(flags));
+    }
+#endif // WXWIN_COMPATIBILITY_3_2
+
+    bool EnableCategories( bool enable );
+
+    // Make sure virtual height is up-to-date.
+    void EnsureVirtualHeight()
+    {
+        if ( m_vhCalcPending )
+        {
+            RecalculateVirtualHeight();
+            m_vhCalcPending = false;
+        }
+    }
+
+    // Returns (precalculated) height of contained visible properties.
+    unsigned int GetVirtualHeight() const
+    {
+        wxASSERT( !m_vhCalcPending );
+        return m_virtualHeight;
+    }
+
+    // Returns (precalculated) height of contained visible properties.
+    unsigned int GetVirtualHeight()
+    {
+        EnsureVirtualHeight();
+        return m_virtualHeight;
+    }
+
+    // Returns actual height of contained visible properties.
+    // Mostly used for internal diagnostic purposes.
+    unsigned int GetActualVirtualHeight() const;
+
+    unsigned int GetColumnCount() const
+    {
+        return (unsigned int) m_colWidths.size();
+    }
+
+    int GetColumnMinWidth( int column ) const;
+
+    int GetColumnWidth( unsigned int column ) const
+    {
+        return m_colWidths[column];
+    }
+
+    wxPropertyGrid* GetGrid() const { return m_pPropGrid; }
+
+    // Returns last item which could be iterated using given flags.
+    wxPGProperty* GetLastItem( int flags = wxPG_ITERATE_DEFAULT );
+
+    const wxPGProperty* GetLastItem( int flags = wxPG_ITERATE_DEFAULT ) const
+    {
+        return const_cast<wxPropertyGridPageState*>(this)->GetLastItem(flags);
+    }
+
+    // Returns currently selected property.
+    wxPGProperty* GetSelection() const
+    {
+        return m_selection.empty()? nullptr: m_selection[0];
+    }
+
+    wxPropertyCategory* GetPropertyCategory( const wxPGProperty* p ) const;
+
+#if WXWIN_COMPATIBILITY_3_0
+    wxDEPRECATED_MSG("don't refer directly to wxPropertyGridPageState::GetPropertyByLabel")
+    wxPGProperty* GetPropertyByLabel( const wxString& name,
+                                      wxPGProperty* parent = nullptr ) const;
+#endif // WXWIN_COMPATIBILITY_3_0
+
+    // Returns combined width of margin and all the columns
+    int GetVirtualWidth() const
+    {
+        return m_width;
+    }
+
+#if WXWIN_COMPATIBILITY_3_0
+    wxDEPRECATED_MSG("call GetColumnFullWidth(wxPGProperty*, int) instead")
+    int GetColumnFullWidth(const wxDC& dc, wxPGProperty* p, unsigned int col);
+#endif // WXWIN_COMPATIBILITY_3_0
+    int GetColumnFullWidth(wxPGProperty* p, unsigned int col) const;
+
+    // Returns information about arbitrary position in the grid.
+    // pt - Logical coordinates in the virtual grid space. Use
+    //   wxScrolled<T>::CalcUnscrolledPosition() if you need to
+    //   translate a scrolled position into a logical one.
+    wxPropertyGridHitTestResult HitTest( const wxPoint& pt ) const;
+
+    // Returns true if page is visibly displayed.
+    bool IsDisplayed() const;
+
+    bool IsInNonCatMode() const { return m_properties == m_abcArray; }
+
+    // Called after virtual height needs to be recalculated.
+    void VirtualHeightChanged()
+    {
+        m_vhCalcPending = true;
+    }
+
+protected:
+    wxSize DoFitColumns(bool allowGridResize = false);
+
+    wxPGProperty* DoGetItemAtY(int y) const;
+
+    void DoSetSelection(wxPGProperty* prop)
+    {
+        m_selection.clear();
+        if (prop)
+            m_selection.push_back(prop);
+    }
+
+    bool DoClearSelection()
+    {
+        return DoSelectProperty(nullptr);
+    }
+
+    void DoRemoveFromSelection(wxPGProperty* prop);
+
+    void DoSetColumnProportion(unsigned int column, int proportion);
+
+    int DoGetColumnProportion(unsigned int column) const
+    {
+        return m_columnProportions[column];
+    }
+
+    wxVariant DoGetPropertyValues(const wxString& listname, wxPGProperty* baseparent,
+                                  wxPGPropertyValuesFlags flags) const;
+
+    wxPGProperty* DoGetRoot() const { return m_properties; }
+
+    void DoSetPropertyName(wxPGProperty* p, const wxString& newName);
+
+    // Utility to check if two properties are visibly next to each other
+    bool ArePropertiesAdjacent( wxPGProperty* prop1,
+                                wxPGProperty* prop2,
+                                int iterFlags = wxPG_ITERATE_VISIBLE ) const;
+
+    int DoGetSplitterPosition( int splitterIndex = 0 ) const;
+
+    void DoLimitPropertyEditing(wxPGProperty* p, bool limit = true)
+    {
+        p->SetFlagRecursively(wxPGFlags::NoEditor, limit);
+    }
+
+    bool DoSelectProperty(wxPGProperty* p, wxPGSelectPropertyFlags flags = wxPGSelectPropertyFlags::Null);
+
+    // Base append.
+    wxPGProperty* DoAppend(wxPGProperty* property);
+
+    // Called in, for example, wxPropertyGrid::Clear.
+    void DoClear();
+
+    bool DoIsPropertySelected(wxPGProperty* prop) const;
+
+    bool DoCollapse(wxPGProperty* p);
+
+    bool DoExpand(wxPGProperty* p);
+
+    // Returns column at x coordinate (in GetGrid()->GetPanel()).
+    // pSplitterHit - Give pointer to int that receives index to splitter that is at x.
+    // pSplitterHitOffset - Distance from said splitter.
+    int HitTestH( int x, int* pSplitterHit, int* pSplitterHitOffset ) const;
+
+    bool PrepareToAddItem( wxPGProperty* property,
+                           wxPGProperty* scheduledParent );
+
+    // Returns property by its label.
+    wxPGProperty* BaseGetPropertyByLabel( const wxString& label,
+                                      const wxPGProperty* parent = nullptr ) const;
+
+    // Unselect sub-properties.
+    void DoRemoveChildrenFromSelection(wxPGProperty* p, bool recursive,
+                                       wxPGSelectPropertyFlags selFlags);
+
+    // Mark sub-properties as being deleted.
+    void DoMarkChildrenAsDeleted(wxPGProperty* p, bool recursive);
+
+    // Rename the property
+    // so it won't remain in the way of the user code.
+    void DoInvalidatePropertyName(wxPGProperty* p);
+
+    // Rename sub-properties
+    // so it won't remain in the way of the user code.
+    void DoInvalidateChildrenNames(wxPGProperty* p, bool recursive);
+
+    bool DoHideProperty(wxPGProperty* p, bool hide, wxPGPropertyValuesFlags flags = wxPGPropertyValuesFlags::Recurse);
+
+    bool DoSetPropertyValueString(wxPGProperty* p, const wxString& value);
+
+    bool DoSetPropertyValue(wxPGProperty* p, wxVariant& value);
+
+    bool DoSetPropertyValueWxObjectPtr(wxPGProperty* p, wxObject* value);
+    void DoSetPropertyValues(const wxVariantList& list,
+                             wxPGProperty* default_category);
+
+    void DoSortChildren(wxPGProperty* p, wxPGPropertyValuesFlags flags = wxPGPropertyValuesFlags::DontRecurse);
+    void DoSort(wxPGPropertyValuesFlags flags = wxPGPropertyValuesFlags::DontRecurse);
+
+    // widthChange is non-client.
+    void OnClientWidthChange(int newWidth, int widthChange, bool fromOnResize = false);
+
+    // Check if property contains given sub-category.
+    bool IsChildCategory(wxPGProperty* p,
+                         wxPropertyCategory* cat, bool recursive);
+
+    void PropagateColSizeDec(int column, int decrease, int dir);
+
+    void CalculateFontAndBitmapStuff(int vspacing);
+
+    // Returns property by its name.
+    wxPGProperty* BaseGetPropertyByName(const wxString& name) const;
+
+    // Returns minimal width for given column so that all images and texts
+    // will fit entirely.
+    // Used by SetSplitterLeft() and DoFitColumns().
+#if WXWIN_COMPATIBILITY_3_0
+    wxDEPRECATED_MSG("call GetColumnFitWidth(wxPGProperty*, int, bool) instead")
+    int GetColumnFitWidth(const wxDC& dc, wxPGProperty* pwc,
+                          unsigned int col, bool subProps) const;
+#endif // WXWIN_COMPATIBILITY_3_0
+    int GetColumnFitWidth(const wxPGProperty* p, unsigned int col, bool subProps) const;
+
+    void SetSplitterLeft(bool subProps = false);
+
+    void SetColumnCount(int colCount);
+
+#if WXWIN_COMPATIBILITY_3_2
+    wxDEPRECATED_MSG("use ResetColumnSizes with wxPGSplitterPositionFlags argument")
+    void ResetColumnSizes(int setSplitterFlags)
+    {
+        ResetColumnSizes(static_cast<wxPGSplitterPositionFlags>(setSplitterFlags));
+    }
+#endif // WXWIN_COMPATIBILITY_3_2
+    void ResetColumnSizes(wxPGSplitterPositionFlags setSplitterFlags);
+
+    bool PrepareAfterItemsAdded();
+
+    // Recalculates m_virtualHeight.
+    void RecalculateVirtualHeight()
+    {
+        m_virtualHeight = GetActualVirtualHeight();
+    }
+
+    // Set virtual width for this particular page.
+    void SetVirtualWidth(int width);
+
+    // If visible, then this is pointer to wxPropertyGrid.
+    // This shall *never* be null to indicate that this state is not visible.
+    wxPropertyGrid*             m_pPropGrid;
+
+    // Pointer to currently used array.
+    wxPGProperty*               m_properties;
+
+    // Array for categoric mode.
+    wxPGRootProperty            m_regularArray;
+
+    // Array for root of non-categoric mode.
+    wxPGRootProperty*           m_abcArray;
+
+    // Dictionary for name-based access.
+    std::unordered_map<wxString, wxPGProperty*> m_dictName;
+
+    // List of column widths (first column does not include margin).
+    std::vector<int>            m_colWidths;
+
+    // List of indices of columns the user can edit by clicking it.
+    std::set<unsigned int>      m_editableColumns;
+
+    // Column proportions.
+    std::vector<int>            m_columnProportions;
+
+    double                      m_fSplitterX;
+
+    // Most recently added category.
+    wxPropertyCategory*         m_currentCategory;
+
+    // Array of selected property.
+    wxArrayPGProperty           m_selection;
+
+    // Virtual width.
+    int                         m_width;
+
+    // Indicates total virtual height of visible properties.
+    unsigned int                m_virtualHeight;
+
+#if WXWIN_COMPATIBILITY_3_0
+    // 1 items appended/inserted, so stuff needs to be done before drawing;
+    // If m_virtualHeight == 0, then calcylatey's must be done.
+    // Otherwise just sort.
+    unsigned char               m_itemsAdded;
+
+    // 1 if any value is modified.
+    unsigned char               m_anyModified;
+
+    unsigned char               m_vhCalcPending;
+#else
+    // True: items appended/inserted, so stuff needs to be done before drawing;
+    // If m_virtualHeight == 0, then calcylatey's must be done.
+    // Otherwise just sort.
+    bool                        m_itemsAdded;
+
+    // True if any value is modified.
+    bool                        m_anyModified;
+
+    bool                        m_vhCalcPending;
+#endif // WXWIN_COMPATIBILITY_3_0
+
+    // True if splitter has been pre-set by the application.
+    bool                        m_isSplitterPreSet;
+
+    // Used to (temporarily) disable splitter centering.
+    bool                        m_dontCenterSplitter;
+
+private:
+    void InitNonCatMode();
+};
+
+// -----------------------------------------------------------------------
+
+#endif // wxUSE_PROPGRID
+
+#endif // _WX_PROPGRID_PROPGRIDPAGESTATE_H_