Add wx headers and ext

wxheaders/wxext/anybutton_ext.h

@@ -0,0 +1,154 @@
+#ifndef _WX_ANYBUTTON_H_EXT_
+#define _WX_ANYBUTTON_H_EXT_
+
+#include <wx/anybutton.h>
+#include <wx/vidmode.h>
+
+class wxAnyButtonBaseExt;
+typedef bool (*wxAnyButtonBaseExtShouldInheritColoursFunc)(const wxAnyButtonBaseExt* self);
+typedef wxAnyButtonBase::State (*wxAnyButtonBaseExtGetNormalStateFunc)(const wxAnyButtonBaseExt* self);
+typedef wxBorder (*wxAnyButtonBaseExtGetDefaultBorderFunc)(const wxAnyButtonBaseExt* self);
+typedef wxBitmap (*wxAnyButtonBaseExtDoGetBitmapFunc)(const wxAnyButtonBaseExt* self, wxAnyButtonBase::State param0);
+typedef void (*wxAnyButtonBaseExtDoSetBitmapFunc)(const wxAnyButtonBaseExt* self, wxBitmapBundle const& param0, wxAnyButtonBase::State param1);
+typedef wxSize (*wxAnyButtonBaseExtDoGetBitmapMarginsFunc)(const wxAnyButtonBaseExt* self);
+typedef void (*wxAnyButtonBaseExtDoSetBitmapMarginsFunc)(const wxAnyButtonBaseExt* self, wxCoord param0, wxCoord param1);
+typedef void (*wxAnyButtonBaseExtDoSetBitmapPositionFunc)(const wxAnyButtonBaseExt* self, wxDirection param0);
+typedef bool (*wxAnyButtonBaseExtDoGetAuthNeededFunc)(const wxAnyButtonBaseExt* self);
+typedef void (*wxAnyButtonBaseExtDoSetAuthNeededFunc)(const wxAnyButtonBaseExt* self, bool param0);
+
+class wxAnyButtonBaseExt: public wxAnyButtonBase
+{
+public:
+  wxAnyButtonBaseExt(): wxAnyButtonBase()  {  }
+  wxAnyButtonBaseExtShouldInheritColoursFunc m_wxAnyButtonBaseExtShouldInheritColours = NULL;
+  virtual bool ShouldInheritColours() const override
+  {
+    bool res = wxAnyButtonBase::ShouldInheritColours();
+    if (*m_wxAnyButtonBaseExtShouldInheritColours != NULL){
+      return m_wxAnyButtonBaseExtShouldInheritColours(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAnyButtonBaseExtGetNormalStateFunc m_wxAnyButtonBaseExtGetNormalState = NULL;
+  virtual wxAnyButtonBase::State GetNormalState() const override
+  {
+    wxAnyButtonBase::State res = wxAnyButtonBase::GetNormalState();
+    if (*m_wxAnyButtonBaseExtGetNormalState != NULL){
+      return m_wxAnyButtonBaseExtGetNormalState(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAnyButtonBaseExtGetDefaultBorderFunc m_wxAnyButtonBaseExtGetDefaultBorder = NULL;
+  virtual wxBorder GetDefaultBorder() const override
+  {
+    wxBorder res = wxAnyButtonBase::GetDefaultBorder();
+    if (*m_wxAnyButtonBaseExtGetDefaultBorder != NULL){
+      return m_wxAnyButtonBaseExtGetDefaultBorder(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAnyButtonBaseExtDoGetBitmapFunc m_wxAnyButtonBaseExtDoGetBitmap = NULL;
+  virtual wxBitmap DoGetBitmap(wxAnyButtonBase::State param0) const override
+  {
+    wxBitmap res = wxAnyButtonBase::DoGetBitmap(param0);
+    if (*m_wxAnyButtonBaseExtDoGetBitmap != NULL){
+      return m_wxAnyButtonBaseExtDoGetBitmap(this, param0);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAnyButtonBaseExtDoSetBitmapFunc m_wxAnyButtonBaseExtDoSetBitmap = NULL;
+  virtual void DoSetBitmap(wxBitmapBundle const& param0, wxAnyButtonBase::State param1) override
+  {
+    wxAnyButtonBase::DoSetBitmap(param0, param1);
+    if (*m_wxAnyButtonBaseExtDoSetBitmap != NULL){
+      return m_wxAnyButtonBaseExtDoSetBitmap(this, param0, param1);
+    }
+  }
+  wxAnyButtonBaseExtDoGetBitmapMarginsFunc m_wxAnyButtonBaseExtDoGetBitmapMargins = NULL;
+  virtual wxSize DoGetBitmapMargins() const override
+  {
+    wxSize res = wxAnyButtonBase::DoGetBitmapMargins();
+    if (*m_wxAnyButtonBaseExtDoGetBitmapMargins != NULL){
+      return m_wxAnyButtonBaseExtDoGetBitmapMargins(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAnyButtonBaseExtDoSetBitmapMarginsFunc m_wxAnyButtonBaseExtDoSetBitmapMargins = NULL;
+  virtual void DoSetBitmapMargins(wxCoord param0, wxCoord param1) override
+  {
+    wxAnyButtonBase::DoSetBitmapMargins(param0, param1);
+    if (*m_wxAnyButtonBaseExtDoSetBitmapMargins != NULL){
+      return m_wxAnyButtonBaseExtDoSetBitmapMargins(this, param0, param1);
+    }
+  }
+  wxAnyButtonBaseExtDoSetBitmapPositionFunc m_wxAnyButtonBaseExtDoSetBitmapPosition = NULL;
+  virtual void DoSetBitmapPosition(wxDirection param0) override
+  {
+    wxAnyButtonBase::DoSetBitmapPosition(param0);
+    if (*m_wxAnyButtonBaseExtDoSetBitmapPosition != NULL){
+      return m_wxAnyButtonBaseExtDoSetBitmapPosition(this, param0);
+    }
+  }
+  wxAnyButtonBaseExtDoGetAuthNeededFunc m_wxAnyButtonBaseExtDoGetAuthNeeded = NULL;
+  virtual bool DoGetAuthNeeded() const override
+  {
+    bool res = wxAnyButtonBase::DoGetAuthNeeded();
+    if (*m_wxAnyButtonBaseExtDoGetAuthNeeded != NULL){
+      return m_wxAnyButtonBaseExtDoGetAuthNeeded(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAnyButtonBaseExtDoSetAuthNeededFunc m_wxAnyButtonBaseExtDoSetAuthNeeded = NULL;
+  virtual void DoSetAuthNeeded(bool param0) override
+  {
+    wxAnyButtonBase::DoSetAuthNeeded(param0);
+    if (*m_wxAnyButtonBaseExtDoSetAuthNeeded != NULL){
+      return m_wxAnyButtonBaseExtDoSetAuthNeeded(this, param0);
+    }
+  }
+  wxAnyButtonBaseExt(wxAnyButtonBaseExtShouldInheritColoursFunc a_ShouldInheritColours, wxAnyButtonBaseExtGetNormalStateFunc a_GetNormalState, wxAnyButtonBaseExtGetDefaultBorderFunc a_GetDefaultBorder, wxAnyButtonBaseExtDoGetBitmapFunc a_DoGetBitmap, wxAnyButtonBaseExtDoSetBitmapFunc a_DoSetBitmap, wxAnyButtonBaseExtDoGetBitmapMarginsFunc a_DoGetBitmapMargins, wxAnyButtonBaseExtDoSetBitmapMarginsFunc a_DoSetBitmapMargins, wxAnyButtonBaseExtDoSetBitmapPositionFunc a_DoSetBitmapPosition, wxAnyButtonBaseExtDoGetAuthNeededFunc a_DoGetAuthNeeded, wxAnyButtonBaseExtDoSetAuthNeededFunc a_DoSetAuthNeeded): wxAnyButtonBase() {
+    m_wxAnyButtonBaseExtShouldInheritColours = a_ShouldInheritColours;
+    m_wxAnyButtonBaseExtGetNormalState = a_GetNormalState;
+    m_wxAnyButtonBaseExtGetDefaultBorder = a_GetDefaultBorder;
+    m_wxAnyButtonBaseExtDoGetBitmap = a_DoGetBitmap;
+    m_wxAnyButtonBaseExtDoSetBitmap = a_DoSetBitmap;
+    m_wxAnyButtonBaseExtDoGetBitmapMargins = a_DoGetBitmapMargins;
+    m_wxAnyButtonBaseExtDoSetBitmapMargins = a_DoSetBitmapMargins;
+    m_wxAnyButtonBaseExtDoSetBitmapPosition = a_DoSetBitmapPosition;
+    m_wxAnyButtonBaseExtDoGetAuthNeeded = a_DoGetAuthNeeded;
+    m_wxAnyButtonBaseExtDoSetAuthNeeded = a_DoSetAuthNeeded;
+  }
+};
+
+
+#if defined(__WXUNIVERSAL__)
+    #include "wxext/univ/anybutton_ext.h"
+#elif defined(__WXMSW__)
+    #include "wxext/msw/anybutton_ext.h"
+//#elif defined(__WXMOTIF__)
+//    #include "wx/motif/anybutton.h"
+#elif defined(__WXGTK20__)
+    #include "wxext/gtk/anybutton_ext.h"
+//#elif defined(__WXGTK__)
+//    #include "wx/gtk1/anybutton.h"
+#elif defined(__WXMAC__)
+    #include "wxext/osx/anybutton_ext.h"
+#elif defined(__WXQT__)
+    #include "wxext/qt/anybutton_ext.h"
+#else
+    typedef wxAnyButtonBaseExt wxAnyButtonExt;
+#endif
+
+#endif

wxheaders/wxext/app_ext.h

@@ -0,0 +1,285 @@
+#ifndef _WX_APP_H_EXT_
+#define _WX_APP_H_EXT_
+
+class wxAppBaseExt;
+typedef bool (*wxAppBaseExtInitializeFunc)(const wxAppBaseExt* self, int& argc, wxChar** argv);
+typedef bool (*wxAppBaseExtOnInitGuiFunc)(const wxAppBaseExt* self);
+typedef int (*wxAppBaseExtOnRunFunc)(const wxAppBaseExt* self);
+typedef int (*wxAppBaseExtOnExitFunc)(const wxAppBaseExt* self);
+typedef void (*wxAppBaseExtCleanUpFunc)(const wxAppBaseExt* self);
+typedef bool (*wxAppBaseExtSafeYieldFunc)(const wxAppBaseExt* self, wxWindow* win, bool onlyIfNeeded);
+typedef bool (*wxAppBaseExtSafeYieldForFunc)(const wxAppBaseExt* self, wxWindow* win, long eventsToProcess);
+typedef bool (*wxAppBaseExtProcessIdleFunc)(const wxAppBaseExt* self);
+typedef bool (*wxAppBaseExtUsesEventLoopFunc)(const wxAppBaseExt* self);
+typedef bool (*wxAppBaseExtIsActiveFunc)(const wxAppBaseExt* self);
+typedef wxWindow* (*wxAppBaseExtGetTopWindowFunc)(const wxAppBaseExt* self);
+typedef wxVideoMode (*wxAppBaseExtGetDisplayModeFunc)(const wxAppBaseExt* self);
+typedef bool (*wxAppBaseExtSetDisplayModeFunc)(const wxAppBaseExt* self, wxVideoMode const& param0);
+typedef void (*wxAppBaseExtSetPrintModeFunc)(const wxAppBaseExt* self, int param0);
+typedef wxLayoutDirection (*wxAppBaseExtGetLayoutDirectionFunc)(const wxAppBaseExt* self);
+typedef bool (*wxAppBaseExtSetNativeThemeFunc)(const wxAppBaseExt* self, wxString const& param0);
+typedef bool (*wxAppBaseExtOnCmdLineParsedFunc)(const wxAppBaseExt* self, wxCmdLineParser& parser);
+typedef void (*wxAppBaseExtOnInitCmdLineFunc)(const wxAppBaseExt* self, wxCmdLineParser& parser);
+typedef void (*wxAppBaseExtSetActiveFunc)(const wxAppBaseExt* self, bool isActive, wxWindow* lastFocus);
+typedef bool (*wxAppBaseExtIsGUIFunc)(const wxAppBaseExt* self);
+typedef wxAppTraits* (*wxAppBaseExtCreateTraitsFunc)(const wxAppBaseExt* self);
+
+class wxAppBaseExt: public wxAppBase
+{
+public:
+  using wxAppBase::wxAppBase;
+  wxAppBaseExt(): wxAppBase()  {  }
+  virtual ~wxAppBaseExt() override  {  }
+  wxAppBaseExtInitializeFunc m_wxAppBaseExtInitialize = NULL;
+  virtual bool Initialize(int& argc, wxChar** argv) override
+  {
+    bool res = wxAppBase::Initialize(argc, argv);
+    if (*m_wxAppBaseExtInitialize != NULL){
+      return m_wxAppBaseExtInitialize(this, argc, argv);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppBaseExtOnInitGuiFunc m_wxAppBaseExtOnInitGui = NULL;
+  virtual bool OnInitGui() override
+  {
+    bool res = wxAppBase::OnInitGui();
+    if (*m_wxAppBaseExtOnInitGui != NULL){
+      return m_wxAppBaseExtOnInitGui(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppBaseExtOnRunFunc m_wxAppBaseExtOnRun = NULL;
+  virtual int OnRun() override
+  {
+    int res = wxAppBase::OnRun();
+    if (*m_wxAppBaseExtOnRun != NULL){
+      return m_wxAppBaseExtOnRun(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppBaseExtOnExitFunc m_wxAppBaseExtOnExit = NULL;
+  virtual int OnExit() override
+  {
+    int res = wxAppBase::OnExit();
+    if (*m_wxAppBaseExtOnExit != NULL){
+      return m_wxAppBaseExtOnExit(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppBaseExtCleanUpFunc m_wxAppBaseExtCleanUp = NULL;
+  virtual void CleanUp() override
+  {
+    wxAppBase::CleanUp();
+    if (*m_wxAppBaseExtCleanUp != NULL){
+      return m_wxAppBaseExtCleanUp(this);
+    }
+  }
+  wxAppBaseExtSafeYieldFunc m_wxAppBaseExtSafeYield = NULL;
+  virtual bool SafeYield(wxWindow* win, bool onlyIfNeeded) override
+  {
+    bool res = wxAppBase::SafeYield(win, onlyIfNeeded);
+    if (*m_wxAppBaseExtSafeYield != NULL){
+      return m_wxAppBaseExtSafeYield(this, win, onlyIfNeeded);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppBaseExtSafeYieldForFunc m_wxAppBaseExtSafeYieldFor = NULL;
+  virtual bool SafeYieldFor(wxWindow* win, long eventsToProcess) override
+  {
+    bool res = wxAppBase::SafeYieldFor(win, eventsToProcess);
+    if (*m_wxAppBaseExtSafeYieldFor != NULL){
+      return m_wxAppBaseExtSafeYieldFor(this, win, eventsToProcess);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppBaseExtProcessIdleFunc m_wxAppBaseExtProcessIdle = NULL;
+  virtual bool ProcessIdle() override
+  {
+    bool res = wxAppBase::ProcessIdle();
+    if (*m_wxAppBaseExtProcessIdle != NULL){
+      return m_wxAppBaseExtProcessIdle(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppBaseExtUsesEventLoopFunc m_wxAppBaseExtUsesEventLoop = NULL;
+  virtual bool UsesEventLoop() const override
+  {
+    bool res = wxAppBase::UsesEventLoop();
+    if (*m_wxAppBaseExtUsesEventLoop != NULL){
+      return m_wxAppBaseExtUsesEventLoop(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppBaseExtIsActiveFunc m_wxAppBaseExtIsActive = NULL;
+  virtual bool IsActive() const override
+  {
+    bool res = wxAppBase::IsActive();
+    if (*m_wxAppBaseExtIsActive != NULL){
+      return m_wxAppBaseExtIsActive(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppBaseExtGetTopWindowFunc m_wxAppBaseExtGetTopWindow = NULL;
+  virtual wxWindow* GetTopWindow() const override
+  {
+    wxWindow* res = wxAppBase::GetTopWindow();
+    if (*m_wxAppBaseExtGetTopWindow != NULL){
+      return m_wxAppBaseExtGetTopWindow(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppBaseExtGetDisplayModeFunc m_wxAppBaseExtGetDisplayMode = NULL;
+  virtual wxVideoMode GetDisplayMode() const override
+  {
+    wxVideoMode res = wxAppBase::GetDisplayMode();
+    if (*m_wxAppBaseExtGetDisplayMode != NULL){
+      return m_wxAppBaseExtGetDisplayMode(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppBaseExtSetDisplayModeFunc m_wxAppBaseExtSetDisplayMode = NULL;
+  virtual bool SetDisplayMode(wxVideoMode const& param0) override
+  {
+    bool res = wxAppBase::SetDisplayMode(param0);
+    if (*m_wxAppBaseExtSetDisplayMode != NULL){
+      return m_wxAppBaseExtSetDisplayMode(this, param0);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppBaseExtSetPrintModeFunc m_wxAppBaseExtSetPrintMode = NULL;
+  virtual void SetPrintMode(int param0) override
+  {
+    wxAppBase::SetPrintMode(param0);
+    if (*m_wxAppBaseExtSetPrintMode != NULL){
+      return m_wxAppBaseExtSetPrintMode(this, param0);
+    }
+  }
+  wxAppBaseExtGetLayoutDirectionFunc m_wxAppBaseExtGetLayoutDirection = NULL;
+  virtual wxLayoutDirection GetLayoutDirection() const override
+  {
+    wxLayoutDirection res = wxAppBase::GetLayoutDirection();
+    if (*m_wxAppBaseExtGetLayoutDirection != NULL){
+      return m_wxAppBaseExtGetLayoutDirection(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppBaseExtSetNativeThemeFunc m_wxAppBaseExtSetNativeTheme = NULL;
+  virtual bool SetNativeTheme(wxString const& param0) override
+  {
+    bool res = wxAppBase::SetNativeTheme(param0);
+    if (*m_wxAppBaseExtSetNativeTheme != NULL){
+      return m_wxAppBaseExtSetNativeTheme(this, param0);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppBaseExtOnCmdLineParsedFunc m_wxAppBaseExtOnCmdLineParsed = NULL;
+  virtual bool OnCmdLineParsed(wxCmdLineParser& parser) override
+  {
+    bool res = wxAppBase::OnCmdLineParsed(parser);
+    if (*m_wxAppBaseExtOnCmdLineParsed != NULL){
+      return m_wxAppBaseExtOnCmdLineParsed(this, parser);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppBaseExtOnInitCmdLineFunc m_wxAppBaseExtOnInitCmdLine = NULL;
+  virtual void OnInitCmdLine(wxCmdLineParser& parser) override
+  {
+    wxAppBase::OnInitCmdLine(parser);
+    if (*m_wxAppBaseExtOnInitCmdLine != NULL){
+      return m_wxAppBaseExtOnInitCmdLine(this, parser);
+    }
+  }
+  wxAppBaseExtSetActiveFunc m_wxAppBaseExtSetActive = NULL;
+  virtual void SetActive(bool isActive, wxWindow* lastFocus) override
+  {
+    wxAppBase::SetActive(isActive, lastFocus);
+    if (*m_wxAppBaseExtSetActive != NULL){
+      return m_wxAppBaseExtSetActive(this, isActive, lastFocus);
+    }
+  }
+  wxAppBaseExtIsGUIFunc m_wxAppBaseExtIsGUI = NULL;
+  virtual bool IsGUI() const override
+  {
+    bool res = wxAppBase::IsGUI();
+    if (*m_wxAppBaseExtIsGUI != NULL){
+      return m_wxAppBaseExtIsGUI(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppBaseExtCreateTraitsFunc m_wxAppBaseExtCreateTraits = NULL;
+  virtual wxAppTraits* CreateTraits() override
+  {
+    wxAppTraits* res = wxAppBase::CreateTraits();
+    if (*m_wxAppBaseExtCreateTraits != NULL){
+      return m_wxAppBaseExtCreateTraits(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppBaseExt(wxAppBaseExtInitializeFunc a_Initialize, wxAppBaseExtOnInitGuiFunc a_OnInitGui, wxAppBaseExtOnRunFunc a_OnRun, wxAppBaseExtOnExitFunc a_OnExit, wxAppBaseExtCleanUpFunc a_CleanUp, wxAppBaseExtSafeYieldFunc a_SafeYield, wxAppBaseExtSafeYieldForFunc a_SafeYieldFor, wxAppBaseExtProcessIdleFunc a_ProcessIdle, wxAppBaseExtUsesEventLoopFunc a_UsesEventLoop, wxAppBaseExtIsActiveFunc a_IsActive, wxAppBaseExtGetTopWindowFunc a_GetTopWindow, wxAppBaseExtGetDisplayModeFunc a_GetDisplayMode, wxAppBaseExtSetDisplayModeFunc a_SetDisplayMode, wxAppBaseExtSetPrintModeFunc a_SetPrintMode, wxAppBaseExtGetLayoutDirectionFunc a_GetLayoutDirection, wxAppBaseExtSetNativeThemeFunc a_SetNativeTheme, wxAppBaseExtOnCmdLineParsedFunc a_OnCmdLineParsed, wxAppBaseExtOnInitCmdLineFunc a_OnInitCmdLine, wxAppBaseExtSetActiveFunc a_SetActive, wxAppBaseExtIsGUIFunc a_IsGUI, wxAppBaseExtCreateTraitsFunc a_CreateTraits): wxAppBase() {
+    m_wxAppBaseExtInitialize = a_Initialize;
+    m_wxAppBaseExtOnInitGui = a_OnInitGui;
+    m_wxAppBaseExtOnRun = a_OnRun;
+    m_wxAppBaseExtOnExit = a_OnExit;
+    m_wxAppBaseExtCleanUp = a_CleanUp;
+    m_wxAppBaseExtSafeYield = a_SafeYield;
+    m_wxAppBaseExtSafeYieldFor = a_SafeYieldFor;
+    m_wxAppBaseExtProcessIdle = a_ProcessIdle;
+    m_wxAppBaseExtUsesEventLoop = a_UsesEventLoop;
+    m_wxAppBaseExtIsActive = a_IsActive;
+    m_wxAppBaseExtGetTopWindow = a_GetTopWindow;
+    m_wxAppBaseExtGetDisplayMode = a_GetDisplayMode;
+    m_wxAppBaseExtSetDisplayMode = a_SetDisplayMode;
+    m_wxAppBaseExtSetPrintMode = a_SetPrintMode;
+    m_wxAppBaseExtGetLayoutDirection = a_GetLayoutDirection;
+    m_wxAppBaseExtSetNativeTheme = a_SetNativeTheme;
+    m_wxAppBaseExtOnCmdLineParsed = a_OnCmdLineParsed;
+    m_wxAppBaseExtOnInitCmdLine = a_OnInitCmdLine;
+    m_wxAppBaseExtSetActive = a_SetActive;
+    m_wxAppBaseExtIsGUI = a_IsGUI;
+    m_wxAppBaseExtCreateTraits = a_CreateTraits;
+  }
+};
+
+/* class wxAppInitializerExt: public wxAppInitializer */
+/* { */
+/* public: */
+/*   wxAppInitializerExt(wxAppInitializerFunction fn): wxAppInitializer(fn)  {  } */
+/* }; */
+
+
+
+#endif

wxheaders/wxext/appconsole_ext.h

@@ -0,0 +1,446 @@
+#ifndef _WX_APP_CONSOLE_H_EXT_
+#define _WX_APP_CONSOLE_H_EXT_
+
+class wxAppConsoleBaseExt;
+typedef bool (*wxAppConsoleBaseExtInitializeFunc)(const wxAppConsoleBaseExt* self, int& argc, wxChar** argv);
+typedef bool (*wxAppConsoleBaseExtCallOnInitFunc)(const wxAppConsoleBaseExt* self);
+typedef bool (*wxAppConsoleBaseExtOnInitFunc)(const wxAppConsoleBaseExt* self);
+typedef int (*wxAppConsoleBaseExtOnRunFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtOnLaunchedFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtOnEventLoopEnterFunc)(const wxAppConsoleBaseExt* self, wxEventLoopBase* param0);
+typedef int (*wxAppConsoleBaseExtOnExitFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtOnEventLoopExitFunc)(const wxAppConsoleBaseExt* self, wxEventLoopBase* param0);
+typedef void (*wxAppConsoleBaseExtCleanUpFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtOnFatalExceptionFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtExitFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtOnInitCmdLineFunc)(const wxAppConsoleBaseExt* self, wxCmdLineParser& parser);
+typedef bool (*wxAppConsoleBaseExtOnCmdLineParsedFunc)(const wxAppConsoleBaseExt* self, wxCmdLineParser& parser);
+typedef bool (*wxAppConsoleBaseExtOnCmdLineHelpFunc)(const wxAppConsoleBaseExt* self, wxCmdLineParser& parser);
+typedef bool (*wxAppConsoleBaseExtOnCmdLineErrorFunc)(const wxAppConsoleBaseExt* self, wxCmdLineParser& parser);
+typedef void (*wxAppConsoleBaseExtSetCLocaleFunc)(const wxAppConsoleBaseExt* self);
+typedef int (*wxAppConsoleBaseExtFilterEventFunc)(const wxAppConsoleBaseExt* self, wxEvent& event);
+typedef void (*wxAppConsoleBaseExtCallEventHandlerFunc)(const wxAppConsoleBaseExt* self, wxEvtHandler* handler, wxEventFunctor& functor, wxEvent& event);
+typedef void (*wxAppConsoleBaseExtHandleEventFunc)(const wxAppConsoleBaseExt* self, wxEvtHandler* handler, wxEventFunction func, wxEvent& event);
+typedef void (*wxAppConsoleBaseExtOnUnhandledExceptionFunc)(const wxAppConsoleBaseExt* self);
+typedef bool (*wxAppConsoleBaseExtOnExceptionInMainLoopFunc)(const wxAppConsoleBaseExt* self);
+typedef bool (*wxAppConsoleBaseExtStoreCurrentExceptionFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtRethrowStoredExceptionFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtProcessPendingEventsFunc)(const wxAppConsoleBaseExt* self);
+typedef bool (*wxAppConsoleBaseExtPendingFunc)(const wxAppConsoleBaseExt* self);
+typedef bool (*wxAppConsoleBaseExtDispatchFunc)(const wxAppConsoleBaseExt* self);
+typedef int (*wxAppConsoleBaseExtMainLoopFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtExitMainLoopFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtWakeUpIdleFunc)(const wxAppConsoleBaseExt* self);
+typedef bool (*wxAppConsoleBaseExtProcessIdleFunc)(const wxAppConsoleBaseExt* self);
+typedef bool (*wxAppConsoleBaseExtUsesEventLoopFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtOnAssertFailureFunc)(const wxAppConsoleBaseExt* self, wxChar const* file, int line, wxChar const* func, wxChar const* cond, wxChar const* msg);
+typedef void (*wxAppConsoleBaseExtOnAssertFunc)(const wxAppConsoleBaseExt* self, wxChar const* file, int line, wxChar const* cond, wxChar const* msg);
+typedef bool (*wxAppConsoleBaseExtIsGUIFunc)(const wxAppConsoleBaseExt* self);
+typedef wxAppTraits* (*wxAppConsoleBaseExtCreateTraitsFunc)(const wxAppConsoleBaseExt* self);
+typedef void* (*wxAppConsoleBaseExtWXReservedApp1Func)(const wxAppConsoleBaseExt* self, void* param0);
+typedef void* (*wxAppConsoleBaseExtWXReservedApp2Func)(const wxAppConsoleBaseExt* self, void* param0);
+
+class wxAppConsoleBaseExt: public wxAppConsoleBase
+{
+public:
+  wxAppConsoleBaseExt(): wxAppConsoleBase()  {  }
+  virtual ~wxAppConsoleBaseExt() override  {  }
+  wxAppConsoleBaseExtInitializeFunc m_wxAppConsoleBaseExtInitialize = NULL;
+  virtual bool Initialize(int& argc, wxChar** argv) override
+  {
+    bool res = wxAppConsoleBase::Initialize(argc, argv);
+    if (*m_wxAppConsoleBaseExtInitialize != NULL){
+      return m_wxAppConsoleBaseExtInitialize(this, argc, argv);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtCallOnInitFunc m_wxAppConsoleBaseExtCallOnInit = NULL;
+  virtual bool CallOnInit() override
+  {
+    bool res = wxAppConsoleBase::CallOnInit();
+    if (*m_wxAppConsoleBaseExtCallOnInit != NULL){
+      return m_wxAppConsoleBaseExtCallOnInit(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtOnInitFunc m_wxAppConsoleBaseExtOnInit = NULL;
+  virtual bool OnInit() override
+  {
+    bool res = wxAppConsoleBase::OnInit();
+    if (*m_wxAppConsoleBaseExtOnInit != NULL){
+      return m_wxAppConsoleBaseExtOnInit(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtOnRunFunc m_wxAppConsoleBaseExtOnRun = NULL;
+  virtual int OnRun() override
+  {
+    int res = wxAppConsoleBase::OnRun();
+    if (*m_wxAppConsoleBaseExtOnRun != NULL){
+      return m_wxAppConsoleBaseExtOnRun(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtOnLaunchedFunc m_wxAppConsoleBaseExtOnLaunched = NULL;
+  virtual void OnLaunched() override
+  {
+    wxAppConsoleBase::OnLaunched();
+    if (*m_wxAppConsoleBaseExtOnLaunched != NULL){
+      return m_wxAppConsoleBaseExtOnLaunched(this);
+    }
+  }
+  wxAppConsoleBaseExtOnEventLoopEnterFunc m_wxAppConsoleBaseExtOnEventLoopEnter = NULL;
+  virtual void OnEventLoopEnter(wxEventLoopBase* param0) override
+  {
+    wxAppConsoleBase::OnEventLoopEnter(param0);
+    if (*m_wxAppConsoleBaseExtOnEventLoopEnter != NULL){
+      return m_wxAppConsoleBaseExtOnEventLoopEnter(this, param0);
+    }
+  }
+  wxAppConsoleBaseExtOnExitFunc m_wxAppConsoleBaseExtOnExit = NULL;
+  virtual int OnExit() override
+  {
+    int res = wxAppConsoleBase::OnExit();
+    if (*m_wxAppConsoleBaseExtOnExit != NULL){
+      return m_wxAppConsoleBaseExtOnExit(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtOnEventLoopExitFunc m_wxAppConsoleBaseExtOnEventLoopExit = NULL;
+  virtual void OnEventLoopExit(wxEventLoopBase* param0) override
+  {
+    wxAppConsoleBase::OnEventLoopExit(param0);
+    if (*m_wxAppConsoleBaseExtOnEventLoopExit != NULL){
+      return m_wxAppConsoleBaseExtOnEventLoopExit(this, param0);
+    }
+  }
+  wxAppConsoleBaseExtCleanUpFunc m_wxAppConsoleBaseExtCleanUp = NULL;
+  virtual void CleanUp() override
+  {
+    wxAppConsoleBase::CleanUp();
+    if (*m_wxAppConsoleBaseExtCleanUp != NULL){
+      return m_wxAppConsoleBaseExtCleanUp(this);
+    }
+  }
+  wxAppConsoleBaseExtOnFatalExceptionFunc m_wxAppConsoleBaseExtOnFatalException = NULL;
+  virtual void OnFatalException() override
+  {
+    wxAppConsoleBase::OnFatalException();
+    if (*m_wxAppConsoleBaseExtOnFatalException != NULL){
+      return m_wxAppConsoleBaseExtOnFatalException(this);
+    }
+  }
+  wxAppConsoleBaseExtExitFunc m_wxAppConsoleBaseExtExit = NULL;
+  virtual void Exit() override
+  {
+    wxAppConsoleBase::Exit();
+    if (*m_wxAppConsoleBaseExtExit != NULL){
+      return m_wxAppConsoleBaseExtExit(this);
+    }
+  }
+  wxAppConsoleBaseExtOnInitCmdLineFunc m_wxAppConsoleBaseExtOnInitCmdLine = NULL;
+  virtual void OnInitCmdLine(wxCmdLineParser& parser) override
+  {
+    wxAppConsoleBase::OnInitCmdLine(parser);
+    if (*m_wxAppConsoleBaseExtOnInitCmdLine != NULL){
+      return m_wxAppConsoleBaseExtOnInitCmdLine(this, parser);
+    }
+  }
+  wxAppConsoleBaseExtOnCmdLineParsedFunc m_wxAppConsoleBaseExtOnCmdLineParsed = NULL;
+  virtual bool OnCmdLineParsed(wxCmdLineParser& parser) override
+  {
+    bool res = wxAppConsoleBase::OnCmdLineParsed(parser);
+    if (*m_wxAppConsoleBaseExtOnCmdLineParsed != NULL){
+      return m_wxAppConsoleBaseExtOnCmdLineParsed(this, parser);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtOnCmdLineHelpFunc m_wxAppConsoleBaseExtOnCmdLineHelp = NULL;
+  virtual bool OnCmdLineHelp(wxCmdLineParser& parser) override
+  {
+    bool res = wxAppConsoleBase::OnCmdLineHelp(parser);
+    if (*m_wxAppConsoleBaseExtOnCmdLineHelp != NULL){
+      return m_wxAppConsoleBaseExtOnCmdLineHelp(this, parser);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtOnCmdLineErrorFunc m_wxAppConsoleBaseExtOnCmdLineError = NULL;
+  virtual bool OnCmdLineError(wxCmdLineParser& parser) override
+  {
+    bool res = wxAppConsoleBase::OnCmdLineError(parser);
+    if (*m_wxAppConsoleBaseExtOnCmdLineError != NULL){
+      return m_wxAppConsoleBaseExtOnCmdLineError(this, parser);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtSetCLocaleFunc m_wxAppConsoleBaseExtSetCLocale = NULL;
+  virtual void SetCLocale() override
+  {
+    wxAppConsoleBase::SetCLocale();
+    if (*m_wxAppConsoleBaseExtSetCLocale != NULL){
+      return m_wxAppConsoleBaseExtSetCLocale(this);
+    }
+  }
+  wxAppConsoleBaseExtFilterEventFunc m_wxAppConsoleBaseExtFilterEvent = NULL;
+  virtual int FilterEvent(wxEvent& event) override
+  {
+    int res = wxAppConsoleBase::FilterEvent(event);
+    if (*m_wxAppConsoleBaseExtFilterEvent != NULL){
+      return m_wxAppConsoleBaseExtFilterEvent(this, event);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtCallEventHandlerFunc m_wxAppConsoleBaseExtCallEventHandler = NULL;
+  virtual void CallEventHandler(wxEvtHandler* handler, wxEventFunctor& functor, wxEvent& event) const override
+  {
+    wxAppConsoleBase::CallEventHandler(handler, functor, event);
+    if (*m_wxAppConsoleBaseExtCallEventHandler != NULL){
+      return m_wxAppConsoleBaseExtCallEventHandler(this, handler, functor, event);
+    }
+  }
+  wxAppConsoleBaseExtHandleEventFunc m_wxAppConsoleBaseExtHandleEvent = NULL;
+  virtual void HandleEvent(wxEvtHandler* handler, wxEventFunction func, wxEvent& event) const override
+  {
+    wxAppConsoleBase::HandleEvent(handler, func, event);
+    if (*m_wxAppConsoleBaseExtHandleEvent != NULL){
+      return m_wxAppConsoleBaseExtHandleEvent(this, handler, func, event);
+    }
+  }
+  wxAppConsoleBaseExtOnUnhandledExceptionFunc m_wxAppConsoleBaseExtOnUnhandledException = NULL;
+  virtual void OnUnhandledException() override
+  {
+    wxAppConsoleBase::OnUnhandledException();
+    if (*m_wxAppConsoleBaseExtOnUnhandledException != NULL){
+      return m_wxAppConsoleBaseExtOnUnhandledException(this);
+    }
+  }
+  wxAppConsoleBaseExtOnExceptionInMainLoopFunc m_wxAppConsoleBaseExtOnExceptionInMainLoop = NULL;
+  virtual bool OnExceptionInMainLoop() override
+  {
+    bool res = wxAppConsoleBase::OnExceptionInMainLoop();
+    if (*m_wxAppConsoleBaseExtOnExceptionInMainLoop != NULL){
+      return m_wxAppConsoleBaseExtOnExceptionInMainLoop(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtStoreCurrentExceptionFunc m_wxAppConsoleBaseExtStoreCurrentException = NULL;
+  virtual bool StoreCurrentException() override
+  {
+    bool res = wxAppConsoleBase::StoreCurrentException();
+    if (*m_wxAppConsoleBaseExtStoreCurrentException != NULL){
+      return m_wxAppConsoleBaseExtStoreCurrentException(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtRethrowStoredExceptionFunc m_wxAppConsoleBaseExtRethrowStoredException = NULL;
+  virtual void RethrowStoredException() override
+  {
+    wxAppConsoleBase::RethrowStoredException();
+    if (*m_wxAppConsoleBaseExtRethrowStoredException != NULL){
+      return m_wxAppConsoleBaseExtRethrowStoredException(this);
+    }
+  }
+  wxAppConsoleBaseExtProcessPendingEventsFunc m_wxAppConsoleBaseExtProcessPendingEvents = NULL;
+  virtual void ProcessPendingEvents() override
+  {
+    wxAppConsoleBase::ProcessPendingEvents();
+    if (*m_wxAppConsoleBaseExtProcessPendingEvents != NULL){
+      return m_wxAppConsoleBaseExtProcessPendingEvents(this);
+    }
+  }
+  wxAppConsoleBaseExtPendingFunc m_wxAppConsoleBaseExtPending = NULL;
+  virtual bool Pending() override
+  {
+    bool res = wxAppConsoleBase::Pending();
+    if (*m_wxAppConsoleBaseExtPending != NULL){
+      return m_wxAppConsoleBaseExtPending(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtDispatchFunc m_wxAppConsoleBaseExtDispatch = NULL;
+  virtual bool Dispatch() override
+  {
+    bool res = wxAppConsoleBase::Dispatch();
+    if (*m_wxAppConsoleBaseExtDispatch != NULL){
+      return m_wxAppConsoleBaseExtDispatch(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtMainLoopFunc m_wxAppConsoleBaseExtMainLoop = NULL;
+  virtual int MainLoop() override
+  {
+    int res = wxAppConsoleBase::MainLoop();
+    if (*m_wxAppConsoleBaseExtMainLoop != NULL){
+      return m_wxAppConsoleBaseExtMainLoop(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtExitMainLoopFunc m_wxAppConsoleBaseExtExitMainLoop = NULL;
+  virtual void ExitMainLoop() override
+  {
+    wxAppConsoleBase::ExitMainLoop();
+    if (*m_wxAppConsoleBaseExtExitMainLoop != NULL){
+      return m_wxAppConsoleBaseExtExitMainLoop(this);
+    }
+  }
+  wxAppConsoleBaseExtWakeUpIdleFunc m_wxAppConsoleBaseExtWakeUpIdle = NULL;
+  virtual void WakeUpIdle() override
+  {
+    wxAppConsoleBase::WakeUpIdle();
+    if (*m_wxAppConsoleBaseExtWakeUpIdle != NULL){
+      return m_wxAppConsoleBaseExtWakeUpIdle(this);
+    }
+  }
+  wxAppConsoleBaseExtProcessIdleFunc m_wxAppConsoleBaseExtProcessIdle = NULL;
+  virtual bool ProcessIdle() override
+  {
+    bool res = wxAppConsoleBase::ProcessIdle();
+    if (*m_wxAppConsoleBaseExtProcessIdle != NULL){
+      return m_wxAppConsoleBaseExtProcessIdle(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtUsesEventLoopFunc m_wxAppConsoleBaseExtUsesEventLoop = NULL;
+  virtual bool UsesEventLoop() const override
+  {
+    bool res = wxAppConsoleBase::UsesEventLoop();
+    if (*m_wxAppConsoleBaseExtUsesEventLoop != NULL){
+      return m_wxAppConsoleBaseExtUsesEventLoop(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtOnAssertFailureFunc m_wxAppConsoleBaseExtOnAssertFailure = NULL;
+  virtual void OnAssertFailure(wxChar const* file, int line, wxChar const* func, wxChar const* cond, wxChar const* msg) override
+  {
+    wxAppConsoleBase::OnAssertFailure(file, line, func, cond, msg);
+    if (*m_wxAppConsoleBaseExtOnAssertFailure != NULL){
+      return m_wxAppConsoleBaseExtOnAssertFailure(this, file, line, func, cond, msg);
+    }
+  }
+  wxAppConsoleBaseExtOnAssertFunc m_wxAppConsoleBaseExtOnAssert = NULL;
+  virtual void OnAssert(wxChar const* file, int line, wxChar const* cond, wxChar const* msg) override
+  {
+    wxAppConsoleBase::OnAssert(file, line, cond, msg);
+    if (*m_wxAppConsoleBaseExtOnAssert != NULL){
+      return m_wxAppConsoleBaseExtOnAssert(this, file, line, cond, msg);
+    }
+  }
+  wxAppConsoleBaseExtIsGUIFunc m_wxAppConsoleBaseExtIsGUI = NULL;
+  virtual bool IsGUI() const override
+  {
+    bool res = wxAppConsoleBase::IsGUI();
+    if (*m_wxAppConsoleBaseExtIsGUI != NULL){
+      return m_wxAppConsoleBaseExtIsGUI(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtCreateTraitsFunc m_wxAppConsoleBaseExtCreateTraits = NULL;
+  virtual wxAppTraits* CreateTraits() override
+  {
+    wxAppTraits* res = wxAppConsoleBase::CreateTraits();
+    if (*m_wxAppConsoleBaseExtCreateTraits != NULL){
+      return m_wxAppConsoleBaseExtCreateTraits(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtWXReservedApp1Func m_wxAppConsoleBaseExtWXReservedApp1 = NULL;
+  virtual void* WXReservedApp1(void* param0) override
+  {
+    void* res = wxAppConsoleBase::WXReservedApp1(param0);
+    if (*m_wxAppConsoleBaseExtWXReservedApp1 != NULL){
+      return m_wxAppConsoleBaseExtWXReservedApp1(this, param0);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExtWXReservedApp2Func m_wxAppConsoleBaseExtWXReservedApp2 = NULL;
+  virtual void* WXReservedApp2(void* param0) override
+  {
+    void* res = wxAppConsoleBase::WXReservedApp2(param0);
+    if (*m_wxAppConsoleBaseExtWXReservedApp2 != NULL){
+      return m_wxAppConsoleBaseExtWXReservedApp2(this, param0);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppConsoleBaseExt(wxAppConsoleBaseExtInitializeFunc a_Initialize, wxAppConsoleBaseExtCallOnInitFunc a_CallOnInit, wxAppConsoleBaseExtOnInitFunc a_OnInit, wxAppConsoleBaseExtOnRunFunc a_OnRun, wxAppConsoleBaseExtOnLaunchedFunc a_OnLaunched, wxAppConsoleBaseExtOnEventLoopEnterFunc a_OnEventLoopEnter, wxAppConsoleBaseExtOnExitFunc a_OnExit, wxAppConsoleBaseExtOnEventLoopExitFunc a_OnEventLoopExit, wxAppConsoleBaseExtCleanUpFunc a_CleanUp, wxAppConsoleBaseExtOnFatalExceptionFunc a_OnFatalException, wxAppConsoleBaseExtExitFunc a_Exit, wxAppConsoleBaseExtOnInitCmdLineFunc a_OnInitCmdLine, wxAppConsoleBaseExtOnCmdLineParsedFunc a_OnCmdLineParsed, wxAppConsoleBaseExtOnCmdLineHelpFunc a_OnCmdLineHelp, wxAppConsoleBaseExtOnCmdLineErrorFunc a_OnCmdLineError, wxAppConsoleBaseExtSetCLocaleFunc a_SetCLocale, wxAppConsoleBaseExtFilterEventFunc a_FilterEvent, wxAppConsoleBaseExtCallEventHandlerFunc a_CallEventHandler, wxAppConsoleBaseExtHandleEventFunc a_HandleEvent, wxAppConsoleBaseExtOnUnhandledExceptionFunc a_OnUnhandledException, wxAppConsoleBaseExtOnExceptionInMainLoopFunc a_OnExceptionInMainLoop, wxAppConsoleBaseExtStoreCurrentExceptionFunc a_StoreCurrentException, wxAppConsoleBaseExtRethrowStoredExceptionFunc a_RethrowStoredException, wxAppConsoleBaseExtProcessPendingEventsFunc a_ProcessPendingEvents, wxAppConsoleBaseExtPendingFunc a_Pending, wxAppConsoleBaseExtDispatchFunc a_Dispatch, wxAppConsoleBaseExtMainLoopFunc a_MainLoop, wxAppConsoleBaseExtExitMainLoopFunc a_ExitMainLoop, wxAppConsoleBaseExtWakeUpIdleFunc a_WakeUpIdle, wxAppConsoleBaseExtProcessIdleFunc a_ProcessIdle, wxAppConsoleBaseExtUsesEventLoopFunc a_UsesEventLoop, wxAppConsoleBaseExtOnAssertFailureFunc a_OnAssertFailure, wxAppConsoleBaseExtOnAssertFunc a_OnAssert, wxAppConsoleBaseExtIsGUIFunc a_IsGUI, wxAppConsoleBaseExtCreateTraitsFunc a_CreateTraits, wxAppConsoleBaseExtWXReservedApp1Func a_WXReservedApp1, wxAppConsoleBaseExtWXReservedApp2Func a_WXReservedApp2): wxAppConsoleBase() {
+    m_wxAppConsoleBaseExtInitialize = a_Initialize;
+    m_wxAppConsoleBaseExtCallOnInit = a_CallOnInit;
+    m_wxAppConsoleBaseExtOnInit = a_OnInit;
+    m_wxAppConsoleBaseExtOnRun = a_OnRun;
+    m_wxAppConsoleBaseExtOnLaunched = a_OnLaunched;
+    m_wxAppConsoleBaseExtOnEventLoopEnter = a_OnEventLoopEnter;
+    m_wxAppConsoleBaseExtOnExit = a_OnExit;
+    m_wxAppConsoleBaseExtOnEventLoopExit = a_OnEventLoopExit;
+    m_wxAppConsoleBaseExtCleanUp = a_CleanUp;
+    m_wxAppConsoleBaseExtOnFatalException = a_OnFatalException;
+    m_wxAppConsoleBaseExtExit = a_Exit;
+    m_wxAppConsoleBaseExtOnInitCmdLine = a_OnInitCmdLine;
+    m_wxAppConsoleBaseExtOnCmdLineParsed = a_OnCmdLineParsed;
+    m_wxAppConsoleBaseExtOnCmdLineHelp = a_OnCmdLineHelp;
+    m_wxAppConsoleBaseExtOnCmdLineError = a_OnCmdLineError;
+    m_wxAppConsoleBaseExtSetCLocale = a_SetCLocale;
+    m_wxAppConsoleBaseExtFilterEvent = a_FilterEvent;
+    m_wxAppConsoleBaseExtCallEventHandler = a_CallEventHandler;
+    m_wxAppConsoleBaseExtHandleEvent = a_HandleEvent;
+    m_wxAppConsoleBaseExtOnUnhandledException = a_OnUnhandledException;
+    m_wxAppConsoleBaseExtOnExceptionInMainLoop = a_OnExceptionInMainLoop;
+    m_wxAppConsoleBaseExtStoreCurrentException = a_StoreCurrentException;
+    m_wxAppConsoleBaseExtRethrowStoredException = a_RethrowStoredException;
+    m_wxAppConsoleBaseExtProcessPendingEvents = a_ProcessPendingEvents;
+    m_wxAppConsoleBaseExtPending = a_Pending;
+    m_wxAppConsoleBaseExtDispatch = a_Dispatch;
+    m_wxAppConsoleBaseExtMainLoop = a_MainLoop;
+    m_wxAppConsoleBaseExtExitMainLoop = a_ExitMainLoop;
+    m_wxAppConsoleBaseExtWakeUpIdle = a_WakeUpIdle;
+    m_wxAppConsoleBaseExtProcessIdle = a_ProcessIdle;
+    m_wxAppConsoleBaseExtUsesEventLoop = a_UsesEventLoop;
+    m_wxAppConsoleBaseExtOnAssertFailure = a_OnAssertFailure;
+    m_wxAppConsoleBaseExtOnAssert = a_OnAssert;
+    m_wxAppConsoleBaseExtIsGUI = a_IsGUI;
+    m_wxAppConsoleBaseExtCreateTraits = a_CreateTraits;
+    m_wxAppConsoleBaseExtWXReservedApp1 = a_WXReservedApp1;
+    m_wxAppConsoleBaseExtWXReservedApp2 = a_WXReservedApp2;
+  }
+};
+
+
+#endif

wxheaders/wxext/button_ext.h

@@ -0,0 +1,32 @@
+#ifndef _WX_BUTTON_H_EXT_
+#define _WX_BUTTON_H_EXT_
+
+#include <wx/wx.h>
+#include <wx/vidmode.h>
+
+class wxButtonBaseExt;
+typedef wxWindow* (*wxButtonBaseExtSetDefaultFunc)(const wxButtonBaseExt* self);
+
+class wxButtonBaseExt: public wxButtonBase
+{
+public:
+  wxButtonBaseExt(): wxButtonBase()  {  }
+  wxButtonBaseExtSetDefaultFunc m_wxButtonBaseExtSetDefault = NULL;
+  virtual wxWindow* SetDefault() override
+  {
+    wxWindow* res = wxButtonBase::SetDefault();
+    if (*m_wxButtonBaseExtSetDefault != NULL){
+      return m_wxButtonBaseExtSetDefault(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxButtonBaseExt(wxButtonBaseExtSetDefaultFunc a_SetDefault): wxButtonBase() {
+    m_wxButtonBaseExtSetDefault = a_SetDefault;
+  }
+};
+
+
+
+#endif

wxheaders/wxext/compile_flags.txt

@@ -0,0 +1,18 @@
+-xc++
+-std=gnu++14
+-funsigned-char
+-fno-stack-protector
+-w
+-ferror-limit=3
+-pthread
+-I../
+-I../../wxheaders
+-I../../swigtemplates
+-I/usr/local/lib/wx/include/osx_cocoa-unicode-3.2
+-I/usr/local/include/wx-3.2
+-D_FILE_OFFSET_BITS=64
+-DWXUSINGDLL
+-D__WXMAC__
+-D__WXOSX__
+-D__WXOSX_COCOA__
+

wxheaders/wxext/control_ext.h

@@ -0,0 +1,106 @@
+#ifndef _WX_CONTROL_H_EXT_
+#define _WX_CONTROL_H_EXT_
+
+#include <wx/control.h>
+
+class wxControlBaseExt;
+typedef void (*wxControlBaseExtCommandFunc)(const wxControlBaseExt* self, wxCommandEvent& event);
+typedef bool (*wxControlBaseExtSetFontFunc)(const wxControlBaseExt* self, wxFont const& font);
+typedef void (*wxControlBaseExtDoUpdateWindowUIFunc)(const wxControlBaseExt* self, wxUpdateUIEvent& event);
+typedef wxBorder (*wxControlBaseExtGetDefaultBorderFunc)(const wxControlBaseExt* self);
+typedef bool (*wxControlBaseExtDoSetLabelMarkupFunc)(const wxControlBaseExt* self, wxString const& markup);
+typedef wxSize (*wxControlBaseExtDoGetSizeFromTextSizeFunc)(const wxControlBaseExt* self, int xlen, int ylen);
+
+class wxControlBaseExt: public wxControlBase
+{
+public:
+  wxControlBaseExt(): wxControlBase()  {  }
+  virtual ~wxControlBaseExt() override  {  }
+  wxControlBaseExtCommandFunc m_wxControlBaseExtCommand = NULL;
+  virtual void Command(wxCommandEvent& event) override
+  {
+    wxControlBase::Command(event);
+    if (*m_wxControlBaseExtCommand != NULL){
+      return m_wxControlBaseExtCommand(this, event);
+    }
+  }
+  wxControlBaseExtSetFontFunc m_wxControlBaseExtSetFont = NULL;
+  virtual bool SetFont(wxFont const& font) override
+  {
+    bool res = wxControlBase::SetFont(font);
+    if (*m_wxControlBaseExtSetFont != NULL){
+      return m_wxControlBaseExtSetFont(this, font);
+    }
+    else {
+      return res;
+    }
+  }
+  wxControlBaseExtDoUpdateWindowUIFunc m_wxControlBaseExtDoUpdateWindowUI = NULL;
+  virtual void DoUpdateWindowUI(wxUpdateUIEvent& event) override
+  {
+    wxControlBase::DoUpdateWindowUI(event);
+    if (*m_wxControlBaseExtDoUpdateWindowUI != NULL){
+      return m_wxControlBaseExtDoUpdateWindowUI(this, event);
+    }
+  }
+  wxControlBaseExtGetDefaultBorderFunc m_wxControlBaseExtGetDefaultBorder = NULL;
+  virtual wxBorder GetDefaultBorder() const override
+  {
+    wxBorder res = wxControlBase::GetDefaultBorder();
+    if (*m_wxControlBaseExtGetDefaultBorder != NULL){
+      return m_wxControlBaseExtGetDefaultBorder(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxControlBaseExtDoSetLabelMarkupFunc m_wxControlBaseExtDoSetLabelMarkup = NULL;
+  virtual bool DoSetLabelMarkup(wxString const& markup) override
+  {
+    bool res = wxControlBase::DoSetLabelMarkup(markup);
+    if (*m_wxControlBaseExtDoSetLabelMarkup != NULL){
+      return m_wxControlBaseExtDoSetLabelMarkup(this, markup);
+    }
+    else {
+      return res;
+    }
+  }
+  wxControlBaseExtDoGetSizeFromTextSizeFunc m_wxControlBaseExtDoGetSizeFromTextSize = NULL;
+  virtual wxSize DoGetSizeFromTextSize(int xlen, int ylen = -1) const override
+  {
+    wxSize res = wxControlBase::DoGetSizeFromTextSize(xlen, ylen);
+    if (*m_wxControlBaseExtDoGetSizeFromTextSize != NULL){
+      return m_wxControlBaseExtDoGetSizeFromTextSize(this, xlen, ylen);
+    }
+    else {
+      return res;
+    }
+  }
+  wxControlBaseExt(wxControlBaseExtCommandFunc a_Command, wxControlBaseExtSetFontFunc a_SetFont, wxControlBaseExtDoUpdateWindowUIFunc a_DoUpdateWindowUI, wxControlBaseExtGetDefaultBorderFunc a_GetDefaultBorder, wxControlBaseExtDoSetLabelMarkupFunc a_DoSetLabelMarkup, wxControlBaseExtDoGetSizeFromTextSizeFunc a_DoGetSizeFromTextSize): wxControlBase() {
+    m_wxControlBaseExtCommand = a_Command;
+    m_wxControlBaseExtSetFont = a_SetFont;
+    m_wxControlBaseExtDoUpdateWindowUI = a_DoUpdateWindowUI;
+    m_wxControlBaseExtGetDefaultBorder = a_GetDefaultBorder;
+    m_wxControlBaseExtDoSetLabelMarkup = a_DoSetLabelMarkup;
+    m_wxControlBaseExtDoGetSizeFromTextSize = a_DoGetSizeFromTextSize;
+  }
+};
+
+
+#if defined(__WXUNIVERSAL__)
+    #include "wxext/univ/control_ext.h"
+#elif defined(__WXMSW__)
+    #include "wxext/msw/control_ext.h"
+#elif defined(__WXMOTIF__)
+    #include "wxext/motif/control_ext.h"
+#elif defined(__WXGTK20__)
+    #include "wxext/gtk/control_ext.h"
+#elif defined(__WXGTK__)
+    #include "wxext/gtk1/control_ext.h"
+#elif defined(__WXMAC__)
+    #include "wxext/osx/control_ext.h"
+#elif defined(__WXQT__)
+    #include "wxext/qt/control_ext.h"
+#endif
+
+#endif

wxheaders/wxext/eventfilter_ext.h

@@ -0,0 +1,33 @@
+#ifndef _WX_EVENTFILTER_H_EXT_
+#define _WX_EVENTFILTER_H_EXT_
+
+#include <wx/wx.h>
+#include <wx/vidmode.h>
+
+class wxEventFilterExt;
+typedef int (*wxEventFilterExtFilterEventFunc)(const wxEventFilterExt* self, wxEvent& event);
+
+class wxEventFilterExt: public wxEventFilter
+{
+public:
+  wxEventFilterExt(): wxEventFilter()  {  }
+  virtual ~wxEventFilterExt()  {  }
+  wxEventFilterExtFilterEventFunc m_wxEventFilterExtFilterEvent = NULL;
+  virtual int FilterEvent(wxEvent& event) override
+  {
+    int res = wxEventFilter::FilterEvent(event);
+    if (*m_wxEventFilterExtFilterEvent != NULL){
+      return m_wxEventFilterExtFilterEvent(this, event);
+    }
+    else {
+      return res;
+    }
+  }
+  wxEventFilterExt(wxEventFilterExtFilterEventFunc a_FilterEvent): wxEventFilter() {
+    m_wxEventFilterExtFilterEvent = a_FilterEvent;
+  }
+};
+
+
+
+#endif

wxheaders/wxext/frame_ext.h

@@ -0,0 +1,244 @@
+#ifndef _WX_FRAME_H_EXT_
+#define _WX_FRAME_H_EXT_
+
+class wxFrameBaseExt;
+typedef wxPoint (*wxFrameBaseExtGetClientAreaOriginFunc)(const wxFrameBaseExt* self);
+typedef void (*wxFrameBaseExtSetMenuBarFunc)(const wxFrameBaseExt* self, wxMenuBar* menubar);
+typedef wxMenuItem* (*wxFrameBaseExtFindItemInMenuBarFunc)(const wxFrameBaseExt* self, int menuId);
+typedef wxStatusBar* (*wxFrameBaseExtCreateStatusBarFunc)(const wxFrameBaseExt* self, int number, long style, wxWindowID winid, wxString const& name);
+typedef wxStatusBar* (*wxFrameBaseExtOnCreateStatusBarFunc)(const wxFrameBaseExt* self, int number, long style, wxWindowID winid, wxString const& name);
+typedef void (*wxFrameBaseExtSetStatusBarFunc)(const wxFrameBaseExt* self, wxStatusBar* statBar);
+typedef void (*wxFrameBaseExtSetStatusTextFunc)(const wxFrameBaseExt* self, wxString const& text, int number);
+typedef void (*wxFrameBaseExtSetStatusWidthsFunc)(const wxFrameBaseExt* self, int n, int const widths_field[]);
+typedef wxToolBar* (*wxFrameBaseExtCreateToolBarFunc)(const wxFrameBaseExt* self, long style, wxWindowID winid, wxString const& name);
+typedef wxToolBar* (*wxFrameBaseExtOnCreateToolBarFunc)(const wxFrameBaseExt* self, long style, wxWindowID winid, wxString const& name);
+typedef void (*wxFrameBaseExtSetToolBarFunc)(const wxFrameBaseExt* self, wxToolBar* toolbar);
+typedef void (*wxFrameBaseExtDoMenuUpdatesFunc)(const wxFrameBaseExt* self, wxMenu* menu);
+typedef void (*wxFrameBaseExtUpdateWindowUIFunc)(const wxFrameBaseExt* self, long flags);
+typedef void (*wxFrameBaseExtOnInternalIdleFunc)(const wxFrameBaseExt* self);
+typedef void (*wxFrameBaseExtDoGiveHelpFunc)(const wxFrameBaseExt* self, wxString const& text, bool show);
+typedef bool (*wxFrameBaseExtIsOneOfBarsFunc)(const wxFrameBaseExt* self, wxWindow const* win);
+typedef void (*wxFrameBaseExtDetachMenuBarFunc)(const wxFrameBaseExt* self);
+typedef void (*wxFrameBaseExtAttachMenuBarFunc)(const wxFrameBaseExt* self, wxMenuBar* menubar);
+typedef wxEventTable const* (*wxFrameBaseExtGetEventTableFunc)(const wxFrameBaseExt* self);
+typedef wxEventHashTable& (*wxFrameBaseExtGetEventHashTableFunc)(const wxFrameBaseExt* self);
+
+class wxFrameBaseExt: public wxFrameBase
+{
+public:
+  wxFrameBaseExt(): wxFrameBase()  {  }
+  virtual ~wxFrameBaseExt() override  {  }
+  wxFrameBaseExtGetClientAreaOriginFunc m_wxFrameBaseExtGetClientAreaOrigin;
+  virtual wxPoint GetClientAreaOrigin() const override
+  {
+    wxPoint res = wxFrameBase::GetClientAreaOrigin();
+    if (*m_wxFrameBaseExtGetClientAreaOrigin != NULL){
+      return m_wxFrameBaseExtGetClientAreaOrigin(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxFrameBaseExtSetMenuBarFunc m_wxFrameBaseExtSetMenuBar;
+  virtual void SetMenuBar(wxMenuBar* menubar) override
+  {
+    wxFrameBase::SetMenuBar(menubar);
+    if (*m_wxFrameBaseExtSetMenuBar != NULL){
+      return m_wxFrameBaseExtSetMenuBar(this, menubar);
+    }
+  }
+  wxFrameBaseExtFindItemInMenuBarFunc m_wxFrameBaseExtFindItemInMenuBar;
+  virtual wxMenuItem* FindItemInMenuBar(int menuId) const override
+  {
+    wxMenuItem* res = wxFrameBase::FindItemInMenuBar(menuId);
+    if (*m_wxFrameBaseExtFindItemInMenuBar != NULL){
+      return m_wxFrameBaseExtFindItemInMenuBar(this, menuId);
+    }
+    else {
+      return res;
+    }
+  }
+  wxFrameBaseExtCreateStatusBarFunc m_wxFrameBaseExtCreateStatusBar;
+  virtual wxStatusBar* CreateStatusBar(int number = 1, long style = (0x0010 | 0x0100 | 0x0020 | 0x00010000), wxWindowID winid = wxID_ANY, wxString const& name = wxString::FromAscii(wxStatusLineNameStr)) override
+  {
+    wxStatusBar* res = wxFrameBase::CreateStatusBar(number, style, winid, name);
+    if (*m_wxFrameBaseExtCreateStatusBar != NULL){
+      return m_wxFrameBaseExtCreateStatusBar(this, number, style, winid, name);
+    }
+    else {
+      return res;
+    }
+  }
+  wxFrameBaseExtOnCreateStatusBarFunc m_wxFrameBaseExtOnCreateStatusBar;
+  virtual wxStatusBar* OnCreateStatusBar(int number, long style, wxWindowID winid, wxString const& name) override
+  {
+    wxStatusBar* res = wxFrameBase::OnCreateStatusBar(number, style, winid, name);
+    if (*m_wxFrameBaseExtOnCreateStatusBar != NULL){
+      return m_wxFrameBaseExtOnCreateStatusBar(this, number, style, winid, name);
+    }
+    else {
+      return res;
+    }
+  }
+  wxFrameBaseExtSetStatusBarFunc m_wxFrameBaseExtSetStatusBar;
+  virtual void SetStatusBar(wxStatusBar* statBar) override
+  {
+    wxFrameBase::SetStatusBar(statBar);
+    if (*m_wxFrameBaseExtSetStatusBar != NULL){
+      return m_wxFrameBaseExtSetStatusBar(this, statBar);
+    }
+  }
+  wxFrameBaseExtSetStatusTextFunc m_wxFrameBaseExtSetStatusText;
+  virtual void SetStatusText(wxString const& text, int number = 0) override
+  {
+    wxFrameBase::SetStatusText(text, number);
+    if (*m_wxFrameBaseExtSetStatusText != NULL){
+      return m_wxFrameBaseExtSetStatusText(this, text, number);
+    }
+  }
+  wxFrameBaseExtSetStatusWidthsFunc m_wxFrameBaseExtSetStatusWidths;
+  virtual void SetStatusWidths(int n, int const widths_field[]) override
+  {
+    wxFrameBase::SetStatusWidths(n, widths_field);
+    if (*m_wxFrameBaseExtSetStatusWidths != NULL){
+      return m_wxFrameBaseExtSetStatusWidths(this, n, widths_field);
+    }
+  }
+  wxFrameBaseExtCreateToolBarFunc m_wxFrameBaseExtCreateToolBar;
+  virtual wxToolBar* CreateToolBar(long style = -1, wxWindowID winid = wxID_ANY, wxString const& name = wxString::FromAscii(wxToolBarNameStr)) override
+  {
+    wxToolBar* res = wxFrameBase::CreateToolBar(style, winid, name);
+    if (*m_wxFrameBaseExtCreateToolBar != NULL){
+      return m_wxFrameBaseExtCreateToolBar(this, style, winid, name);
+    }
+    else {
+      return res;
+    }
+  }
+  wxFrameBaseExtOnCreateToolBarFunc m_wxFrameBaseExtOnCreateToolBar;
+  virtual wxToolBar* OnCreateToolBar(long style, wxWindowID winid, wxString const& name) override
+  {
+    wxToolBar* res = wxFrameBase::OnCreateToolBar(style, winid, name);
+    if (*m_wxFrameBaseExtOnCreateToolBar != NULL){
+      return m_wxFrameBaseExtOnCreateToolBar(this, style, winid, name);
+    }
+    else {
+      return res;
+    }
+  }
+  wxFrameBaseExtSetToolBarFunc m_wxFrameBaseExtSetToolBar;
+  virtual void SetToolBar(wxToolBar* toolbar) override
+  {
+    wxFrameBase::SetToolBar(toolbar);
+    if (*m_wxFrameBaseExtSetToolBar != NULL){
+      return m_wxFrameBaseExtSetToolBar(this, toolbar);
+    }
+  }
+  wxFrameBaseExtDoMenuUpdatesFunc m_wxFrameBaseExtDoMenuUpdates;
+  virtual void DoMenuUpdates(wxMenu* menu = __null) override
+  {
+    wxFrameBase::DoMenuUpdates(menu);
+    if (*m_wxFrameBaseExtDoMenuUpdates != NULL){
+      return m_wxFrameBaseExtDoMenuUpdates(this, menu);
+    }
+  }
+  wxFrameBaseExtUpdateWindowUIFunc m_wxFrameBaseExtUpdateWindowUI;
+  virtual void UpdateWindowUI(long flags = wxUPDATE_UI_NONE) override
+  {
+    wxFrameBase::UpdateWindowUI(flags);
+    if (*m_wxFrameBaseExtUpdateWindowUI != NULL){
+      return m_wxFrameBaseExtUpdateWindowUI(this, flags);
+    }
+  }
+  wxFrameBaseExtOnInternalIdleFunc m_wxFrameBaseExtOnInternalIdle;
+  virtual void OnInternalIdle() override
+  {
+    wxFrameBase::OnInternalIdle();
+    if (*m_wxFrameBaseExtOnInternalIdle != NULL){
+      return m_wxFrameBaseExtOnInternalIdle(this);
+    }
+  }
+  wxFrameBaseExtDoGiveHelpFunc m_wxFrameBaseExtDoGiveHelp;
+  virtual void DoGiveHelp(wxString const& text, bool show) override
+  {
+    wxFrameBase::DoGiveHelp(text, show);
+    if (*m_wxFrameBaseExtDoGiveHelp != NULL){
+      return m_wxFrameBaseExtDoGiveHelp(this, text, show);
+    }
+  }
+  wxFrameBaseExtIsOneOfBarsFunc m_wxFrameBaseExtIsOneOfBars;
+  virtual bool IsOneOfBars(wxWindow const* win) const override
+  {
+    bool res = wxFrameBase::IsOneOfBars(win);
+    if (*m_wxFrameBaseExtIsOneOfBars != NULL){
+      return m_wxFrameBaseExtIsOneOfBars(this, win);
+    }
+    else {
+      return res;
+    }
+  }
+  wxFrameBaseExtDetachMenuBarFunc m_wxFrameBaseExtDetachMenuBar;
+  virtual void DetachMenuBar() override
+  {
+    wxFrameBase::DetachMenuBar();
+    if (*m_wxFrameBaseExtDetachMenuBar != NULL){
+      return m_wxFrameBaseExtDetachMenuBar(this);
+    }
+  }
+  wxFrameBaseExtAttachMenuBarFunc m_wxFrameBaseExtAttachMenuBar;
+  virtual void AttachMenuBar(wxMenuBar* menubar) override
+  {
+    wxFrameBase::AttachMenuBar(menubar);
+    if (*m_wxFrameBaseExtAttachMenuBar != NULL){
+      return m_wxFrameBaseExtAttachMenuBar(this, menubar);
+    }
+  }
+  wxFrameBaseExtGetEventTableFunc m_wxFrameBaseExtGetEventTable;
+  virtual wxEventTable const* GetEventTable() const override
+  {
+    wxEventTable const* res = wxFrameBase::GetEventTable();
+    if (*m_wxFrameBaseExtGetEventTable != NULL){
+      return m_wxFrameBaseExtGetEventTable(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxFrameBaseExtGetEventHashTableFunc m_wxFrameBaseExtGetEventHashTable;
+  virtual wxEventHashTable& GetEventHashTable() const override
+  {
+    wxEventHashTable& res = wxFrameBase::GetEventHashTable();
+    if (*m_wxFrameBaseExtGetEventHashTable != NULL){
+      return m_wxFrameBaseExtGetEventHashTable(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxFrameBaseExt(wxFrameBaseExtGetClientAreaOriginFunc a_GetClientAreaOrigin, wxFrameBaseExtSetMenuBarFunc a_SetMenuBar, wxFrameBaseExtFindItemInMenuBarFunc a_FindItemInMenuBar, wxFrameBaseExtCreateStatusBarFunc a_CreateStatusBar, wxFrameBaseExtOnCreateStatusBarFunc a_OnCreateStatusBar, wxFrameBaseExtSetStatusBarFunc a_SetStatusBar, wxFrameBaseExtSetStatusTextFunc a_SetStatusText, wxFrameBaseExtSetStatusWidthsFunc a_SetStatusWidths, wxFrameBaseExtCreateToolBarFunc a_CreateToolBar, wxFrameBaseExtOnCreateToolBarFunc a_OnCreateToolBar, wxFrameBaseExtSetToolBarFunc a_SetToolBar, wxFrameBaseExtDoMenuUpdatesFunc a_DoMenuUpdates, wxFrameBaseExtUpdateWindowUIFunc a_UpdateWindowUI, wxFrameBaseExtOnInternalIdleFunc a_OnInternalIdle, wxFrameBaseExtDoGiveHelpFunc a_DoGiveHelp, wxFrameBaseExtIsOneOfBarsFunc a_IsOneOfBars, wxFrameBaseExtDetachMenuBarFunc a_DetachMenuBar, wxFrameBaseExtAttachMenuBarFunc a_AttachMenuBar, wxFrameBaseExtGetEventTableFunc a_GetEventTable, wxFrameBaseExtGetEventHashTableFunc a_GetEventHashTable): wxFrameBase() {
+    m_wxFrameBaseExtGetClientAreaOrigin = a_GetClientAreaOrigin;
+    m_wxFrameBaseExtSetMenuBar = a_SetMenuBar;
+    m_wxFrameBaseExtFindItemInMenuBar = a_FindItemInMenuBar;
+    m_wxFrameBaseExtCreateStatusBar = a_CreateStatusBar;
+    m_wxFrameBaseExtOnCreateStatusBar = a_OnCreateStatusBar;
+    m_wxFrameBaseExtSetStatusBar = a_SetStatusBar;
+    m_wxFrameBaseExtSetStatusText = a_SetStatusText;
+    m_wxFrameBaseExtSetStatusWidths = a_SetStatusWidths;
+    m_wxFrameBaseExtCreateToolBar = a_CreateToolBar;
+    m_wxFrameBaseExtOnCreateToolBar = a_OnCreateToolBar;
+    m_wxFrameBaseExtSetToolBar = a_SetToolBar;
+    m_wxFrameBaseExtDoMenuUpdates = a_DoMenuUpdates;
+    m_wxFrameBaseExtUpdateWindowUI = a_UpdateWindowUI;
+    m_wxFrameBaseExtOnInternalIdle = a_OnInternalIdle;
+    m_wxFrameBaseExtDoGiveHelp = a_DoGiveHelp;
+    m_wxFrameBaseExtIsOneOfBars = a_IsOneOfBars;
+    m_wxFrameBaseExtDetachMenuBar = a_DetachMenuBar;
+    m_wxFrameBaseExtAttachMenuBar = a_AttachMenuBar;
+    m_wxFrameBaseExtGetEventTable = a_GetEventTable;
+    m_wxFrameBaseExtGetEventHashTable = a_GetEventHashTable;
+  }
+};
+
+
+
+#endif

wxheaders/wxext/generic/panelg_ext.h

@@ -0,0 +1,33 @@
+#ifndef _WX_GENERIC_PANELG_H_EXT_
+#define _WX_GENERIC_PANELG_H_EXT_
+
+#include <wx/wx.h>
+#include <wx/vidmode.h>
+
+class wxPanelExt;
+typedef wxClassInfo* (*wxPanelExtGetClassInfoFunc)(const wxPanelExt* self);
+
+class wxPanelExt: public wxPanel
+{
+public:
+  wxPanelExt(): wxPanel()  {  }
+  wxPanelExt(wxWindow* parent, wxWindowID winid = wxID_ANY, wxPoint const& pos = wxDefaultPosition, wxSize const& size = wxDefaultSize, long style = 0x00080000 | wxBORDER_NONE, wxString const& name = wxString::FromAscii(wxPanelNameStr)): wxPanel(parent, winid, pos, size, style, name)  {  }
+  wxPanelExtGetClassInfoFunc m_wxPanelExtGetClassInfo = NULL;
+  virtual wxClassInfo* GetClassInfo() const override
+  {
+    wxClassInfo* res = wxPanel::GetClassInfo();
+    if (*m_wxPanelExtGetClassInfo != NULL){
+      return m_wxPanelExtGetClassInfo(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxPanelExt(wxPanelExtGetClassInfoFunc a_GetClassInfo): wxPanel() {
+    m_wxPanelExtGetClassInfo = a_GetClassInfo;
+  }
+};
+
+
+
+#endif

wxheaders/wxext/init_ext.h

@@ -0,0 +1,19 @@
+#ifndef _WX_INIT_H_EXT_
+#define _WX_INIT_H_EXT_
+
+#include <wx/wx.h>
+#include <wx/vidmode.h>
+
+class wxInitializerExt;
+
+class wxInitializerExt: public wxInitializer
+{
+public:
+  wxInitializerExt(): wxInitializer()  {  }
+  wxInitializerExt(int& argc, wxChar** argv): wxInitializer(argc, argv)  {  }
+  wxInitializerExt(int& argc, char** argv): wxInitializer(argc, argv)  {  }
+};
+
+
+
+#endif

wxheaders/wxext/object_ext.h

@@ -0,0 +1,68 @@
+#ifndef _WX_OBJECT_H_EXT_
+#define _WX_OBJECT_H_EXT_
+
+#include <wx/wx.h>
+#include <wx/vidmode.h>
+
+class wxRefCounterExt;
+class wxObjectExt;
+typedef wxClassInfo* (*wxObjectExtGetClassInfoFunc)(const wxObjectExt* self);
+typedef wxObjectRefData* (*wxObjectExtCreateRefDataFunc)(const wxObjectExt* self);
+typedef wxObjectRefData* (*wxObjectExtCloneRefDataFunc)(const wxObjectExt* self, wxObjectRefData const* data);
+
+class wxRefCounterExt: public wxRefCounter
+{
+public:
+  wxRefCounterExt(): wxRefCounter()  {  }
+  virtual ~wxRefCounterExt()  {  }
+};
+
+class wxObjectExt: public wxObject
+{
+public:
+  wxObjectExt(): wxObject()  {  }
+  virtual ~wxObjectExt()  {  }
+  wxObjectExt(wxObject const& other): wxObject(other)  {  }
+  wxObjectExtGetClassInfoFunc m_wxObjectExtGetClassInfo = NULL;
+  virtual wxClassInfo* GetClassInfo() const override
+  {
+    wxClassInfo* res = wxObject::GetClassInfo();
+    if (*m_wxObjectExtGetClassInfo != NULL){
+      return m_wxObjectExtGetClassInfo(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxObjectExtCreateRefDataFunc m_wxObjectExtCreateRefData = NULL;
+  virtual wxObjectRefData* CreateRefData() const override
+  {
+    wxObjectRefData* res = wxObject::CreateRefData();
+    if (*m_wxObjectExtCreateRefData != NULL){
+      return m_wxObjectExtCreateRefData(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxObjectExtCloneRefDataFunc m_wxObjectExtCloneRefData = NULL;
+  virtual wxObjectRefData* CloneRefData(wxObjectRefData const* data) const override
+  {
+    wxObjectRefData* res = wxObject::CloneRefData(data);
+    if (*m_wxObjectExtCloneRefData != NULL){
+      return m_wxObjectExtCloneRefData(this, data);
+    }
+    else {
+      return res;
+    }
+  }
+  wxObjectExt(wxObjectExtGetClassInfoFunc a_GetClassInfo, wxObjectExtCreateRefDataFunc a_CreateRefData, wxObjectExtCloneRefDataFunc a_CloneRefData): wxObject() {
+    m_wxObjectExtGetClassInfo = a_GetClassInfo;
+    m_wxObjectExtCreateRefData = a_CreateRefData;
+    m_wxObjectExtCloneRefData = a_CloneRefData;
+  }
+};
+
+
+
+#endif

wxheaders/wxext/osx/anybutton_ext.h

@@ -0,0 +1,121 @@
+#ifndef _WX_OSX_ANYBUTTON_H_EXT_
+#define _WX_OSX_ANYBUTTON_H_EXT_
+
+class wxAnyButtonExt;
+typedef void (*wxAnyButtonExtSetLabelFunc)(const wxAnyButtonExt* self, wxString const& label);
+typedef wxSize (*wxAnyButtonExtDoGetBestSizeFunc)(const wxAnyButtonExt* self);
+typedef wxBitmap (*wxAnyButtonExtDoGetBitmapFunc)(const wxAnyButtonExt* self, wxAnyButtonBase::State which);
+typedef void (*wxAnyButtonExtDoSetBitmapFunc)(const wxAnyButtonExt* self, wxBitmapBundle const& bitmapBundle, wxAnyButtonBase::State which);
+typedef void (*wxAnyButtonExtDoSetBitmapPositionFunc)(const wxAnyButtonExt* self, wxDirection dir);
+typedef void (*wxAnyButtonExtDoSetBitmapMarginsFunc)(const wxAnyButtonExt* self, int x, int y);
+typedef bool (*wxAnyButtonExtDoSetLabelMarkupFunc)(const wxAnyButtonExt* self, wxString const& markup);
+typedef wxEventTable const* (*wxAnyButtonExtGetEventTableFunc)(const wxAnyButtonExt* self);
+typedef wxEventHashTable& (*wxAnyButtonExtGetEventHashTableFunc)(const wxAnyButtonExt* self);
+
+class wxAnyButtonExt: public wxAnyButton
+{
+public:
+  wxAnyButtonExt(): wxAnyButton()  {  }
+  wxAnyButtonExtSetLabelFunc m_wxAnyButtonExtSetLabel = NULL;
+  virtual void SetLabel(wxString const& label) override
+  {
+    wxAnyButton::SetLabel(label);
+    if (*m_wxAnyButtonExtSetLabel != NULL){
+      return m_wxAnyButtonExtSetLabel(this, label);
+    }
+  }
+  wxAnyButtonExtDoGetBestSizeFunc m_wxAnyButtonExtDoGetBestSize = NULL;
+  virtual wxSize DoGetBestSize() const override
+  {
+    wxSize res = wxAnyButton::DoGetBestSize();
+    if (*m_wxAnyButtonExtDoGetBestSize != NULL){
+      return m_wxAnyButtonExtDoGetBestSize(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAnyButtonExtDoGetBitmapFunc m_wxAnyButtonExtDoGetBitmap = NULL;
+  virtual wxBitmap DoGetBitmap(wxAnyButtonBase::State which) const override
+  {
+    wxBitmap res = wxAnyButton::DoGetBitmap(which);
+    if (*m_wxAnyButtonExtDoGetBitmap != NULL){
+      return m_wxAnyButtonExtDoGetBitmap(this, which);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAnyButtonExtDoSetBitmapFunc m_wxAnyButtonExtDoSetBitmap = NULL;
+  virtual void DoSetBitmap(wxBitmapBundle const& bitmapBundle, wxAnyButtonBase::State which) override
+  {
+    wxAnyButton::DoSetBitmap(bitmapBundle, which);
+    if (*m_wxAnyButtonExtDoSetBitmap != NULL){
+      return m_wxAnyButtonExtDoSetBitmap(this, bitmapBundle, which);
+    }
+  }
+  wxAnyButtonExtDoSetBitmapPositionFunc m_wxAnyButtonExtDoSetBitmapPosition = NULL;
+  virtual void DoSetBitmapPosition(wxDirection dir) override
+  {
+    wxAnyButton::DoSetBitmapPosition(dir);
+    if (*m_wxAnyButtonExtDoSetBitmapPosition != NULL){
+      return m_wxAnyButtonExtDoSetBitmapPosition(this, dir);
+    }
+  }
+  wxAnyButtonExtDoSetBitmapMarginsFunc m_wxAnyButtonExtDoSetBitmapMargins = NULL;
+  virtual void DoSetBitmapMargins(int x, int y) override
+  {
+    wxAnyButton::DoSetBitmapMargins(x, y);
+    if (*m_wxAnyButtonExtDoSetBitmapMargins != NULL){
+      return m_wxAnyButtonExtDoSetBitmapMargins(this, x, y);
+    }
+  }
+  wxAnyButtonExtDoSetLabelMarkupFunc m_wxAnyButtonExtDoSetLabelMarkup = NULL;
+  virtual bool DoSetLabelMarkup(wxString const& markup) override
+  {
+    bool res = wxAnyButton::DoSetLabelMarkup(markup);
+    if (*m_wxAnyButtonExtDoSetLabelMarkup != NULL){
+      return m_wxAnyButtonExtDoSetLabelMarkup(this, markup);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAnyButtonExtGetEventTableFunc m_wxAnyButtonExtGetEventTable = NULL;
+  virtual wxEventTable const* GetEventTable() const override
+  {
+    wxEventTable const* res = wxAnyButton::GetEventTable();
+    if (*m_wxAnyButtonExtGetEventTable != NULL){
+      return m_wxAnyButtonExtGetEventTable(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAnyButtonExtGetEventHashTableFunc m_wxAnyButtonExtGetEventHashTable = NULL;
+  virtual wxEventHashTable& GetEventHashTable() const override
+  {
+    wxEventHashTable& res = wxAnyButton::GetEventHashTable();
+    if (*m_wxAnyButtonExtGetEventHashTable != NULL){
+      return m_wxAnyButtonExtGetEventHashTable(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAnyButtonExt(wxAnyButtonExtSetLabelFunc a_SetLabel, wxAnyButtonExtDoGetBestSizeFunc a_DoGetBestSize, wxAnyButtonExtDoGetBitmapFunc a_DoGetBitmap, wxAnyButtonExtDoSetBitmapFunc a_DoSetBitmap, wxAnyButtonExtDoSetBitmapPositionFunc a_DoSetBitmapPosition, wxAnyButtonExtDoSetBitmapMarginsFunc a_DoSetBitmapMargins, wxAnyButtonExtDoSetLabelMarkupFunc a_DoSetLabelMarkup, wxAnyButtonExtGetEventTableFunc a_GetEventTable, wxAnyButtonExtGetEventHashTableFunc a_GetEventHashTable): wxAnyButton() {
+    m_wxAnyButtonExtSetLabel = a_SetLabel;
+    m_wxAnyButtonExtDoGetBestSize = a_DoGetBestSize;
+    m_wxAnyButtonExtDoGetBitmap = a_DoGetBitmap;
+    m_wxAnyButtonExtDoSetBitmap = a_DoSetBitmap;
+    m_wxAnyButtonExtDoSetBitmapPosition = a_DoSetBitmapPosition;
+    m_wxAnyButtonExtDoSetBitmapMargins = a_DoSetBitmapMargins;
+    m_wxAnyButtonExtDoSetLabelMarkup = a_DoSetLabelMarkup;
+    m_wxAnyButtonExtGetEventTable = a_GetEventTable;
+    m_wxAnyButtonExtGetEventHashTable = a_GetEventHashTable;
+  }
+};
+
+
+
+#endif

wxheaders/wxext/osx/app_ext.h

@@ -0,0 +1,336 @@
+#ifndef _WX_OSX_APP_H_EXT_
+#define _WX_OSX_APP_H_EXT_
+#include <iostream>
+
+class wxAppExt;
+typedef void (*wxAppExtWakeUpIdleFunc)(const wxAppExt* self);
+typedef bool (*wxAppExtCallOnInitFunc)(const wxAppExt* self);
+typedef bool (*wxAppExtOnInitGuiFunc)(const wxAppExt* self);
+typedef int (*wxAppExtOnRunFunc)(const wxAppExt* self);
+typedef bool (*wxAppExtProcessIdleFunc)(const wxAppExt* self);
+typedef bool (*wxAppExtInitializeFunc)(const wxAppExt* self, int& argc, wxChar** argv);
+typedef void (*wxAppExtCleanUpFunc)(const wxAppExt* self);
+typedef WX_NSObject (*wxAppExtOSXCreateAppControllerFunc)(const wxAppExt* self);
+typedef void (*wxAppExtMacHandleUnhandledEventFunc)(const wxAppExt* self, WXEVENTREF ev);
+typedef void (*wxAppExtMacOpenFilesFunc)(const wxAppExt* self, wxArrayString const& fileNames);
+typedef void (*wxAppExtMacOpenFileFunc)(const wxAppExt* self, wxString const& fileName);
+typedef void (*wxAppExtMacOpenURLFunc)(const wxAppExt* self, wxString const& url);
+typedef void (*wxAppExtMacPrintFilesFunc)(const wxAppExt* self, wxArrayString const& fileNames);
+typedef void (*wxAppExtMacPrintFileFunc)(const wxAppExt* self, wxString const& fileName);
+typedef void (*wxAppExtMacNewFileFunc)(const wxAppExt* self);
+typedef void (*wxAppExtMacReopenAppFunc)(const wxAppExt* self);
+typedef void (*wxAppExtOSXOnWillFinishLaunchingFunc)(const wxAppExt* self);
+typedef void (*wxAppExtOSXOnDidFinishLaunchingFunc)(const wxAppExt* self);
+typedef bool (*wxAppExtOSXOnShouldTerminateFunc)(const wxAppExt* self);
+typedef void (*wxAppExtOSXOnWillTerminateFunc)(const wxAppExt* self);
+
+
+typedef bool (*wxAppBaseExtInitializeFunc)(const wxAppBaseExt* self, int& argc, wxChar** argv);
+typedef bool (*wxAppBaseExtOnInitGuiFunc)(const wxAppBaseExt* self);
+typedef int (*wxAppBaseExtOnRunFunc)(const wxAppBaseExt* self);
+typedef int (*wxAppBaseExtOnExitFunc)(const wxAppBaseExt* self);
+typedef void (*wxAppBaseExtCleanUpFunc)(const wxAppBaseExt* self);
+typedef bool (*wxAppBaseExtSafeYieldFunc)(const wxAppBaseExt* self, wxWindow* win, bool onlyIfNeeded);
+typedef bool (*wxAppBaseExtSafeYieldForFunc)(const wxAppBaseExt* self, wxWindow* win, long eventsToProcess);
+typedef bool (*wxAppBaseExtProcessIdleFunc)(const wxAppBaseExt* self);
+typedef wxWindow* (*wxAppBaseExtGetTopWindowFunc)(const wxAppBaseExt* self);
+typedef wxVideoMode (*wxAppBaseExtGetDisplayModeFunc)(const wxAppBaseExt* self);
+typedef wxLayoutDirection (*wxAppBaseExtGetLayoutDirectionFunc)(const wxAppBaseExt* self);
+typedef bool (*wxAppBaseExtOnCmdLineParsedFunc)(const wxAppBaseExt* self, wxCmdLineParser& parser);
+typedef void (*wxAppBaseExtOnInitCmdLineFunc)(const wxAppBaseExt* self, wxCmdLineParser& parser);
+typedef void (*wxAppBaseExtSetActiveFunc)(const wxAppBaseExt* self, bool isActive, wxWindow* lastFocus);
+typedef wxAppTraits* (*wxAppBaseExtCreateTraitsFunc)(const wxAppBaseExt* self);
+
+typedef bool (*wxAppConsoleBaseExtInitializeFunc)(const wxAppConsoleBaseExt* self, int& argc, wxChar** argv);
+typedef bool (*wxAppConsoleBaseExtCallOnInitFunc)(const wxAppConsoleBaseExt* self);
+typedef bool (*wxAppConsoleBaseExtOnInitFunc)(const wxAppConsoleBaseExt* self);
+typedef int (*wxAppConsoleBaseExtOnRunFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtOnLaunchedFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtOnEventLoopEnterFunc)(const wxAppConsoleBaseExt* self, wxEventLoopBase* param0);
+typedef int (*wxAppConsoleBaseExtOnExitFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtOnEventLoopExitFunc)(const wxAppConsoleBaseExt* self, wxEventLoopBase* param0);
+typedef void (*wxAppConsoleBaseExtCleanUpFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtOnFatalExceptionFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtExitFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtOnInitCmdLineFunc)(const wxAppConsoleBaseExt* self, wxCmdLineParser& parser);
+typedef bool (*wxAppConsoleBaseExtOnCmdLineParsedFunc)(const wxAppConsoleBaseExt* self, wxCmdLineParser& parser);
+typedef bool (*wxAppConsoleBaseExtOnCmdLineHelpFunc)(const wxAppConsoleBaseExt* self, wxCmdLineParser& parser);
+typedef bool (*wxAppConsoleBaseExtOnCmdLineErrorFunc)(const wxAppConsoleBaseExt* self, wxCmdLineParser& parser);
+typedef void (*wxAppConsoleBaseExtSetCLocaleFunc)(const wxAppConsoleBaseExt* self);
+typedef int (*wxAppConsoleBaseExtFilterEventFunc)(const wxAppConsoleBaseExt* self, wxEvent& event);
+typedef void (*wxAppConsoleBaseExtCallEventHandlerFunc)(const wxAppConsoleBaseExt* self, wxEvtHandler* handler, wxEventFunctor& functor, wxEvent& event);
+typedef void (*wxAppConsoleBaseExtHandleEventFunc)(const wxAppConsoleBaseExt* self, wxEvtHandler* handler, wxEventFunction func, wxEvent& event);
+typedef void (*wxAppConsoleBaseExtOnUnhandledExceptionFunc)(const wxAppConsoleBaseExt* self);
+typedef bool (*wxAppConsoleBaseExtOnExceptionInMainLoopFunc)(const wxAppConsoleBaseExt* self);
+typedef bool (*wxAppConsoleBaseExtStoreCurrentExceptionFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtRethrowStoredExceptionFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtProcessPendingEventsFunc)(const wxAppConsoleBaseExt* self);
+typedef bool (*wxAppConsoleBaseExtPendingFunc)(const wxAppConsoleBaseExt* self);
+typedef bool (*wxAppConsoleBaseExtDispatchFunc)(const wxAppConsoleBaseExt* self);
+typedef int (*wxAppConsoleBaseExtMainLoopFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtExitMainLoopFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtWakeUpIdleFunc)(const wxAppConsoleBaseExt* self);
+typedef bool (*wxAppConsoleBaseExtProcessIdleFunc)(const wxAppConsoleBaseExt* self);
+typedef bool (*wxAppConsoleBaseExtUsesEventLoopFunc)(const wxAppConsoleBaseExt* self);
+typedef void (*wxAppConsoleBaseExtOnAssertFailureFunc)(const wxAppConsoleBaseExt* self, wxChar const* file, int line, wxChar const* func, wxChar const* cond, wxChar const* msg);
+typedef void (*wxAppConsoleBaseExtOnAssertFunc)(const wxAppConsoleBaseExt* self, wxChar const* file, int line, wxChar const* cond, wxChar const* msg);
+typedef bool (*wxAppConsoleBaseExtIsGUIFunc)(const wxAppConsoleBaseExt* self);
+typedef wxAppTraits* (*wxAppConsoleBaseExtCreateTraitsFunc)(const wxAppConsoleBaseExt* self);
+typedef void* (*wxAppConsoleBaseExtWXReservedApp1Func)(const wxAppConsoleBaseExt* self, void* param0);
+typedef void* (*wxAppConsoleBaseExtWXReservedApp2Func)(const wxAppConsoleBaseExt* self, void* param0);
+
+class wxAppExt: public wxApp
+{
+public:
+  using wxApp::wxApp;
+  wxAppExt(): wxApp()  {  }
+  virtual ~wxAppExt()  {  }
+  wxAppExtWakeUpIdleFunc m_wxAppExtWakeUpIdle = NULL;
+  virtual void WakeUpIdle() override
+  {
+    wxApp::WakeUpIdle();
+    if (*m_wxAppExtWakeUpIdle != NULL){
+      return m_wxAppExtWakeUpIdle(this);
+    }
+  }
+  wxAppExtCallOnInitFunc m_wxAppExtCallOnInit = NULL;
+  virtual bool CallOnInit() override
+  {
+    bool res = wxApp::CallOnInit();
+    if (*m_wxAppExtCallOnInit != NULL){
+      return m_wxAppExtCallOnInit(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppExtOnInitGuiFunc m_wxAppExtOnInitGui = NULL;
+  virtual bool OnInitGui() override
+  {
+    bool res = wxApp::OnInitGui();
+    if (*m_wxAppExtOnInitGui != NULL){
+      return m_wxAppExtOnInitGui(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppExtOnRunFunc m_wxAppExtOnRun = NULL;
+  virtual int OnRun() override
+  {
+    int res = wxApp::OnRun();
+    if (*m_wxAppExtOnRun != NULL){
+      return m_wxAppExtOnRun(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppExtProcessIdleFunc m_wxAppExtProcessIdle = NULL;
+  virtual bool ProcessIdle() override
+  {
+    bool res = wxApp::ProcessIdle();
+    if (*m_wxAppExtProcessIdle != NULL){
+      return m_wxAppExtProcessIdle(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppExtInitializeFunc m_wxAppExtInitialize = NULL;
+  virtual bool Initialize(int& argc, wxChar** argv) override
+  {
+    bool res = wxApp::Initialize(argc, argv);
+    if (*m_wxAppExtInitialize != NULL){
+      return m_wxAppExtInitialize(this, argc, argv);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppExtCleanUpFunc m_wxAppExtCleanUp = NULL;
+  virtual void CleanUp() override
+  {
+    wxApp::CleanUp();
+    if (*m_wxAppExtCleanUp != NULL){
+      return m_wxAppExtCleanUp(this);
+    }
+  }
+  wxAppExtOSXCreateAppControllerFunc m_wxAppExtOSXCreateAppController = NULL;
+  virtual WX_NSObject OSXCreateAppController() override
+  {
+    WX_NSObject res = wxApp::OSXCreateAppController();
+    if (*m_wxAppExtOSXCreateAppController != NULL){
+      return m_wxAppExtOSXCreateAppController(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppExtMacHandleUnhandledEventFunc m_wxAppExtMacHandleUnhandledEvent = NULL;
+  virtual void MacHandleUnhandledEvent(WXEVENTREF ev) override
+  {
+    wxApp::MacHandleUnhandledEvent(ev);
+    if (*m_wxAppExtMacHandleUnhandledEvent != NULL){
+      return m_wxAppExtMacHandleUnhandledEvent(this, ev);
+    }
+  }
+  wxAppExtMacOpenFilesFunc m_wxAppExtMacOpenFiles = NULL;
+  virtual void MacOpenFiles(wxArrayString const& fileNames) override
+  {
+    wxApp::MacOpenFiles(fileNames);
+    if (*m_wxAppExtMacOpenFiles != NULL){
+      return m_wxAppExtMacOpenFiles(this, fileNames);
+    }
+  }
+  wxAppExtMacOpenFileFunc m_wxAppExtMacOpenFile = NULL;
+  virtual void MacOpenFile(wxString const& fileName) override
+  {
+    wxApp::MacOpenFile(fileName);
+    if (*m_wxAppExtMacOpenFile != NULL){
+      return m_wxAppExtMacOpenFile(this, fileName);
+    }
+  }
+  wxAppExtMacOpenURLFunc m_wxAppExtMacOpenURL = NULL;
+  virtual void MacOpenURL(wxString const& url) override
+  {
+    wxApp::MacOpenURL(url);
+    if (*m_wxAppExtMacOpenURL != NULL){
+      return m_wxAppExtMacOpenURL(this, url);
+    }
+  }
+  wxAppExtMacPrintFilesFunc m_wxAppExtMacPrintFiles = NULL;
+  virtual void MacPrintFiles(wxArrayString const& fileNames) override
+  {
+    wxApp::MacPrintFiles(fileNames);
+    if (*m_wxAppExtMacPrintFiles != NULL){
+      return m_wxAppExtMacPrintFiles(this, fileNames);
+    }
+  }
+  wxAppExtMacPrintFileFunc m_wxAppExtMacPrintFile = NULL;
+  virtual void MacPrintFile(wxString const& fileName) override
+  {
+    wxApp::MacPrintFile(fileName);
+    if (*m_wxAppExtMacPrintFile != NULL){
+      return m_wxAppExtMacPrintFile(this, fileName);
+    }
+  }
+  wxAppExtMacNewFileFunc m_wxAppExtMacNewFile = NULL;
+  virtual void MacNewFile() override
+  {
+    wxApp::MacNewFile();
+    if (*m_wxAppExtMacNewFile != NULL){
+      return m_wxAppExtMacNewFile(this);
+    }
+  }
+  wxAppExtMacReopenAppFunc m_wxAppExtMacReopenApp = NULL;
+  virtual void MacReopenApp() override
+  {
+    wxApp::MacReopenApp();
+    if (*m_wxAppExtMacReopenApp != NULL){
+      return m_wxAppExtMacReopenApp(this);
+    }
+  }
+  wxAppExtOSXOnWillFinishLaunchingFunc m_wxAppExtOSXOnWillFinishLaunching = NULL;
+  virtual void OSXOnWillFinishLaunching() override
+  {
+    wxApp::OSXOnWillFinishLaunching();
+    if (*m_wxAppExtOSXOnWillFinishLaunching != NULL){
+      return m_wxAppExtOSXOnWillFinishLaunching(this);
+    }
+  }
+  wxAppExtOSXOnDidFinishLaunchingFunc m_wxAppExtOSXOnDidFinishLaunching = NULL;
+  virtual void OSXOnDidFinishLaunching() override
+  {
+    wxApp::OSXOnDidFinishLaunching();
+    if (*m_wxAppExtOSXOnDidFinishLaunching != NULL){
+      return m_wxAppExtOSXOnDidFinishLaunching(this);
+    }
+  }
+  wxAppExtOSXOnShouldTerminateFunc m_wxAppExtOSXOnShouldTerminate = NULL;
+  virtual bool OSXOnShouldTerminate() override
+  {
+    bool res = wxApp::OSXOnShouldTerminate();
+    if (*m_wxAppExtOSXOnShouldTerminate != NULL){
+      return m_wxAppExtOSXOnShouldTerminate(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxAppExtOSXOnWillTerminateFunc m_wxAppExtOSXOnWillTerminate = NULL;
+  virtual void OSXOnWillTerminate() override
+  {
+    wxApp::OSXOnWillTerminate();
+    if (*m_wxAppExtOSXOnWillTerminate != NULL){
+      return m_wxAppExtOSXOnWillTerminate(this);
+    }
+  }
+  static void SetInitializerFunction(wxAppInitializerFunction fn)
+        { ms_appInitFn = fn; }
+  wxAppExt(wxAppExtWakeUpIdleFunc a_WakeUpIdle, wxAppExtCallOnInitFunc a_CallOnInit, wxAppExtOnInitGuiFunc a_OnInitGui, wxAppExtOnRunFunc a_OnRun, wxAppExtProcessIdleFunc a_ProcessIdle, wxAppExtInitializeFunc a_Initialize, wxAppExtCleanUpFunc a_CleanUp, wxAppExtOSXCreateAppControllerFunc a_OSXCreateAppController, wxAppExtMacHandleUnhandledEventFunc a_MacHandleUnhandledEvent, wxAppExtMacOpenFilesFunc a_MacOpenFiles, wxAppExtMacOpenFileFunc a_MacOpenFile, wxAppExtMacOpenURLFunc a_MacOpenURL, wxAppExtMacPrintFilesFunc a_MacPrintFiles, wxAppExtMacPrintFileFunc a_MacPrintFile, wxAppExtMacNewFileFunc a_MacNewFile, wxAppExtMacReopenAppFunc a_MacReopenApp, wxAppExtOSXOnWillFinishLaunchingFunc a_OSXOnWillFinishLaunching, wxAppExtOSXOnDidFinishLaunchingFunc a_OSXOnDidFinishLaunching, wxAppExtOSXOnShouldTerminateFunc a_OSXOnShouldTerminate, wxAppExtOSXOnWillTerminateFunc a_OSXOnWillTerminate): wxApp() {
+    m_wxAppExtWakeUpIdle = a_WakeUpIdle;
+    m_wxAppExtCallOnInit = a_CallOnInit;
+    m_wxAppExtOnInitGui = a_OnInitGui;
+    m_wxAppExtOnRun = a_OnRun;
+    m_wxAppExtProcessIdle = a_ProcessIdle;
+    m_wxAppExtInitialize = a_Initialize;
+    m_wxAppExtCleanUp = a_CleanUp;
+    m_wxAppExtOSXCreateAppController = a_OSXCreateAppController;
+    m_wxAppExtMacHandleUnhandledEvent = a_MacHandleUnhandledEvent;
+    m_wxAppExtMacOpenFiles = a_MacOpenFiles;
+    m_wxAppExtMacOpenFile = a_MacOpenFile;
+    m_wxAppExtMacOpenURL = a_MacOpenURL;
+    m_wxAppExtMacPrintFiles = a_MacPrintFiles;
+    m_wxAppExtMacPrintFile = a_MacPrintFile;
+    m_wxAppExtMacNewFile = a_MacNewFile;
+    m_wxAppExtMacReopenApp = a_MacReopenApp;
+    m_wxAppExtOSXOnWillFinishLaunching = a_OSXOnWillFinishLaunching;
+    m_wxAppExtOSXOnDidFinishLaunching = a_OSXOnDidFinishLaunching;
+    m_wxAppExtOSXOnShouldTerminate = a_OSXOnShouldTerminate;
+    m_wxAppExtOSXOnWillTerminate = a_OSXOnWillTerminate;
+  }
+  wxAppExt(wxAppConsoleBaseExtInitializeFunc a_Initialize, wxAppConsoleBaseExtCallOnInitFunc a_CallOnInit, wxAppConsoleBaseExtOnInitFunc a_OnInit, wxAppConsoleBaseExtOnRunFunc a_OnRun, wxAppConsoleBaseExtOnLaunchedFunc a_OnLaunched, wxAppConsoleBaseExtOnEventLoopEnterFunc a_OnEventLoopEnter, wxAppConsoleBaseExtOnExitFunc a_OnExit, wxAppConsoleBaseExtOnEventLoopExitFunc a_OnEventLoopExit, wxAppConsoleBaseExtCleanUpFunc a_CleanUp, wxAppConsoleBaseExtOnFatalExceptionFunc a_OnFatalException, wxAppConsoleBaseExtExitFunc a_Exit, wxAppConsoleBaseExtOnInitCmdLineFunc a_OnInitCmdLine, wxAppConsoleBaseExtOnCmdLineParsedFunc a_OnCmdLineParsed, wxAppConsoleBaseExtOnCmdLineHelpFunc a_OnCmdLineHelp, wxAppConsoleBaseExtOnCmdLineErrorFunc a_OnCmdLineError, wxAppConsoleBaseExtSetCLocaleFunc a_SetCLocale, wxAppConsoleBaseExtFilterEventFunc a_FilterEvent, wxAppConsoleBaseExtCallEventHandlerFunc a_CallEventHandler, wxAppConsoleBaseExtHandleEventFunc a_HandleEvent, wxAppConsoleBaseExtOnUnhandledExceptionFunc a_OnUnhandledException, wxAppConsoleBaseExtOnExceptionInMainLoopFunc a_OnExceptionInMainLoop, wxAppConsoleBaseExtStoreCurrentExceptionFunc a_StoreCurrentException, wxAppConsoleBaseExtRethrowStoredExceptionFunc a_RethrowStoredException, wxAppConsoleBaseExtProcessPendingEventsFunc a_ProcessPendingEvents, wxAppConsoleBaseExtPendingFunc a_Pending, wxAppConsoleBaseExtDispatchFunc a_Dispatch, wxAppConsoleBaseExtMainLoopFunc a_MainLoop, wxAppConsoleBaseExtExitMainLoopFunc a_ExitMainLoop, wxAppConsoleBaseExtWakeUpIdleFunc a_WakeUpIdle, wxAppConsoleBaseExtProcessIdleFunc a_ProcessIdle, wxAppConsoleBaseExtUsesEventLoopFunc a_UsesEventLoop, wxAppConsoleBaseExtOnAssertFailureFunc a_OnAssertFailure, wxAppConsoleBaseExtOnAssertFunc a_OnAssert, wxAppConsoleBaseExtIsGUIFunc a_IsGUI, wxAppConsoleBaseExtCreateTraitsFunc a_CreateTraits, wxAppConsoleBaseExtWXReservedApp1Func a_WXReservedApp1, wxAppConsoleBaseExtWXReservedApp2Func a_WXReservedApp2): wxApp() {
+    m_wxAppConsoleBaseExtInitialize = a_Initialize;
+    m_wxAppConsoleBaseExtCallOnInit = a_CallOnInit;
+    m_wxAppConsoleBaseExtOnInit = a_OnInit;
+    m_wxAppConsoleBaseExtOnRun = a_OnRun;
+    m_wxAppConsoleBaseExtOnLaunched = a_OnLaunched;
+    m_wxAppConsoleBaseExtOnEventLoopEnter = a_OnEventLoopEnter;
+    m_wxAppConsoleBaseExtOnExit = a_OnExit;
+    m_wxAppConsoleBaseExtOnEventLoopExit = a_OnEventLoopExit;
+    m_wxAppConsoleBaseExtCleanUp = a_CleanUp;
+    m_wxAppConsoleBaseExtOnFatalException = a_OnFatalException;
+    m_wxAppConsoleBaseExtExit = a_Exit;
+    m_wxAppConsoleBaseExtOnInitCmdLine = a_OnInitCmdLine;
+    m_wxAppConsoleBaseExtOnCmdLineParsed = a_OnCmdLineParsed;
+    m_wxAppConsoleBaseExtOnCmdLineHelp = a_OnCmdLineHelp;
+    m_wxAppConsoleBaseExtOnCmdLineError = a_OnCmdLineError;
+    m_wxAppConsoleBaseExtSetCLocale = a_SetCLocale;
+    m_wxAppConsoleBaseExtFilterEvent = a_FilterEvent;
+    m_wxAppConsoleBaseExtCallEventHandler = a_CallEventHandler;
+    m_wxAppConsoleBaseExtHandleEvent = a_HandleEvent;
+    m_wxAppConsoleBaseExtOnUnhandledException = a_OnUnhandledException;
+    m_wxAppConsoleBaseExtOnExceptionInMainLoop = a_OnExceptionInMainLoop;
+    m_wxAppConsoleBaseExtStoreCurrentException = a_StoreCurrentException;
+    m_wxAppConsoleBaseExtRethrowStoredException = a_RethrowStoredException;
+    m_wxAppConsoleBaseExtProcessPendingEvents = a_ProcessPendingEvents;
+    m_wxAppConsoleBaseExtPending = a_Pending;
+    m_wxAppConsoleBaseExtDispatch = a_Dispatch;
+    m_wxAppConsoleBaseExtMainLoop = a_MainLoop;
+    m_wxAppConsoleBaseExtExitMainLoop = a_ExitMainLoop;
+    m_wxAppConsoleBaseExtWakeUpIdle = a_WakeUpIdle;
+    m_wxAppConsoleBaseExtProcessIdle = a_ProcessIdle;
+    m_wxAppConsoleBaseExtUsesEventLoop = a_UsesEventLoop;
+    m_wxAppConsoleBaseExtOnAssertFailure = a_OnAssertFailure;
+    m_wxAppConsoleBaseExtOnAssert = a_OnAssert;
+    m_wxAppConsoleBaseExtIsGUI = a_IsGUI;
+    m_wxAppConsoleBaseExtCreateTraits = a_CreateTraits;
+    m_wxAppConsoleBaseExtWXReservedApp1 = a_WXReservedApp1;
+    m_wxAppConsoleBaseExtWXReservedApp2 = a_WXReservedApp2;
+  }
+};
+
+
+
+#endif

wxheaders/wxext/osx/button_ext.h

@@ -0,0 +1,79 @@
+#ifndef _WX_OSX_BUTTON_H_EXT_
+#define _WX_OSX_BUTTON_H_EXT_
+
+#include <wx/wx.h>
+#include <wx/vidmode.h>
+
+class wxButtonExt;
+typedef void (*wxButtonExtSetLabelFunc)(const wxButtonExt* self, wxString const& label);
+typedef wxWindow* (*wxButtonExtSetDefaultFunc)(const wxButtonExt* self);
+typedef void (*wxButtonExtCommandFunc)(const wxButtonExt* self, wxCommandEvent& event);
+typedef bool (*wxButtonExtOSXHandleClickedFunc)(const wxButtonExt* self, double timestampsec);
+typedef wxClassInfo* (*wxButtonExtGetClassInfoFunc)(const wxButtonExt* self);
+
+class wxButtonExt: public wxButton
+{
+public:
+  wxButtonExt(): wxButton()  {  }
+  wxButtonExt(wxWindow* parent, wxWindowID id, wxString const& label = wxEmptyString, wxPoint const& pos = wxDefaultPosition, wxSize const& size = wxDefaultSize, long style = 0, wxValidator const& validator = wxDefaultValidator, wxString const& name = wxASCII_STR(wxButtonNameStr)): wxButton(parent, id, label, pos, size, style, validator, name)  {  }
+  wxButtonExtSetLabelFunc m_wxButtonExtSetLabel = NULL;
+  virtual void SetLabel(wxString const& label) override
+  {
+    wxButton::SetLabel(label);
+    if (*m_wxButtonExtSetLabel != NULL){
+      return m_wxButtonExtSetLabel(this, label);
+    }
+  }
+  wxButtonExtSetDefaultFunc m_wxButtonExtSetDefault = NULL;
+  virtual wxWindow* SetDefault() override
+  {
+    wxWindow* res = wxButton::SetDefault();
+    if (*m_wxButtonExtSetDefault != NULL){
+      return m_wxButtonExtSetDefault(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxButtonExtCommandFunc m_wxButtonExtCommand = NULL;
+  virtual void Command(wxCommandEvent& event) override
+  {
+    wxButton::Command(event);
+    if (*m_wxButtonExtCommand != NULL){
+      return m_wxButtonExtCommand(this, event);
+    }
+  }
+  wxButtonExtOSXHandleClickedFunc m_wxButtonExtOSXHandleClicked = NULL;
+  virtual bool OSXHandleClicked(double timestampsec) override
+  {
+    bool res = wxButton::OSXHandleClicked(timestampsec);
+    if (*m_wxButtonExtOSXHandleClicked != NULL){
+      return m_wxButtonExtOSXHandleClicked(this, timestampsec);
+    }
+    else {
+      return res;
+    }
+  }
+  wxButtonExtGetClassInfoFunc m_wxButtonExtGetClassInfo = NULL;
+  virtual wxClassInfo* GetClassInfo() const override
+  {
+    wxClassInfo* res = wxButton::GetClassInfo();
+    if (*m_wxButtonExtGetClassInfo != NULL){
+      return m_wxButtonExtGetClassInfo(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxButtonExt(wxButtonExtSetLabelFunc a_SetLabel, wxButtonExtSetDefaultFunc a_SetDefault, wxButtonExtCommandFunc a_Command, wxButtonExtOSXHandleClickedFunc a_OSXHandleClicked, wxButtonExtGetClassInfoFunc a_GetClassInfo): wxButton() {
+    m_wxButtonExtSetLabel = a_SetLabel;
+    m_wxButtonExtSetDefault = a_SetDefault;
+    m_wxButtonExtCommand = a_Command;
+    m_wxButtonExtOSXHandleClicked = a_OSXHandleClicked;
+    m_wxButtonExtGetClassInfo = a_GetClassInfo;
+  }
+};
+
+
+
+#endif

wxheaders/wxext/osx/control_ext.h

@@ -0,0 +1,33 @@
+#ifndef _WX_OSX_CONTROL_H_EXT_
+#define _WX_OSX_CONTROL_H_EXT_
+
+#include <wx/wx.h>
+#include <wx/vidmode.h>
+
+class wxControlExt;
+typedef wxClassInfo* (*wxControlExtGetClassInfoFunc)(const wxControlExt* self);
+
+class wxControlExt: public wxControl
+{
+public:
+  wxControlExtGetClassInfoFunc m_wxControlExtGetClassInfo = NULL;
+  virtual wxClassInfo* GetClassInfo() const override
+  {
+    wxClassInfo* res = wxControl::GetClassInfo();
+    if (*m_wxControlExtGetClassInfo != NULL){
+      return m_wxControlExtGetClassInfo(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxControlExt(): wxControl()  {  }
+  wxControlExt(wxWindow* parent, wxWindowID winid, wxPoint const& pos = wxDefaultPosition, wxSize const& size = wxDefaultSize, long style = 0, wxValidator const& validator = wxDefaultValidator, wxString const& name = wxString::FromAscii(wxControlNameStr)): wxControl(parent, winid, pos, size, style, validator, name)  {  }
+  wxControlExt(wxControlExtGetClassInfoFunc a_GetClassInfo): wxControl() {
+    m_wxControlExtGetClassInfo = a_GetClassInfo;
+  }
+};
+
+
+
+#endif

wxheaders/wxext/osx/frame_ext.h

@@ -0,0 +1,192 @@
+#ifndef _WX_OSX_FRAME_H_EXT_
+#define _WX_OSX_FRAME_H_EXT_
+
+#include <wx/wx.h>
+#include <wx/vidmode.h>
+
+class wxFrameExt;
+typedef wxPoint (*wxFrameExtGetClientAreaOriginFunc)(const wxFrameExt* self);
+typedef bool (*wxFrameExtShowFunc)(const wxFrameExt* self, bool show);
+typedef bool (*wxFrameExtEnableFunc)(const wxFrameExt* self, bool enable);
+typedef wxToolBar* (*wxFrameExtCreateToolBarFunc)(const wxFrameExt* self, long style, wxWindowID id, wxString const& name);
+typedef void (*wxFrameExtSetToolBarFunc)(const wxFrameExt* self, wxToolBar* toolbar);
+typedef wxStatusBar* (*wxFrameExtOnCreateStatusBarFunc)(const wxFrameExt* self, int number, long style, wxWindowID id, wxString const& name);
+typedef void (*wxFrameExtSetStatusBarFunc)(const wxFrameExt* self, wxStatusBar* statbar);
+typedef void (*wxFrameExtPositionToolBarFunc)(const wxFrameExt* self);
+typedef void (*wxFrameExtPositionStatusBarFunc)(const wxFrameExt* self);
+typedef void (*wxFrameExtDoGetClientSizeFunc)(const wxFrameExt* self, int* width, int* height);
+typedef void (*wxFrameExtDoSetClientSizeFunc)(const wxFrameExt* self, int width, int height);
+typedef void (*wxFrameExtDetachMenuBarFunc)(const wxFrameExt* self);
+typedef void (*wxFrameExtAttachMenuBarFunc)(const wxFrameExt* self, wxMenuBar* menubar);
+typedef bool (*wxFrameExtMacIsChildOfClientAreaFunc)(const wxFrameExt* self, wxWindow const* child);
+typedef wxClassInfo* (*wxFrameExtGetClassInfoFunc)(const wxFrameExt* self);
+
+class wxFrameExt: public wxFrame
+{
+public:
+  wxFrameExt(): wxFrame()  {  }
+  wxFrameExt(wxWindow* parent, wxWindowID id, wxString const& title, wxPoint const& pos = wxDefaultPosition, wxSize const& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, wxString const& name = wxASCII_STR(wxFrameNameStr)): wxFrame(parent, id, title, pos, size, style, name)  {
+  }
+  wxFrameExtGetClientAreaOriginFunc m_wxFrameExtGetClientAreaOrigin = NULL;
+  virtual wxPoint GetClientAreaOrigin() const override
+  {
+    wxPoint res = wxFrame::GetClientAreaOrigin();
+    if (*m_wxFrameExtGetClientAreaOrigin != NULL){
+      return m_wxFrameExtGetClientAreaOrigin(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxFrameExtShowFunc m_wxFrameExtShow = NULL;
+  virtual bool Show(bool show = true) override
+  {
+    bool res = wxFrame::Show(show);
+    if (*m_wxFrameExtShow != NULL){
+      return m_wxFrameExtShow(this, show);
+    }
+    else {
+      return res;
+    }
+  }
+  wxFrameExtEnableFunc m_wxFrameExtEnable = NULL;
+  virtual bool Enable(bool enable = true) override
+  {
+    bool res = wxFrame::Enable(enable);
+    if (*m_wxFrameExtEnable != NULL){
+      return m_wxFrameExtEnable(this, enable);
+    }
+    else {
+      return res;
+    }
+  }
+  wxFrameExtCreateToolBarFunc m_wxFrameExtCreateToolBar = NULL;
+  virtual wxToolBar* CreateToolBar(long style = -1, wxWindowID id = -1, wxString const& name = wxString::FromAscii(wxToolBarNameStr)) override
+  {
+    wxToolBar* res = wxFrame::CreateToolBar(style, id, name);
+    if (*m_wxFrameExtCreateToolBar != NULL){
+      return m_wxFrameExtCreateToolBar(this, style, id, name);
+    }
+    else {
+      return res;
+    }
+  }
+  wxFrameExtSetToolBarFunc m_wxFrameExtSetToolBar = NULL;
+  virtual void SetToolBar(wxToolBar* toolbar) override
+  {
+    wxFrame::SetToolBar(toolbar);
+    if (*m_wxFrameExtSetToolBar != NULL){
+      return m_wxFrameExtSetToolBar(this, toolbar);
+    }
+  }
+  wxFrameExtOnCreateStatusBarFunc m_wxFrameExtOnCreateStatusBar = NULL;
+  virtual wxStatusBar* OnCreateStatusBar(int number = 1, long style = wxSTB_DEFAULT_STYLE, wxWindowID id = 0, wxString const& name = wxASCII_STR(wxStatusLineNameStr)) override
+  {
+    wxStatusBar* res = wxFrame::OnCreateStatusBar(number, style, id, name);
+    if (*m_wxFrameExtOnCreateStatusBar != NULL){
+      return m_wxFrameExtOnCreateStatusBar(this, number, style, id, name);
+    }
+    else {
+      return res;
+    }
+  }
+  wxFrameExtSetStatusBarFunc m_wxFrameExtSetStatusBar = NULL;
+  virtual void SetStatusBar(wxStatusBar* statbar) override
+  {
+    wxFrame::SetStatusBar(statbar);
+    if (*m_wxFrameExtSetStatusBar != NULL){
+      return m_wxFrameExtSetStatusBar(this, statbar);
+    }
+  }
+  wxFrameExtPositionToolBarFunc m_wxFrameExtPositionToolBar = NULL;
+  virtual void PositionToolBar() override
+  {
+    wxFrame::PositionToolBar();
+    if (*m_wxFrameExtPositionToolBar != NULL){
+      return m_wxFrameExtPositionToolBar(this);
+    }
+  }
+  wxFrameExtPositionStatusBarFunc m_wxFrameExtPositionStatusBar = NULL;
+  virtual void PositionStatusBar() override
+  {
+    wxFrame::PositionStatusBar();
+    if (*m_wxFrameExtPositionStatusBar != NULL){
+      return m_wxFrameExtPositionStatusBar(this);
+    }
+  }
+  wxFrameExtDoGetClientSizeFunc m_wxFrameExtDoGetClientSize = NULL;
+  virtual void DoGetClientSize(int* width, int* height) const override
+  {
+    wxFrame::DoGetClientSize(width, height);
+    if (*m_wxFrameExtDoGetClientSize != NULL){
+      return m_wxFrameExtDoGetClientSize(this, width, height);
+    }
+  }
+  wxFrameExtDoSetClientSizeFunc m_wxFrameExtDoSetClientSize = NULL;
+  virtual void DoSetClientSize(int width, int height) override
+  {
+    wxFrame::DoSetClientSize(width, height);
+    if (*m_wxFrameExtDoSetClientSize != NULL){
+      return m_wxFrameExtDoSetClientSize(this, width, height);
+    }
+  }
+  wxFrameExtDetachMenuBarFunc m_wxFrameExtDetachMenuBar = NULL;
+  virtual void DetachMenuBar() override
+  {
+    wxFrame::DetachMenuBar();
+    if (*m_wxFrameExtDetachMenuBar != NULL){
+      return m_wxFrameExtDetachMenuBar(this);
+    }
+  }
+  wxFrameExtAttachMenuBarFunc m_wxFrameExtAttachMenuBar = NULL;
+  virtual void AttachMenuBar(wxMenuBar* menubar) override
+  {
+    wxFrame::AttachMenuBar(menubar);
+    if (*m_wxFrameExtAttachMenuBar != NULL){
+      return m_wxFrameExtAttachMenuBar(this, menubar);
+    }
+  }
+  wxFrameExtMacIsChildOfClientAreaFunc m_wxFrameExtMacIsChildOfClientArea = NULL;
+  virtual bool MacIsChildOfClientArea(wxWindow const* child) const override
+  {
+    bool res = wxFrame::MacIsChildOfClientArea(child);
+    if (*m_wxFrameExtMacIsChildOfClientArea != NULL){
+      return m_wxFrameExtMacIsChildOfClientArea(this, child);
+    }
+    else {
+      return res;
+    }
+  }
+  wxFrameExtGetClassInfoFunc m_wxFrameExtGetClassInfo = NULL;
+  virtual wxClassInfo* GetClassInfo() const override
+  {
+    wxClassInfo* res = wxFrame::GetClassInfo();
+    if (*m_wxFrameExtGetClassInfo != NULL){
+      return m_wxFrameExtGetClassInfo(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxFrameExt(wxFrameExtGetClientAreaOriginFunc a_GetClientAreaOrigin, wxFrameExtShowFunc a_Show, wxFrameExtEnableFunc a_Enable, wxFrameExtCreateToolBarFunc a_CreateToolBar, wxFrameExtSetToolBarFunc a_SetToolBar, wxFrameExtOnCreateStatusBarFunc a_OnCreateStatusBar, wxFrameExtSetStatusBarFunc a_SetStatusBar, wxFrameExtPositionToolBarFunc a_PositionToolBar, wxFrameExtPositionStatusBarFunc a_PositionStatusBar, wxFrameExtDoGetClientSizeFunc a_DoGetClientSize, wxFrameExtDoSetClientSizeFunc a_DoSetClientSize, wxFrameExtDetachMenuBarFunc a_DetachMenuBar, wxFrameExtAttachMenuBarFunc a_AttachMenuBar, wxFrameExtMacIsChildOfClientAreaFunc a_MacIsChildOfClientArea, wxFrameExtGetClassInfoFunc a_GetClassInfo): wxFrame() {
+    m_wxFrameExtGetClientAreaOrigin = a_GetClientAreaOrigin;
+    m_wxFrameExtShow = a_Show;
+    m_wxFrameExtEnable = a_Enable;
+    m_wxFrameExtCreateToolBar = a_CreateToolBar;
+    m_wxFrameExtSetToolBar = a_SetToolBar;
+    m_wxFrameExtOnCreateStatusBar = a_OnCreateStatusBar;
+    m_wxFrameExtSetStatusBar = a_SetStatusBar;
+    m_wxFrameExtPositionToolBar = a_PositionToolBar;
+    m_wxFrameExtPositionStatusBar = a_PositionStatusBar;
+    m_wxFrameExtDoGetClientSize = a_DoGetClientSize;
+    m_wxFrameExtDoSetClientSize = a_DoSetClientSize;
+    m_wxFrameExtDetachMenuBar = a_DetachMenuBar;
+    m_wxFrameExtAttachMenuBar = a_AttachMenuBar;
+    m_wxFrameExtMacIsChildOfClientArea = a_MacIsChildOfClientArea;
+    m_wxFrameExtGetClassInfo = a_GetClassInfo;
+  }
+};
+
+
+
+#endif

wxheaders/wxext/osx/toplevel_ext.h

@@ -0,0 +1,345 @@
+#ifndef _WX_OSX_TOPLEVEL_H_EXT_
+#define _WX_OSX_TOPLEVEL_H_EXT_
+
+#include <wx/wx.h>
+#include <wx/vidmode.h>
+
+class wxTopLevelWindowMacExt;
+typedef bool (*wxTopLevelWindowMacExtDestroyFunc)(const wxTopLevelWindowMacExt* self);
+typedef wxPoint (*wxTopLevelWindowMacExtGetClientAreaOriginFunc)(const wxTopLevelWindowMacExt* self);
+typedef void (*wxTopLevelWindowMacExtRequestUserAttentionFunc)(const wxTopLevelWindowMacExt* self, int flags);
+typedef void (*wxTopLevelWindowMacExtMaximizeFunc)(const wxTopLevelWindowMacExt* self, bool maximize);
+typedef bool (*wxTopLevelWindowMacExtIsMaximizedFunc)(const wxTopLevelWindowMacExt* self);
+typedef void (*wxTopLevelWindowMacExtIconizeFunc)(const wxTopLevelWindowMacExt* self, bool iconize);
+typedef bool (*wxTopLevelWindowMacExtIsIconizedFunc)(const wxTopLevelWindowMacExt* self);
+typedef void (*wxTopLevelWindowMacExtRestoreFunc)(const wxTopLevelWindowMacExt* self);
+typedef bool (*wxTopLevelWindowMacExtIsActiveFunc)(const wxTopLevelWindowMacExt* self);
+typedef void (*wxTopLevelWindowMacExtShowWithoutActivatingFunc)(const wxTopLevelWindowMacExt* self);
+typedef bool (*wxTopLevelWindowMacExtEnableFullScreenViewFunc)(const wxTopLevelWindowMacExt* self, bool enable, long style);
+typedef bool (*wxTopLevelWindowMacExtShowFullScreenFunc)(const wxTopLevelWindowMacExt* self, bool show, long style);
+typedef bool (*wxTopLevelWindowMacExtIsFullScreenFunc)(const wxTopLevelWindowMacExt* self);
+typedef wxContentProtection (*wxTopLevelWindowMacExtGetContentProtectionFunc)(const wxTopLevelWindowMacExt* self);
+typedef bool (*wxTopLevelWindowMacExtSetContentProtectionFunc)(const wxTopLevelWindowMacExt* self, wxContentProtection contentProtection);
+typedef void (*wxTopLevelWindowMacExtSetTitleFunc)(const wxTopLevelWindowMacExt* self, wxString const& title);
+typedef wxString (*wxTopLevelWindowMacExtGetTitleFunc)(const wxTopLevelWindowMacExt* self);
+typedef bool (*wxTopLevelWindowMacExtEnableCloseButtonFunc)(const wxTopLevelWindowMacExt* self, bool enable);
+typedef bool (*wxTopLevelWindowMacExtEnableMaximizeButtonFunc)(const wxTopLevelWindowMacExt* self, bool enable);
+typedef bool (*wxTopLevelWindowMacExtEnableMinimizeButtonFunc)(const wxTopLevelWindowMacExt* self, bool enable);
+typedef void (*wxTopLevelWindowMacExtSetLabelFunc)(const wxTopLevelWindowMacExt* self, wxString const& label);
+typedef wxString (*wxTopLevelWindowMacExtGetLabelFunc)(const wxTopLevelWindowMacExt* self);
+typedef void (*wxTopLevelWindowMacExtOSXSetModifiedFunc)(const wxTopLevelWindowMacExt* self, bool modified);
+typedef bool (*wxTopLevelWindowMacExtOSXIsModifiedFunc)(const wxTopLevelWindowMacExt* self);
+typedef void (*wxTopLevelWindowMacExtSetRepresentedFilenameFunc)(const wxTopLevelWindowMacExt* self, wxString const& filename);
+typedef wxEventTable const* (*wxTopLevelWindowMacExtGetEventTableFunc)(const wxTopLevelWindowMacExt* self);
+typedef wxEventHashTable& (*wxTopLevelWindowMacExtGetEventHashTableFunc)(const wxTopLevelWindowMacExt* self);
+
+class wxTopLevelWindowMacExt: public wxTopLevelWindowMac
+{
+public:
+  wxTopLevelWindowMacExt(): wxTopLevelWindowMac()  {  }
+  wxTopLevelWindowMacExt(wxWindow* parent, wxWindowID id, wxString const& title, wxPoint const& pos = wxDefaultPosition, wxSize const& size = wxDefaultSize, long style = (0x0800 | 0x0040 | 0x0400 | 0x0200 | 0x1000 | 0x20000000 | 0x00400000), wxString const& name = wxString::FromAscii(wxFrameNameStr)): wxTopLevelWindowMac(parent, id, title, pos, size, style, name)  {  }
+  virtual ~wxTopLevelWindowMacExt() override  {  }
+  wxTopLevelWindowMacExtDestroyFunc m_wxTopLevelWindowMacExtDestroy = NULL;
+  virtual bool Destroy() override
+  {
+    bool res = wxTopLevelWindowMac::Destroy();
+    if (*m_wxTopLevelWindowMacExtDestroy != NULL){
+      return m_wxTopLevelWindowMacExtDestroy(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowMacExtGetClientAreaOriginFunc m_wxTopLevelWindowMacExtGetClientAreaOrigin = NULL;
+  virtual wxPoint GetClientAreaOrigin() const override
+  {
+    wxPoint res = wxTopLevelWindowMac::GetClientAreaOrigin();
+    if (*m_wxTopLevelWindowMacExtGetClientAreaOrigin != NULL){
+      return m_wxTopLevelWindowMacExtGetClientAreaOrigin(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowMacExtRequestUserAttentionFunc m_wxTopLevelWindowMacExtRequestUserAttention = NULL;
+  virtual void RequestUserAttention(int flags = wxUSER_ATTENTION_INFO) override
+  {
+    wxTopLevelWindowMac::RequestUserAttention(flags);
+    if (*m_wxTopLevelWindowMacExtRequestUserAttention != NULL){
+      return m_wxTopLevelWindowMacExtRequestUserAttention(this, flags);
+    }
+  }
+  wxTopLevelWindowMacExtMaximizeFunc m_wxTopLevelWindowMacExtMaximize = NULL;
+  virtual void Maximize(bool maximize = true) override
+  {
+    wxTopLevelWindowMac::Maximize(maximize);
+    if (*m_wxTopLevelWindowMacExtMaximize != NULL){
+      return m_wxTopLevelWindowMacExtMaximize(this, maximize);
+    }
+  }
+  wxTopLevelWindowMacExtIsMaximizedFunc m_wxTopLevelWindowMacExtIsMaximized = NULL;
+  virtual bool IsMaximized() const override
+  {
+    bool res = wxTopLevelWindowMac::IsMaximized();
+    if (*m_wxTopLevelWindowMacExtIsMaximized != NULL){
+      return m_wxTopLevelWindowMacExtIsMaximized(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowMacExtIconizeFunc m_wxTopLevelWindowMacExtIconize = NULL;
+  virtual void Iconize(bool iconize = true) override
+  {
+    wxTopLevelWindowMac::Iconize(iconize);
+    if (*m_wxTopLevelWindowMacExtIconize != NULL){
+      return m_wxTopLevelWindowMacExtIconize(this, iconize);
+    }
+  }
+  wxTopLevelWindowMacExtIsIconizedFunc m_wxTopLevelWindowMacExtIsIconized = NULL;
+  virtual bool IsIconized() const override
+  {
+    bool res = wxTopLevelWindowMac::IsIconized();
+    if (*m_wxTopLevelWindowMacExtIsIconized != NULL){
+      return m_wxTopLevelWindowMacExtIsIconized(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowMacExtRestoreFunc m_wxTopLevelWindowMacExtRestore = NULL;
+  virtual void Restore() override
+  {
+    wxTopLevelWindowMac::Restore();
+    if (*m_wxTopLevelWindowMacExtRestore != NULL){
+      return m_wxTopLevelWindowMacExtRestore(this);
+    }
+  }
+  wxTopLevelWindowMacExtIsActiveFunc m_wxTopLevelWindowMacExtIsActive = NULL;
+  virtual bool IsActive() override
+  {
+    bool res = wxTopLevelWindowMac::IsActive();
+    if (*m_wxTopLevelWindowMacExtIsActive != NULL){
+      return m_wxTopLevelWindowMacExtIsActive(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowMacExtShowWithoutActivatingFunc m_wxTopLevelWindowMacExtShowWithoutActivating = NULL;
+  virtual void ShowWithoutActivating() override
+  {
+    wxTopLevelWindowMac::ShowWithoutActivating();
+    if (*m_wxTopLevelWindowMacExtShowWithoutActivating != NULL){
+      return m_wxTopLevelWindowMacExtShowWithoutActivating(this);
+    }
+  }
+  wxTopLevelWindowMacExtEnableFullScreenViewFunc m_wxTopLevelWindowMacExtEnableFullScreenView = NULL;
+  virtual bool EnableFullScreenView(bool enable = true, long style = wxFULLSCREEN_ALL) override
+  {
+    bool res = wxTopLevelWindowMac::EnableFullScreenView(enable, style);
+    if (*m_wxTopLevelWindowMacExtEnableFullScreenView != NULL){
+      return m_wxTopLevelWindowMacExtEnableFullScreenView(this, enable, style);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowMacExtShowFullScreenFunc m_wxTopLevelWindowMacExtShowFullScreen = NULL;
+  virtual bool ShowFullScreen(bool show, long style = wxFULLSCREEN_ALL) override
+  {
+    bool res = wxTopLevelWindowMac::ShowFullScreen(show, style);
+    if (*m_wxTopLevelWindowMacExtShowFullScreen != NULL){
+      return m_wxTopLevelWindowMacExtShowFullScreen(this, show, style);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowMacExtIsFullScreenFunc m_wxTopLevelWindowMacExtIsFullScreen = NULL;
+  virtual bool IsFullScreen() const override
+  {
+    bool res = wxTopLevelWindowMac::IsFullScreen();
+    if (*m_wxTopLevelWindowMacExtIsFullScreen != NULL){
+      return m_wxTopLevelWindowMacExtIsFullScreen(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowMacExtGetContentProtectionFunc m_wxTopLevelWindowMacExtGetContentProtection = NULL;
+  virtual wxContentProtection GetContentProtection() const override
+  {
+    wxContentProtection res = wxTopLevelWindowMac::GetContentProtection();
+    if (*m_wxTopLevelWindowMacExtGetContentProtection != NULL){
+      return m_wxTopLevelWindowMacExtGetContentProtection(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowMacExtSetContentProtectionFunc m_wxTopLevelWindowMacExtSetContentProtection = NULL;
+  virtual bool SetContentProtection(wxContentProtection contentProtection) override
+  {
+    bool res = wxTopLevelWindowMac::SetContentProtection(contentProtection);
+    if (*m_wxTopLevelWindowMacExtSetContentProtection != NULL){
+      return m_wxTopLevelWindowMacExtSetContentProtection(this, contentProtection);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowMacExtSetTitleFunc m_wxTopLevelWindowMacExtSetTitle = NULL;
+  virtual void SetTitle(wxString const& title) override
+  {
+    wxTopLevelWindowMac::SetTitle(title);
+    if (*m_wxTopLevelWindowMacExtSetTitle != NULL){
+      return m_wxTopLevelWindowMacExtSetTitle(this, title);
+    }
+  }
+  wxTopLevelWindowMacExtGetTitleFunc m_wxTopLevelWindowMacExtGetTitle = NULL;
+  virtual wxString GetTitle() const override
+  {
+    wxString res = wxTopLevelWindowMac::GetTitle();
+    if (*m_wxTopLevelWindowMacExtGetTitle != NULL){
+      return m_wxTopLevelWindowMacExtGetTitle(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowMacExtEnableCloseButtonFunc m_wxTopLevelWindowMacExtEnableCloseButton = NULL;
+  virtual bool EnableCloseButton(bool enable = true) override
+  {
+    bool res = wxTopLevelWindowMac::EnableCloseButton(enable);
+    if (*m_wxTopLevelWindowMacExtEnableCloseButton != NULL){
+      return m_wxTopLevelWindowMacExtEnableCloseButton(this, enable);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowMacExtEnableMaximizeButtonFunc m_wxTopLevelWindowMacExtEnableMaximizeButton = NULL;
+  virtual bool EnableMaximizeButton(bool enable = true) override
+  {
+    bool res = wxTopLevelWindowMac::EnableMaximizeButton(enable);
+    if (*m_wxTopLevelWindowMacExtEnableMaximizeButton != NULL){
+      return m_wxTopLevelWindowMacExtEnableMaximizeButton(this, enable);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowMacExtEnableMinimizeButtonFunc m_wxTopLevelWindowMacExtEnableMinimizeButton = NULL;
+  virtual bool EnableMinimizeButton(bool enable = true) override
+  {
+    bool res = wxTopLevelWindowMac::EnableMinimizeButton(enable);
+    if (*m_wxTopLevelWindowMacExtEnableMinimizeButton != NULL){
+      return m_wxTopLevelWindowMacExtEnableMinimizeButton(this, enable);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowMacExtSetLabelFunc m_wxTopLevelWindowMacExtSetLabel = NULL;
+  virtual void SetLabel(wxString const& label) override
+  {
+    wxTopLevelWindowMac::SetLabel(label);
+    if (*m_wxTopLevelWindowMacExtSetLabel != NULL){
+      return m_wxTopLevelWindowMacExtSetLabel(this, label);
+    }
+  }
+  wxTopLevelWindowMacExtGetLabelFunc m_wxTopLevelWindowMacExtGetLabel = NULL;
+  virtual wxString GetLabel() const override
+  {
+    wxString res = wxTopLevelWindowMac::GetLabel();
+    if (*m_wxTopLevelWindowMacExtGetLabel != NULL){
+      return m_wxTopLevelWindowMacExtGetLabel(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowMacExtOSXSetModifiedFunc m_wxTopLevelWindowMacExtOSXSetModified = NULL;
+  virtual void OSXSetModified(bool modified) override
+  {
+    wxTopLevelWindowMac::OSXSetModified(modified);
+    if (*m_wxTopLevelWindowMacExtOSXSetModified != NULL){
+      return m_wxTopLevelWindowMacExtOSXSetModified(this, modified);
+    }
+  }
+  wxTopLevelWindowMacExtOSXIsModifiedFunc m_wxTopLevelWindowMacExtOSXIsModified = NULL;
+  virtual bool OSXIsModified() const override
+  {
+    bool res = wxTopLevelWindowMac::OSXIsModified();
+    if (*m_wxTopLevelWindowMacExtOSXIsModified != NULL){
+      return m_wxTopLevelWindowMacExtOSXIsModified(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowMacExtSetRepresentedFilenameFunc m_wxTopLevelWindowMacExtSetRepresentedFilename = NULL;
+  virtual void SetRepresentedFilename(wxString const& filename) override
+  {
+    wxTopLevelWindowMac::SetRepresentedFilename(filename);
+    if (*m_wxTopLevelWindowMacExtSetRepresentedFilename != NULL){
+      return m_wxTopLevelWindowMacExtSetRepresentedFilename(this, filename);
+    }
+  }
+  wxTopLevelWindowMacExtGetEventTableFunc m_wxTopLevelWindowMacExtGetEventTable = NULL;
+  virtual wxEventTable const* GetEventTable() const override
+  {
+    wxEventTable const* res = wxTopLevelWindowMac::GetEventTable();
+    if (*m_wxTopLevelWindowMacExtGetEventTable != NULL){
+      return m_wxTopLevelWindowMacExtGetEventTable(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowMacExtGetEventHashTableFunc m_wxTopLevelWindowMacExtGetEventHashTable = NULL;
+  virtual wxEventHashTable& GetEventHashTable() const override
+  {
+    wxEventHashTable& res = wxTopLevelWindowMac::GetEventHashTable();
+    if (*m_wxTopLevelWindowMacExtGetEventHashTable != NULL){
+      return m_wxTopLevelWindowMacExtGetEventHashTable(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowMacExt(wxTopLevelWindowMacExtDestroyFunc a_Destroy, wxTopLevelWindowMacExtGetClientAreaOriginFunc a_GetClientAreaOrigin, wxTopLevelWindowMacExtRequestUserAttentionFunc a_RequestUserAttention, wxTopLevelWindowMacExtMaximizeFunc a_Maximize, wxTopLevelWindowMacExtIsMaximizedFunc a_IsMaximized, wxTopLevelWindowMacExtIconizeFunc a_Iconize, wxTopLevelWindowMacExtIsIconizedFunc a_IsIconized, wxTopLevelWindowMacExtRestoreFunc a_Restore, wxTopLevelWindowMacExtIsActiveFunc a_IsActive, wxTopLevelWindowMacExtShowWithoutActivatingFunc a_ShowWithoutActivating, wxTopLevelWindowMacExtEnableFullScreenViewFunc a_EnableFullScreenView, wxTopLevelWindowMacExtShowFullScreenFunc a_ShowFullScreen, wxTopLevelWindowMacExtIsFullScreenFunc a_IsFullScreen, wxTopLevelWindowMacExtGetContentProtectionFunc a_GetContentProtection, wxTopLevelWindowMacExtSetContentProtectionFunc a_SetContentProtection, wxTopLevelWindowMacExtSetTitleFunc a_SetTitle, wxTopLevelWindowMacExtGetTitleFunc a_GetTitle, wxTopLevelWindowMacExtEnableCloseButtonFunc a_EnableCloseButton, wxTopLevelWindowMacExtEnableMaximizeButtonFunc a_EnableMaximizeButton, wxTopLevelWindowMacExtEnableMinimizeButtonFunc a_EnableMinimizeButton, wxTopLevelWindowMacExtSetLabelFunc a_SetLabel, wxTopLevelWindowMacExtGetLabelFunc a_GetLabel, wxTopLevelWindowMacExtOSXSetModifiedFunc a_OSXSetModified, wxTopLevelWindowMacExtOSXIsModifiedFunc a_OSXIsModified, wxTopLevelWindowMacExtSetRepresentedFilenameFunc a_SetRepresentedFilename, wxTopLevelWindowMacExtGetEventTableFunc a_GetEventTable, wxTopLevelWindowMacExtGetEventHashTableFunc a_GetEventHashTable): wxTopLevelWindowMac() {
+    m_wxTopLevelWindowMacExtDestroy = a_Destroy;
+    m_wxTopLevelWindowMacExtGetClientAreaOrigin = a_GetClientAreaOrigin;
+    m_wxTopLevelWindowMacExtRequestUserAttention = a_RequestUserAttention;
+    m_wxTopLevelWindowMacExtMaximize = a_Maximize;
+    m_wxTopLevelWindowMacExtIsMaximized = a_IsMaximized;
+    m_wxTopLevelWindowMacExtIconize = a_Iconize;
+    m_wxTopLevelWindowMacExtIsIconized = a_IsIconized;
+    m_wxTopLevelWindowMacExtRestore = a_Restore;
+    m_wxTopLevelWindowMacExtIsActive = a_IsActive;
+    m_wxTopLevelWindowMacExtShowWithoutActivating = a_ShowWithoutActivating;
+    m_wxTopLevelWindowMacExtEnableFullScreenView = a_EnableFullScreenView;
+    m_wxTopLevelWindowMacExtShowFullScreen = a_ShowFullScreen;
+    m_wxTopLevelWindowMacExtIsFullScreen = a_IsFullScreen;
+    m_wxTopLevelWindowMacExtGetContentProtection = a_GetContentProtection;
+    m_wxTopLevelWindowMacExtSetContentProtection = a_SetContentProtection;
+    m_wxTopLevelWindowMacExtSetTitle = a_SetTitle;
+    m_wxTopLevelWindowMacExtGetTitle = a_GetTitle;
+    m_wxTopLevelWindowMacExtEnableCloseButton = a_EnableCloseButton;
+    m_wxTopLevelWindowMacExtEnableMaximizeButton = a_EnableMaximizeButton;
+    m_wxTopLevelWindowMacExtEnableMinimizeButton = a_EnableMinimizeButton;
+    m_wxTopLevelWindowMacExtSetLabel = a_SetLabel;
+    m_wxTopLevelWindowMacExtGetLabel = a_GetLabel;
+    m_wxTopLevelWindowMacExtOSXSetModified = a_OSXSetModified;
+    m_wxTopLevelWindowMacExtOSXIsModified = a_OSXIsModified;
+    m_wxTopLevelWindowMacExtSetRepresentedFilename = a_SetRepresentedFilename;
+    m_wxTopLevelWindowMacExtGetEventTable = a_GetEventTable;
+    m_wxTopLevelWindowMacExtGetEventHashTable = a_GetEventHashTable;
+  }
+};
+
+
+
+#endif

wxheaders/wxext/panel_ext.h

@@ -0,0 +1,29 @@
+#ifndef _WX_PANEL_H_EXT_
+#define _WX_PANEL_H_EXT_
+
+#include <wx/wx.h>
+#include <wx/vidmode.h>
+
+class wxPanelBaseExt;
+typedef void (*wxPanelBaseExtInitDialogFunc)(const wxPanelBaseExt* self);
+
+class wxPanelBaseExt: public wxPanelBase
+{
+public:
+  wxPanelBaseExt(): wxPanelBase()  {  }
+  wxPanelBaseExtInitDialogFunc m_wxPanelBaseExtInitDialog = NULL;
+  virtual void InitDialog() override
+  {
+    wxPanelBase::InitDialog();
+    if (*m_wxPanelBaseExtInitDialog != NULL){
+      return m_wxPanelBaseExtInitDialog(this);
+    }
+  }
+  wxPanelBaseExt(wxPanelBaseExtInitDialogFunc a_InitDialog): wxPanelBase() {
+    m_wxPanelBaseExtInitDialog = a_InitDialog;
+  }
+};
+
+
+
+#endif

wxheaders/wxext/rtti_ext.h

@@ -0,0 +1,17 @@
+#ifndef _WX_RTTI_H_EXT_
+#define _WX_RTTI_H_EXT_
+
+#include <wx/wx.h>
+#include <wx/vidmode.h>
+
+class wxClassInfoExt;
+
+class wxClassInfoExt: public wxClassInfo
+{
+public:
+  wxClassInfoExt(wxChar const* className, wxClassInfo const* baseInfo1, wxClassInfo const* baseInfo2, int size, wxObjectConstructorFn ctor): wxClassInfo(className, baseInfo1, baseInfo2, size, ctor)  {  }
+};
+
+
+
+#endif

wxheaders/wxext/toplevel_ext.h

@@ -0,0 +1,359 @@
+#ifndef _WX_TOPLEVEL_H_EXT_
+#define _WX_TOPLEVEL_H_EXT_
+
+#include <wx/toplevel.h>
+
+class wxTopLevelWindowBaseExt;
+typedef void (*wxTopLevelWindowBaseExtMaximizeFunc)(const wxTopLevelWindowBaseExt* self, bool maximize);
+typedef void (*wxTopLevelWindowBaseExtRestoreFunc)(const wxTopLevelWindowBaseExt* self);
+typedef void (*wxTopLevelWindowBaseExtIconizeFunc)(const wxTopLevelWindowBaseExt* self, bool iconize);
+typedef bool (*wxTopLevelWindowBaseExtIsMaximizedFunc)(const wxTopLevelWindowBaseExt* self);
+typedef bool (*wxTopLevelWindowBaseExtIsAlwaysMaximizedFunc)(const wxTopLevelWindowBaseExt* self);
+typedef bool (*wxTopLevelWindowBaseExtIsIconizedFunc)(const wxTopLevelWindowBaseExt* self);
+typedef void (*wxTopLevelWindowBaseExtSetIconsFunc)(const wxTopLevelWindowBaseExt* self, wxIconBundle const& icons);
+typedef bool (*wxTopLevelWindowBaseExtEnableFullScreenViewFunc)(const wxTopLevelWindowBaseExt* self, bool param0, long param1);
+typedef bool (*wxTopLevelWindowBaseExtShowFullScreenFunc)(const wxTopLevelWindowBaseExt* self, bool show, long style);
+typedef void (*wxTopLevelWindowBaseExtShowWithoutActivatingFunc)(const wxTopLevelWindowBaseExt* self);
+typedef bool (*wxTopLevelWindowBaseExtIsFullScreenFunc)(const wxTopLevelWindowBaseExt* self);
+typedef wxContentProtection (*wxTopLevelWindowBaseExtGetContentProtectionFunc)(const wxTopLevelWindowBaseExt* self);
+typedef bool (*wxTopLevelWindowBaseExtSetContentProtectionFunc)(const wxTopLevelWindowBaseExt* self, wxContentProtection param0);
+typedef void (*wxTopLevelWindowBaseExtSetTitleFunc)(const wxTopLevelWindowBaseExt* self, wxString const& title);
+typedef wxString (*wxTopLevelWindowBaseExtGetTitleFunc)(const wxTopLevelWindowBaseExt* self);
+typedef bool (*wxTopLevelWindowBaseExtEnableCloseButtonFunc)(const wxTopLevelWindowBaseExt* self, bool param0);
+typedef bool (*wxTopLevelWindowBaseExtEnableMaximizeButtonFunc)(const wxTopLevelWindowBaseExt* self, bool param0);
+typedef bool (*wxTopLevelWindowBaseExtEnableMinimizeButtonFunc)(const wxTopLevelWindowBaseExt* self, bool param0);
+typedef void (*wxTopLevelWindowBaseExtRequestUserAttentionFunc)(const wxTopLevelWindowBaseExt* self, int flags);
+typedef bool (*wxTopLevelWindowBaseExtIsActiveFunc)(const wxTopLevelWindowBaseExt* self);
+typedef bool (*wxTopLevelWindowBaseExtShouldPreventAppExitFunc)(const wxTopLevelWindowBaseExt* self);
+class GeometrySerializerExt;
+typedef bool (*GeometrySerializerExtSaveFieldFunc)(const GeometrySerializerExt* self, wxString const& name, int value);
+typedef bool (*GeometrySerializerExtRestoreFieldFunc)(const GeometrySerializerExt* self, wxString const& name, int* value);
+class wxTopLevelWindowExt;
+typedef wxClassInfo* (*wxTopLevelWindowExtGetClassInfoFunc)(const wxTopLevelWindowExt* self);
+
+class wxTopLevelWindowBaseExt: public wxTopLevelWindowBase
+{
+public:
+  wxTopLevelWindowBaseExt(): wxTopLevelWindowBase()  {  }
+  virtual ~wxTopLevelWindowBaseExt() override  {  }
+  wxTopLevelWindowBaseExtMaximizeFunc m_wxTopLevelWindowBaseExtMaximize = NULL;
+  virtual void Maximize(bool maximize = true) override
+  {
+    wxTopLevelWindowBase::Maximize(maximize);
+    if (*m_wxTopLevelWindowBaseExtMaximize != NULL){
+      return m_wxTopLevelWindowBaseExtMaximize(this, maximize);
+    }
+  }
+  wxTopLevelWindowBaseExtRestoreFunc m_wxTopLevelWindowBaseExtRestore = NULL;
+  virtual void Restore() override
+  {
+    wxTopLevelWindowBase::Restore();
+    if (*m_wxTopLevelWindowBaseExtRestore != NULL){
+      return m_wxTopLevelWindowBaseExtRestore(this);
+    }
+  }
+  wxTopLevelWindowBaseExtIconizeFunc m_wxTopLevelWindowBaseExtIconize = NULL;
+  virtual void Iconize(bool iconize = true) override
+  {
+    wxTopLevelWindowBase::Iconize(iconize);
+    if (*m_wxTopLevelWindowBaseExtIconize != NULL){
+      return m_wxTopLevelWindowBaseExtIconize(this, iconize);
+    }
+  }
+  wxTopLevelWindowBaseExtIsMaximizedFunc m_wxTopLevelWindowBaseExtIsMaximized = NULL;
+  virtual bool IsMaximized() const override
+  {
+    bool res = wxTopLevelWindowBase::IsMaximized();
+    if (*m_wxTopLevelWindowBaseExtIsMaximized != NULL){
+      return m_wxTopLevelWindowBaseExtIsMaximized(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowBaseExtIsAlwaysMaximizedFunc m_wxTopLevelWindowBaseExtIsAlwaysMaximized = NULL;
+  virtual bool IsAlwaysMaximized() const override
+  {
+    bool res = wxTopLevelWindowBase::IsAlwaysMaximized();
+    if (*m_wxTopLevelWindowBaseExtIsAlwaysMaximized != NULL){
+      return m_wxTopLevelWindowBaseExtIsAlwaysMaximized(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowBaseExtIsIconizedFunc m_wxTopLevelWindowBaseExtIsIconized = NULL;
+  virtual bool IsIconized() const override
+  {
+    bool res = wxTopLevelWindowBase::IsIconized();
+    if (*m_wxTopLevelWindowBaseExtIsIconized != NULL){
+      return m_wxTopLevelWindowBaseExtIsIconized(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowBaseExtSetIconsFunc m_wxTopLevelWindowBaseExtSetIcons = NULL;
+  virtual void SetIcons(wxIconBundle const& icons) override
+  {
+    wxTopLevelWindowBase::SetIcons(icons);
+    if (*m_wxTopLevelWindowBaseExtSetIcons != NULL){
+      return m_wxTopLevelWindowBaseExtSetIcons(this, icons);
+    }
+  }
+  wxTopLevelWindowBaseExtEnableFullScreenViewFunc m_wxTopLevelWindowBaseExtEnableFullScreenView = NULL;
+  virtual bool EnableFullScreenView(bool param0 = true, long param1 = wxFULLSCREEN_ALL) override
+  {
+    bool res = wxTopLevelWindowBase::EnableFullScreenView(param0, param1);
+    if (*m_wxTopLevelWindowBaseExtEnableFullScreenView != NULL){
+      return m_wxTopLevelWindowBaseExtEnableFullScreenView(this, param0, param1);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowBaseExtShowFullScreenFunc m_wxTopLevelWindowBaseExtShowFullScreen = NULL;
+  virtual bool ShowFullScreen(bool show, long style = wxFULLSCREEN_ALL) override
+  {
+    bool res = wxTopLevelWindowBase::ShowFullScreen(show, style);
+    if (*m_wxTopLevelWindowBaseExtShowFullScreen != NULL){
+      return m_wxTopLevelWindowBaseExtShowFullScreen(this, show, style);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowBaseExtShowWithoutActivatingFunc m_wxTopLevelWindowBaseExtShowWithoutActivating = NULL;
+  virtual void ShowWithoutActivating() override
+  {
+    wxTopLevelWindowBase::ShowWithoutActivating();
+    if (*m_wxTopLevelWindowBaseExtShowWithoutActivating != NULL){
+      return m_wxTopLevelWindowBaseExtShowWithoutActivating(this);
+    }
+  }
+  wxTopLevelWindowBaseExtIsFullScreenFunc m_wxTopLevelWindowBaseExtIsFullScreen = NULL;
+  virtual bool IsFullScreen() const override
+  {
+    bool res = wxTopLevelWindowBase::IsFullScreen();
+    if (*m_wxTopLevelWindowBaseExtIsFullScreen != NULL){
+      return m_wxTopLevelWindowBaseExtIsFullScreen(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowBaseExtGetContentProtectionFunc m_wxTopLevelWindowBaseExtGetContentProtection = NULL;
+  virtual wxContentProtection GetContentProtection() const override
+  {
+    wxContentProtection res = wxTopLevelWindowBase::GetContentProtection();
+    if (*m_wxTopLevelWindowBaseExtGetContentProtection != NULL){
+      return m_wxTopLevelWindowBaseExtGetContentProtection(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowBaseExtSetContentProtectionFunc m_wxTopLevelWindowBaseExtSetContentProtection = NULL;
+  virtual bool SetContentProtection(wxContentProtection param0) override
+  {
+    bool res = wxTopLevelWindowBase::SetContentProtection(param0);
+    if (*m_wxTopLevelWindowBaseExtSetContentProtection != NULL){
+      return m_wxTopLevelWindowBaseExtSetContentProtection(this, param0);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowBaseExtSetTitleFunc m_wxTopLevelWindowBaseExtSetTitle = NULL;
+  virtual void SetTitle(wxString const& title) override
+  {
+    wxTopLevelWindowBase::SetTitle(title);
+    if (*m_wxTopLevelWindowBaseExtSetTitle != NULL){
+      return m_wxTopLevelWindowBaseExtSetTitle(this, title);
+    }
+  }
+  wxTopLevelWindowBaseExtGetTitleFunc m_wxTopLevelWindowBaseExtGetTitle = NULL;
+  virtual wxString GetTitle() const override
+  {
+    wxString res = wxTopLevelWindowBase::GetTitle();
+    if (*m_wxTopLevelWindowBaseExtGetTitle != NULL){
+      return m_wxTopLevelWindowBaseExtGetTitle(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowBaseExtEnableCloseButtonFunc m_wxTopLevelWindowBaseExtEnableCloseButton = NULL;
+  virtual bool EnableCloseButton(bool param0 = true) override
+  {
+    bool res = wxTopLevelWindowBase::EnableCloseButton(param0);
+    if (*m_wxTopLevelWindowBaseExtEnableCloseButton != NULL){
+      return m_wxTopLevelWindowBaseExtEnableCloseButton(this, param0);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowBaseExtEnableMaximizeButtonFunc m_wxTopLevelWindowBaseExtEnableMaximizeButton = NULL;
+  virtual bool EnableMaximizeButton(bool param0 = true) override
+  {
+    bool res = wxTopLevelWindowBase::EnableMaximizeButton(param0);
+    if (*m_wxTopLevelWindowBaseExtEnableMaximizeButton != NULL){
+      return m_wxTopLevelWindowBaseExtEnableMaximizeButton(this, param0);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowBaseExtEnableMinimizeButtonFunc m_wxTopLevelWindowBaseExtEnableMinimizeButton = NULL;
+  virtual bool EnableMinimizeButton(bool param0 = true) override
+  {
+    bool res = wxTopLevelWindowBase::EnableMinimizeButton(param0);
+    if (*m_wxTopLevelWindowBaseExtEnableMinimizeButton != NULL){
+      return m_wxTopLevelWindowBaseExtEnableMinimizeButton(this, param0);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowBaseExtRequestUserAttentionFunc m_wxTopLevelWindowBaseExtRequestUserAttention = NULL;
+  virtual void RequestUserAttention(int flags = wxUSER_ATTENTION_INFO) override
+  {
+    wxTopLevelWindowBase::RequestUserAttention(flags);
+    if (*m_wxTopLevelWindowBaseExtRequestUserAttention != NULL){
+      return m_wxTopLevelWindowBaseExtRequestUserAttention(this, flags);
+    }
+  }
+  wxTopLevelWindowBaseExtIsActiveFunc m_wxTopLevelWindowBaseExtIsActive = NULL;
+  virtual bool IsActive() override
+  {
+    bool res = wxTopLevelWindowBase::IsActive();
+    if (*m_wxTopLevelWindowBaseExtIsActive != NULL){
+      return m_wxTopLevelWindowBaseExtIsActive(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowBaseExtShouldPreventAppExitFunc m_wxTopLevelWindowBaseExtShouldPreventAppExit = NULL;
+  virtual bool ShouldPreventAppExit() const override
+  {
+    bool res = wxTopLevelWindowBase::ShouldPreventAppExit();
+    if (*m_wxTopLevelWindowBaseExtShouldPreventAppExit != NULL){
+      return m_wxTopLevelWindowBaseExtShouldPreventAppExit(this);
+    }
+    else {
+      return res;
+    }
+  }
+  wxTopLevelWindowBaseExt(wxTopLevelWindowBaseExtMaximizeFunc a_Maximize, wxTopLevelWindowBaseExtRestoreFunc a_Restore, wxTopLevelWindowBaseExtIconizeFunc a_Iconize, wxTopLevelWindowBaseExtIsMaximizedFunc a_IsMaximized, wxTopLevelWindowBaseExtIsAlwaysMaximizedFunc a_IsAlwaysMaximized, wxTopLevelWindowBaseExtIsIconizedFunc a_IsIconized, wxTopLevelWindowBaseExtSetIconsFunc a_SetIcons, wxTopLevelWindowBaseExtEnableFullScreenViewFunc a_EnableFullScreenView, wxTopLevelWindowBaseExtShowFullScreenFunc a_ShowFullScreen, wxTopLevelWindowBaseExtShowWithoutActivatingFunc a_ShowWithoutActivating, wxTopLevelWindowBaseExtIsFullScreenFunc a_IsFullScreen, wxTopLevelWindowBaseExtGetContentProtectionFunc a_GetContentProtection, wxTopLevelWindowBaseExtSetContentProtectionFunc a_SetContentProtection, wxTopLevelWindowBaseExtSetTitleFunc a_SetTitle, wxTopLevelWindowBaseExtGetTitleFunc a_GetTitle, wxTopLevelWindowBaseExtEnableCloseButtonFunc a_EnableCloseButton, wxTopLevelWindowBaseExtEnableMaximizeButtonFunc a_EnableMaximizeButton, wxTopLevelWindowBaseExtEnableMinimizeButtonFunc a_EnableMinimizeButton, wxTopLevelWindowBaseExtRequestUserAttentionFunc a_RequestUserAttention, wxTopLevelWindowBaseExtIsActiveFunc a_IsActive, wxTopLevelWindowBaseExtShouldPreventAppExitFunc a_ShouldPreventAppExit): wxTopLevelWindowBase() {
+    m_wxTopLevelWindowBaseExtMaximize = a_Maximize;
+    m_wxTopLevelWindowBaseExtRestore = a_Restore;
+    m_wxTopLevelWindowBaseExtIconize = a_Iconize;
+    m_wxTopLevelWindowBaseExtIsMaximized = a_IsMaximized;
+    m_wxTopLevelWindowBaseExtIsAlwaysMaximized = a_IsAlwaysMaximized;
+    m_wxTopLevelWindowBaseExtIsIconized = a_IsIconized;
+    m_wxTopLevelWindowBaseExtSetIcons = a_SetIcons;
+    m_wxTopLevelWindowBaseExtEnableFullScreenView = a_EnableFullScreenView;
+    m_wxTopLevelWindowBaseExtShowFullScreen = a_ShowFullScreen;
+    m_wxTopLevelWindowBaseExtShowWithoutActivating = a_ShowWithoutActivating;
+    m_wxTopLevelWindowBaseExtIsFullScreen = a_IsFullScreen;
+    m_wxTopLevelWindowBaseExtGetContentProtection = a_GetContentProtection;
+    m_wxTopLevelWindowBaseExtSetContentProtection = a_SetContentProtection;
+    m_wxTopLevelWindowBaseExtSetTitle = a_SetTitle;
+    m_wxTopLevelWindowBaseExtGetTitle = a_GetTitle;
+    m_wxTopLevelWindowBaseExtEnableCloseButton = a_EnableCloseButton;
+    m_wxTopLevelWindowBaseExtEnableMaximizeButton = a_EnableMaximizeButton;
+    m_wxTopLevelWindowBaseExtEnableMinimizeButton = a_EnableMinimizeButton;
+    m_wxTopLevelWindowBaseExtRequestUserAttention = a_RequestUserAttention;
+    m_wxTopLevelWindowBaseExtIsActive = a_IsActive;
+    m_wxTopLevelWindowBaseExtShouldPreventAppExit = a_ShouldPreventAppExit;
+    }
+};
+
+class GeometrySerializerExt: public wxTopLevelWindowBase::GeometrySerializer
+{
+public:
+    virtual ~GeometrySerializerExt()    {    }
+    GeometrySerializerExtSaveFieldFunc m_GeometrySerializerExtSaveField = NULL;
+    virtual bool SaveField(wxString const& name, int value) const override
+    {
+      bool res = GeometrySerializer::SaveField(name, value);
+      if (*m_GeometrySerializerExtSaveField != NULL){
+        return m_GeometrySerializerExtSaveField(this, name, value);
+      }
+      else {
+        return res;
+      }
+    }
+    GeometrySerializerExtRestoreFieldFunc m_GeometrySerializerExtRestoreField = NULL;
+    virtual bool RestoreField(wxString const& name, int* value) override
+    {
+      bool res = GeometrySerializer::RestoreField(name, value);
+      if (*m_GeometrySerializerExtRestoreField != NULL){
+        return m_GeometrySerializerExtRestoreField(this, name, value);
+      }
+      else {
+        return res;
+      }
+    }
+    GeometrySerializerExt(GeometrySerializerExtSaveFieldFunc a_SaveField, GeometrySerializerExtRestoreFieldFunc a_RestoreField): GeometrySerializer() {
+        m_GeometrySerializerExtSaveField = a_SaveField;
+        m_GeometrySerializerExtRestoreField = a_RestoreField;
+    }
+};
+
+#if defined(__WXMSW__)
+    #include "wxext/msw/toplevel_ext.h"
+    #define wxTopLevelWindowNativeExt wxTopLevelWindowMSW
+#elif defined(__WXGTK20__)
+    #include "wxext/gtk/toplevel_ext.h"
+    #define wxTopLevelWindowNativeExt wxTopLevelWindowGTK
+#elif defined(__WXGTK__)
+    #include "wxext/gtk1/toplevel_ext.h"
+    #define wxTopLevelWindowNativeExt wxTopLevelWindowGTK
+#elif defined(__WXX11__)
+    #include "wxext/x11/toplevel_ext.h"
+    #define wxTopLevelWindowNativeExt wxTopLevelWindowX11
+#elif defined(__WXDFB__)
+    #include "wxext/dfb/toplevel_ext.h"
+    #define wxTopLevelWindowNativeExt wxTopLevelWindowDFB
+#elif defined(__WXMAC__)
+    #include "wxext/osx/toplevel_ext.h"
+    #define wxTopLevelWindowNativeExt wxTopLevelWindowMac
+#elif defined(__WXMOTIF__)
+    #include "wxext/motif/toplevel_ext.h"
+    #define wxTopLevelWindowNativeExt wxTopLevelWindowMotif
+#elif defined(__WXQT__)
+    #include "wxext/qt/toplevel_ext.h"
+#define wxTopLevelWindowNativeExt wxTopLevelWindowQt
+#endif
+
+#ifdef __WXUNIVERSAL__
+    #include "wxext/univ/toplevel_ext.h"
+#else // !__WXUNIVERSAL__
+class wxTopLevelWindowExt: public wxTopLevelWindowNativeExt
+{
+public:
+    wxTopLevelWindowExt(): wxTopLevelWindowNativeExt()    {    }
+    wxTopLevelWindowExt(wxWindow* parent, wxWindowID winid, wxString const& title, wxPoint const& pos = wxDefaultPosition, wxSize const& size = wxDefaultSize, long style = (0x0800 | 0x0040 | 0x0400 | 0x0200 | 0x1000 | 0x20000000 | 0x00400000), wxString const& name = wxString::FromAscii(wxFrameNameStr)): wxTopLevelWindowNativeExt(parent, winid, title, pos, size, style, name)    {    }
+    wxTopLevelWindowExtGetClassInfoFunc m_wxTopLevelWindowExtGetClassInfo = NULL;
+    virtual wxClassInfo* GetClassInfo() const override
+    {
+      wxClassInfo* res = wxTopLevelWindowNativeExt::GetClassInfo();
+      if (*m_wxTopLevelWindowExtGetClassInfo != NULL){
+        return m_wxTopLevelWindowExtGetClassInfo(this);
+      }
+      else {
+        return res;
+      }
+    }
+    wxTopLevelWindowExt(wxTopLevelWindowExtGetClassInfoFunc a_GetClassInfo): wxTopLevelWindowNativeExt() {
+        m_wxTopLevelWindowExtGetClassInfo = a_GetClassInfo;
+    }
+};
+#endif // __WXUNIVERSAL__/!__WXUNIVERSAL__
+
+
+
+#endif

wxheaders/wxext/tracker_ext.h

@@ -0,0 +1,39 @@
+#ifndef _WX_TRACKER_H_EXT_
+#define _WX_TRACKER_H_EXT_
+
+#include <wx/wx.h>
+#include <wx/tracker.h>
+#include <wx/vidmode.h>
+
+class wxTrackerNodeExt;
+typedef void (*wxTrackerNodeExtOnObjectDestroyFunc)(const wxTrackerNodeExt* self);
+class wxTrackableExt;
+
+class wxTrackerNodeExt: public wxTrackerNode
+{
+public:
+  wxTrackerNodeExt(): wxTrackerNode()  {  }
+  virtual ~wxTrackerNodeExt()  {  }
+  wxTrackerNodeExtOnObjectDestroyFunc m_wxTrackerNodeExtOnObjectDestroy = NULL;
+  virtual void OnObjectDestroy() override
+  {
+    wxTrackerNode::OnObjectDestroy();
+    if (*m_wxTrackerNodeExtOnObjectDestroy != NULL){
+      return m_wxTrackerNodeExtOnObjectDestroy(this);
+    }
+  }
+  wxTrackerNodeExt(wxTrackerNodeExtOnObjectDestroyFunc a_OnObjectDestroy): wxTrackerNode() {
+    m_wxTrackerNodeExtOnObjectDestroy = a_OnObjectDestroy;
+  }
+};
+
+class wxTrackableExt: public wxTrackable
+{
+public:
+  wxTrackableExt(): wxTrackable()  {  }
+  wxTrackableExt(wxTrackable const& param0): wxTrackable(param0)  {  }
+};
+
+
+
+#endif

wxheaders/wxext/window_ext.h

@@ -0,0 +1,338 @@
+#ifndef _WX_WINDOW_H_EXT_
+#define _WX_WINDOW_H_EXT_
+
+
+class wxVisualAttributesExt;
+class wxWindowListNodeExt;
+typedef void (*wxWindowListNodeExtDeleteDataFunc)(const wxWindowListNodeExt* self);
+class wxWindowListExt;
+class compatibility_iteratorExt;
+class iteratorExt;
+class const_iteratorExt;
+class reverse_iteratorExt;
+class const_reverse_iteratorExt;
+class wxWindowBaseExt;
+typedef bool (*wxWindowBaseExtDestroyFunc)(const wxWindowBaseExt* self);
+typedef void (*wxWindowBaseExtSetLabelFunc)(const wxWindowBaseExt* self, wxString const& label);
+typedef wxString (*wxWindowBaseExtGetLabelFunc)(const wxWindowBaseExt* self);
+typedef wxCoord (*wxWindowBaseExtAdjustForLayoutDirectionFunc)(const wxWindowBaseExt* self, wxCoord x, wxCoord width, wxCoord widthTotal);
+typedef void (*wxWindowBaseExtRaiseFunc)(const wxWindowBaseExt* self);
+typedef void (*wxWindowBaseExtLowerFunc)(const wxWindowBaseExt* self);
+typedef wxPoint (*wxWindowBaseExtGetClientAreaOriginFunc)(const wxWindowBaseExt* self);
+typedef wxSize (*wxWindowBaseExtClientToWindowSizeFunc)(const wxWindowBaseExt* self, wxSize const& size);
+typedef wxSize (*wxWindowBaseExtWindowToClientSizeFunc)(const wxWindowBaseExt* self, wxSize const& size);
+typedef wxSize (*wxWindowBaseExtGetEffectiveMinSizeFunc)(const wxWindowBaseExt* self);
+typedef void (*wxWindowBaseExtFitFunc)(const wxWindowBaseExt* self);
+typedef void (*wxWindowBaseExtFitInsideFunc)(const wxWindowBaseExt* self);
+typedef void (*wxWindowBaseExtSetMinSizeFunc)(const wxWindowBaseExt* self, wxSize const& minSize);
+typedef void (*wxWindowBaseExtSetMaxSizeFunc)(const wxWindowBaseExt* self, wxSize const& maxSize);
+typedef void (*wxWindowBaseExtDoSetVirtualSizeFunc)(const wxWindowBaseExt* self, int x, int y);
+typedef wxSize (*wxWindowBaseExtDoGetVirtualSizeFunc)(const wxWindowBaseExt* self);
+typedef double (*wxWindowBaseExtGetContentScaleFactorFunc)(const wxWindowBaseExt* self);
+typedef double (*wxWindowBaseExtGetDPIScaleFactorFunc)(const wxWindowBaseExt* self);
+typedef wxSize (*wxWindowBaseExtGetWindowBorderSizeFunc)(const wxWindowBaseExt* self);
+typedef bool (*wxWindowBaseExtInformFirstDirectionFunc)(const wxWindowBaseExt* self, int direction, int size, int availableOtherDir);
+typedef void (*wxWindowBaseExtSendSizeEventFunc)(const wxWindowBaseExt* self, int flags);
+class ChildrenRepositioningGuardExt;
+
+class wxVisualAttributesExt: public wxVisualAttributes
+{
+};
+
+class wxWindowListNodeExt: public wxWindowListNode
+{
+public:
+  wxWindowListNodeExt(wxListBase* list = __null, wxWindowListNode* previous = __null, wxWindowListNode* next = __null, wxWindow* data = __null, wxListKey const& key = wxDefaultListKey): wxWindowListNode(list, previous, next, data, key)  {  }
+  wxWindowListNodeExtDeleteDataFunc m_wxWindowListNodeExtDeleteData = NULL;
+  virtual void DeleteData() override
+  {
+    wxWindowListNode::DeleteData();
+    if (*m_wxWindowListNodeExtDeleteData != NULL){
+      return m_wxWindowListNodeExtDeleteData(this);
+    }
+  }
+  wxWindowListNodeExt(wxWindowListNodeExtDeleteDataFunc a_DeleteData): wxWindowListNode() {
+    m_wxWindowListNodeExtDeleteData = a_DeleteData;
+  }
+};
+
+class wxWindowListExt: public wxWindowList
+{
+    public:
+        class compatibility_iteratorExt: public compatibility_iterator
+        {
+        public:
+            compatibility_iteratorExt(wxWindowList::Node* ptr = __null): compatibility_iterator(ptr)    {    }
+    };
+};
+
+class iteratorExt: public wxWindowList::iterator
+{
+public:
+    iteratorExt(wxWindowList::iterator::Node* node, wxWindowList::iterator::Node* init): iterator(node, init)    {    }
+    iteratorExt(): iterator()    {    }
+};
+
+class const_iteratorExt: public wxWindowList::const_iterator
+{
+public:
+    const_iteratorExt(wxWindowList::const_iterator::Node* node, wxWindowList::const_iterator::Node* init): const_iterator(node, init)    {    }
+    const_iteratorExt(): const_iterator()    {    }
+    const_iteratorExt(wxWindowList::iterator const& it): const_iterator(it)    {    }
+};
+
+class reverse_iteratorExt: public wxWindowList::reverse_iterator
+{
+public:
+    reverse_iteratorExt(wxWindowList::reverse_iterator::Node* node, wxWindowList::reverse_iterator::Node* init): reverse_iterator(node, init)    {    }
+    reverse_iteratorExt(): reverse_iterator()    {    }
+};
+
+class const_reverse_iteratorExt: public wxWindowList::const_reverse_iterator
+{
+public:
+    const_reverse_iteratorExt(wxWindowList::const_reverse_iterator::Node* node, wxWindowList::const_reverse_iterator::Node* init): const_reverse_iterator(node, init)    {    }
+    const_reverse_iteratorExt(): const_reverse_iterator()    {    }
+    const_reverse_iteratorExt(wxWindowList::reverse_iterator const& it): const_reverse_iterator(it)    {    }
+};
+
+class wxWindowBaseExt: public wxWindowBase
+{
+public:
+    wxWindowBaseExt(): wxWindowBase()    {    }
+    virtual ~wxWindowBaseExt() override    {    }
+    wxWindowBaseExtDestroyFunc m_wxWindowBaseExtDestroy = NULL;
+    virtual bool Destroy() override
+    {
+      bool res = wxWindowBase::Destroy();
+      if (*m_wxWindowBaseExtDestroy != NULL){
+        return m_wxWindowBaseExtDestroy(this);
+      }
+      else {
+        return res;
+      }
+    }
+    wxWindowBaseExtSetLabelFunc m_wxWindowBaseExtSetLabel = NULL;
+    virtual void SetLabel(wxString const& label) override
+    {
+      wxWindowBase::SetLabel(label);
+      if (*m_wxWindowBaseExtSetLabel != NULL){
+        return m_wxWindowBaseExtSetLabel(this, label);
+      }
+    }
+    wxWindowBaseExtGetLabelFunc m_wxWindowBaseExtGetLabel = NULL;
+    virtual wxString GetLabel() const override
+    {
+      wxString res = wxWindowBase::GetLabel();
+      if (*m_wxWindowBaseExtGetLabel != NULL){
+        return m_wxWindowBaseExtGetLabel(this);
+      }
+      else {
+        return res;
+      }
+    }
+    wxWindowBaseExtAdjustForLayoutDirectionFunc m_wxWindowBaseExtAdjustForLayoutDirection = NULL;
+    virtual wxCoord AdjustForLayoutDirection(wxCoord x, wxCoord width, wxCoord widthTotal) const override
+    {
+      wxCoord res = wxWindowBase::AdjustForLayoutDirection(x, width, widthTotal);
+      if (*m_wxWindowBaseExtAdjustForLayoutDirection != NULL){
+        return m_wxWindowBaseExtAdjustForLayoutDirection(this, x, width, widthTotal);
+      }
+      else {
+        return res;
+      }
+    }
+    wxWindowBaseExtRaiseFunc m_wxWindowBaseExtRaise = NULL;
+    virtual void Raise() override
+    {
+      wxWindowBase::Raise();
+      if (*m_wxWindowBaseExtRaise != NULL){
+        return m_wxWindowBaseExtRaise(this);
+      }
+    }
+    wxWindowBaseExtLowerFunc m_wxWindowBaseExtLower = NULL;
+    virtual void Lower() override
+    {
+      wxWindowBase::Lower();
+      if (*m_wxWindowBaseExtLower != NULL){
+        return m_wxWindowBaseExtLower(this);
+      }
+    }
+    wxWindowBaseExtGetClientAreaOriginFunc m_wxWindowBaseExtGetClientAreaOrigin = NULL;
+    virtual wxPoint GetClientAreaOrigin() const override
+    {
+      wxPoint res = wxWindowBase::GetClientAreaOrigin();
+      if (*m_wxWindowBaseExtGetClientAreaOrigin != NULL){
+        return m_wxWindowBaseExtGetClientAreaOrigin(this);
+      }
+      else {
+        return res;
+      }
+    }
+    wxWindowBaseExtClientToWindowSizeFunc m_wxWindowBaseExtClientToWindowSize = NULL;
+    virtual wxSize ClientToWindowSize(wxSize const& size) const override
+    {
+      wxSize res = wxWindowBase::ClientToWindowSize(size);
+      if (*m_wxWindowBaseExtClientToWindowSize != NULL){
+        return m_wxWindowBaseExtClientToWindowSize(this, size);
+      }
+      else {
+        return res;
+      }
+    }
+    wxWindowBaseExtWindowToClientSizeFunc m_wxWindowBaseExtWindowToClientSize = NULL;
+    virtual wxSize WindowToClientSize(wxSize const& size) const override
+    {
+      wxSize res = wxWindowBase::WindowToClientSize(size);
+      if (*m_wxWindowBaseExtWindowToClientSize != NULL){
+        return m_wxWindowBaseExtWindowToClientSize(this, size);
+      }
+      else {
+        return res;
+      }
+    }
+    wxWindowBaseExtGetEffectiveMinSizeFunc m_wxWindowBaseExtGetEffectiveMinSize = NULL;
+    virtual wxSize GetEffectiveMinSize() const override
+    {
+      wxSize res = wxWindowBase::GetEffectiveMinSize();
+      if (*m_wxWindowBaseExtGetEffectiveMinSize != NULL){
+        return m_wxWindowBaseExtGetEffectiveMinSize(this);
+      }
+      else {
+        return res;
+      }
+    }
+    wxWindowBaseExtFitFunc m_wxWindowBaseExtFit = NULL;
+    virtual void Fit() override
+    {
+      wxWindowBase::Fit();
+      if (*m_wxWindowBaseExtFit != NULL){
+        return m_wxWindowBaseExtFit(this);
+      }
+    }
+    wxWindowBaseExtFitInsideFunc m_wxWindowBaseExtFitInside = NULL;
+    virtual void FitInside() override
+    {
+      wxWindowBase::FitInside();
+      if (*m_wxWindowBaseExtFitInside != NULL){
+        return m_wxWindowBaseExtFitInside(this);
+      }
+    }
+    wxWindowBaseExtSetMinSizeFunc m_wxWindowBaseExtSetMinSize = NULL;
+    virtual void SetMinSize(wxSize const& minSize) override
+    {
+      wxWindowBase::SetMinSize(minSize);
+      if (*m_wxWindowBaseExtSetMinSize != NULL){
+        return m_wxWindowBaseExtSetMinSize(this, minSize);
+      }
+    }
+    wxWindowBaseExtSetMaxSizeFunc m_wxWindowBaseExtSetMaxSize = NULL;
+    virtual void SetMaxSize(wxSize const& maxSize) override
+    {
+      wxWindowBase::SetMaxSize(maxSize);
+      if (*m_wxWindowBaseExtSetMaxSize != NULL){
+        return m_wxWindowBaseExtSetMaxSize(this, maxSize);
+      }
+    }
+    wxWindowBaseExtDoSetVirtualSizeFunc m_wxWindowBaseExtDoSetVirtualSize = NULL;
+    virtual void DoSetVirtualSize(int x, int y) override
+    {
+      wxWindowBase::DoSetVirtualSize(x, y);
+      if (*m_wxWindowBaseExtDoSetVirtualSize != NULL){
+        return m_wxWindowBaseExtDoSetVirtualSize(this, x, y);
+      }
+    }
+    wxWindowBaseExtDoGetVirtualSizeFunc m_wxWindowBaseExtDoGetVirtualSize = NULL;
+    virtual wxSize DoGetVirtualSize() const override
+    {
+      wxSize res = wxWindowBase::DoGetVirtualSize();
+      if (*m_wxWindowBaseExtDoGetVirtualSize != NULL){
+        return m_wxWindowBaseExtDoGetVirtualSize(this);
+      }
+      else {
+        return res;
+      }
+    }
+    wxWindowBaseExtGetContentScaleFactorFunc m_wxWindowBaseExtGetContentScaleFactor = NULL;
+    virtual double GetContentScaleFactor() const override
+    {
+      double res = wxWindowBase::GetContentScaleFactor();
+      if (*m_wxWindowBaseExtGetContentScaleFactor != NULL){
+        return m_wxWindowBaseExtGetContentScaleFactor(this);
+      }
+      else {
+        return res;
+      }
+    }
+    wxWindowBaseExtGetDPIScaleFactorFunc m_wxWindowBaseExtGetDPIScaleFactor = NULL;
+    virtual double GetDPIScaleFactor() const override
+    {
+      double res = wxWindowBase::GetDPIScaleFactor();
+      if (*m_wxWindowBaseExtGetDPIScaleFactor != NULL){
+        return m_wxWindowBaseExtGetDPIScaleFactor(this);
+      }
+      else {
+        return res;
+      }
+    }
+    wxWindowBaseExtGetWindowBorderSizeFunc m_wxWindowBaseExtGetWindowBorderSize = NULL;
+    virtual wxSize GetWindowBorderSize() const override
+    {
+      wxSize res = wxWindowBase::GetWindowBorderSize();
+      if (*m_wxWindowBaseExtGetWindowBorderSize != NULL){
+        return m_wxWindowBaseExtGetWindowBorderSize(this);
+      }
+      else {
+        return res;
+      }
+    }
+    wxWindowBaseExtInformFirstDirectionFunc m_wxWindowBaseExtInformFirstDirection = NULL;
+    virtual bool InformFirstDirection(int direction, int size, int availableOtherDir) override
+    {
+      bool res = wxWindowBase::InformFirstDirection(direction, size, availableOtherDir);
+      if (*m_wxWindowBaseExtInformFirstDirection != NULL){
+        return m_wxWindowBaseExtInformFirstDirection(this, direction, size, availableOtherDir);
+      }
+      else {
+        return res;
+      }
+    }
+    wxWindowBaseExtSendSizeEventFunc m_wxWindowBaseExtSendSizeEvent = NULL;
+    virtual void SendSizeEvent(int flags = 0) override
+    {
+      wxWindowBase::SendSizeEvent(flags);
+      if (*m_wxWindowBaseExtSendSizeEvent != NULL){
+        return m_wxWindowBaseExtSendSizeEvent(this, flags);
+      }
+    }
+    class ChildrenRepositioningGuardExt: public ChildrenRepositioningGuard
+    {
+    public:
+          explicit ChildrenRepositioningGuardExt(wxWindowBase* win): ChildrenRepositioningGuard(win)      {      }
+    };
+    wxWindowBaseExt(wxWindowBaseExtDestroyFunc a_Destroy, wxWindowBaseExtSetLabelFunc a_SetLabel, wxWindowBaseExtGetLabelFunc a_GetLabel, wxWindowBaseExtAdjustForLayoutDirectionFunc a_AdjustForLayoutDirection, wxWindowBaseExtRaiseFunc a_Raise, wxWindowBaseExtLowerFunc a_Lower, wxWindowBaseExtGetClientAreaOriginFunc a_GetClientAreaOrigin, wxWindowBaseExtClientToWindowSizeFunc a_ClientToWindowSize, wxWindowBaseExtWindowToClientSizeFunc a_WindowToClientSize, wxWindowBaseExtGetEffectiveMinSizeFunc a_GetEffectiveMinSize, wxWindowBaseExtFitFunc a_Fit, wxWindowBaseExtFitInsideFunc a_FitInside, wxWindowBaseExtSetMinSizeFunc a_SetMinSize, wxWindowBaseExtSetMaxSizeFunc a_SetMaxSize, wxWindowBaseExtDoSetVirtualSizeFunc a_DoSetVirtualSize, wxWindowBaseExtDoGetVirtualSizeFunc a_DoGetVirtualSize, wxWindowBaseExtGetContentScaleFactorFunc a_GetContentScaleFactor, wxWindowBaseExtGetDPIScaleFactorFunc a_GetDPIScaleFactor, wxWindowBaseExtGetWindowBorderSizeFunc a_GetWindowBorderSize, wxWindowBaseExtInformFirstDirectionFunc a_InformFirstDirection, wxWindowBaseExtSendSizeEventFunc a_SendSizeEvent): wxWindowBaseExt() {
+        m_wxWindowBaseExtDestroy = a_Destroy;
+        m_wxWindowBaseExtSetLabel = a_SetLabel;
+        m_wxWindowBaseExtGetLabel = a_GetLabel;
+        m_wxWindowBaseExtAdjustForLayoutDirection = a_AdjustForLayoutDirection;
+        m_wxWindowBaseExtRaise = a_Raise;
+        m_wxWindowBaseExtLower = a_Lower;
+        m_wxWindowBaseExtGetClientAreaOrigin = a_GetClientAreaOrigin;
+        m_wxWindowBaseExtClientToWindowSize = a_ClientToWindowSize;
+        m_wxWindowBaseExtWindowToClientSize = a_WindowToClientSize;
+        m_wxWindowBaseExtGetEffectiveMinSize = a_GetEffectiveMinSize;
+        m_wxWindowBaseExtFit = a_Fit;
+        m_wxWindowBaseExtFitInside = a_FitInside;
+        m_wxWindowBaseExtSetMinSize = a_SetMinSize;
+        m_wxWindowBaseExtSetMaxSize = a_SetMaxSize;
+        m_wxWindowBaseExtDoSetVirtualSize = a_DoSetVirtualSize;
+        m_wxWindowBaseExtDoGetVirtualSize = a_DoGetVirtualSize;
+        m_wxWindowBaseExtGetContentScaleFactor = a_GetContentScaleFactor;
+        m_wxWindowBaseExtGetDPIScaleFactor = a_GetDPIScaleFactor;
+        m_wxWindowBaseExtGetWindowBorderSize = a_GetWindowBorderSize;
+        m_wxWindowBaseExtInformFirstDirection = a_InformFirstDirection;
+        m_wxWindowBaseExtSendSizeEvent = a_SendSizeEvent;
+      }
+};
+
+#endif

wxheaders/wxext/window_ext_inc.h

@@ -0,0 +1,58 @@
+#if defined(__WXMSW__)
+    #ifdef __WXUNIVERSAL__
+        #define wxWindowNative wxWindowMSW
+    #else // !wxUniv
+        #define wxWindowMSW wxWindowExt
+    #endif // wxUniv/!wxUniv
+    #include "wxext/msw/window_ext.h"
+#elif defined(__WXMOTIF__)
+    #include "wxext/motif/window_ext.h"
+#elif defined(__WXGTK20__)
+    #ifdef __WXUNIVERSAL__
+        #define wxWindowNative wxWindowGTK
+    #else // !wxUniv
+        #define wxWindowGTK wxWindowExt
+    #endif // wxUniv
+    #include "wxext/gtk/window_ext.h"
+#elif defined(__WXGTK__)
+    #ifdef __WXUNIVERSAL__
+        #define wxWindowNative wxWindowGTK
+    #else // !wxUniv
+        #define wxWindowGTK wxWindowExt
+    #endif // wxUniv
+    #include "wxext/gtk1/window_ext.h"
+#elif defined(__WXX11__)
+    #ifdef __WXUNIVERSAL__
+        #define wxWindowNative wxWindowX11
+    #else // !wxUniv
+        #define wxWindowX11 wxWindowExt
+    #endif // wxUniv
+    #include "wxext/x11/window_ext.h"
+#elif defined(__WXDFB__)
+    #define wxWindowNative wxWindowDFB
+    #include "wxext/dfb/window_ext.h"
+#elif defined(__WXMAC__)
+    #ifdef __WXUNIVERSAL__
+        #define wxWindowNative wxWindowMac
+    #else // !wxUniv
+        #define wxWindowMacExt wxWindowExt
+    #endif // wxUniv
+    #include "wxext/osx/window_ext.h"
+#elif defined(__WXQT__)
+    #ifdef __WXUNIVERSAL__
+        #define wxWindowNative wxWindowQt
+    #else // !wxUniv
+        #define wxWindowQt wxWindowExt
+    #endif // wxUniv
+    #include "wxext/qt/window_ext.h"
+#endif
+
+// for wxUniversal, we now derive the real wxWindow from wxWindow<platform>,
+// for the native ports we already have defined it above
+#if defined(__WXUNIVERSAL__)
+    #ifndef wxWindowNative
+        #error "wxWindowNative must be defined above!"
+    #endif
+
+    #include "wxext/univ/window_ext.h"
+#endif // wxUniv