initial commit

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

libs/wxWidgets-3.3.1/include/wx/xrc/xh_activityindicator.h

@@ -0,0 +1,31 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_activityindicator.h
+// Purpose:     Declaration of wxActivityIndicator XRC handler.
+// Author:      Vadim Zeitlin
+// Created:     2015-03-18
+// Copyright:   (c) 2015 Vadim Zeitlin <vadim@wxwidgets.org>
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_ACTIVITYINDICATOR_H_
+#define _WX_XH_ACTIVITYINDICATOR_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_ACTIVITYINDICATOR
+
+class WXDLLIMPEXP_XRC wxActivityIndicatorXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxActivityIndicatorXmlHandler();
+
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    wxDECLARE_DYNAMIC_CLASS(wxActivityIndicatorXmlHandler);
+};
+
+#endif // wxUSE_XRC && wxUSE_ACTIVITYINDICATOR
+
+#endif // _WX_XH_ACTIVITYINDICATOR_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_all.h

@@ -0,0 +1,84 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_all.h
+// Purpose:     includes all xh_*.h files
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_ALL_H_
+#define _WX_XH_ALL_H_
+
+
+// Existing handlers:
+
+#include "wx/xrc/xh_activityindicator.h"
+#include "wx/xrc/xh_animatctrl.h"
+#include "wx/xrc/xh_bannerwindow.h"
+#include "wx/xrc/xh_bmp.h"
+#include "wx/xrc/xh_bmpbt.h"
+#include "wx/xrc/xh_bmpcbox.h"
+#include "wx/xrc/xh_bttn.h"
+#include "wx/xrc/xh_cald.h"
+#include "wx/xrc/xh_chckb.h"
+#include "wx/xrc/xh_chckl.h"
+#include "wx/xrc/xh_choic.h"
+#include "wx/xrc/xh_choicbk.h"
+#include "wx/xrc/xh_clrpicker.h"
+#include "wx/xrc/xh_cmdlinkbn.h"
+#include "wx/xrc/xh_collpane.h"
+#include "wx/xrc/xh_combo.h"
+#include "wx/xrc/xh_comboctrl.h"
+#include "wx/xrc/xh_dataview.h"
+#include "wx/xrc/xh_datectrl.h"
+#include "wx/xrc/xh_dirpicker.h"
+#include "wx/xrc/xh_dlg.h"
+#include "wx/xrc/xh_editlbox.h"
+#include "wx/xrc/xh_filectrl.h"
+#include "wx/xrc/xh_filepicker.h"
+#include "wx/xrc/xh_fontpicker.h"
+#include "wx/xrc/xh_frame.h"
+#include "wx/xrc/xh_gauge.h"
+#include "wx/xrc/xh_gdctl.h"
+#include "wx/xrc/xh_grid.h"
+#include "wx/xrc/xh_html.h"
+#include "wx/xrc/xh_htmllbox.h"
+#include "wx/xrc/xh_hyperlink.h"
+#include "wx/xrc/xh_infobar.h"
+#include "wx/xrc/xh_listb.h"
+#include "wx/xrc/xh_listc.h"
+#include "wx/xrc/xh_listbk.h"
+#include "wx/xrc/xh_mdi.h"
+#include "wx/xrc/xh_menu.h"
+#include "wx/xrc/xh_notbk.h"
+#include "wx/xrc/xh_odcombo.h"
+#include "wx/xrc/xh_panel.h"
+#include "wx/xrc/xh_propdlg.h"
+#include "wx/xrc/xh_radbt.h"
+#include "wx/xrc/xh_radbx.h"
+#include "wx/xrc/xh_scrol.h"
+#include "wx/xrc/xh_scwin.h"
+#include "wx/xrc/xh_simplebook.h"
+#include "wx/xrc/xh_sizer.h"
+#include "wx/xrc/xh_slidr.h"
+#include "wx/xrc/xh_spin.h"
+#include "wx/xrc/xh_split.h"
+#include "wx/xrc/xh_srchctrl.h"
+#include "wx/xrc/xh_statbar.h"
+#include "wx/xrc/xh_stbox.h"
+#include "wx/xrc/xh_stbmp.h"
+#include "wx/xrc/xh_sttxt.h"
+#include "wx/xrc/xh_stlin.h"
+#include "wx/xrc/xh_text.h"
+#include "wx/xrc/xh_tglbtn.h"
+#include "wx/xrc/xh_timectrl.h"
+#include "wx/xrc/xh_toolb.h"
+#include "wx/xrc/xh_toolbk.h"
+#include "wx/xrc/xh_tree.h"
+#include "wx/xrc/xh_treebk.h"
+#include "wx/xrc/xh_unkwn.h"
+#include "wx/xrc/xh_vlistbox.h"
+#include "wx/xrc/xh_wizrd.h"
+
+#endif // _WX_XH_ALL_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_animatctrl.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_animatctrl.h
+// Purpose:     XML resource handler for wxAnimationCtrl
+// Author:      Francesco Montorsi
+// Created:     2006-10-15
+// Copyright:   (c) 2006 Francesco Montorsi
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_ANIMATIONCTRL_H_
+#define _WX_XH_ANIMATIONCTRL_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_ANIMATIONCTRL
+
+class WXDLLIMPEXP_XRC wxAnimationCtrlXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxAnimationCtrlXmlHandler);
+
+public:
+    wxAnimationCtrlXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_ANIMATIONCTRL
+
+#endif // _WX_XH_ANIMATIONCTRL_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_aui.h

@@ -0,0 +1,51 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_aui.h
+// Purpose:     XRC resource handler for wxAUI
+// Author:      Andrea Zanellato, Steve Lamerton (wxAuiNotebook)
+// Created:     2011-09-18
+// Copyright:   (c) 2011 wxWidgets Team
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_AUI_H_
+#define _WX_XH_AUI_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_AUI
+
+#include "wx/vector.h"
+
+class WXDLLIMPEXP_FWD_AUI wxAuiManager;
+class WXDLLIMPEXP_FWD_AUI wxAuiNotebook;
+
+class WXDLLIMPEXP_AUI wxAuiXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxAuiXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+    // Returns the wxAuiManager for the specified window
+    wxAuiManager *GetAuiManager(wxWindow *managed) const;
+
+private:
+    // Used to UnInit() the wxAuiManager before destroying its managed window
+    void OnManagedWindowClose(wxWindowDestroyEvent &event);
+
+    typedef wxVector<wxAuiManager*> Managers;
+    Managers m_managers; // all wxAuiManagers created in this handler
+
+    wxAuiManager    *m_manager;  // Current wxAuiManager
+    wxWindow        *m_window;   // Current managed wxWindow
+    wxAuiNotebook   *m_notebook;
+
+    bool m_mgrInside; // Are we handling a wxAuiManager or panes inside it?
+    bool m_anbInside; // Are we handling a wxAuiNotebook or pages inside it?
+
+    wxDECLARE_DYNAMIC_CLASS(wxAuiXmlHandler);
+};
+
+#endif //wxUSE_XRC && wxUSE_AUI
+
+#endif //_WX_XH_AUI_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_auitoolb.h

@@ -0,0 +1,51 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_toolb.h
+// Purpose:     XML resource handler for wxAuiToolBar
+// Author:      Rodolphe Suescun
+// Created:     2013-11-23
+// Copyright:   (c) 2013 Rodolphe Suescun
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_AUITOOLB_H_
+#define _WX_XH_AUITOOLB_H_
+
+#include "wx/aui/auibar.h"
+#include "wx/menu.h"
+#include "wx/vector.h"
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_AUI
+
+class WXDLLIMPEXP_FWD_AUI wxAuiToolBar;
+
+class WXDLLIMPEXP_AUI wxAuiToolBarXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxAuiToolBarXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    bool m_isInside;
+    wxAuiToolBar *m_toolbar;
+    wxSize m_toolSize;
+
+    class MenuHandler : public wxEvtHandler
+    {
+    public:
+        void OnDropDown(wxAuiToolBarEvent& event);
+        unsigned RegisterMenu(wxAuiToolBar *toobar, int id, wxMenu *menu);
+
+    private:
+        wxVector<wxMenu*> m_menus;
+    };
+
+    MenuHandler m_menuHandler;
+
+    wxDECLARE_DYNAMIC_CLASS(wxAuiToolBarXmlHandler);
+};
+
+#endif // wxUSE_XRC && wxUSE_AUI
+
+#endif // _WX_XH_AUITOOLB_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_bannerwindow.h

@@ -0,0 +1,30 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_bannerwindow.h
+// Purpose:     Declaration of wxBannerWindow XRC handler.
+// Author:      Vadim Zeitlin
+// Created:     2011-08-16
+// Copyright:   (c) 2011 Vadim Zeitlin <vadim@wxwidgets.org>
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_BANNERWINDOW_H_
+#define _WX_XH_BANNERWINDOW_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_BANNERWINDOW
+
+class WXDLLIMPEXP_XRC wxBannerWindowXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxBannerWindowXmlHandler();
+
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+    wxDECLARE_DYNAMIC_CLASS(wxBannerWindowXmlHandler);
+};
+
+#endif // wxUSE_XRC && wxUSE_BANNERWINDOW
+
+#endif // _WX_XH_BANNERWINDOW_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_bmp.h

@@ -0,0 +1,39 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_bmp.h
+// Purpose:     XML resource handler for wxBitmap and wxIcon
+// Author:      Vaclav Slavik
+// Created:     2000/09/00
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_BMP_H_
+#define _WX_XH_BMP_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC
+
+class WXDLLIMPEXP_XRC wxBitmapXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxBitmapXmlHandler);
+
+public:
+    wxBitmapXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+class WXDLLIMPEXP_XRC wxIconXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxIconXmlHandler);
+
+public:
+    wxIconXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC
+
+#endif // _WX_XH_BMP_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_bmpbt.h

@@ -0,0 +1,39 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_bmpbt.h
+// Purpose:     XML resource handler for bitmap buttons
+// Author:      Brian Gavin
+// Created:     2000/03/05
+// Copyright:   (c) 2000 Brian Gavin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_BMPBT_H_
+#define _WX_XH_BMPBT_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_BMPBUTTON
+
+#include "wx/bmpbuttn.h"
+
+class WXDLLIMPEXP_XRC wxBitmapButtonXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxBitmapButtonXmlHandler);
+
+public:
+    wxBitmapButtonXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    typedef void (wxBitmapButton::*BitmapSetter)(const wxBitmapBundle&);
+
+    void SetBitmapIfSpecified(wxBitmapButton* button,
+                              BitmapSetter setter,
+                              const char* paramName,
+                              const char* paramNameAlt = nullptr);
+};
+
+#endif // wxUSE_XRC && wxUSE_BMPBUTTON
+
+#endif // _WX_XH_BMPBT_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_bmpcbox.h

@@ -0,0 +1,35 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_bmpcbox.h
+// Purpose:     XML resource handler for wxBitmapComboBox
+// Author:      Jaakko Salli
+// Created:     Sep-10-2006
+// Copyright:   (c) 2006 Jaakko Salli
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_BMPCBOX_H_
+#define _WX_XH_BMPCBOX_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_BITMAPCOMBOBOX
+
+class WXDLLIMPEXP_FWD_CORE wxBitmapComboBox;
+
+class WXDLLIMPEXP_XRC wxBitmapComboBoxXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxBitmapComboBoxXmlHandler);
+
+public:
+    wxBitmapComboBoxXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    wxBitmapComboBox*    m_combobox;
+    bool                m_isInside;
+};
+
+#endif // wxUSE_XRC && wxUSE_BITMAPCOMBOBOX
+
+#endif // _WX_XH_BMPCBOX_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_bookctrlbase.h

@@ -0,0 +1,82 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_bookctrlbase.h
+// Purpose:     Base class for wxBookCtrl-derived classes XRC handlers
+// Author:      Vadim Zeitlin
+// Created:     2022-02-23
+// Copyright:   (c) 2022 Vadim Zeitlin <vadim@wxwidgets.org>
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XRC_XH_BOOKCTRLBASE_H_
+#define _WX_XRC_XH_BOOKCTRLBASE_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_BOOKCTRL
+
+class WXDLLIMPEXP_FWD_CORE wxBookCtrlBase;
+
+// ----------------------------------------------------------------------------
+// wxBookCtrlXmlHandlerBase: base class of handlers for wxBookCtrl subclasses
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_XRC wxBookCtrlXmlHandlerBase : public wxXmlResourceHandler
+{
+protected:
+    wxBookCtrlXmlHandlerBase();
+    virtual ~wxBookCtrlXmlHandlerBase();
+
+    // Create all pages under the current node and add them to the book control.
+    //
+    // This should be called instead of calling CreateChildren() directly by
+    // the derived class to deal with the contents of the book control node.
+    void DoCreatePages(wxBookCtrlBase* book);
+
+    // Create a new page using the contents of the current node.
+    //
+    // This should be called to handle the book control page node.
+    wxObject* DoCreatePage(wxBookCtrlBase* book);
+
+    // Return true if we're parsing the book control node itself.
+    bool IsInside() const { return m_isInside; }
+
+    // This struct contains the actual page, created by DoCreatePage(), and all
+    // its attributes read from wxXmlNode.
+    struct PageWithAttrs
+    {
+        PageWithAttrs();
+
+        // Returns bmpId if it's valid or imgId (which can still be invalid)
+        // otherwise.
+        int GetImageId() const;
+
+        wxWindow* wnd;
+        wxString label;
+        bool selected;
+        int imgId; // index in the image list
+        int bmpId; // index in m_bookImages vector
+    };
+
+private:
+    // This function is implemented by just calling AddPage() in the base
+    // class, but can be overridden if something else is needed, as is e.g. the
+    // case for wxTreebookXmlHandler.
+    virtual void
+    DoAddPage(wxBookCtrlBase* book, size_t n, const PageWithAttrs& page);
+
+
+    // And this vector contains all the pages created so far.
+    wxVector<PageWithAttrs> m_bookPages;
+
+    // All bitmaps defined for the pages, may be empty.
+    wxVector<wxBitmapBundle> m_bookImages;
+
+    // True if we're used for parsing the contents of the book control node.
+    bool m_isInside;
+
+    wxDECLARE_NO_COPY_CLASS(wxBookCtrlXmlHandlerBase);
+};
+
+#endif // wxUSE_XRC && wxUSE_BOOKCTRL
+
+#endif // _WX_XRC_XH_BOOKCTRLBASE_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_bttn.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_bttn.h
+// Purpose:     XML resource handler for buttons
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_BTTN_H_
+#define _WX_XH_BTTN_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_BUTTON
+
+class WXDLLIMPEXP_XRC wxButtonXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxButtonXmlHandler);
+
+public:
+    wxButtonXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_BUTTON
+
+#endif // _WX_XH_BTTN_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_cald.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_cald.h
+// Purpose:     XML resource handler for wxCalendarCtrl
+// Author:      Brian Gavin
+// Created:     2000/09/09
+// Copyright:   (c) 2000 Brian Gavin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_CALD_H_
+#define _WX_XH_CALD_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_CALENDARCTRL
+
+class WXDLLIMPEXP_XRC wxCalendarCtrlXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxCalendarCtrlXmlHandler);
+
+public:
+    wxCalendarCtrlXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_CALENDARCTRL
+
+#endif // _WX_XH_CALD_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_chckb.h

@@ -0,0 +1,30 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_chckb.h
+// Purpose:     XML resource handler for wxCheckBox
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_CHCKB_H_
+#define _WX_XH_CHCKB_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_CHECKBOX
+
+class WXDLLIMPEXP_XRC wxCheckBoxXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxCheckBoxXmlHandler);
+
+public:
+    wxCheckBoxXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_CHECKBOX
+
+#endif // _WX_XH_CHECKBOX_H_
+

libs/wxWidgets-3.3.1/include/wx/xrc/xh_chckl.h

@@ -0,0 +1,33 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_chckl.h
+// Purpose:     XML resource handler for wxCheckListBox
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_CHCKL_H_
+#define _WX_XH_CHCKL_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_CHECKLISTBOX
+
+class WXDLLIMPEXP_XRC wxCheckListBoxXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxCheckListBoxXmlHandler);
+
+public:
+    wxCheckListBoxXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    bool m_insideBox;
+    wxArrayString strList;
+};
+
+#endif // wxUSE_XRC && wxUSE_CHECKLISTBOX
+
+#endif // _WX_XH_CHECKLIST_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_choic.h

@@ -0,0 +1,33 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_choic.h
+// Purpose:     XML resource handler for wxChoice
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_CHOIC_H_
+#define _WX_XH_CHOIC_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_CHOICE
+
+class WXDLLIMPEXP_XRC wxChoiceXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxChoiceXmlHandler);
+
+public:
+    wxChoiceXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    bool m_insideBox;
+    wxArrayString strList;
+};
+
+#endif // wxUSE_XRC && wxUSE_CHOICE
+
+#endif // _WX_XH_CHOIC_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_choicbk.h

@@ -0,0 +1,33 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_choicbk.h
+// Purpose:     XML resource handler for wxChoicebook
+// Author:      Vaclav Slavik
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_CHOICEBK_H_
+#define _WX_XH_CHOICEBK_H_
+
+#include "wx/xrc/xh_bookctrlbase.h"
+
+#if wxUSE_XRC && wxUSE_CHOICEBOOK
+
+class WXDLLIMPEXP_FWD_CORE wxChoicebook;
+
+class WXDLLIMPEXP_XRC wxChoicebookXmlHandler : public wxBookCtrlXmlHandlerBase
+{
+    wxDECLARE_DYNAMIC_CLASS(wxChoicebookXmlHandler);
+
+public:
+    wxChoicebookXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    wxChoicebook *m_choicebook;
+};
+
+#endif // wxUSE_XRC && wxUSE_CHOICEBOOK
+
+#endif // _WX_XH_CHOICEBK_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_clrpicker.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_clrpicker.h
+// Purpose:     XML resource handler for wxColourPickerCtrl
+// Author:      Francesco Montorsi
+// Created:     2006-04-17
+// Copyright:   (c) 2006 Francesco Montorsi
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_CLRPICKERCTRL_H_
+#define _WX_XH_CLRPICKERCTRL_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_COLOURPICKERCTRL
+
+class WXDLLIMPEXP_XRC wxColourPickerCtrlXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxColourPickerCtrlXmlHandler);
+
+public:
+    wxColourPickerCtrlXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_COLOURPICKERCTRL
+
+#endif // _WX_XH_CLRPICKERCTRL_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_cmdlinkbn.h

@@ -0,0 +1,31 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_cmdlinkbn.h
+// Purpose:     XML resource handler for command link buttons
+// Author:      Kinaou Herve
+// Created:     2010-10-20
+// Copyright:   (c) 2010 wxWidgets development team
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_CMDLINKBN_H_
+#define _WX_XH_CMDLINKBN_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_COMMANDLINKBUTTON
+
+class WXDLLIMPEXP_XRC wxCommandLinkButtonXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxCommandLinkButtonXmlHandler();
+
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    wxDECLARE_DYNAMIC_CLASS(wxCommandLinkButtonXmlHandler);
+};
+
+#endif // wxUSE_XRC && wxUSE_COMMANDLINKBUTTON
+
+#endif // _WX_XH_CMDLINKBN_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_collpane.h

@@ -0,0 +1,35 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_collpane.h
+// Purpose:     XML resource handler for wxCollapsiblePane
+// Author:      Francesco Montorsi
+// Created:     2006-10-27
+// Copyright:   (c) 2006 Francesco Montorsi
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_COLLPANE_H_
+#define _WX_XH_COLLPANE_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_COLLPANE
+
+class WXDLLIMPEXP_FWD_CORE wxCollapsiblePane;
+
+class WXDLLIMPEXP_XRC wxCollapsiblePaneXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxCollapsiblePaneXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    bool m_isInside;
+    wxCollapsiblePane *m_collpane;
+
+    wxDECLARE_DYNAMIC_CLASS(wxCollapsiblePaneXmlHandler);
+};
+
+#endif // wxUSE_XRC && wxUSE_COLLPANE
+
+#endif // _WX_XH_COLLPANE_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_combo.h

@@ -0,0 +1,33 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_combo.h
+// Purpose:     XML resource handler for wxComboBox
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_COMBO_H_
+#define _WX_XH_COMBO_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_COMBOBOX
+
+class WXDLLIMPEXP_XRC wxComboBoxXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxComboBoxXmlHandler);
+
+public:
+    wxComboBoxXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    bool m_insideBox;
+    wxArrayString strList;
+};
+
+#endif // wxUSE_XRC && wxUSE_COMBOBOX
+
+#endif // _WX_XH_COMBO_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_comboctrl.h

@@ -0,0 +1,31 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_comboctrl.h
+// Purpose:     XML resource handler for wxComboBox
+// Author:      Jaakko Salli
+// Created:     2009/01/25
+// Copyright:   (c) 2009 Jaakko Salli
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_COMBOCTRL_H_
+#define _WX_XH_COMBOCTRL_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_COMBOCTRL
+
+class WXDLLIMPEXP_XRC wxComboCtrlXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxComboCtrlXmlHandler);
+
+public:
+    wxComboCtrlXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+};
+
+#endif // wxUSE_XRC && wxUSE_COMBOCTRL
+
+#endif // _WX_XH_COMBOCTRL_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_dataview.h

@@ -0,0 +1,34 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_dataview.h
+// Purpose:     XML resource handler for wxDataViewCtrl
+// Author:      Anton Triest
+// Created:     2019/06/27
+// Copyright:   (c) 2019 Anton Triest, Bricsys
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_DATAVIEW_H_
+#define _WX_XH_DATAVIEW_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_DATAVIEWCTRL
+
+class WXDLLIMPEXP_XRC wxDataViewXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxDataViewXmlHandler);
+
+public:
+    wxDataViewXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    wxObject* HandleCtrl();
+    wxObject* HandleListCtrl();
+    wxObject* HandleTreeCtrl();
+};
+
+#endif // wxUSE_XRC && wxUSE_DATAVIEWCTRL
+
+#endif // _WX_XH_DATAVIEW_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_datectrl.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_datectrl.h
+// Purpose:     XML resource handler for wxDatePickerCtrl
+// Author:      Vaclav Slavik
+// Created:     2005-02-07
+// Copyright:   (c) 2005 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_DATECTRL_H_
+#define _WX_XH_DATECTRL_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_DATEPICKCTRL
+
+class WXDLLIMPEXP_XRC wxDateCtrlXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxDateCtrlXmlHandler);
+
+public:
+    wxDateCtrlXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_DATEPICKCTRL
+
+#endif // _WX_XH_DATECTRL_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_dirpicker.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_dirpicker.h
+// Purpose:     XML resource handler for wxDirPickerCtrl
+// Author:      Francesco Montorsi
+// Created:     2006-04-17
+// Copyright:   (c) 2006 Francesco Montorsi
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_DIRPICKERCTRL_H_
+#define _WX_XH_DIRPICKERCTRL_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_DIRPICKERCTRL
+
+class WXDLLIMPEXP_XRC wxDirPickerCtrlXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxDirPickerCtrlXmlHandler);
+
+public:
+    wxDirPickerCtrlXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_DIRPICKERCTRL
+
+#endif // _WX_XH_DIRPICKERCTRL_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_dlg.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_dlg.h
+// Purpose:     XML resource handler for dialogs
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_DLG_H_
+#define _WX_XH_DLG_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC
+
+class WXDLLIMPEXP_XRC wxDialogXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxDialogXmlHandler);
+
+public:
+    wxDialogXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC
+
+#endif // _WX_XH_DLG_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_editlbox.h

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_editlbox.h
+// Purpose:     declaration of wxEditableListBox XRC handler
+// Author:      Vadim Zeitlin
+// Created:     2009-06-04
+// Copyright:   (c) 2009 Vadim Zeitlin <vadim@wxwidgets.org>
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XRC_XH_EDITLBOX_H_
+#define _WX_XRC_XH_EDITLBOX_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_EDITABLELISTBOX
+
+// ----------------------------------------------------------------------------
+// wxEditableListBoxXmlHandler: XRC handler for wxEditableListBox
+// ----------------------------------------------------------------------------
+
+class WXDLLIMPEXP_XRC wxEditableListBoxXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxEditableListBoxXmlHandler();
+
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    bool m_insideBox;
+    wxArrayString m_items;
+
+    wxDECLARE_DYNAMIC_CLASS(wxEditableListBoxXmlHandler);
+};
+
+#endif // wxUSE_XRC && wxUSE_EDITABLELISTBOX
+
+#endif // _WX_XRC_XH_EDITLBOX_H_
+

libs/wxWidgets-3.3.1/include/wx/xrc/xh_filectrl.h

@@ -0,0 +1,30 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_filectrl.h
+// Purpose:     XML resource handler for wxFileCtrl
+// Author:      Kinaou Hervé
+// Created:     2009-05-11
+// Copyright:   (c) 2009 wxWidgets development team
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_FILECTRL_H_
+#define _WX_XH_FILECTRL_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_FILECTRL
+
+class WXDLLIMPEXP_XRC wxFileCtrlXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxFileCtrlXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    wxDECLARE_DYNAMIC_CLASS(wxFileCtrlXmlHandler);
+};
+
+#endif // wxUSE_XRC && wxUSE_FILECTRL
+
+#endif // _WX_XH_FILEPICKERCTRL_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_filepicker.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_filepicker.h
+// Purpose:     XML resource handler for wxFilePickerCtrl
+// Author:      Francesco Montorsi
+// Created:     2006-04-17
+// Copyright:   (c) 2006 Francesco Montorsi
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_FILEPICKERCTRL_H_
+#define _WX_XH_FILEPICKERCTRL_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_FILEPICKERCTRL
+
+class WXDLLIMPEXP_XRC wxFilePickerCtrlXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxFilePickerCtrlXmlHandler);
+
+public:
+    wxFilePickerCtrlXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_FILEPICKERCTRL
+
+#endif // _WX_XH_FILEPICKERCTRL_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_fontpicker.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_fontpicker.h
+// Purpose:     XML resource handler for wxFontPickerCtrl
+// Author:      Francesco Montorsi
+// Created:     2006-04-17
+// Copyright:   (c) 2006 Francesco Montorsi
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_FONTPICKERCTRL_H_
+#define _WX_XH_FONTPICKERCTRL_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_FONTPICKERCTRL
+
+class WXDLLIMPEXP_XRC wxFontPickerCtrlXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxFontPickerCtrlXmlHandler);
+
+public:
+    wxFontPickerCtrlXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_FONTPICKERCTRL
+
+#endif // _WX_XH_FONTPICKERCTRL_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_frame.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_frame.h
+// Purpose:     XML resource handler for wxFrame
+// Author:      Vaclav Slavik & Aleks.
+// Created:     2000/03/05
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_FRAME_H_
+#define _WX_XH_FRAME_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC
+
+class WXDLLIMPEXP_XRC wxFrameXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxFrameXmlHandler);
+
+public:
+    wxFrameXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC
+
+#endif // _WX_XH_FRAME_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_gauge.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_gauge.h
+// Purpose:     XML resource handler for wxGauge
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_GAUGE_H_
+#define _WX_XH_GAUGE_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_GAUGE
+
+class WXDLLIMPEXP_XRC wxGaugeXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxGaugeXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+    wxDECLARE_DYNAMIC_CLASS(wxGaugeXmlHandler);
+};
+
+#endif // wxUSE_XRC && wxUSE_GAUGE
+
+#endif // _WX_XH_GAUGE_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_gdctl.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_gdctl.h
+// Purpose:     XML resource handler for wxGenericDirCtrl
+// Author:      Markus Greither
+// Created:     2002/01/20
+// Copyright:   (c) 2002 Markus Greither
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_GDCTL_H_
+#define _WX_XH_GDCTL_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_DIRDLG
+
+class WXDLLIMPEXP_XRC wxGenericDirCtrlXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxGenericDirCtrlXmlHandler);
+
+public:
+    wxGenericDirCtrlXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_DIRDLG
+
+#endif // _WX_XH_GDCTL_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_grid.h

@@ -0,0 +1,30 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_grid.h
+// Purpose:     XML resource handler for wxGrid
+// Author:      Agron Selimaj
+// Created:     2005/08/11
+// Copyright:   (c) 2005 Agron Selimaj, Freepour Controls Inc.
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_GRD_H_
+#define _WX_XH_GRD_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_GRID
+
+class WXDLLIMPEXP_XRC wxGridXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxGridXmlHandler);
+
+public:
+    wxGridXmlHandler();
+
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_GRID
+
+#endif // _WX_XH_GRD_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_html.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_html.h
+// Purpose:     XML resource handler for wxHtmlWindow
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_HTML_H_
+#define _WX_XH_HTML_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_HTML
+
+class WXDLLIMPEXP_XRC wxHtmlWindowXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxHtmlWindowXmlHandler);
+
+public:
+    wxHtmlWindowXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_HTML
+
+#endif // _WX_XH_HTML_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_htmllbox.h

@@ -0,0 +1,33 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_htmllbox.h
+// Purpose:     XML resource handler for wxSimpleHtmlListBox
+// Author:      Francesco Montorsi
+// Created:     2006/10/21
+// Copyright:   (c) 2006 Francesco Montorsi
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_SIMPLEHTMLLISTBOX_H_
+#define _WX_XH_SIMPLEHTMLLISTBOX_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_HTML
+
+class WXDLLIMPEXP_XRC wxSimpleHtmlListBoxXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxSimpleHtmlListBoxXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    bool m_insideBox;
+    wxArrayString strList;
+
+    wxDECLARE_DYNAMIC_CLASS(wxSimpleHtmlListBoxXmlHandler);
+};
+
+#endif // wxUSE_XRC && wxUSE_HTML
+
+#endif // _WX_XH_SIMPLEHTMLLISTBOX_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_hyperlink.h

@@ -0,0 +1,36 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_hyperlink.h
+// Purpose:     Hyperlink control (wxAdv)
+// Author:      David Norris <danorris@gmail.com>
+// Modified by: Ryan Norton, Francesco Montorsi
+// Created:     04/02/2005
+// Copyright:   (c) 2005 David Norris
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_HYPERLINKH__
+#define _WX_XH_HYPERLINKH__
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_HYPERLINKCTRL
+
+class WXDLLIMPEXP_XRC wxHyperlinkCtrlXmlHandler : public wxXmlResourceHandler
+{
+    // Register with wxWindows' dynamic class subsystem.
+    wxDECLARE_DYNAMIC_CLASS(wxHyperlinkCtrlXmlHandler);
+
+public:
+    // Constructor.
+    wxHyperlinkCtrlXmlHandler();
+
+    // Creates the control and returns a pointer to it.
+    virtual wxObject *DoCreateResource() override;
+
+    // Returns true if we know how to create a control for the given node.
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_HYPERLINKCTRL
+
+#endif // _WX_XH_HYPERLINKH__

libs/wxWidgets-3.3.1/include/wx/xrc/xh_infobar.h

@@ -0,0 +1,36 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_infobar.h
+// Purpose:     XML resource handler for wxInfoBar
+// Author:      Ilya Sinitsyn
+// Created:     2019-09-25
+// Copyright:   (c) 2019 TT-Solutions SARL
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_INFOBAR_H_
+#define _WX_XH_INFOBAR_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_INFOBAR
+
+class WXDLLIMPEXP_XRC wxInfoBarXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxInfoBarXmlHandler);
+
+public:
+    wxInfoBarXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    wxShowEffect GetShowEffect(wxString const& param);
+
+    bool m_insideBar;
+
+    wxString m_effectNames[wxSHOW_EFFECT_MAX];
+};
+
+#endif // wxUSE_XRC && wxUSE_INFOBAR
+
+#endif // _WX_XH_INFOBAR_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_listb.h

@@ -0,0 +1,33 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_listb.h
+// Purpose:     XML resource handler for wxListbox
+// Author:      Bob Mitchell & Vaclav Slavik
+// Created:     2000/07/29
+// Copyright:   (c) 2000 Bob Mitchell & Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_LISTB_H_
+#define _WX_XH_LISTB_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_LISTBOX
+
+class WXDLLIMPEXP_XRC wxListBoxXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxListBoxXmlHandler);
+
+public:
+    wxListBoxXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    bool m_insideBox;
+    wxArrayString strList;
+};
+
+#endif // wxUSE_XRC && wxUSE_LISTBOX
+
+#endif // _WX_XH_LISTB_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_listbk.h

@@ -0,0 +1,33 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_listbk.h
+// Purpose:     XML resource handler for wxListbook
+// Author:      Vaclav Slavik
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_LISTBK_H_
+#define _WX_XH_LISTBK_H_
+
+#include "wx/xrc/xh_bookctrlbase.h"
+
+#if wxUSE_XRC && wxUSE_LISTBOOK
+
+class WXDLLIMPEXP_FWD_CORE wxListbook;
+
+class WXDLLIMPEXP_XRC wxListbookXmlHandler : public wxBookCtrlXmlHandlerBase
+{
+    wxDECLARE_DYNAMIC_CLASS(wxListbookXmlHandler);
+
+public:
+    wxListbookXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    wxListbook *m_listbook;
+};
+
+#endif // wxUSE_XRC && wxUSE_LISTBOOK
+
+#endif // _WX_XH_LISTBK_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_listc.h

@@ -0,0 +1,45 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_listc.h
+// Purpose:     XML resource handler for wxListCtrl
+// Author:      Brian Gavin
+// Created:     2000/09/09
+// Copyright:   (c) 2000 Brian Gavin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_LISTC_H_
+#define _WX_XH_LISTC_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_LISTCTRL
+
+class WXDLLIMPEXP_FWD_CORE wxListCtrl;
+class WXDLLIMPEXP_FWD_CORE wxListItem;
+
+class WXDLLIMPEXP_XRC wxListCtrlXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxListCtrlXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    // handlers for wxListCtrl itself and its listcol and listitem children
+    wxListCtrl *HandleListCtrl();
+    void HandleListCol();
+    void HandleListItem();
+
+    // common part to HandleList{Col,Item}()
+    void HandleCommonItemAttrs(wxListItem& item);
+
+    // gets the items image index in the corresponding image list (normal if
+    // which is wxIMAGE_LIST_NORMAL or small if it is wxIMAGE_LIST_SMALL)
+    long GetImageIndex(wxListCtrl *listctrl, int which);
+
+    wxDECLARE_DYNAMIC_CLASS(wxListCtrlXmlHandler);
+};
+
+#endif // wxUSE_XRC && wxUSE_LISTCTRL
+
+#endif // _WX_XH_LISTC_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_mdi.h

@@ -0,0 +1,34 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_mdi.h
+// Purpose:     XML resource handler for wxMDI
+// Author:      David M. Falkinder & Vaclav Slavik
+// Created:     14/02/2005
+// Copyright:   (c) 2005 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_MDI_H_
+#define _WX_XH_MDI_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_MDI
+
+class WXDLLIMPEXP_FWD_CORE wxWindow;
+
+class WXDLLIMPEXP_XRC wxMdiXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxMdiXmlHandler);
+
+public:
+    wxMdiXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    wxWindow *CreateFrame();
+};
+
+#endif // wxUSE_XRC && wxUSE_MDI
+
+#endif // _WX_XH_MDI_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_menu.h

@@ -0,0 +1,42 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_menu.h
+// Purpose:     XML resource handler for menus/menubars
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_MENU_H_
+#define _WX_XH_MENU_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_MENUS
+
+class WXDLLIMPEXP_XRC wxMenuXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxMenuXmlHandler);
+
+public:
+    wxMenuXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    bool m_insideMenu;
+};
+
+class WXDLLIMPEXP_XRC wxMenuBarXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxMenuBarXmlHandler);
+
+public:
+    wxMenuBarXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_MENUS
+
+#endif // _WX_XH_MENU_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_notbk.h

@@ -0,0 +1,33 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_notbk.h
+// Purpose:     XML resource handler for wxNotebook
+// Author:      Vaclav Slavik
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_NOTBK_H_
+#define _WX_XH_NOTBK_H_
+
+#include "wx/xrc/xh_bookctrlbase.h"
+
+#if wxUSE_XRC && wxUSE_NOTEBOOK
+
+class WXDLLIMPEXP_FWD_CORE wxNotebook;
+
+class WXDLLIMPEXP_XRC wxNotebookXmlHandler : public wxBookCtrlXmlHandlerBase
+{
+    wxDECLARE_DYNAMIC_CLASS(wxNotebookXmlHandler);
+
+public:
+    wxNotebookXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    wxNotebook *m_notebook;
+};
+
+#endif // wxUSE_XRC && wxUSE_NOTEBOOK
+
+#endif // _WX_XH_NOTBK_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_odcombo.h

@@ -0,0 +1,34 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_odcombo.h
+// Purpose:     XML resource handler for wxOwnerDrawnComboBox
+// Author:      Alex Bligh - based on wx/xrc/xh_combo.h
+// Created:     2006/06/19
+// Copyright:   (c) 2006 Alex Bligh
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_ODCOMBO_H_
+#define _WX_XH_ODCOMBO_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_ODCOMBOBOX
+
+class WXDLLIMPEXP_XRC wxOwnerDrawnComboBoxXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxOwnerDrawnComboBoxXmlHandler);
+
+public:
+    wxOwnerDrawnComboBoxXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    bool m_insideBox;
+    wxArrayString strList;
+};
+
+#endif // wxUSE_XRC && wxUSE_ODCOMBOBOX
+
+#endif // _WX_XH_ODCOMBO_H_
+

libs/wxWidgets-3.3.1/include/wx/xrc/xh_panel.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_panel.h
+// Purpose:     XML resource handler for wxPanel
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_PANEL_H_
+#define _WX_XH_PANEL_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC
+
+class WXDLLIMPEXP_XRC wxPanelXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxPanelXmlHandler);
+
+public:
+    wxPanelXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC
+
+#endif // _WX_XH_PANEL_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_propdlg.h

@@ -0,0 +1,34 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_propdlg.h
+// Purpose:     XML resource handler for wxPropertySheetDialog
+// Author:      Sander Berents
+// Created:     2007/07/12
+// Copyright:   (c) 2007 Sander Berents
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_PROPDLG_H_
+#define _WX_XH_PROPDLG_H_
+
+#include "wx/xrc/xh_bookctrlbase.h"
+
+#if wxUSE_XRC && wxUSE_BOOKCTRL
+
+class WXDLLIMPEXP_FWD_CORE wxPropertySheetDialog;
+
+class WXDLLIMPEXP_XRC wxPropertySheetDialogXmlHandler : public wxBookCtrlXmlHandlerBase
+{
+    wxDECLARE_DYNAMIC_CLASS(wxPropertySheetDialogXmlHandler);
+
+public:
+    wxPropertySheetDialogXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    wxPropertySheetDialog *m_dialog;
+};
+
+#endif // wxUSE_XRC && wxUSE_BOOKCTRL
+
+#endif // _WX_XH_PROPDLG_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_propgrid.h

@@ -0,0 +1,57 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        xh_propgrid.h
+// Purpose:     XML resource handler for wxPropertyGrid
+// Author:      Jaakko Salli
+// Modified by:
+// Created:     May-16-2007
+// RCS-ID:      $Id:
+// Copyright:   (c) Jaakko Salli
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XRC_XH_PROPGRID_H_
+#define _WX_XRC_XH_PROPGRID_H_
+
+/*
+
+  NOTE: relevant source file, xh_propgrid.cpp is *not* included in the
+    wxPropertyGrid library (to prevent xrc-lib dependency). To use this
+    code, you will need to separately add src/xh_propgrid.cpp to your
+    application.
+
+*/
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_PROPGRID
+
+class WXDLLIMPEXP_FWD_PROPGRID wxPropertyGrid;
+class WXDLLIMPEXP_FWD_PROPGRID wxPropertyGridManager;
+class WXDLLIMPEXP_FWD_PROPGRID wxPropertyGridPageState;
+class WXDLLIMPEXP_FWD_PROPGRID wxPropertyGridPopulator;
+
+class WXDLLIMPEXP_PROPGRID wxPropertyGridXmlHandler : public wxXmlResourceHandler
+{
+    friend class wxPropertyGridXrcPopulator;
+    DECLARE_DYNAMIC_CLASS(wxPropertyGridXmlHandler)
+
+public:
+    wxPropertyGridXmlHandler();
+    wxObject *DoCreateResource() override;
+    bool CanHandle(wxXmlNode *node) override;
+
+    void InitPopulator();
+    void PopulatePage( wxPropertyGridPageState* state );
+    void DonePopulator();
+
+    void HandlePropertyGridParams();
+
+private:
+    wxPropertyGridManager*      m_manager = nullptr;
+    wxPropertyGrid*             m_pg = nullptr;
+    wxPropertyGridPopulator*    m_populator = nullptr;
+};
+
+#endif // wxUSE_XRC && wxUSE_PROPGRID
+
+#endif // _WX_XRC_XH_PROPGRID_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_radbt.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_radbt.h
+// Purpose:     XML resource handler for wxRadioButton
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_RADBT_H_
+#define _WX_XH_RADBT_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_RADIOBTN
+
+class WXDLLIMPEXP_XRC wxRadioButtonXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxRadioButtonXmlHandler);
+
+public:
+    wxRadioButtonXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_RADIOBOX
+
+#endif // _WX_XH_RADBT_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_radbx.h

@@ -0,0 +1,49 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_radbx.h
+// Purpose:     XML resource handler for wxRadioBox
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_RADBX_H_
+#define _WX_XH_RADBX_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_RADIOBOX
+
+class WXDLLIMPEXP_XRC wxRadioBoxXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxRadioBoxXmlHandler);
+
+public:
+    wxRadioBoxXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    bool m_insideBox;
+
+    // the items labels
+    wxArrayString m_labels;
+
+#if wxUSE_TOOLTIPS
+    // the items tooltips
+    wxArrayString m_tooltips;
+#endif // wxUSE_TOOLTIPS
+
+    // the item help text
+    wxArrayString m_helptexts;
+    wxArrayInt    m_helptextSpecified;
+
+    // if the corresponding array element is 1, the radiobox item is
+    // disabled/hidden
+    wxArrayInt m_isEnabled,
+               m_isShown;
+};
+
+#endif // wxUSE_XRC && wxUSE_RADIOBOX
+
+#endif // _WX_XH_RADBX_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_ribbon.h

@@ -0,0 +1,47 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_ribbon.h
+// Purpose:     XML resource handler for wxRibbon related classes
+// Author:      Armel Asselin
+// Created:     2010-04-23
+// Copyright:   (c) 2010 Armel Asselin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XRC_XH_RIBBON_H_
+#define _WX_XRC_XH_RIBBON_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_RIBBON
+
+class WXDLLIMPEXP_FWD_RIBBON wxRibbonControl;
+
+class WXDLLIMPEXP_RIBBON wxRibbonXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxRibbonXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    const wxClassInfo *m_isInside;
+
+    bool IsRibbonControl (wxXmlNode *node);
+
+    wxObject* Handle_buttonbar();
+    wxObject* Handle_button();
+    wxObject* Handle_control();
+    wxObject* Handle_page();
+    wxObject* Handle_gallery();
+    wxObject* Handle_galleryitem();
+    wxObject* Handle_panel();
+    wxObject* Handle_bar();
+
+    void Handle_RibbonArtProvider(wxRibbonControl *control);
+
+    wxDECLARE_DYNAMIC_CLASS(wxRibbonXmlHandler);
+};
+
+#endif // wxUSE_XRC && wxUSE_RIBBON
+
+#endif // _WX_XRC_XH_RIBBON_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_richtext.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_richtext.h
+// Purpose:     XML resource handler for wxRichTextCtrl
+// Author:      Julian Smart
+// Created:     2006-11-08
+// Copyright:   (c) 2006 Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_RICHTEXT_H_
+#define _WX_XH_RICHTEXT_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_RICHTEXT
+
+class WXDLLIMPEXP_RICHTEXT wxRichTextCtrlXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxRichTextCtrlXmlHandler);
+
+public:
+    wxRichTextCtrlXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_RICHTEXT
+
+#endif // _WX_XH_RICHTEXT_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_scrol.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_scrol.h
+// Purpose:     XML resource handler for wxScrollBar
+// Author:      Brian Gavin
+// Created:     2000/09/09
+// Copyright:   (c) 2000 Brian Gavin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_SCROL_H_
+#define _WX_XH_SCROL_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_SCROLLBAR
+
+class WXDLLIMPEXP_XRC wxScrollBarXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxScrollBarXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+    wxDECLARE_DYNAMIC_CLASS(wxScrollBarXmlHandler);
+};
+
+#endif // wxUSE_XRC && wxUSE_SCROLLBAR
+
+#endif // _WX_XH_SCROL_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_scwin.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_scwin.h
+// Purpose:     XML resource handler for wxScrolledWindow
+// Author:      Vaclav Slavik
+// Created:     2002/10/18
+// Copyright:   (c) 2002 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_SCWIN_H_
+#define _WX_XH_SCWIN_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC
+
+class WXDLLIMPEXP_XRC wxScrolledWindowXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxScrolledWindowXmlHandler);
+
+public:
+    wxScrolledWindowXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC
+
+#endif // _WX_XH_SCWIN_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_simplebook.h

@@ -0,0 +1,36 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_simplebook.h
+// Purpose:     XML resource handler for wxSimplebook
+// Author:      Vadim Zeitlin
+// Created:     2014-08-05
+// Copyright:   (c) 2014 Vadim Zeitlin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_SIMPLEBOOK_H_
+#define _WX_XH_SIMPLEBOOK_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_BOOKCTRL
+
+class wxSimplebook;
+
+class WXDLLIMPEXP_XRC wxSimplebookXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxSimplebookXmlHandler();
+
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    bool m_isInside;
+    wxSimplebook *m_simplebook;
+
+    wxDECLARE_DYNAMIC_CLASS(wxSimplebookXmlHandler);
+};
+
+#endif // wxUSE_XRC && wxUSE_BOOKCTRL
+
+#endif // _WX_XH_SIMPLEBOOK_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_sizer.h

@@ -0,0 +1,84 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_sizer.h
+// Purpose:     XML resource handler for wxBoxSizer
+// Author:      Vaclav Slavik
+// Created:     2000/04/24
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_SIZER_H_
+#define _WX_XH_SIZER_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC
+
+#include "wx/sizer.h"
+#include "wx/gbsizer.h"
+
+class WXDLLIMPEXP_XRC wxSizerXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxSizerXmlHandler);
+
+public:
+    wxSizerXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+protected:
+    virtual wxSizer* DoCreateSizer(const wxString& name);
+    virtual bool IsSizerNode(wxXmlNode *node) const;
+
+private:
+    bool m_isInside;
+    bool m_isGBS;
+
+    wxSizer *m_parentSizer;
+
+
+    wxObject* Handle_sizeritem();
+    wxObject* Handle_spacer();
+    wxObject* Handle_sizer();
+    wxSizer*  Handle_wxBoxSizer();
+#if wxUSE_STATBOX
+    wxSizer*  Handle_wxStaticBoxSizer();
+#endif
+    wxSizer*  Handle_wxGridSizer();
+    wxFlexGridSizer* Handle_wxFlexGridSizer();
+    wxGridBagSizer* Handle_wxGridBagSizer();
+    wxSizer*  Handle_wxWrapSizer();
+
+    bool ValidateGridSizerChildren();
+    void SetFlexibleMode(wxFlexGridSizer* fsizer);
+    void SetGrowables(wxFlexGridSizer* fsizer, const wxChar* param, bool rows);
+    wxGBPosition GetGBPos();
+    wxGBSpan GetGBSpan();
+    wxSizerItem* MakeSizerItem();
+    void SetSizerItemAttributes(wxSizerItem* sitem);
+    void AddSizerItem(wxSizerItem* sitem);
+    int GetSizerFlags();
+};
+
+#if wxUSE_BUTTON
+
+class WXDLLIMPEXP_XRC wxStdDialogButtonSizerXmlHandler
+    : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxStdDialogButtonSizerXmlHandler);
+
+public:
+    wxStdDialogButtonSizerXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    bool m_isInside;
+    wxStdDialogButtonSizer *m_parentSizer;
+};
+
+#endif // wxUSE_BUTTON
+
+#endif // wxUSE_XRC
+
+#endif // _WX_XH_SIZER_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_slidr.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_slidr.h
+// Purpose:     XML resource handler for wxSlider
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_SLIDR_H_
+#define _WX_XH_SLIDR_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_SLIDER
+
+class WXDLLIMPEXP_XRC wxSliderXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxSliderXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+    wxDECLARE_DYNAMIC_CLASS(wxSliderXmlHandler);
+};
+
+#endif // wxUSE_XRC && wxUSE_SLIDER
+
+#endif // _WX_XH_SLIDR_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_spin.h

@@ -0,0 +1,57 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_spin.h
+// Purpose:     XML resource handler for wxSpinButton, wxSpinCtrl, wxSpinCtrlDouble
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// Copyright:   (c) 2000 Bob Mitchell and Verant Interactive
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_SPIN_H_
+#define _WX_XH_SPIN_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC
+
+#if wxUSE_SPINBTN
+
+class WXDLLIMPEXP_XRC wxSpinButtonXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxSpinButtonXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+    wxDECLARE_DYNAMIC_CLASS(wxSpinButtonXmlHandler);
+};
+
+#endif // wxUSE_SPINBTN
+
+#if wxUSE_SPINCTRL
+
+class WXDLLIMPEXP_XRC wxSpinCtrlXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxSpinCtrlXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+    wxDECLARE_DYNAMIC_CLASS(wxSpinCtrlXmlHandler);
+};
+
+class WXDLLIMPEXP_XRC wxSpinCtrlDoubleXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxSpinCtrlDoubleXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+    wxDECLARE_DYNAMIC_CLASS(wxSpinCtrlDoubleXmlHandler);
+};
+
+#endif // wxUSE_SPINCTRL
+
+#endif // wxUSE_XRC
+
+#endif // _WX_XH_SPIN_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_split.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_split.h
+// Purpose:     XRC resource for wxSplitterWindow
+// Author:      panga@freemail.hu, Vaclav Slavik
+// Created:     2003/01/26
+// Copyright:   (c) 2003 panga@freemail.hu, Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_SPLIT_H_
+#define _WX_XH_SPLIT_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_SPLITTER
+
+class WXDLLIMPEXP_XRC wxSplitterWindowXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxSplitterWindowXmlHandler);
+
+public:
+    wxSplitterWindowXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_SPLITTER
+
+#endif // _WX_XH_SPLIT_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_srchctrl.h

@@ -0,0 +1,30 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_srchctl.h
+// Purpose:     XRC resource handler for wxSearchCtrl
+// Author:      Sander Berents
+// Created:     2007/07/12
+// Copyright:   (c) 2007 Sander Berents
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_SRCH_H_
+#define _WX_XH_SRCH_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_SEARCHCTRL
+
+class WXDLLIMPEXP_XRC wxSearchCtrlXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxSearchCtrlXmlHandler();
+
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+    wxDECLARE_DYNAMIC_CLASS(wxSearchCtrlXmlHandler);
+};
+
+#endif // wxUSE_XRC && wxUSE_SEARCHCTRL
+
+#endif // _WX_XH_SRCH_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_statbar.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_statbar.h
+// Purpose:     XML resource handler for wxStatusBar
+// Author:      Brian Ravnsgaard Riis
+// Created:     2004/01/21
+// Copyright:   (c) 2004 Brian Ravnsgaard Riis
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_STATBAR_H_
+#define _WX_XH_STATBAR_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_STATUSBAR
+
+class WXDLLIMPEXP_XRC wxStatusBarXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxStatusBarXmlHandler);
+
+public:
+    wxStatusBarXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_STATUSBAR
+
+#endif // _WX_XH_STATBAR_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_stbmp.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_stbmp.h
+// Purpose:     XML resource handler for wxStaticBitmap
+// Author:      Vaclav Slavik
+// Created:     2000/04/22
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_STBMP_H_
+#define _WX_XH_STBMP_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_STATBMP
+
+class WXDLLIMPEXP_XRC wxStaticBitmapXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxStaticBitmapXmlHandler);
+
+public:
+    wxStaticBitmapXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_STATBMP
+
+#endif // _WX_XH_STBMP_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_stbox.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_stbox.h
+// Purpose:     XML resource handler for wxStaticBox
+// Author:      Brian Gavin
+// Created:     2000/09/00
+// Copyright:   (c) 2000 Brian Gavin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_STBOX_H_
+#define _WX_XH_STBOX_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_STATBOX
+
+class WXDLLIMPEXP_XRC wxStaticBoxXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxStaticBoxXmlHandler);
+
+public:
+    wxStaticBoxXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_STATBOX
+
+#endif // _WX_XH_STBOX_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_stlin.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_stlin.h
+// Purpose:     XML resource handler for wxStaticLine
+// Author:      Vaclav Slavik
+// Created:     2000/09/00
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_STLIN_H_
+#define _WX_XH_STLIN_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_STATLINE
+
+class WXDLLIMPEXP_XRC wxStaticLineXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxStaticLineXmlHandler);
+
+public:
+    wxStaticLineXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_STATLINE
+
+#endif // _WX_XH_STLIN_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_sttxt.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_sttxt.h
+// Purpose:     XML resource handler for wxStaticText
+// Author:      Bob Mitchell
+// Created:     2000/03/21
+// Copyright:   (c) 2000 Bob Mitchell
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_STTXT_H_
+#define _WX_XH_STTXT_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_STATTEXT
+
+class WXDLLIMPEXP_XRC wxStaticTextXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxStaticTextXmlHandler);
+
+public:
+    wxStaticTextXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_STATTEXT
+
+#endif // _WX_XH_STTXT_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_styledtextctrl.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_styledtextctrl.h
+// Purpose:     XML resource handler for wxStyledTextCtrl
+// Author:      Alexander Koshelev
+// Created:     2021-09-22
+// Copyright:   (c) 2021 TT-Solutions SARL
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_STYLEDTEXTCTRL_H_
+#define _WX_XH_STYLEDTEXTCTRL_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_STC
+
+class WXDLLIMPEXP_STC wxStyledTextCtrlXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxStyledTextCtrlXmlHandler);
+
+public:
+    wxStyledTextCtrlXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_STC
+
+#endif // _WX_XH_STYLEDTEXTCTRL_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_text.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_text.h
+// Purpose:     XML resource handler for wxTextCtrl
+// Author:      Aleksandras Gluchovas
+// Created:     2000/03/21
+// Copyright:   (c) 2000 Aleksandras Gluchovas
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_TEXT_H_
+#define _WX_XH_TEXT_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_TEXTCTRL
+
+class WXDLLIMPEXP_XRC wxTextCtrlXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxTextCtrlXmlHandler);
+
+public:
+    wxTextCtrlXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_TEXTCTRL
+
+#endif // _WX_XH_TEXT_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_tglbtn.h

@@ -0,0 +1,35 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_tglbtn.h
+// Purpose:     XML resource handler for wxToggleButton
+// Author:      Julian Smart
+// Created:     2004-08-30
+// Copyright:   (c) 2004 Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_TGLBTN_H_
+#define _WX_XH_TGLBTN_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_TOGGLEBTN
+
+class WXDLLIMPEXP_XRC wxToggleButtonXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxToggleButtonXmlHandler);
+
+public:
+    wxToggleButtonXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+protected:
+    virtual void DoCreateToggleButton(wxObject *control);
+#if !defined(__WXUNIVERSAL__)
+    virtual void DoCreateBitmapToggleButton(wxObject *control);
+#endif
+};
+
+#endif // wxUSE_XRC && wxUSE_TOGGLEBTN
+
+#endif // _WX_XH_TGLBTN_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_timectrl.h

@@ -0,0 +1,30 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_timectrl.h
+// Purpose:     XML resource handler for wxTimePickerCtrl
+// Author:      Vadim Zeitlin
+// Created:     2011-09-22
+// Copyright:   (c) 2011 Vadim Zeitlin <vadim@wxwidgets.org>
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_TIMECTRL_H_
+#define _WX_XH_TIMECTRL_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_TIMEPICKCTRL
+
+class WXDLLIMPEXP_XRC wxTimeCtrlXmlHandler : public wxXmlResourceHandler
+{
+public:
+    wxTimeCtrlXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    wxDECLARE_DYNAMIC_CLASS(wxTimeCtrlXmlHandler);
+};
+
+#endif // wxUSE_XRC && wxUSE_TIMEPICKCTRL
+
+#endif // _WX_XH_TIMECTRL_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_toolb.h

@@ -0,0 +1,36 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_toolb.h
+// Purpose:     XML resource handler for wxToolBar
+// Author:      Vaclav Slavik
+// Created:     2000/08/11
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_TOOLB_H_
+#define _WX_XH_TOOLB_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_TOOLBAR
+
+class WXDLLIMPEXP_FWD_CORE wxToolBar;
+
+class WXDLLIMPEXP_XRC wxToolBarXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxToolBarXmlHandler);
+
+public:
+    wxToolBarXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    bool m_isInside;
+    wxToolBar *m_toolbar;
+    wxSize m_toolSize;
+};
+
+#endif // wxUSE_XRC && wxUSE_TOOLBAR
+
+#endif // _WX_XH_TOOLB_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_toolbk.h

@@ -0,0 +1,35 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_toolbk.h
+// Purpose:     XML resource handler for wxToolbook
+// Author:      Andrea Zanellato
+// Created:     2009/12/12
+// Copyright:   (c) 2010 wxWidgets development team
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_TOOLBK_H_
+#define _WX_XH_TOOLBK_H_
+
+#include "wx/xrc/xh_bookctrlbase.h"
+
+#if wxUSE_XRC && wxUSE_TOOLBOOK
+
+class WXDLLIMPEXP_FWD_CORE wxToolbook;
+
+class WXDLLIMPEXP_XRC wxToolbookXmlHandler : public wxBookCtrlXmlHandlerBase
+{
+public:
+    wxToolbookXmlHandler();
+
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    wxToolbook *m_toolbook;
+
+    wxDECLARE_DYNAMIC_CLASS(wxToolbookXmlHandler);
+};
+
+#endif // wxUSE_XRC && wxUSE_TOOLBOOK
+
+#endif // _WX_XH_TOOLBK_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_tree.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_tree.h
+// Purpose:     XML resource handler for wxTreeCtrl
+// Author:      Brian Gavin
+// Created:     2000/09/09
+// Copyright:   (c) 2000 Brian Gavin
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_TREE_H_
+#define _WX_XH_TREE_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_TREECTRL
+
+class WXDLLIMPEXP_XRC wxTreeCtrlXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxTreeCtrlXmlHandler);
+
+public:
+    wxTreeCtrlXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_TREECTRL
+
+#endif // _WX_XH_TREE_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_treebk.h

@@ -0,0 +1,90 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_treebk.h
+// Purpose:     XML resource handler for wxTreebook
+// Author:      Evgeniy Tarassov
+// Created:     2005/09/28
+// Copyright:   (c) 2005 TT-Solutions <vadim@tt-solutions.com>
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_TREEBK_H_
+#define _WX_XH_TREEBK_H_
+
+#include "wx/xrc/xh_bookctrlbase.h"
+
+#if wxUSE_XRC && wxUSE_TREEBOOK
+
+class  WXDLLIMPEXP_FWD_CORE wxTreebook;
+#include "wx/dynarray.h"
+
+WX_DEFINE_USER_EXPORTED_ARRAY_SIZE_T(size_t, wxArrayTbkPageIndexes,
+                                     class WXDLLIMPEXP_XRC);
+
+// ---------------------------------------------------------------------
+// wxTreebookXmlHandler class
+// ---------------------------------------------------------------------
+// Resource xml structure have to be almost the "same" as for wxNotebook
+// except the additional (size_t)depth parameter for treebookpage nodes
+// which indicates the depth of the page in the tree.
+// There is only one logical constraint on this parameter :
+// it cannot be greater than the previous page depth plus one
+class WXDLLIMPEXP_XRC wxTreebookXmlHandler : public wxBookCtrlXmlHandlerBase
+{
+    wxDECLARE_DYNAMIC_CLASS(wxTreebookXmlHandler);
+
+public:
+    wxTreebookXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    virtual void
+    DoAddPage(wxBookCtrlBase* book, size_t n, const PageWithAttrs& page) override;
+
+    wxTreebook *m_tbk;
+
+    // N-th element contains the index of the parent page at depth N.
+    wxArrayTbkPageIndexes m_treeContext;
+
+    // The index of the parent page or -1 if the page is a top level one.
+    wxVector<int> m_pageParents;
+};
+
+
+// Example:
+// -------
+// Label
+// \--First
+// |  \--Second
+// \--Third
+//
+//<resource>
+//  ...
+//  <object class="wxTreebook">
+//    <object class="treebookpage">
+//      <object class="wxWindow" />
+//      <label>My first page</label>
+//      <depth>0</depth>
+//    </object>
+//    <object class="treebookpage">
+//      <object class="wxWindow" />
+//      <label>First</label>
+//      <depth>1</depth>
+//    </object>
+//    <object class="treebookpage">
+//      <object class="wxWindow" />
+//      <label>Second</label>
+//      <depth>2</depth>
+//    </object>
+//    <object class="treebookpage">
+//      <object class="wxWindow" />
+//      <label>Third</label>
+//      <depth>1</depth>
+//    </object>
+//  </object>
+//  ...
+//</resource>
+
+#endif // wxUSE_XRC && wxUSE_TREEBOOK
+
+#endif // _WX_XH_TREEBK_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_unkwn.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_unkwn.h
+// Purpose:     XML resource handler for unknown widget
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_UNKWN_H_
+#define _WX_XH_UNKWN_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC
+
+class WXDLLIMPEXP_XRC wxUnknownWidgetXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxUnknownWidgetXmlHandler);
+
+public:
+    wxUnknownWidgetXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC
+
+#endif // _WX_XH_UNKWN_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_vlistbox.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_vlistbox.h
+// Purpose:     XML resource handler for wxVListBox
+// Author:      Vaclav Slavik, Bill Su
+// Created:     2000/03/05, 2024/10/07
+// Copyright:   (c) 2000 Vaclav Slavik, 2024 Bill Su
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_VLISTBOX_H_
+#define _WX_XH_VLISTBOX_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_LISTBOX
+
+class WXDLLIMPEXP_XRC wxVListBoxXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxVListBoxXmlHandler);
+
+public:
+    wxVListBoxXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+};
+
+#endif // wxUSE_XRC && wxUSE_LISTBOX
+
+#endif // _WX_XH_VLISTBOX_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xh_wizrd.h

@@ -0,0 +1,36 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xh_wizrd.h
+// Purpose:     XML resource handler for wxWizard
+// Author:      Vaclav Slavik
+// Created:     2003/03/02
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XH_WIZRD_H_
+#define _WX_XH_WIZRD_H_
+
+#include "wx/xrc/xmlres.h"
+
+#if wxUSE_XRC && wxUSE_WIZARDDLG
+
+class WXDLLIMPEXP_FWD_CORE wxWizard;
+class WXDLLIMPEXP_FWD_CORE wxWizardPageSimple;
+
+class WXDLLIMPEXP_XRC wxWizardXmlHandler : public wxXmlResourceHandler
+{
+    wxDECLARE_DYNAMIC_CLASS(wxWizardXmlHandler);
+
+public:
+    wxWizardXmlHandler();
+    virtual wxObject *DoCreateResource() override;
+    virtual bool CanHandle(wxXmlNode *node) override;
+
+private:
+    wxWizard *m_wizard;
+    wxWizardPageSimple *m_lastSimplePage;
+};
+
+#endif // wxUSE_XRC && wxUSE_WIZARDDLG
+
+#endif // _WX_XH_WIZRD_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xmlres.h

@@ -0,0 +1,724 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xmlres.h
+// Purpose:     XML resources
+// Author:      Vaclav Slavik
+// Created:     2000/03/05
+// Copyright:   (c) 2000 Vaclav Slavik
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XMLRES_H_
+#define _WX_XMLRES_H_
+
+#include "wx/defs.h"
+
+#if wxUSE_XRC
+
+#include "wx/string.h"
+#include "wx/dynarray.h"
+#include "wx/arrstr.h"
+#include "wx/datetime.h"
+#include "wx/gdicmn.h"
+#include "wx/filesys.h"
+#include "wx/bitmap.h"
+#include "wx/icon.h"
+#include "wx/artprov.h"
+#include "wx/colour.h"
+
+#include "wx/xrc/xmlreshandler.h"
+
+class WXDLLIMPEXP_FWD_BASE wxFileName;
+
+class WXDLLIMPEXP_FWD_CORE wxIconBundle;
+class WXDLLIMPEXP_FWD_CORE wxImageList;
+class WXDLLIMPEXP_FWD_CORE wxMenu;
+class WXDLLIMPEXP_FWD_CORE wxMenuBar;
+class WXDLLIMPEXP_FWD_CORE wxDialog;
+class WXDLLIMPEXP_FWD_CORE wxPanel;
+class WXDLLIMPEXP_FWD_CORE wxWindow;
+class WXDLLIMPEXP_FWD_CORE wxFrame;
+class WXDLLIMPEXP_FWD_CORE wxToolBar;
+
+class WXDLLIMPEXP_FWD_XML wxXmlDocument;
+class WXDLLIMPEXP_FWD_XML wxXmlNode;
+class WXDLLIMPEXP_FWD_XRC wxXmlSubclassFactory;
+class wxXmlResourceModule;
+class wxXmlResourceDataRecords;
+class wxXmlResourceInternal;
+
+// These macros indicate current version of XML resources (this information is
+// encoded in root node of XRC file as "version" property).
+//
+// Rules for increasing version number:
+//   - change it only if you made incompatible change to the format. Addition
+//     of new attribute to control handler is _not_ incompatible change, because
+//     older versions of the library may ignore it.
+//   - if you change version number, follow these steps:
+//       - set major, minor and release numbers to respective version numbers of
+//         the wxWidgets library (see wx/version.h)
+//       - reset revision to 0 unless the first three are same as before,
+//         in which case you should increase revision by one
+#define WX_XMLRES_CURRENT_VERSION_MAJOR            2
+#define WX_XMLRES_CURRENT_VERSION_MINOR            5
+#define WX_XMLRES_CURRENT_VERSION_RELEASE          3
+#define WX_XMLRES_CURRENT_VERSION_REVISION         0
+#define WX_XMLRES_CURRENT_VERSION_STRING       wxT("2.5.3.0")
+
+#define WX_XMLRES_CURRENT_VERSION \
+                (WX_XMLRES_CURRENT_VERSION_MAJOR * 256*256*256 + \
+                 WX_XMLRES_CURRENT_VERSION_MINOR * 256*256 + \
+                 WX_XMLRES_CURRENT_VERSION_RELEASE * 256 + \
+                 WX_XMLRES_CURRENT_VERSION_REVISION)
+
+enum wxXmlResourceFlags
+{
+    wxXRC_USE_LOCALE     = 1,
+    wxXRC_NO_SUBCLASSING = 2,
+    wxXRC_NO_RELOADING   = 4,
+    wxXRC_USE_ENVVARS    = 8
+};
+
+// This class holds XML resources from one or more .xml files
+// (or derived forms, either binary or zipped -- see manual for
+// details).
+class WXDLLIMPEXP_XRC wxXmlResource : public wxObject
+{
+public:
+    // Constructor.
+    // Flags: wxXRC_USE_LOCALE
+    //              translatable strings will be translated via _()
+    //              using the given domain if specified
+    //        wxXRC_NO_SUBCLASSING
+    //              subclass property of object nodes will be ignored
+    //              (useful for previews in XRC editors)
+    //        wxXRC_NO_RELOADING
+    //              don't check the modification time of the XRC files and
+    //              reload them if they have changed on disk
+    //        wxXRC_USE_ENVVARS
+    //              expand environment variables for paths
+    //              (such as bitmaps or icons).
+    wxXmlResource(int flags = wxXRC_USE_LOCALE,
+                  const wxString& domain = wxEmptyString);
+
+    // Constructor.
+    // Flags: wxXRC_USE_LOCALE
+    //              translatable strings will be translated via _()
+    //              using the given domain if specified
+    //        wxXRC_NO_SUBCLASSING
+    //              subclass property of object nodes will be ignored
+    //              (useful for previews in XRC editors)
+    //        wxXRC_NO_RELOADING
+    //              don't check the modification time of the XRC files and
+    //              reload them if they have changed on disk
+    //        wxXRC_USE_ENVVARS
+    //              expand environment variables for paths
+    //              (such as bitmaps or icons).
+    wxXmlResource(const wxString& filemask, int flags = wxXRC_USE_LOCALE,
+                  const wxString& domain = wxEmptyString);
+
+    // Destructor.
+    virtual ~wxXmlResource();
+
+    // Loads resources from XML files that match given filemask.
+    // This method understands wxFileSystem URLs if wxUSE_FILESYS.
+    bool Load(const wxString& filemask);
+
+    // Loads resources from single XRC file.
+    bool LoadFile(const wxFileName& file);
+
+    // Loads all XRC files from a directory.
+    bool LoadAllFiles(const wxString& dirname);
+
+    // Loads resources from the given XML document, taking ownership of it.
+    //
+    // The name argument is only used to Unload() the document later here and
+    // doesn't need to be an existing filename at all (but should be unique if
+    // specified, otherwise it's just synthesized internally).
+    bool LoadDocument(wxXmlDocument* doc, const wxString& name = wxString());
+
+    // Unload resource from the given XML file (wildcards not allowed)
+    bool Unload(const wxString& filename);
+
+    // Initialize handlers for all supported controls/windows. This will
+    // make the executable quite big because it forces linking against
+    // most of the wxWidgets library.
+    void InitAllHandlers();
+
+    // Initialize only a specific handler (or custom handler). Convention says
+    // that handler name is equal to the control's name plus 'XmlHandler', for
+    // example wxTextCtrlXmlHandler, wxHtmlWindowXmlHandler. The XML resource
+    // compiler (xmlres) can create include file that contains initialization
+    // code for all controls used within the resource.
+    void AddHandler(wxXmlResourceHandler *handler);
+
+    // Add a new handler at the beginning of the handler list
+    void InsertHandler(wxXmlResourceHandler *handler);
+
+    // Removes all handlers
+    void ClearHandlers();
+
+    // Registers subclasses factory for use in XRC. This function is not meant
+    // for public use, please see the comment above wxXmlSubclassFactory
+    // definition.
+    static void AddSubclassFactory(wxXmlSubclassFactory *factory);
+
+    // Loads menu from resource. Returns nullptr on failure.
+    wxMenu *LoadMenu(const wxString& name);
+
+    // Loads menubar from resource. Returns nullptr on failure.
+    wxMenuBar *LoadMenuBar(wxWindow *parent, const wxString& name);
+
+    // Loads menubar from resource. Returns nullptr on failure.
+    wxMenuBar *LoadMenuBar(const wxString& name) { return LoadMenuBar(nullptr, name); }
+
+#if wxUSE_TOOLBAR
+    // Loads a toolbar.
+    wxToolBar *LoadToolBar(wxWindow *parent, const wxString& name);
+#endif
+
+    // Loads a dialog. dlg points to parent window (if any).
+    wxDialog *LoadDialog(wxWindow *parent, const wxString& name);
+
+    // Loads a dialog. dlg points to parent window (if any). This form
+    // is used to finish creation of already existing instance (main reason
+    // for this is that you may want to use derived class with new event table)
+    // Example (typical usage):
+    //      MyDialog dlg;
+    //      wxTheXmlResource->LoadDialog(&dlg, mainFrame, "my_dialog");
+    //      dlg->ShowModal();
+    bool LoadDialog(wxDialog *dlg, wxWindow *parent, const wxString& name);
+
+    // Loads a panel. panel points to parent window (if any).
+    wxPanel *LoadPanel(wxWindow *parent, const wxString& name);
+
+    // Loads a panel. panel points to parent window (if any). This form
+    // is used to finish creation of already existing instance.
+    bool LoadPanel(wxPanel *panel, wxWindow *parent, const wxString& name);
+
+    // Loads a frame.
+    wxFrame *LoadFrame(wxWindow* parent, const wxString& name);
+    bool LoadFrame(wxFrame* frame, wxWindow *parent, const wxString& name);
+
+    // Load an object from the resource specifying both the resource name and
+    // the classname.  This lets you load nonstandard container windows.
+    wxObject *LoadObject(wxWindow *parent, const wxString& name,
+                         const wxString& classname)
+    {
+        return DoLoadObject(parent, name, classname, false /* !recursive */);
+    }
+
+    // Load an object from the resource specifying both the resource name and
+    // the classname.  This form lets you finish the creation of an existing
+    // instance.
+    bool LoadObject(wxObject *instance,
+                    wxWindow *parent,
+                    const wxString& name,
+                    const wxString& classname)
+    {
+        return DoLoadObject(instance, parent, name, classname, false);
+    }
+
+    // These versions of LoadObject() look for the object with the given name
+    // recursively (breadth first) and can be used to instantiate an individual
+    // control defined anywhere in an XRC file. No check is done that the name
+    // is unique, it's up to the caller to ensure this.
+    wxObject *LoadObjectRecursively(wxWindow *parent,
+                                    const wxString& name,
+                                    const wxString& classname)
+    {
+        return DoLoadObject(parent, name, classname, true /* recursive */);
+    }
+
+    bool LoadObjectRecursively(wxObject *instance,
+                               wxWindow *parent,
+                               const wxString& name,
+                               const wxString& classname)
+    {
+        return DoLoadObject(instance, parent, name, classname, true);
+    }
+
+    // Loads a bitmap resource from a file.
+    wxBitmap LoadBitmap(const wxString& name);
+
+    // Loads an icon resource from a file.
+    wxIcon LoadIcon(const wxString& name);
+
+    // Attaches an unknown control to the given panel/window/dialog.
+    // Unknown controls are used in conjunction with <object class="unknown">.
+    bool AttachUnknownControl(const wxString& name, wxWindow *control,
+                              wxWindow *parent = nullptr);
+
+    // Returns a numeric ID that is equivalent to the string ID used in an XML
+    // resource. If an unknown str_id is requested (i.e. other than wxID_XXX
+    // or integer), a new record is created which associates the given string
+    // with a number. If value_if_not_found == wxID_NONE, the number is obtained via
+    // wxWindow::NewControlId(). Otherwise value_if_not_found is used.
+    // Macro XRCID(name) is provided for convenient use in event tables.
+    static int GetXRCID(const wxString& str_id, int value_if_not_found = wxID_NONE)
+        { return DoGetXRCID(str_id.utf8_str(), value_if_not_found); }
+
+    // version for internal use only
+    static int DoGetXRCID(const char *str_id, int value_if_not_found = wxID_NONE);
+
+
+    // Find the string ID with the given numeric value, returns an empty string
+    // if no such ID is found.
+    //
+    // Notice that unlike GetXRCID(), which is fast, this operation is slow as
+    // it checks all the IDs used in XRC.
+    static wxString FindXRCIDById(int numId);
+
+
+    // Returns version information (a.b.c.d = d+ 256*c + 256^2*b + 256^3*a).
+    long GetVersion() const { return m_version; }
+
+    // Compares resources version to argument. Returns -1 if resources version
+    // is less than the argument, +1 if greater and 0 if they equal.
+    int CompareVersion(int major, int minor, int release, int revision) const
+    {
+        long diff = GetVersion() -
+                    (major*256*256*256 + minor*256*256 + release*256 + revision);
+        if ( diff < 0 )
+            return -1;
+        else if ( diff > 0 )
+            return +1;
+        else
+            return 0;
+    }
+
+    //// Singleton accessors.
+
+    // Gets the global resources object or creates one if none exists.
+    static wxXmlResource *Get();
+
+    // Sets the global resources object and returns a pointer to the previous one (may be null).
+    static wxXmlResource *Set(wxXmlResource *res);
+
+    // Returns flags, which is a bitlist of wxXmlResourceFlags.
+    int GetFlags() const { return m_flags; }
+    // Set flags after construction.
+    void SetFlags(int flags) { m_flags = flags; }
+
+    // Get/Set the domain to be passed to the translation functions, defaults
+    // to empty string (no domain).
+    const wxString& GetDomain() const { return m_domain; }
+    void SetDomain(const wxString& domain);
+
+    // Add a feature considered to be enabled: this will affect the subsequent
+    // calls to LoadDocument() and related functions and will keep any nodes
+    // using this string in their "feature" attribute (if any).
+    //
+    // Can be called multiple times to enable more than one feature.
+    void EnableFeature(const wxString& feature);
+
+
+    // This function returns the wxXmlNode containing the definition of the
+    // object with the given name or nullptr.
+    //
+    // It can be used to access additional information defined in the XRC file
+    // and not used by wxXmlResource itself.
+    const wxXmlNode *GetResourceNode(const wxString& name) const
+        { return GetResourceNodeAndLocation(name, wxString(), true); }
+
+protected:
+    // reports input error at position 'context'
+    void ReportError(const wxXmlNode *context, const wxString& message);
+
+    // override this in derived class to customize errors reporting
+    virtual void DoReportError(const wxString& xrcFile, const wxXmlNode *position,
+                               const wxString& message);
+
+    // Load the contents of a single file and returns its contents as a new
+    // wxXmlDocument (which will be owned by caller) on success or nullptr.
+    wxXmlDocument *DoLoadFile(const wxString& file);
+
+    // Load XRC from the given document and returns true on success.
+    bool DoLoadDocument(const wxXmlDocument& doc);
+
+    // Scans the resources list for unloaded files and loads them. Also reloads
+    // files that have been modified since last loading.
+    bool UpdateResources();
+
+
+    // Common implementation of GetResourceNode() and FindResource(): searches
+    // all top-level or all (if recursive == true) nodes if all loaded XRC
+    // files and returns the node, if found, as well as the path of the file it
+    // was found in if path is non-null
+    wxXmlNode *GetResourceNodeAndLocation(const wxString& name,
+                                          const wxString& classname,
+                                          bool recursive = false,
+                                          wxString *path = nullptr) const;
+
+
+    // Note that these functions are used outside of wxWidgets itself, e.g.
+    // there are several known cases of inheriting from wxXmlResource just to
+    // be able to call FindResource() so we keep them for compatibility even if
+    // their names are not really consistent with GetResourceNode() public
+    // function and FindResource() is also non-const because it changes the
+    // current path of m_curFileSystem to ensure that relative paths work
+    // correctly when CreateResFromNode() is called immediately afterwards
+    // (something const public function intentionally does not do)
+
+    // Returns the node containing the resource with the given name and class
+    // name unless it's empty (then any class matches) or nullptr if not found.
+    wxXmlNode *FindResource(const wxString& name, const wxString& classname,
+                            bool recursive = false);
+
+    // Helper function used by FindResource() to look under the given node.
+    wxXmlNode *DoFindResource(wxXmlNode *parent, const wxString& name,
+                              const wxString& classname, bool recursive) const;
+
+    // Creates a resource from information in the given node
+    // (Uses only 'handlerToUse' if != nullptr)
+    wxObject *CreateResFromNode(wxXmlNode *node, wxObject *parent,
+                                wxObject *instance = nullptr,
+                                wxXmlResourceHandler *handlerToUse = nullptr)
+    {
+        return node ? DoCreateResFromNode(*node, parent, instance, handlerToUse)
+                    : nullptr;
+    }
+
+    // Helper of Load() and Unload(): returns the URL corresponding to the
+    // given file if it's indeed a file, otherwise returns the original string
+    // unmodified
+    static wxString ConvertFileNameToURL(const wxString& filename);
+
+    // loading resources from archives is impossible without wxFileSystem
+#if wxUSE_FILESYSTEM
+    // Another helper: detect if the filename is a ZIP or XRS file
+    static bool IsArchive(const wxString& filename);
+#endif // wxUSE_FILESYSTEM
+
+private:
+    wxXmlResourceDataRecords& Data() const;
+
+    // the real implementation of CreateResFromNode(): this should be only
+    // called if node is non-null
+    wxObject *DoCreateResFromNode(wxXmlNode& node,
+                                  wxObject *parent,
+                                  wxObject *instance,
+                                  wxXmlResourceHandler *handlerToUse = nullptr);
+
+    // common part of LoadObject() and LoadObjectRecursively()
+    wxObject *DoLoadObject(wxWindow *parent,
+                           const wxString& name,
+                           const wxString& classname,
+                           bool recursive);
+    bool DoLoadObject(wxObject *instance,
+                      wxWindow *parent,
+                      const wxString& name,
+                      const wxString& classname,
+                      bool recursive);
+
+private:
+    long m_version;
+
+    int m_flags;
+
+    // This object contains all private data of this class.
+    wxXmlResourceInternal* m_internal;
+
+#if wxUSE_FILESYSTEM
+    wxFileSystem m_curFileSystem;
+    wxFileSystem& GetCurFileSystem() { return m_curFileSystem; }
+#endif
+
+    // domain to pass to translation functions, if any.
+    wxString m_domain;
+
+    friend class wxXmlResourceHandlerImpl;
+    friend class wxXmlResourceModule;
+    friend class wxIdRangeManager;
+    friend class wxIdRange;
+
+    // singleton instance:
+    static wxXmlResource *ms_instance;
+};
+
+
+// This macro translates string identifier (as used in XML resource,
+// e.g. <menuitem id="my_menu">...</menuitem>) to integer id that is needed by
+// wxWidgets event tables.
+// Example:
+//    wxBEGIN_EVENT_TABLE(MyFrame, wxFrame)
+//       EVT_MENU(XRCID("quit"), MyFrame::OnQuit)
+//       EVT_MENU(XRCID("about"), MyFrame::OnAbout)
+//       EVT_MENU(XRCID("new"), MyFrame::OnNew)
+//       EVT_MENU(XRCID("open"), MyFrame::OnOpen)
+//    wxEND_EVENT_TABLE()
+
+#define XRCID(str_id) \
+    wxXmlResource::DoGetXRCID(str_id)
+
+
+// This macro returns pointer to particular control in dialog
+// created using XML resources. You can use it to set/get values from
+// controls.
+// Example:
+//    wxDialog dlg;
+//    wxXmlResource::Get()->LoadDialog(&dlg, mainFrame, "my_dialog");
+//    XRCCTRL(dlg, "my_textctrl", wxTextCtrl)->SetValue(wxT("default value"));
+
+#define XRCCTRL(window, id, type) \
+    (wxStaticCast((window).FindWindow(XRCID(id)), type))
+
+// This macro returns pointer to sizer item
+// Example:
+//
+// <object class="spacer" name="area">
+//   <size>400, 300</size>
+// </object>
+//
+// wxSizerItem* item = XRCSIZERITEM(*this, "area")
+
+#define XRCSIZERITEM(window, id) \
+    ((window).GetSizer() ? (window).GetSizer()->GetItemById(XRCID(id)) : nullptr)
+
+
+// wxXmlResourceHandlerImpl is the back-end of the wxXmlResourceHander class to
+// really implementing all its functionality. It is defined in the "xrc"
+// library unlike wxXmlResourceHandler itself which is defined in "core" to
+// allow inheriting from it in the code from the other libraries too.
+
+class WXDLLIMPEXP_XRC wxXmlResourceHandlerImpl : public wxXmlResourceHandlerImplBase
+{
+public:
+    // Constructor.
+    wxXmlResourceHandlerImpl(wxXmlResourceHandler *handler);
+
+    // Destructor.
+    virtual ~wxXmlResourceHandlerImpl() = default;
+
+    // Creates an object (menu, dialog, control, ...) from an XML node.
+    // Should check for validity.
+    // parent is a higher-level object (usually window, dialog or panel)
+    // that is often necessary to create the resource.
+    // If instance is non-null it should not create a new instance via 'new' but
+    // should rather use this one, and call its Create method.
+    wxObject *CreateResource(wxXmlNode *node, wxObject *parent,
+                             wxObject *instance) override;
+
+
+    // --- Handy methods:
+
+    // Returns true if the node has a property class equal to classname,
+    // e.g. <object class="wxDialog">.
+    bool IsOfClass(wxXmlNode *node, const wxString& classname) const override;
+
+    bool IsObjectNode(const wxXmlNode *node) const override;
+
+    // Returns the name of the node, e.g. "object" or "sizeritem".
+    wxString GetNodeName(const wxXmlNode *node) const override;
+
+    // Returns the value of the given attribute under the node.
+    wxString GetNodeAttribute(const wxXmlNode *node,
+                              const wxString& attrName,
+                              const wxString& defaultValue) const override;
+
+    // Gets node content from wxXML_ENTITY_NODE
+    // The problem is, <tag>content<tag> is represented as
+    // wxXML_ENTITY_NODE name="tag", content=""
+    //    |-- wxXML_TEXT_NODE or
+    //        wxXML_CDATA_SECTION_NODE name="" content="content"
+    wxString GetNodeContent(const wxXmlNode *node) const override;
+
+    wxXmlNode *GetNodeParent(const wxXmlNode *node) const override;
+    wxXmlNode *GetNodeNext(const wxXmlNode *node) const override;
+    wxXmlNode *GetNodeChildren(const wxXmlNode *node) const override;
+
+    // Check to see if a parameter exists.
+    bool HasParam(const wxString& param) override;
+
+    // Finds the node or returns nullptr.
+    wxXmlNode *GetParamNode(const wxString& param) override;
+
+    // Finds the parameter value or returns the empty string.
+    wxString GetParamValue(const wxString& param) override;
+
+    // Returns the parameter value from given node.
+    wxString GetParamValue(const wxXmlNode* node) override;
+
+    // Gets style flags from text in form "flag | flag2| flag3 |..."
+    // Only understands flags added with AddStyle
+    int GetStyle(const wxString& param = wxT("style"), int defaults = 0) override;
+
+    // Gets text from param and does some conversions:
+    // - replaces \n, \r, \t by respective chars (according to C syntax)
+    // - replaces _ by & and __ by _ (needed for _File => &File because of XML)
+    // - calls wxGetTranslations (unless disabled in wxXmlResource)
+    //
+    // The first two conversions can be disabled by using wxXRC_TEXT_NO_ESCAPE
+    // in flags and the last one -- by using wxXRC_TEXT_NO_TRANSLATE.
+    wxString GetNodeText(const wxXmlNode *node, int flags = 0) override;
+
+    // Returns the XRCID.
+    int GetID() override;
+
+    // Returns the resource name.
+    wxString GetName() override;
+
+    // Gets a bool flag (1, t, yes, on, true are true, everything else is false).
+    bool GetBool(const wxString& param, bool defaultv = false) override;
+
+    // Gets an integer value from the parameter.
+    long GetLong(const wxString& param, long defaultv = 0) override;
+
+    // Gets a float value from the parameter.
+    float GetFloat(const wxString& param, float defaultv = 0) override;
+
+    // Gets colour from the parameter, returning one of the provided default
+    // values if it's not specified depending on whether we're using light or
+    // dark mode.
+    wxColour GetColour(const wxString& param,
+                       const wxColour& defaultLight = wxNullColour,
+                       const wxColour& defaultDark = wxNullColour) override;
+
+    // Gets the size (may be in dialog units).
+    wxSize GetSize(const wxString& param = wxT("size"),
+                   wxWindow *windowToUse = nullptr) override;
+
+    // Gets the position (may be in dialog units).
+    wxPoint GetPosition(const wxString& param = wxT("pos"),
+                        wxWindow *windowToUse = nullptr) override;
+
+    // Gets a dimension (may be in dialog units).
+    wxCoord GetDimension(const wxString& param, wxCoord defaultv = 0,
+                         wxWindow *windowToUse = nullptr) override;
+
+    // Gets a size which is not expressed in pixels, so not in dialog units.
+    wxSize GetPairInts(const wxString& param) override;
+
+    // Gets a direction, complains if the value is invalid.
+    wxDirection GetDirection(const wxString& param, wxDirection dirDefault = wxLEFT) override;
+
+    // Gets a bitmap.
+    wxBitmap GetBitmap(const wxString& param = wxT("bitmap"),
+                       const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER),
+                       wxSize size = wxDefaultSize) override;
+
+    // Gets a bitmap from an XmlNode.
+    wxBitmap GetBitmap(const wxXmlNode* node,
+                       const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER),
+                       wxSize size = wxDefaultSize) override;
+
+    // Gets a bitmap bundle.
+    wxBitmapBundle GetBitmapBundle(const wxString& param = wxT("bitmap"),
+                                   const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER),
+                                   wxSize size = wxDefaultSize) override;
+
+    // Gets a bitmap bundle from the provided node.
+    wxBitmapBundle GetBitmapBundle(const wxXmlNode* node,
+                                   const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER),
+                                   wxSize size = wxDefaultSize) override;
+
+    // Gets an icon.
+    wxIcon GetIcon(const wxString& param = wxT("icon"),
+                   const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER),
+                   wxSize size = wxDefaultSize) override;
+
+    // Gets an icon from an XmlNode.
+    wxIcon GetIcon(const wxXmlNode* node,
+                   const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER),
+                   wxSize size = wxDefaultSize) override;
+
+    // Gets an icon bundle.
+    wxIconBundle GetIconBundle(const wxString& param,
+                               const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER)) override;
+
+    // Gets an image list.
+    wxImageList *GetImageList(const wxString& param = wxT("imagelist")) override;
+
+#if wxUSE_ANIMATIONCTRL
+    // Get all the animations defined in the given parameter which may contain
+    // more than one semicolon-separated paths.
+    wxAnimationBundle GetAnimations(const wxString& param = wxT("animation"),
+                                    wxAnimationCtrlBase* ctrl = nullptr) override;
+
+#if WXWIN_COMPATIBILITY_3_2
+    wxDEPRECATED_MSG("Use GetAnimations() instead")
+    // Gets an animation creating it using the provided control (so that it
+    // will be compatible with it) if any.
+    wxAnimation* GetAnimation(const wxString& param = wxT("animation"),
+                              wxAnimationCtrlBase* ctrl = nullptr) override;
+#endif // WXWIN_COMPATIBILITY_3_2
+#endif // wxUSE_ANIMATIONCTRL
+
+    // Gets a font.
+    wxFont GetFont(const wxString& param = wxT("font"), wxWindow* parent = nullptr) override;
+
+    // Gets the value of a boolean attribute (only "0" and "1" are valid values)
+    bool GetBoolAttr(const wxString& attr, bool defaultv) override;
+
+    // Gets a file path from the given node, expanding environment variables in
+    // it if wxXRC_USE_ENVVARS is in use.
+    wxString GetFilePath(const wxXmlNode* node) override;
+
+    // Returns the window associated with the handler (may be null).
+    wxWindow* GetParentAsWindow() const { return m_handler->GetParentAsWindow(); }
+
+    // Sets common window options.
+    void SetupWindow(wxWindow *wnd) override;
+
+    // Creates children.
+    void CreateChildren(wxObject *parent, bool this_hnd_only = false) override;
+
+    // Helper function.
+    void CreateChildrenPrivately(wxObject *parent, wxXmlNode *rootnode = nullptr) override;
+
+    // Creates a resource from a node.
+    wxObject *CreateResFromNode(wxXmlNode *node,
+                                wxObject *parent, wxObject *instance = nullptr) override;
+
+    // helper
+#if wxUSE_FILESYSTEM
+    wxFileSystem& GetCurFileSystem() override;
+#endif
+
+    // reports input error at position 'context'
+    void ReportError(wxXmlNode *context, const wxString& message) override;
+    // reports input error at m_node
+    void ReportError(const wxString& message) override;
+    // reports input error when parsing parameter with given name
+    void ReportParamError(const wxString& param, const wxString& message) override;
+};
+
+
+// Programmer-friendly macros for writing XRC handlers:
+
+#define XRC_MAKE_INSTANCE(variable, classname) \
+   classname *variable = nullptr; \
+   if (m_instance) \
+       variable = wxStaticCast(m_instance, classname); \
+   if (!variable) \
+       variable = new classname; \
+   if (GetBool(wxT("hidden"), 0) == 1) \
+       variable->Hide();
+
+
+// FIXME -- remove this $%^#$%#$@# as soon as Ron checks his changes in!!
+WXDLLIMPEXP_XRC void wxXmlInitResourceModule();
+
+
+// This class is used to create instances of XRC "object" nodes with "subclass"
+// property. It is _not_ supposed to be used by XRC users, you should instead
+// register your subclasses via wxWidgets' RTTI mechanism. This class is useful
+// only for language bindings developer who need a way to implement subclassing
+// in wxWidgets ports that don't support wxRTTI (e.g. wxPython).
+class WXDLLIMPEXP_XRC wxXmlSubclassFactory
+{
+public:
+    // Try to create instance of given class and return it, return nullptr on
+    // failure:
+    virtual wxObject *Create(const wxString& className) = 0;
+    virtual ~wxXmlSubclassFactory() = default;
+};
+
+
+/* -------------------------------------------------------------------------
+   Backward compatibility macros. Do *NOT* use, they may disappear in future
+   versions of the XRC library!
+   ------------------------------------------------------------------------- */
+
+#endif // wxUSE_XRC
+
+#endif // _WX_XMLRES_H_

libs/wxWidgets-3.3.1/include/wx/xrc/xmlreshandler.h

@@ -0,0 +1,484 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/xrc/xmlreshandler.cpp
+// Purpose:     XML resource handler
+// Author:      Steven Lamerton
+// Created:     2011/01/26
+// Copyright:   (c) 2011 Steven Lamerton
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_XRC_XMLRESHANDLER_H_
+#define _WX_XRC_XMLRESHANDLER_H_
+
+#include "wx/defs.h"
+
+#if wxUSE_XRC
+
+#include "wx/string.h"
+#include "wx/artprov.h"
+#include "wx/colour.h"
+#include "wx/filesys.h"
+#include "wx/imaglist.h"
+#include "wx/window.h"
+
+class WXDLLIMPEXP_FWD_CORE wxAnimation;
+class WXDLLIMPEXP_FWD_CORE wxAnimationBundle;
+class WXDLLIMPEXP_FWD_CORE wxAnimationCtrlBase;
+
+class WXDLLIMPEXP_FWD_XML wxXmlNode;
+class WXDLLIMPEXP_FWD_XML wxXmlResource;
+
+class WXDLLIMPEXP_FWD_CORE wxXmlResourceHandler;
+
+// Helper macro used by the classes derived from wxXmlResourceHandler but also
+// by wxXmlResourceHandler implementation itself.
+#define XRC_ADD_STYLE(style) AddStyle(wxT(#style), style)
+
+// Flags for GetNodeText().
+enum
+{
+    wxXRC_TEXT_NO_TRANSLATE = 1,
+    wxXRC_TEXT_NO_ESCAPE    = 2
+};
+
+// Abstract base class for the implementation object used by
+// wxXmlResourceHandlerImpl. The real implementation is in
+// wxXmlResourceHandlerImpl class in the "xrc" library while this class is in
+// the "core" itself -- but it is so small that it doesn't matter.
+
+class WXDLLIMPEXP_CORE wxXmlResourceHandlerImplBase : public wxObject
+{
+public:
+    // Constructor.
+    wxXmlResourceHandlerImplBase(wxXmlResourceHandler *handler)
+        : m_handler(handler)
+    {}
+
+    // Destructor.
+    virtual ~wxXmlResourceHandlerImplBase() = default;
+
+    virtual wxObject *CreateResource(wxXmlNode *node, wxObject *parent,
+                                     wxObject *instance) = 0;
+    virtual bool IsOfClass(wxXmlNode *node, const wxString& classname) const = 0;
+    virtual bool IsObjectNode(const wxXmlNode *node) const = 0;
+    virtual wxString GetNodeName(const wxXmlNode *node) const = 0;
+    virtual wxString GetNodeAttribute(const wxXmlNode *node,
+                                      const wxString& attrName,
+                                      const wxString& defaultValue) const = 0;
+    virtual wxString GetNodeContent(const wxXmlNode *node) const = 0;
+    virtual wxXmlNode *GetNodeParent(const wxXmlNode *node) const = 0;
+    virtual wxXmlNode *GetNodeNext(const wxXmlNode *node) const = 0;
+    virtual wxXmlNode *GetNodeChildren(const wxXmlNode *node) const = 0;
+    virtual bool HasParam(const wxString& param) = 0;
+    virtual wxXmlNode *GetParamNode(const wxString& param) = 0;
+    virtual wxString GetParamValue(const wxString& param) = 0;
+    virtual wxString GetParamValue(const wxXmlNode* node) = 0;
+    virtual int GetStyle(const wxString& param = wxT("style"), int defaults = 0) = 0;
+    virtual wxString GetNodeText(const wxXmlNode *node, int flags = 0) = 0;
+    virtual int GetID() = 0;
+    virtual wxString GetName() = 0;
+    virtual bool GetBool(const wxString& param, bool defaultv = false) = 0;
+    virtual long GetLong(const wxString& param, long defaultv = 0) = 0;
+    virtual float GetFloat(const wxString& param, float defaultv = 0) = 0;
+    virtual wxColour GetColour(const wxString& param,
+                               const wxColour& defaultLight = wxNullColour,
+                               const wxColour& defaultDark = wxNullColour) = 0;
+    virtual wxSize GetSize(const wxString& param = wxT("size"),
+                           wxWindow *windowToUse = nullptr) = 0;
+    virtual wxPoint GetPosition(const wxString& param = wxT("pos"),
+                                wxWindow *windowToUse = nullptr) = 0;
+    virtual wxCoord GetDimension(const wxString& param, wxCoord defaultv = 0,
+                                 wxWindow *windowToUse = nullptr) = 0;
+    virtual wxSize GetPairInts(const wxString& param) = 0;
+    virtual wxDirection GetDirection(const wxString& param, wxDirection dir = wxLEFT) = 0;
+    virtual wxBitmap GetBitmap(const wxString& param = wxT("bitmap"),
+                               const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER),
+                               wxSize size = wxDefaultSize) = 0;
+    virtual wxBitmap GetBitmap(const wxXmlNode* node,
+                               const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER),
+                               wxSize size = wxDefaultSize) = 0;
+    virtual wxBitmapBundle GetBitmapBundle(const wxString& param = wxT("bitmap"),
+                                           const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER),
+                                           wxSize size = wxDefaultSize) = 0;
+    virtual wxBitmapBundle GetBitmapBundle(const wxXmlNode* node,
+                                           const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER),
+                                           wxSize size = wxDefaultSize) = 0;
+    virtual wxIcon GetIcon(const wxString& param = wxT("icon"),
+                           const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER),
+                           wxSize size = wxDefaultSize) = 0;
+    virtual wxIcon GetIcon(const wxXmlNode* node,
+                           const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER),
+                           wxSize size = wxDefaultSize) = 0;
+    virtual wxIconBundle GetIconBundle(const wxString& param,
+                                       const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER)) = 0;
+    virtual wxImageList *GetImageList(const wxString& param = wxT("imagelist")) = 0;
+
+#if wxUSE_ANIMATIONCTRL
+    virtual wxAnimationBundle GetAnimations(const wxString& param = wxT("animation"),
+                                            wxAnimationCtrlBase* ctrl = nullptr) = 0;
+
+#if WXWIN_COMPATIBILITY_3_2
+    wxDEPRECATED_BUT_USED_INTERNALLY_MSG("Use GetAnimations() instead")
+    virtual wxAnimation* GetAnimation(const wxString& param = wxT("animation"),
+                                      wxAnimationCtrlBase* ctrl = nullptr) = 0;
+#endif // WXWIN_COMPATIBILITY_3_2
+#endif // wxUSE_ANIMATIONCTRL
+
+    virtual wxFont GetFont(const wxString& param = wxT("font"), wxWindow* parent = nullptr) = 0;
+    virtual bool GetBoolAttr(const wxString& attr, bool defaultv) = 0;
+    virtual wxString GetFilePath(const wxXmlNode* node) = 0;
+    virtual void SetupWindow(wxWindow *wnd) = 0;
+    virtual void CreateChildren(wxObject *parent, bool this_hnd_only = false) = 0;
+    virtual void CreateChildrenPrivately(wxObject *parent,
+                                         wxXmlNode *rootnode = nullptr) = 0;
+    virtual wxObject *CreateResFromNode(wxXmlNode *node, wxObject *parent,
+                                        wxObject *instance = nullptr) = 0;
+
+#if wxUSE_FILESYSTEM
+    virtual wxFileSystem& GetCurFileSystem() = 0;
+#endif
+    virtual void ReportError(wxXmlNode *context, const wxString& message) = 0;
+    virtual void ReportError(const wxString& message) = 0;
+    virtual void ReportParamError(const wxString& param, const wxString& message) = 0;
+
+    wxXmlResourceHandler* GetHandler() { return m_handler; }
+
+protected:
+    wxXmlResourceHandler *m_handler;
+};
+
+// Base class for all XRC handlers.
+//
+// Notice that this class is defined in the core library itself and so can be
+// used as the base class by classes in any GUI library. However to actually be
+// usable, it needs to be registered with wxXmlResource which implies linking
+// the application with the xrc library.
+//
+// Also note that all the methods forwarding to GetImpl() are documented only
+// in wxXmlResourceHandlerImpl in wx/xrc/xmlres.h to avoid duplication.
+
+class WXDLLIMPEXP_CORE wxXmlResourceHandler : public wxObject
+{
+public:
+    // Constructor creates an unusable object, before anything can be done with
+    // it, SetImpl() needs to be called as done by wxXmlResource::AddHandler().
+    wxXmlResourceHandler()
+    {
+        m_node = nullptr;
+        m_parent =
+        m_instance = nullptr;
+        m_parentAsWindow = nullptr;
+        m_resource = nullptr;
+
+        m_impl = nullptr;
+    }
+
+    // This should be called exactly once.
+    void SetImpl(wxXmlResourceHandlerImplBase* impl)
+    {
+        wxASSERT_MSG( !m_impl, wxS("Should be called exactly once") );
+
+        m_impl = impl;
+    }
+
+
+    // Destructor.
+    virtual ~wxXmlResourceHandler()
+    {
+        delete m_impl;
+    }
+
+    wxObject *CreateResource(wxXmlNode *node, wxObject *parent,
+                             wxObject *instance)
+    {
+        return GetImpl()->CreateResource(node, parent, instance);
+    }
+
+    // This one is called from CreateResource after variables
+    // were filled.
+    virtual wxObject *DoCreateResource() = 0;
+
+    // Returns true if it understands this node and can create
+    // a resource from it, false otherwise.
+    virtual bool CanHandle(wxXmlNode *node) = 0;
+
+
+    void SetParentResource(wxXmlResource *res)
+    {
+        m_resource = res;
+    }
+
+
+    // These methods are not forwarded to wxXmlResourceHandlerImpl because they
+    // are called from the derived classes ctors and so before SetImpl() can be
+    // called.
+
+    // Add a style flag (e.g. wxMB_DOCKABLE) to the list of flags
+    // understood by this handler.
+    void AddStyle(const wxString& name, int value);
+
+    // Add styles common to all wxWindow-derived classes.
+    void AddWindowStyles();
+
+protected:
+    // Everything else is simply forwarded to wxXmlResourceHandlerImpl.
+    void ReportError(wxXmlNode *context, const wxString& message)
+    {
+        GetImpl()->ReportError(context, message);
+    }
+    void ReportError(const wxString& message)
+    {
+        GetImpl()->ReportError(message);
+    }
+    void ReportParamError(const wxString& param, const wxString& message)
+    {
+        GetImpl()->ReportParamError(param, message);
+    }
+
+    bool IsOfClass(wxXmlNode *node, const wxString& classname) const
+    {
+        return GetImpl()->IsOfClass(node, classname);
+    }
+
+    bool IsObjectNode(const wxXmlNode *node) const
+    {
+        return GetImpl()->IsObjectNode(node);
+    }
+
+    wxString GetNodeName(const wxXmlNode *node) const
+    {
+        return GetImpl()->GetNodeName(node);
+    }
+
+    wxString GetNodeAttribute(const wxXmlNode *node,
+                              const wxString& attrName,
+                              const wxString& defaultValue = {}) const
+    {
+        return GetImpl()->GetNodeAttribute(node, attrName, defaultValue);
+    }
+
+    wxString GetNodeContent(const wxXmlNode *node) const
+    {
+        return GetImpl()->GetNodeContent(node);
+    }
+
+    wxXmlNode *GetNodeParent(const wxXmlNode *node) const
+    {
+        return GetImpl()->GetNodeParent(node);
+    }
+    wxXmlNode *GetNodeNext(const wxXmlNode *node) const
+    {
+        return GetImpl()->GetNodeNext(node);
+    }
+    wxXmlNode *GetNodeChildren(const wxXmlNode *node) const
+    {
+        return GetImpl()->GetNodeChildren(node);
+    }
+
+    bool HasParam(const wxString& param)
+    {
+        return GetImpl()->HasParam(param);
+    }
+
+    wxXmlNode *GetParamNode(const wxString& param)
+    {
+        return GetImpl()->GetParamNode(param);
+    }
+    wxString GetParamValue(const wxString& param)
+    {
+        return GetImpl()->GetParamValue(param);
+    }
+    wxString GetParamValue(const wxXmlNode* node)
+    {
+        return GetImpl()->GetParamValue(node);
+    }
+    int GetStyle(const wxString& param = wxT("style"), int defaults = 0)
+    {
+        return GetImpl()->GetStyle(param, defaults);
+    }
+    wxString GetNodeText(const wxXmlNode *node, int flags = 0)
+    {
+        return GetImpl()->GetNodeText(node, flags);
+    }
+    wxString GetText(const wxString& param, bool translate = true)
+    {
+        return GetImpl()->GetNodeText(GetImpl()->GetParamNode(param),
+                                      translate ? 0 : wxXRC_TEXT_NO_TRANSLATE);
+    }
+    int GetID() const
+    {
+        return GetImpl()->GetID();
+    }
+    wxString GetName()
+    {
+        return GetImpl()->GetName();
+    }
+    bool GetBool(const wxString& param, bool defaultv = false)
+    {
+        return GetImpl()->GetBool(param, defaultv);
+    }
+    long GetLong(const wxString& param, long defaultv = 0)
+    {
+        return GetImpl()->GetLong(param, defaultv);
+    }
+    float GetFloat(const wxString& param, float defaultv = 0)
+    {
+        return GetImpl()->GetFloat(param, defaultv);
+    }
+    wxColour GetColour(const wxString& param,
+                       const wxColour& defaultLight = wxNullColour,
+                       const wxColour& defaultDark = wxNullColour)
+    {
+        return GetImpl()->GetColour(param, defaultLight, defaultDark);
+    }
+    wxSize GetSize(const wxString& param = wxT("size"),
+                   wxWindow *windowToUse = nullptr)
+    {
+        return GetImpl()->GetSize(param, windowToUse);
+    }
+    wxPoint GetPosition(const wxString& param = wxT("pos"),
+                        wxWindow *windowToUse = nullptr)
+    {
+        return GetImpl()->GetPosition(param, windowToUse);
+    }
+    wxCoord GetDimension(const wxString& param, wxCoord defaultv = 0,
+                         wxWindow *windowToUse = nullptr)
+    {
+        return GetImpl()->GetDimension(param, defaultv, windowToUse);
+    }
+    wxSize GetPairInts(const wxString& param)
+    {
+        return GetImpl()->GetPairInts(param);
+    }
+    wxDirection GetDirection(const wxString& param, wxDirection dir = wxLEFT)
+    {
+        return GetImpl()->GetDirection(param, dir);
+    }
+    wxBitmap GetBitmap(const wxString& param = wxT("bitmap"),
+                       const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER),
+                       wxSize size = wxDefaultSize)
+    {
+        return GetImpl()->GetBitmap(param, defaultArtClient, size);
+    }
+    wxBitmap GetBitmap(const wxXmlNode* node,
+                       const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER),
+                       wxSize size = wxDefaultSize)
+    {
+        return GetImpl()->GetBitmap(node, defaultArtClient, size);
+    }
+    wxBitmapBundle GetBitmapBundle(const wxString& param = wxT("bitmap"),
+                                   const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER),
+                                   wxSize size = wxDefaultSize)
+    {
+        return GetImpl()->GetBitmapBundle(param, defaultArtClient, size);
+    }
+    wxBitmapBundle GetBitmapBundle(const wxXmlNode* node,
+                                   const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER),
+                                   wxSize size = wxDefaultSize)
+    {
+        return GetImpl()->GetBitmapBundle(node, defaultArtClient, size);
+    }
+    wxIcon GetIcon(const wxString& param = wxT("icon"),
+                   const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER),
+                   wxSize size = wxDefaultSize)
+    {
+        return GetImpl()->GetIcon(param, defaultArtClient, size);
+    }
+    wxIcon GetIcon(const wxXmlNode* node,
+                   const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER),
+                   wxSize size = wxDefaultSize)
+    {
+        return GetImpl()->GetIcon(node, defaultArtClient, size);
+    }
+    wxIconBundle GetIconBundle(const wxString& param,
+                               const wxArtClient& defaultArtClient = wxASCII_STR(wxART_OTHER))
+    {
+        return GetImpl()->GetIconBundle(param, defaultArtClient);
+    }
+    wxImageList *GetImageList(const wxString& param = wxT("imagelist"))
+    {
+        return GetImpl()->GetImageList(param);
+    }
+
+#if wxUSE_ANIMATIONCTRL
+    wxAnimationBundle GetAnimations(const wxString& param = wxT("animation"),
+                                    wxAnimationCtrlBase* ctrl = nullptr);
+
+#if WXWIN_COMPATIBILITY_3_2
+    wxAnimation* GetAnimation(const wxString& param = wxT("animation"),
+                              wxAnimationCtrlBase* ctrl = nullptr);
+#endif // WXWIN_COMPATIBILITY_3_2
+#endif // wxUSE_ANIMATIONCTRL
+
+    wxFont GetFont(const wxString& param = wxT("font"),
+                   wxWindow* parent = nullptr)
+    {
+        return GetImpl()->GetFont(param, parent);
+    }
+    bool GetBoolAttr(const wxString& attr, bool defaultv)
+    {
+        return GetImpl()->GetBoolAttr(attr, defaultv);
+    }
+    wxString GetFilePath(const wxXmlNode* node)
+    {
+        return GetImpl()->GetFilePath(node);
+    }
+    void SetupWindow(wxWindow *wnd)
+    {
+        GetImpl()->SetupWindow(wnd);
+    }
+    void CreateChildren(wxObject *parent, bool this_hnd_only = false)
+    {
+        GetImpl()->CreateChildren(parent, this_hnd_only);
+    }
+    void CreateChildrenPrivately(wxObject *parent, wxXmlNode *rootnode = nullptr)
+    {
+        GetImpl()->CreateChildrenPrivately(parent, rootnode);
+    }
+    wxObject *CreateResFromNode(wxXmlNode *node,
+                                wxObject *parent, wxObject *instance = nullptr)
+    {
+        return GetImpl()->CreateResFromNode(node, parent, instance);
+    }
+
+#if wxUSE_FILESYSTEM
+    wxFileSystem& GetCurFileSystem()
+    {
+        return GetImpl()->GetCurFileSystem();
+    }
+#endif
+
+    // Variables (filled by CreateResource)
+    wxXmlNode *m_node;
+    wxString m_class;
+    wxObject *m_parent, *m_instance;
+    wxWindow *m_parentAsWindow;
+    wxXmlResource *m_resource;
+
+    // provide method access to those member variables
+    wxXmlResource* GetResource() const        { return m_resource; }
+    wxXmlNode* GetNode() const                { return m_node; }
+    wxString GetClass() const                 { return m_class; }
+    wxObject* GetParent() const               { return m_parent; }
+    wxObject* GetInstance() const             { return m_instance; }
+    wxWindow* GetParentAsWindow() const       { return m_parentAsWindow; }
+
+
+    wxArrayString m_styleNames;
+    wxArrayInt m_styleValues;
+
+    friend class wxXmlResourceHandlerImpl;
+
+private:
+    // This is supposed to never return nullptr because SetImpl() should have been
+    // called.
+    wxXmlResourceHandlerImplBase* GetImpl() const;
+
+    wxXmlResourceHandlerImplBase *m_impl;
+
+    wxDECLARE_ABSTRACT_CLASS(wxXmlResourceHandler);
+};
+
+#endif // wxUSE_XRC
+
+#endif // _WX_XRC_XMLRESHANDLER_H_