jyapayne/wxc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove files and add icon/bitmap

Browse source
This commit is contained in:
Joey Yakimowich-Payne 2023-02-17 11:48:00 -07:00
commit 3397f151c5
No known key found for this signature in database
GPG key ID: 6BFE655FA5ABD1E1
13 changed files with 1611 additions and 1800 deletions
Download patch file Download diff file Expand all files Collapse all files

731
swigtemplates/appbaseext.h
View file

@ -1,731 +0,0 @@
#include <wx/wx.h>
#include <wx/vidmode.h>
#ifndef _WX_APP_H_EXT_
#define _WX_APP_H_EXT_
#include <wx/wx.h>
#include <wx/vidmode.h>
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 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 wxAppInitializerExt;
class wxAppConsoleBaseExt: public wxAppConsoleBase
{
public:
wxAppConsoleBaseExt(): wxAppConsoleBase() { }
virtual ~wxAppConsoleBaseExt() override { }
wxAppConsoleBaseExtInitializeFunc m_wxAppConsoleBaseExtInitialize;
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;
virtual bool CallOnInit() override
{
bool res = wxAppConsoleBase::CallOnInit();
if (*m_wxAppConsoleBaseExtCallOnInit != NULL){
return m_wxAppConsoleBaseExtCallOnInit(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtOnInitFunc m_wxAppConsoleBaseExtOnInit;
virtual bool OnInit() override
{
bool res = wxAppConsoleBase::OnInit();
if (*m_wxAppConsoleBaseExtOnInit != NULL){
return m_wxAppConsoleBaseExtOnInit(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtOnRunFunc m_wxAppConsoleBaseExtOnRun;
virtual int OnRun() override
{
int res = wxAppConsoleBase::OnRun();
if (*m_wxAppConsoleBaseExtOnRun != NULL){
return m_wxAppConsoleBaseExtOnRun(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtOnLaunchedFunc m_wxAppConsoleBaseExtOnLaunched;
virtual void OnLaunched() override
{
wxAppConsoleBase::OnLaunched();
if (*m_wxAppConsoleBaseExtOnLaunched != NULL){
return m_wxAppConsoleBaseExtOnLaunched(this);
}
}
wxAppConsoleBaseExtOnEventLoopEnterFunc m_wxAppConsoleBaseExtOnEventLoopEnter;
virtual void OnEventLoopEnter(wxEventLoopBase* param0) override
{
wxAppConsoleBase::OnEventLoopEnter(param0);
if (*m_wxAppConsoleBaseExtOnEventLoopEnter != NULL){
return m_wxAppConsoleBaseExtOnEventLoopEnter(this, param0);
}
}
wxAppConsoleBaseExtOnExitFunc m_wxAppConsoleBaseExtOnExit;
virtual int OnExit() override
{
int res = wxAppConsoleBase::OnExit();
if (*m_wxAppConsoleBaseExtOnExit != NULL){
return m_wxAppConsoleBaseExtOnExit(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtOnEventLoopExitFunc m_wxAppConsoleBaseExtOnEventLoopExit;
virtual void OnEventLoopExit(wxEventLoopBase* param0) override
{
wxAppConsoleBase::OnEventLoopExit(param0);
if (*m_wxAppConsoleBaseExtOnEventLoopExit != NULL){
return m_wxAppConsoleBaseExtOnEventLoopExit(this, param0);
}
}
wxAppConsoleBaseExtCleanUpFunc m_wxAppConsoleBaseExtCleanUp;
virtual void CleanUp() override
{
wxAppConsoleBase::CleanUp();
if (*m_wxAppConsoleBaseExtCleanUp != NULL){
return m_wxAppConsoleBaseExtCleanUp(this);
}
}
wxAppConsoleBaseExtOnFatalExceptionFunc m_wxAppConsoleBaseExtOnFatalException;
virtual void OnFatalException() override
{
wxAppConsoleBase::OnFatalException();
if (*m_wxAppConsoleBaseExtOnFatalException != NULL){
return m_wxAppConsoleBaseExtOnFatalException(this);
}
}
wxAppConsoleBaseExtExitFunc m_wxAppConsoleBaseExtExit;
virtual void Exit() override
{
wxAppConsoleBase::Exit();
if (*m_wxAppConsoleBaseExtExit != NULL){
return m_wxAppConsoleBaseExtExit(this);
}
}
wxAppConsoleBaseExtOnInitCmdLineFunc m_wxAppConsoleBaseExtOnInitCmdLine;
virtual void OnInitCmdLine(wxCmdLineParser& parser) override
{
wxAppConsoleBase::OnInitCmdLine(parser);
if (*m_wxAppConsoleBaseExtOnInitCmdLine != NULL){
return m_wxAppConsoleBaseExtOnInitCmdLine(this, parser);
}
}
wxAppConsoleBaseExtOnCmdLineParsedFunc m_wxAppConsoleBaseExtOnCmdLineParsed;
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;
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;
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;
virtual void SetCLocale() override
{
wxAppConsoleBase::SetCLocale();
if (*m_wxAppConsoleBaseExtSetCLocale != NULL){
return m_wxAppConsoleBaseExtSetCLocale(this);
}
}
wxAppConsoleBaseExtFilterEventFunc m_wxAppConsoleBaseExtFilterEvent;
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;
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;
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;
virtual void OnUnhandledException() override
{
wxAppConsoleBase::OnUnhandledException();
if (*m_wxAppConsoleBaseExtOnUnhandledException != NULL){
return m_wxAppConsoleBaseExtOnUnhandledException(this);
}
}
wxAppConsoleBaseExtOnExceptionInMainLoopFunc m_wxAppConsoleBaseExtOnExceptionInMainLoop;
virtual bool OnExceptionInMainLoop() override
{
bool res = wxAppConsoleBase::OnExceptionInMainLoop();
if (*m_wxAppConsoleBaseExtOnExceptionInMainLoop != NULL){
return m_wxAppConsoleBaseExtOnExceptionInMainLoop(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtStoreCurrentExceptionFunc m_wxAppConsoleBaseExtStoreCurrentException;
virtual bool StoreCurrentException() override
{
bool res = wxAppConsoleBase::StoreCurrentException();
if (*m_wxAppConsoleBaseExtStoreCurrentException != NULL){
return m_wxAppConsoleBaseExtStoreCurrentException(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtRethrowStoredExceptionFunc m_wxAppConsoleBaseExtRethrowStoredException;
virtual void RethrowStoredException() override
{
wxAppConsoleBase::RethrowStoredException();
if (*m_wxAppConsoleBaseExtRethrowStoredException != NULL){
return m_wxAppConsoleBaseExtRethrowStoredException(this);
}
}
wxAppConsoleBaseExtProcessPendingEventsFunc m_wxAppConsoleBaseExtProcessPendingEvents;
virtual void ProcessPendingEvents() override
{
wxAppConsoleBase::ProcessPendingEvents();
if (*m_wxAppConsoleBaseExtProcessPendingEvents != NULL){
return m_wxAppConsoleBaseExtProcessPendingEvents(this);
}
}
wxAppConsoleBaseExtPendingFunc m_wxAppConsoleBaseExtPending;
virtual bool Pending() override
{
bool res = wxAppConsoleBase::Pending();
if (*m_wxAppConsoleBaseExtPending != NULL){
return m_wxAppConsoleBaseExtPending(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtDispatchFunc m_wxAppConsoleBaseExtDispatch;
virtual bool Dispatch() override
{
bool res = wxAppConsoleBase::Dispatch();
if (*m_wxAppConsoleBaseExtDispatch != NULL){
return m_wxAppConsoleBaseExtDispatch(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtMainLoopFunc m_wxAppConsoleBaseExtMainLoop;
virtual int MainLoop() override
{
int res = wxAppConsoleBase::MainLoop();
if (*m_wxAppConsoleBaseExtMainLoop != NULL){
return m_wxAppConsoleBaseExtMainLoop(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtExitMainLoopFunc m_wxAppConsoleBaseExtExitMainLoop;
virtual void ExitMainLoop() override
{
wxAppConsoleBase::ExitMainLoop();
if (*m_wxAppConsoleBaseExtExitMainLoop != NULL){
return m_wxAppConsoleBaseExtExitMainLoop(this);
}
}
wxAppConsoleBaseExtWakeUpIdleFunc m_wxAppConsoleBaseExtWakeUpIdle;
virtual void WakeUpIdle() override
{
wxAppConsoleBase::WakeUpIdle();
if (*m_wxAppConsoleBaseExtWakeUpIdle != NULL){
return m_wxAppConsoleBaseExtWakeUpIdle(this);
}
}
wxAppConsoleBaseExtProcessIdleFunc m_wxAppConsoleBaseExtProcessIdle;
virtual bool ProcessIdle() override
{
bool res = wxAppConsoleBase::ProcessIdle();
if (*m_wxAppConsoleBaseExtProcessIdle != NULL){
return m_wxAppConsoleBaseExtProcessIdle(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtUsesEventLoopFunc m_wxAppConsoleBaseExtUsesEventLoop;
virtual bool UsesEventLoop() const override
{
bool res = wxAppConsoleBase::UsesEventLoop();
if (*m_wxAppConsoleBaseExtUsesEventLoop != NULL){
return m_wxAppConsoleBaseExtUsesEventLoop(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtOnAssertFailureFunc m_wxAppConsoleBaseExtOnAssertFailure;
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;
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;
virtual bool IsGUI() const override
{
bool res = wxAppConsoleBase::IsGUI();
if (*m_wxAppConsoleBaseExtIsGUI != NULL){
return m_wxAppConsoleBaseExtIsGUI(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtCreateTraitsFunc m_wxAppConsoleBaseExtCreateTraits;
virtual wxAppTraits* CreateTraits() override
{
wxAppTraits* res = wxAppConsoleBase::CreateTraits();
if (*m_wxAppConsoleBaseExtCreateTraits != NULL){
return m_wxAppConsoleBaseExtCreateTraits(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtWXReservedApp1Func m_wxAppConsoleBaseExtWXReservedApp1;
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;
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;
}
};
class wxAppBaseExt: public wxAppBase
{
public:
wxAppBaseExt(): wxAppBase() { }
virtual ~wxAppBaseExt() override { }
wxAppBaseExtInitializeFunc m_wxAppBaseExtInitialize;
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;
virtual bool OnInitGui() override
{
bool res = wxAppBase::OnInitGui();
if (*m_wxAppBaseExtOnInitGui != NULL){
return m_wxAppBaseExtOnInitGui(this);
}
else {
return res;
}
}
wxAppBaseExtOnRunFunc m_wxAppBaseExtOnRun;
virtual int OnRun() override
{
int res = wxAppBase::OnRun();
if (*m_wxAppBaseExtOnRun != NULL){
return m_wxAppBaseExtOnRun(this);
}
else {
return res;
}
}
wxAppBaseExtOnExitFunc m_wxAppBaseExtOnExit;
virtual int OnExit() override
{
int res = wxAppBase::OnExit();
if (*m_wxAppBaseExtOnExit != NULL){
return m_wxAppBaseExtOnExit(this);
}
else {
return res;
}
}
wxAppBaseExtCleanUpFunc m_wxAppBaseExtCleanUp;
virtual void CleanUp() override
{
wxAppBase::CleanUp();
if (*m_wxAppBaseExtCleanUp != NULL){
return m_wxAppBaseExtCleanUp(this);
}
}
wxAppBaseExtSafeYieldFunc m_wxAppBaseExtSafeYield;
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;
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;
virtual bool ProcessIdle() override
{
bool res = wxAppBase::ProcessIdle();
if (*m_wxAppBaseExtProcessIdle != NULL){
return m_wxAppBaseExtProcessIdle(this);
}
else {
return res;
}
}
wxAppBaseExtUsesEventLoopFunc m_wxAppBaseExtUsesEventLoop;
virtual bool UsesEventLoop() const override
{
bool res = wxAppBase::UsesEventLoop();
if (*m_wxAppBaseExtUsesEventLoop != NULL){
return m_wxAppBaseExtUsesEventLoop(this);
}
else {
return res;
}
}
wxAppBaseExtIsActiveFunc m_wxAppBaseExtIsActive;
virtual bool IsActive() const override
{
bool res = wxAppBase::IsActive();
if (*m_wxAppBaseExtIsActive != NULL){
return m_wxAppBaseExtIsActive(this);
}
else {
return res;
}
}
wxAppBaseExtGetTopWindowFunc m_wxAppBaseExtGetTopWindow;
virtual wxWindow* GetTopWindow() const override
{
wxWindow* res = wxAppBase::GetTopWindow();
if (*m_wxAppBaseExtGetTopWindow != NULL){
return m_wxAppBaseExtGetTopWindow(this);
}
else {
return res;
}
}
wxAppBaseExtGetDisplayModeFunc m_wxAppBaseExtGetDisplayMode;
virtual wxVideoMode GetDisplayMode() const override
{
wxVideoMode res = wxAppBase::GetDisplayMode();
if (*m_wxAppBaseExtGetDisplayMode != NULL){
return m_wxAppBaseExtGetDisplayMode(this);
}
else {
return res;
}
}
wxAppBaseExtSetDisplayModeFunc m_wxAppBaseExtSetDisplayMode;
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;
virtual void SetPrintMode(int param0) override
{
wxAppBase::SetPrintMode(param0);
if (*m_wxAppBaseExtSetPrintMode != NULL){
return m_wxAppBaseExtSetPrintMode(this, param0);
}
}
wxAppBaseExtGetLayoutDirectionFunc m_wxAppBaseExtGetLayoutDirection;
virtual wxLayoutDirection GetLayoutDirection() const override
{
wxLayoutDirection res = wxAppBase::GetLayoutDirection();
if (*m_wxAppBaseExtGetLayoutDirection != NULL){
return m_wxAppBaseExtGetLayoutDirection(this);
}
else {
return res;
}
}
wxAppBaseExtSetNativeThemeFunc m_wxAppBaseExtSetNativeTheme;
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;
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;
virtual void OnInitCmdLine(wxCmdLineParser& parser) override
{
wxAppBase::OnInitCmdLine(parser);
if (*m_wxAppBaseExtOnInitCmdLine != NULL){
return m_wxAppBaseExtOnInitCmdLine(this, parser);
}
}
wxAppBaseExtSetActiveFunc m_wxAppBaseExtSetActive;
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;
virtual bool IsGUI() const override
{
bool res = wxAppBase::IsGUI();
if (*m_wxAppBaseExtIsGUI != NULL){
return m_wxAppBaseExtIsGUI(this);
}
else {
return res;
}
}
wxAppBaseExtCreateTraitsFunc m_wxAppBaseExtCreateTraits;
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

722
swigtemplates/appext.h
View file

@ -1,722 +0,0 @@
#include <wx/wx.h>
#include <wx/vidmode.h>
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 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 wxAppInitializerExt;
class wxAppConsoleBaseExt: public wxAppConsoleBase
{
public:
wxAppConsoleBaseExt(): wxAppConsoleBase() { }
virtual ~wxAppConsoleBaseExt() override { }
wxAppConsoleBaseExtInitializeFunc m_wxAppConsoleBaseExtInitialize;
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;
virtual bool CallOnInit() override
{
bool res = wxAppConsoleBase::CallOnInit();
if (*m_wxAppConsoleBaseExtCallOnInit != NULL){
return m_wxAppConsoleBaseExtCallOnInit(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtOnInitFunc m_wxAppConsoleBaseExtOnInit;
virtual bool OnInit() override
{
bool res = wxAppConsoleBase::OnInit();
if (*m_wxAppConsoleBaseExtOnInit != NULL){
return m_wxAppConsoleBaseExtOnInit(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtOnRunFunc m_wxAppConsoleBaseExtOnRun;
virtual int OnRun() override
{
int res = wxAppConsoleBase::OnRun();
if (*m_wxAppConsoleBaseExtOnRun != NULL){
return m_wxAppConsoleBaseExtOnRun(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtOnLaunchedFunc m_wxAppConsoleBaseExtOnLaunched;
virtual void OnLaunched() override
{
wxAppConsoleBase::OnLaunched();
if (*m_wxAppConsoleBaseExtOnLaunched != NULL){
return m_wxAppConsoleBaseExtOnLaunched(this);
}
}
wxAppConsoleBaseExtOnEventLoopEnterFunc m_wxAppConsoleBaseExtOnEventLoopEnter;
virtual void OnEventLoopEnter(wxEventLoopBase* param0) override
{
wxAppConsoleBase::OnEventLoopEnter(param0);
if (*m_wxAppConsoleBaseExtOnEventLoopEnter != NULL){
return m_wxAppConsoleBaseExtOnEventLoopEnter(this, param0);
}
}
wxAppConsoleBaseExtOnExitFunc m_wxAppConsoleBaseExtOnExit;
virtual int OnExit() override
{
int res = wxAppConsoleBase::OnExit();
if (*m_wxAppConsoleBaseExtOnExit != NULL){
return m_wxAppConsoleBaseExtOnExit(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtOnEventLoopExitFunc m_wxAppConsoleBaseExtOnEventLoopExit;
virtual void OnEventLoopExit(wxEventLoopBase* param0) override
{
wxAppConsoleBase::OnEventLoopExit(param0);
if (*m_wxAppConsoleBaseExtOnEventLoopExit != NULL){
return m_wxAppConsoleBaseExtOnEventLoopExit(this, param0);
}
}
wxAppConsoleBaseExtCleanUpFunc m_wxAppConsoleBaseExtCleanUp;
virtual void CleanUp() override
{
wxAppConsoleBase::CleanUp();
if (*m_wxAppConsoleBaseExtCleanUp != NULL){
return m_wxAppConsoleBaseExtCleanUp(this);
}
}
wxAppConsoleBaseExtOnFatalExceptionFunc m_wxAppConsoleBaseExtOnFatalException;
virtual void OnFatalException() override
{
wxAppConsoleBase::OnFatalException();
if (*m_wxAppConsoleBaseExtOnFatalException != NULL){
return m_wxAppConsoleBaseExtOnFatalException(this);
}
}
wxAppConsoleBaseExtExitFunc m_wxAppConsoleBaseExtExit;
virtual void Exit() override
{
wxAppConsoleBase::Exit();
if (*m_wxAppConsoleBaseExtExit != NULL){
return m_wxAppConsoleBaseExtExit(this);
}
}
wxAppConsoleBaseExtOnInitCmdLineFunc m_wxAppConsoleBaseExtOnInitCmdLine;
virtual void OnInitCmdLine(wxCmdLineParser& parser) override
{
wxAppConsoleBase::OnInitCmdLine(parser);
if (*m_wxAppConsoleBaseExtOnInitCmdLine != NULL){
return m_wxAppConsoleBaseExtOnInitCmdLine(this, parser);
}
}
wxAppConsoleBaseExtOnCmdLineParsedFunc m_wxAppConsoleBaseExtOnCmdLineParsed;
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;
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;
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;
virtual void SetCLocale() override
{
wxAppConsoleBase::SetCLocale();
if (*m_wxAppConsoleBaseExtSetCLocale != NULL){
return m_wxAppConsoleBaseExtSetCLocale(this);
}
}
wxAppConsoleBaseExtFilterEventFunc m_wxAppConsoleBaseExtFilterEvent;
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;
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;
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;
virtual void OnUnhandledException() override
{
wxAppConsoleBase::OnUnhandledException();
if (*m_wxAppConsoleBaseExtOnUnhandledException != NULL){
return m_wxAppConsoleBaseExtOnUnhandledException(this);
}
}
wxAppConsoleBaseExtOnExceptionInMainLoopFunc m_wxAppConsoleBaseExtOnExceptionInMainLoop;
virtual bool OnExceptionInMainLoop() override
{
bool res = wxAppConsoleBase::OnExceptionInMainLoop();
if (*m_wxAppConsoleBaseExtOnExceptionInMainLoop != NULL){
return m_wxAppConsoleBaseExtOnExceptionInMainLoop(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtStoreCurrentExceptionFunc m_wxAppConsoleBaseExtStoreCurrentException;
virtual bool StoreCurrentException() override
{
bool res = wxAppConsoleBase::StoreCurrentException();
if (*m_wxAppConsoleBaseExtStoreCurrentException != NULL){
return m_wxAppConsoleBaseExtStoreCurrentException(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtRethrowStoredExceptionFunc m_wxAppConsoleBaseExtRethrowStoredException;
virtual void RethrowStoredException() override
{
wxAppConsoleBase::RethrowStoredException();
if (*m_wxAppConsoleBaseExtRethrowStoredException != NULL){
return m_wxAppConsoleBaseExtRethrowStoredException(this);
}
}
wxAppConsoleBaseExtProcessPendingEventsFunc m_wxAppConsoleBaseExtProcessPendingEvents;
virtual void ProcessPendingEvents() override
{
wxAppConsoleBase::ProcessPendingEvents();
if (*m_wxAppConsoleBaseExtProcessPendingEvents != NULL){
return m_wxAppConsoleBaseExtProcessPendingEvents(this);
}
}
wxAppConsoleBaseExtPendingFunc m_wxAppConsoleBaseExtPending;
virtual bool Pending() override
{
bool res = wxAppConsoleBase::Pending();
if (*m_wxAppConsoleBaseExtPending != NULL){
return m_wxAppConsoleBaseExtPending(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtDispatchFunc m_wxAppConsoleBaseExtDispatch;
virtual bool Dispatch() override
{
bool res = wxAppConsoleBase::Dispatch();
if (*m_wxAppConsoleBaseExtDispatch != NULL){
return m_wxAppConsoleBaseExtDispatch(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtMainLoopFunc m_wxAppConsoleBaseExtMainLoop;
virtual int MainLoop() override
{
int res = wxAppConsoleBase::MainLoop();
if (*m_wxAppConsoleBaseExtMainLoop != NULL){
return m_wxAppConsoleBaseExtMainLoop(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtExitMainLoopFunc m_wxAppConsoleBaseExtExitMainLoop;
virtual void ExitMainLoop() override
{
wxAppConsoleBase::ExitMainLoop();
if (*m_wxAppConsoleBaseExtExitMainLoop != NULL){
return m_wxAppConsoleBaseExtExitMainLoop(this);
}
}
wxAppConsoleBaseExtWakeUpIdleFunc m_wxAppConsoleBaseExtWakeUpIdle;
virtual void WakeUpIdle() override
{
wxAppConsoleBase::WakeUpIdle();
if (*m_wxAppConsoleBaseExtWakeUpIdle != NULL){
return m_wxAppConsoleBaseExtWakeUpIdle(this);
}
}
wxAppConsoleBaseExtProcessIdleFunc m_wxAppConsoleBaseExtProcessIdle;
virtual bool ProcessIdle() override
{
bool res = wxAppConsoleBase::ProcessIdle();
if (*m_wxAppConsoleBaseExtProcessIdle != NULL){
return m_wxAppConsoleBaseExtProcessIdle(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtUsesEventLoopFunc m_wxAppConsoleBaseExtUsesEventLoop;
virtual bool UsesEventLoop() const override
{
bool res = wxAppConsoleBase::UsesEventLoop();
if (*m_wxAppConsoleBaseExtUsesEventLoop != NULL){
return m_wxAppConsoleBaseExtUsesEventLoop(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtOnAssertFailureFunc m_wxAppConsoleBaseExtOnAssertFailure;
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;
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;
virtual bool IsGUI() const override
{
bool res = wxAppConsoleBase::IsGUI();
if (*m_wxAppConsoleBaseExtIsGUI != NULL){
return m_wxAppConsoleBaseExtIsGUI(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtCreateTraitsFunc m_wxAppConsoleBaseExtCreateTraits;
virtual wxAppTraits* CreateTraits() override
{
wxAppTraits* res = wxAppConsoleBase::CreateTraits();
if (*m_wxAppConsoleBaseExtCreateTraits != NULL){
return m_wxAppConsoleBaseExtCreateTraits(this);
}
else {
return res;
}
}
wxAppConsoleBaseExtWXReservedApp1Func m_wxAppConsoleBaseExtWXReservedApp1;
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;
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;
}
};
class wxAppBaseExt: public wxAppBase
{
public:
wxAppBaseExt(): wxAppBase() { }
virtual ~wxAppBaseExt() override { }
wxAppBaseExtInitializeFunc m_wxAppBaseExtInitialize;
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;
virtual bool OnInitGui() override
{
bool res = wxAppBase::OnInitGui();
if (*m_wxAppBaseExtOnInitGui != NULL){
return m_wxAppBaseExtOnInitGui(this);
}
else {
return res;
}
}
wxAppBaseExtOnRunFunc m_wxAppBaseExtOnRun;
virtual int OnRun() override
{
int res = wxAppBase::OnRun();
if (*m_wxAppBaseExtOnRun != NULL){
return m_wxAppBaseExtOnRun(this);
}
else {
return res;
}
}
wxAppBaseExtOnExitFunc m_wxAppBaseExtOnExit;
virtual int OnExit() override
{
int res = wxAppBase::OnExit();
if (*m_wxAppBaseExtOnExit != NULL){
return m_wxAppBaseExtOnExit(this);
}
else {
return res;
}
}
wxAppBaseExtCleanUpFunc m_wxAppBaseExtCleanUp;
virtual void CleanUp() override
{
wxAppBase::CleanUp();
if (*m_wxAppBaseExtCleanUp != NULL){
return m_wxAppBaseExtCleanUp(this);
}
}
wxAppBaseExtSafeYieldFunc m_wxAppBaseExtSafeYield;
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;
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;
virtual bool ProcessIdle() override
{
bool res = wxAppBase::ProcessIdle();
if (*m_wxAppBaseExtProcessIdle != NULL){
return m_wxAppBaseExtProcessIdle(this);
}
else {
return res;
}
}
wxAppBaseExtUsesEventLoopFunc m_wxAppBaseExtUsesEventLoop;
virtual bool UsesEventLoop() const override
{
bool res = wxAppBase::UsesEventLoop();
if (*m_wxAppBaseExtUsesEventLoop != NULL){
return m_wxAppBaseExtUsesEventLoop(this);
}
else {
return res;
}
}
wxAppBaseExtIsActiveFunc m_wxAppBaseExtIsActive;
virtual bool IsActive() const override
{
bool res = wxAppBase::IsActive();
if (*m_wxAppBaseExtIsActive != NULL){
return m_wxAppBaseExtIsActive(this);
}
else {
return res;
}
}
wxAppBaseExtGetTopWindowFunc m_wxAppBaseExtGetTopWindow;
virtual wxWindow* GetTopWindow() const override
{
wxWindow* res = wxAppBase::GetTopWindow();
if (*m_wxAppBaseExtGetTopWindow != NULL){
return m_wxAppBaseExtGetTopWindow(this);
}
else {
return res;
}
}
wxAppBaseExtGetDisplayModeFunc m_wxAppBaseExtGetDisplayMode;
virtual wxVideoMode GetDisplayMode() const override
{
wxVideoMode res = wxAppBase::GetDisplayMode();
if (*m_wxAppBaseExtGetDisplayMode != NULL){
return m_wxAppBaseExtGetDisplayMode(this);
}
else {
return res;
}
}
wxAppBaseExtSetDisplayModeFunc m_wxAppBaseExtSetDisplayMode;
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;
virtual void SetPrintMode(int param0) override
{
wxAppBase::SetPrintMode(param0);
if (*m_wxAppBaseExtSetPrintMode != NULL){
return m_wxAppBaseExtSetPrintMode(this, param0);
}
}
wxAppBaseExtGetLayoutDirectionFunc m_wxAppBaseExtGetLayoutDirection;
virtual wxLayoutDirection GetLayoutDirection() const override
{
wxLayoutDirection res = wxAppBase::GetLayoutDirection();
if (*m_wxAppBaseExtGetLayoutDirection != NULL){
return m_wxAppBaseExtGetLayoutDirection(this);
}
else {
return res;
}
}
wxAppBaseExtSetNativeThemeFunc m_wxAppBaseExtSetNativeTheme;
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;
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;
virtual void OnInitCmdLine(wxCmdLineParser& parser) override
{
wxAppBase::OnInitCmdLine(parser);
if (*m_wxAppBaseExtOnInitCmdLine != NULL){
return m_wxAppBaseExtOnInitCmdLine(this, parser);
}
}
wxAppBaseExtSetActiveFunc m_wxAppBaseExtSetActive;
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;
virtual bool IsGUI() const override
{
bool res = wxAppBase::IsGUI();
if (*m_wxAppBaseExtIsGUI != NULL){
return m_wxAppBaseExtIsGUI(this);
}
else {
return res;
}
}
wxAppBaseExtCreateTraitsFunc m_wxAppBaseExtCreateTraits;
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) { }
};

284
swigtemplates/appextmac.h
View file

@ -1,284 +0,0 @@
#include <wx/wx.h>
#include <wx/vidmode.h>
class wxAppExt;
typedef wxClassInfo* (*wxAppExtGetClassInfoFunc)(const wxAppExt* self);
typedef void (*wxAppExtWakeUpIdleFunc)(const wxAppExt* self);
typedef void (*wxAppExtSetPrintModeFunc)(const wxAppExt* self, int mode);
typedef int (*wxAppExtGetPrintModeFunc)(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 bool (*wxAppExtOSXIsGUIApplicationFunc)(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);
class wxAppExt: public wxApp
{
public:
wxAppExtGetClassInfoFunc m_wxAppExtGetClassInfo;
virtual wxClassInfo* GetClassInfo() const override
{
wxClassInfo* res = wxApp::GetClassInfo();
if (*m_wxAppExtGetClassInfo != NULL){
return m_wxAppExtGetClassInfo(this);
}
else {
return res;
}
}
wxAppExt(): wxApp() { }
virtual ~wxAppExt() { }
wxAppExtWakeUpIdleFunc m_wxAppExtWakeUpIdle;
virtual void WakeUpIdle() override
{
wxApp::WakeUpIdle();
if (*m_wxAppExtWakeUpIdle != NULL){
return m_wxAppExtWakeUpIdle(this);
}
}
wxAppExtSetPrintModeFunc m_wxAppExtSetPrintMode;
virtual void SetPrintMode(int mode) override
{
wxApp::SetPrintMode(mode);
if (*m_wxAppExtSetPrintMode != NULL){
return m_wxAppExtSetPrintMode(this, mode);
}
}
wxAppExtGetPrintModeFunc m_wxAppExtGetPrintMode;
virtual int GetPrintMode() const override
{
int res = wxApp::GetPrintMode();
if (*m_wxAppExtGetPrintMode != NULL){
return m_wxAppExtGetPrintMode(this);
}
else {
return res;
}
}
wxAppExtCallOnInitFunc m_wxAppExtCallOnInit;
virtual bool CallOnInit() override
{
bool res = wxApp::CallOnInit();
if (*m_wxAppExtCallOnInit != NULL){
return m_wxAppExtCallOnInit(this);
}
else {
return res;
}
}
wxAppExtOnInitGuiFunc m_wxAppExtOnInitGui;
virtual bool OnInitGui() override
{
bool res = wxApp::OnInitGui();
if (*m_wxAppExtOnInitGui != NULL){
return m_wxAppExtOnInitGui(this);
}
else {
return res;
}
}
wxAppExtOnRunFunc m_wxAppExtOnRun;
virtual int OnRun() override
{
int res = wxApp::OnRun();
if (*m_wxAppExtOnRun != NULL){
return m_wxAppExtOnRun(this);
}
else {
return res;
}
}
wxAppExtProcessIdleFunc m_wxAppExtProcessIdle;
virtual bool ProcessIdle() override
{
bool res = wxApp::ProcessIdle();
if (*m_wxAppExtProcessIdle != NULL){
return m_wxAppExtProcessIdle(this);
}
else {
return res;
}
}
wxAppExtInitializeFunc m_wxAppExtInitialize;
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;
virtual void CleanUp() override
{
wxApp::CleanUp();
if (*m_wxAppExtCleanUp != NULL){
return m_wxAppExtCleanUp(this);
}
}
wxAppExtOSXCreateAppControllerFunc m_wxAppExtOSXCreateAppController;
virtual WX_NSObject OSXCreateAppController() override
{
WX_NSObject res = wxApp::OSXCreateAppController();
if (*m_wxAppExtOSXCreateAppController != NULL){
return m_wxAppExtOSXCreateAppController(this);
}
else {
return res;
}
}
wxAppExtMacHandleUnhandledEventFunc m_wxAppExtMacHandleUnhandledEvent;
virtual void MacHandleUnhandledEvent(WXEVENTREF ev) override
{
wxApp::MacHandleUnhandledEvent(ev);
if (*m_wxAppExtMacHandleUnhandledEvent != NULL){
return m_wxAppExtMacHandleUnhandledEvent(this, ev);
}
}
wxAppExtMacOpenFilesFunc m_wxAppExtMacOpenFiles;
virtual void MacOpenFiles(wxArrayString const& fileNames) override
{
wxApp::MacOpenFiles(fileNames);
if (*m_wxAppExtMacOpenFiles != NULL){
return m_wxAppExtMacOpenFiles(this, fileNames);
}
}
wxAppExtMacOpenFileFunc m_wxAppExtMacOpenFile;
virtual void MacOpenFile(wxString const& fileName) override
{
wxApp::MacOpenFile(fileName);
if (*m_wxAppExtMacOpenFile != NULL){
return m_wxAppExtMacOpenFile(this, fileName);
}
}
wxAppExtMacOpenURLFunc m_wxAppExtMacOpenURL;
virtual void MacOpenURL(wxString const& url) override
{
wxApp::MacOpenURL(url);
if (*m_wxAppExtMacOpenURL != NULL){
return m_wxAppExtMacOpenURL(this, url);
}
}
wxAppExtMacPrintFilesFunc m_wxAppExtMacPrintFiles;
virtual void MacPrintFiles(wxArrayString const& fileNames) override
{
wxApp::MacPrintFiles(fileNames);
if (*m_wxAppExtMacPrintFiles != NULL){
return m_wxAppExtMacPrintFiles(this, fileNames);
}
}
wxAppExtMacPrintFileFunc m_wxAppExtMacPrintFile;
virtual void MacPrintFile(wxString const& fileName) override
{
wxApp::MacPrintFile(fileName);
if (*m_wxAppExtMacPrintFile != NULL){
return m_wxAppExtMacPrintFile(this, fileName);
}
}
wxAppExtMacNewFileFunc m_wxAppExtMacNewFile;
virtual void MacNewFile() override
{
wxApp::MacNewFile();
if (*m_wxAppExtMacNewFile != NULL){
return m_wxAppExtMacNewFile(this);
}
}
wxAppExtMacReopenAppFunc m_wxAppExtMacReopenApp;
virtual void MacReopenApp() override
{
wxApp::MacReopenApp();
if (*m_wxAppExtMacReopenApp != NULL){
return m_wxAppExtMacReopenApp(this);
}
}
wxAppExtOSXIsGUIApplicationFunc m_wxAppExtOSXIsGUIApplication;
virtual bool OSXIsGUIApplication() override
{
bool res = wxApp::OSXIsGUIApplication();
if (*m_wxAppExtOSXIsGUIApplication != NULL){
return m_wxAppExtOSXIsGUIApplication(this);
}
else {
return res;
}
}
wxAppExtOSXOnWillFinishLaunchingFunc m_wxAppExtOSXOnWillFinishLaunching;
virtual void OSXOnWillFinishLaunching() override
{
wxApp::OSXOnWillFinishLaunching();
if (*m_wxAppExtOSXOnWillFinishLaunching != NULL){
return m_wxAppExtOSXOnWillFinishLaunching(this);
}
}
wxAppExtOSXOnDidFinishLaunchingFunc m_wxAppExtOSXOnDidFinishLaunching;
virtual void OSXOnDidFinishLaunching() override
{
wxApp::OSXOnDidFinishLaunching();
if (*m_wxAppExtOSXOnDidFinishLaunching != NULL){
return m_wxAppExtOSXOnDidFinishLaunching(this);
}
}
wxAppExtOSXOnShouldTerminateFunc m_wxAppExtOSXOnShouldTerminate;
virtual bool OSXOnShouldTerminate() override
{
bool res = wxApp::OSXOnShouldTerminate();
if (*m_wxAppExtOSXOnShouldTerminate != NULL){
return m_wxAppExtOSXOnShouldTerminate(this);
}
else {
return res;
}
}
wxAppExtOSXOnWillTerminateFunc m_wxAppExtOSXOnWillTerminate;
virtual void OSXOnWillTerminate() override
{
wxApp::OSXOnWillTerminate();
if (*m_wxAppExtOSXOnWillTerminate != NULL){
return m_wxAppExtOSXOnWillTerminate(this);
}
}
wxAppExt(wxAppExtGetClassInfoFunc a_GetClassInfo, wxAppExtWakeUpIdleFunc a_WakeUpIdle, wxAppExtSetPrintModeFunc a_SetPrintMode, wxAppExtGetPrintModeFunc a_GetPrintMode, 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, wxAppExtOSXIsGUIApplicationFunc a_OSXIsGUIApplication, wxAppExtOSXOnWillFinishLaunchingFunc a_OSXOnWillFinishLaunching, wxAppExtOSXOnDidFinishLaunchingFunc a_OSXOnDidFinishLaunching, wxAppExtOSXOnShouldTerminateFunc a_OSXOnShouldTerminate, wxAppExtOSXOnWillTerminateFunc a_OSXOnWillTerminate): wxApp() {
m_wxAppExtGetClassInfo = a_GetClassInfo;
m_wxAppExtWakeUpIdle = a_WakeUpIdle;
m_wxAppExtSetPrintMode = a_SetPrintMode;
m_wxAppExtGetPrintMode = a_GetPrintMode;
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_wxAppExtOSXIsGUIApplication = a_OSXIsGUIApplication;
m_wxAppExtOSXOnWillFinishLaunching = a_OSXOnWillFinishLaunching;
m_wxAppExtOSXOnDidFinishLaunching = a_OSXOnDidFinishLaunching;
m_wxAppExtOSXOnShouldTerminate = a_OSXOnShouldTerminate;
m_wxAppExtOSXOnWillTerminate = a_OSXOnWillTerminate;
}
};

43
swigtemplates/bitmap.i Normal file
View file

@ -0,0 +1,43 @@
%module bitmap
%include <common.i>
%{
#include <wx/vidmode.h>
#include "wxext/bitmap_ext.h"
%}
%ignore wxBitmapBaseExt;
%import "object.i"
%import "string.i"
#if defined(__WXMSW__)
#define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_BMP_RESOURCE
%include "wx/msw/bitmap.h"
#elif defined(__WXMOTIF__)
#define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_XPM
%include "wx/x11/bitmap.h"
#elif defined(__WXGTK20__)
#ifdef __WINDOWS__
#define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_BMP_RESOURCE
#else
#define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_XPM
#endif
%include "wx/gtk/bitmap.h"
#elif defined(__WXGTK__)
#define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_XPM
%include "wx/gtk1/bitmap.h"
#elif defined(__WXX11__)
#define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_XPM
%include "wx/x11/bitmap.h"
#elif defined(__WXDFB__)
#define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_BMP_RESOURCE
%include "wx/dfb/bitmap.h"
#elif defined(__WXMAC__)
#define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_PICT_RESOURCE
%include "wx/osx/bitmap.h"
#elif defined(__WXQT__)
#define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_XPM
%include "wx/qt/bitmap.h"
#endif
%include "wxext/bitmap_ext.h"

26
swigtemplates/buttonext.h
View file

@ -1,26 +0,0 @@
#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_SetDefault;
virtual wxWindow* SetDefault() override
{
wxWindow* res = wxButtonBase::SetDefault();
if (*m_SetDefault != NULL){
return m_SetDefault(this);
}
else {
return res;
}
}
wxButtonBaseExt(wxButtonBaseExtSetDefaultFunc a_SetDefault): wxButtonBase() {
m_SetDefault = a_SetDefault;
}
};

17
swigtemplates/frame_ext.h
View file

@ -1,17 +0,0 @@
#include<wx/wx.h>
typedef wxWindow* (* InitTopWindow)();
wxWindow* privInitTopWindow();
const char* wxBuildOptionsSignature();
class wxFrameExt : public wxFrame
{
private:
InitTopWindow initTopWindowFunc;
public:
wxFrameExt(): wxFrame() {};
void SetTopWindowInitFunc(InitTopWindow init);
virtual bool OnInit();
};

69
swigtemplates/icon.i Normal file
View file

@ -0,0 +1,69 @@
%module icon
%include <common.i>
%{
#include <wx/vidmode.h>
#include "wxext/icon_ext.h"
%}
%import "object.i"
%import "string.i"
%import "bitmap.i"
%import "wx/list.h"
%import "wx/variant.h"
%include "wx/icon.h"
%include "wx/iconbndl.h"
#if defined(__WXMSW__)
#define wxICON_DEFAULT_TYPE wxBITMAP_TYPE_ICO_RESOURCE
%include "wx/msw/icon.h"
#define wxICON_DIFFERENT_FROM_BITMAP
#elif defined(__WXMOTIF__)
#define wxICON_DEFAULT_TYPE wxBITMAP_TYPE_XPM
%include "wx/motif/icon.h"
#elif defined(__WXGTK20__)
#ifdef __WINDOWS__
#define wxICON_DEFAULT_TYPE wxBITMAP_TYPE_ICO_RESOURCE
#else
#define wxICON_DEFAULT_TYPE wxBITMAP_TYPE_XPM
#endif
%include "wx/generic/icon.h"
#elif defined(__WXGTK__)
#define wxICON_DEFAULT_TYPE wxBITMAP_TYPE_XPM
%include "wx/generic/icon.h"
#elif defined(__WXX11__)
#define wxICON_DEFAULT_TYPE wxBITMAP_TYPE_XPM
%include "wx/generic/icon.h"
#elif defined(__WXDFB__)
#define wxICON_DEFAULT_TYPE wxBITMAP_TYPE_XPM
%include "wx/generic/icon.h"
#elif defined(__WXMAC__)
#if wxOSX_USE_COCOA_OR_CARBON
#define wxICON_DEFAULT_TYPE wxBITMAP_TYPE_ICON_RESOURCE
%include "wx/generic/icon.h"
#else
// iOS and others
#define wxICON_DEFAULT_TYPE wxBITMAP_TYPE_PNG_RESOURCE
%include "wx/generic/icon.h"
#endif
#elif defined(__WXQT__)
#define wxICON_DEFAULT_TYPE wxBITMAP_TYPE_XPM
%include "wx/generic/icon.h"
#endif
#ifndef wxICON_DIFFERENT_FROM_BITMAP
#define wxICON_IS_BITMAP
#endif
//-----------------------------------------------------------------------------
// wxVariant support
//-----------------------------------------------------------------------------
#if wxUSE_VARIANT
%include "wx/variant.h"
DECLARE_VARIANT_OBJECT_EXPORTED(wxIcon,WXDLLIMPEXP_CORE)
#endif
%include "wxext/icon_ext.h"

18
swigtemplates/mainapp.h
View file

@ -1,18 +0,0 @@
#include<wx/wx.h>
/* typedef wxWindow* (* InitTopWindow)(); */
/* wxWindow* privInitTopWindow(); */
const char* wxBuildOptionsSignature();
const bool wxCheckBuildOptions(char * libName);
/* class MainApp : public wxApp */
/* { */
/* private: */
/* InitTopWindow initTopWindowFunc; */
/* public: */
/* MainApp(); */
/* void SetTopWindowInitFunc(InitTopWindow init); */
/* virtual bool OnInit(); */
/* }; */

1
swigtemplates/toplevel.i
View file

@ -8,6 +8,7 @@
%import "object.i"
%import "string.i"
%import "validate.i"
%import "icon.i"
%import "colour.i"
%import "window.i"

238
wxheaders/wx/bitmap.h
View file

@ -327,7 +327,243 @@ protected:
#include "wx/dfb/bitmap.h"
#elif defined(__WXMAC__)
#define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_PICT_RESOURCE
#include "wx/osx/bitmap.h"
#ifndef __CPPAST__
#include "wx/osx/bitmap.h"
#else
#ifndef _WX_BITMAP_H_
#define _WX_BITMAP_H_
#include "wx/palette.h"
// Bitmap
class wxBitmapRefData ;
// A mask is a bitmap used for drawing bitmaps
// Internally it is stored as a 8 bit deep memory chunk, 0 = black means the source will be drawn
// 255 = white means the source will not be drawn, no other values will be present
// 8 bit is chosen only for performance reasons, note also that this is the inverse value range
// from alpha, where 0 = invisible , 255 = fully drawn
class WXDLLIMPEXP_CORE wxMask: public wxMaskBase
{
wxDECLARE_DYNAMIC_CLASS(wxMask);
public:
wxMask();
// Copy constructor
wxMask(const wxMask& mask);
// Construct a mask from a bitmap and a colour indicating
// the transparent area
wxMask(const wxBitmap& bitmap, const wxColour& colour);
// Construct a mask from a mono bitmap (black meaning show pixels, white meaning transparent)
wxMask(const wxBitmap& bitmap);
virtual ~wxMask();
wxBitmap GetBitmap() const;
// Implementation below
void Init() ;
// a 8 bit depth mask
void* GetRawAccess() const;
int GetBytesPerRow() const;
int GetWidth() const;
int GetHeight() const;
// renders/updates native representation when necessary
void RealizeNative() ;
WXHBITMAP GetHBITMAP() const ;
// implementation helper only : construct a mask from a 8 bpp memory buffer
bool OSXCreate(const wxMemoryBuffer& buf, int width , int height , int bytesPerRow ) ;
protected:
// this function is called from Create() to free the existing mask data
virtual void FreeData() wxOVERRIDE;
// these functions must be overridden to implement the corresponding public
// Create() methods, they shouldn't call FreeData() as it's already called
// by the public wrappers
virtual bool InitFromColour(const wxBitmap& bitmap,
const wxColour& colour) wxOVERRIDE;
virtual bool InitFromMonoBitmap(const wxBitmap& bitmap) wxOVERRIDE;
private:
void DoCreateMaskBitmap(int width, int height, int bytesPerRow = -1);
wxCFRef<CGContextRef> m_maskBitmap ;
};
class WXDLLIMPEXP_CORE wxBitmap: public wxBitmapBase
{
wxDECLARE_DYNAMIC_CLASS(wxBitmap);
friend class WXDLLIMPEXP_FWD_CORE wxBitmapHandler;
public:
wxBitmap() {} // Platform-specific
// Initialize with raw data.
wxBitmap(const char bits[], int width, int height, int depth = 1);
// Initialize with XPM data
wxBitmap(const char* const* bits);
// Load a file or resource
wxBitmap(const wxString& name, wxBitmapType type = wxBITMAP_DEFAULT_TYPE);
// Constructor for generalised creation from data
wxBitmap(const void* data, wxBitmapType type, int width, int height, int depth = 1);
// creates an bitmap from the native image format
wxBitmap(CGImageRef image, double scale = 1.0);
wxBitmap(WXImage image);
wxBitmap(CGContextRef bitmapcontext);
// Create a bitmap compatible with the given DC
wxBitmap(int width, int height, const wxDC& dc);
// If depth is omitted, will create a bitmap compatible with the display
wxBitmap(int width, int height, int depth = -1) { (void)Create(width, height, depth); }
wxBitmap(const wxSize& sz, int depth = -1) { (void)Create(sz, depth); }
// Convert from wxImage:
wxBitmap(const wxImage& image, int depth = -1, double scale = 1.0);
wxBitmap(const wxImage& image, const wxDC& dc);
// Convert from wxIcon
wxBitmap(const wxIcon& icon) { CopyFromIcon(icon); }
#if wxOSX_USE_COCOA
// Convert from wxCursor
wxBitmap(const wxCursor &cursor);
#endif
virtual ~wxBitmap() {}
wxImage ConvertToImage() const wxOVERRIDE;
// get the given part of bitmap
wxBitmap GetSubBitmap( const wxRect& rect ) const wxOVERRIDE;
virtual bool Create(int width, int height, int depth = wxBITMAP_SCREEN_DEPTH) wxOVERRIDE;
virtual bool Create(const wxSize& sz, int depth = wxBITMAP_SCREEN_DEPTH) wxOVERRIDE
{ return Create(sz.GetWidth(), sz.GetHeight(), depth); }
virtual bool Create(const void* data, wxBitmapType type, int width, int height, int depth = 1);
bool Create( CGImageRef image, double scale = 1.0 );
bool Create( WXImage image );
bool Create( CGContextRef bitmapcontext);
// Create a bitmap compatible with the given DC, inheriting its magnification factor
bool Create(int width, int height, const wxDC& dc);
// virtual bool Create( WXHICON icon) ;
virtual bool LoadFile(const wxString& name, wxBitmapType type = wxBITMAP_DEFAULT_TYPE) wxOVERRIDE;
virtual bool SaveFile(const wxString& name, wxBitmapType type, const wxPalette *cmap = NULL) const wxOVERRIDE;
const wxBitmapRefData *GetBitmapData() const
{ return (const wxBitmapRefData *)m_refData; }
wxBitmapRefData *GetBitmapData()
{ return (wxBitmapRefData *)m_refData; }
int GetWidth() const wxOVERRIDE;
int GetHeight() const wxOVERRIDE;
int GetDepth() const wxOVERRIDE;
#if WXWIN_COMPATIBILITY_3_0
wxDEPRECATED_MSG("this value is determined during creation, this method could lead to inconsistencies")
void SetWidth(int width) wxOVERRIDE;
wxDEPRECATED_MSG("this value is determined during creation, this method could lead to inconsistencies")
void SetHeight(int height) wxOVERRIDE;
wxDEPRECATED_MSG("this value is determined during creation, this method could lead to inconsistencies")
void SetDepth(int depth) wxOVERRIDE;
#endif
#if wxUSE_PALETTE
wxPalette* GetPalette() const wxOVERRIDE;
void SetPalette(const wxPalette& palette) wxOVERRIDE;
#endif // wxUSE_PALETTE
wxMask *GetMask() const wxOVERRIDE;
void SetMask(wxMask *mask) wxOVERRIDE;
static void InitStandardHandlers();
// raw bitmap access support functions, for internal use only
void *GetRawData(wxPixelDataBase& data, int bpp);
void UngetRawData(wxPixelDataBase& data);
bool HasAlpha() const wxOVERRIDE;
bool UseAlpha(bool use = true) wxOVERRIDE;
// returns the 'native' implementation, a GWorldPtr for the content and one for the mask
WXHBITMAP GetHBITMAP( WXHBITMAP * mask = NULL ) const;
// returns a CGImageRef which must released after usage with CGImageRelease
CGImageRef CreateCGImage() const ;
// returns nil for invalid bitmap
WXImage OSXGetImage() const;
#if wxOSX_USE_COCOA
// returns an autoreleased version of the image
WX_NSImage GetNSImage() const
{ return OSXGetImage(); }
#endif
#if wxOSX_USE_IPHONE
// returns an autoreleased version of the image
WX_UIImage GetUIImage() const
{ return OSXGetImage(); }
#endif
#if WXWIN_COMPATIBILITY_3_0
#if wxOSX_USE_ICONREF
// returns a IconRef which must be retained before and released after usage
wxDEPRECATED_MSG("IconRefs are deprecated, this will be removed in the future")
IconRef GetIconRef() const;
// returns a IconRef which must be released after usage
wxDEPRECATED_MSG("IconRefs are deprecated, this will be removed in the future")
IconRef CreateIconRef() const;
#endif
// get read only access to the underlying buffer
wxDEPRECATED_MSG("use GetRawData for accessing the buffer")
const void *GetRawAccess() const;
// brackets to the underlying OS structure for read/write access
// makes sure that no cached images will be constructed until terminated
wxDEPRECATED_MSG("use GetRawData for accessing the buffer")
void *BeginRawAccess();
wxDEPRECATED_MSG("use GetRawData for accessing the buffer")
void EndRawAccess();
#endif
void SetScaleFactor(double scale) wxOVERRIDE;
double GetScaleFactor() const wxOVERRIDE;
void SetSelectedInto(wxDC *dc);
wxDC *GetSelectedInto() const;
protected:
virtual wxGDIRefData *CreateGDIRefData() const wxOVERRIDE;
virtual wxGDIRefData *CloneGDIRefData(const wxGDIRefData *data) const wxOVERRIDE;
virtual bool DoCreate(const wxSize& sz, double scale, int depth) wxOVERRIDE;
private:
void InitFromImage(const wxImage& image, int depth, double scale);
};
#endif // _WX_BITMAP_H_
#endif
#elif defined(__WXQT__)
#define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_XPM
#include "wx/qt/bitmap.h"

54
wxheaders/wx/icon.h
View file

@ -49,7 +49,59 @@
#elif defined(__WXMAC__)
#if wxOSX_USE_COCOA_OR_CARBON
#define wxICON_DEFAULT_TYPE wxBITMAP_TYPE_ICON_RESOURCE
#include "wx/generic/icon.h"
#ifndef __CPPAST__
#include "wx/generic/icon.h"
#else
#ifndef _WX_GENERIC_ICON_H_
#define _WX_GENERIC_ICON_H_
#include "wx/bitmap.h"
//-----------------------------------------------------------------------------
// wxIcon
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxIcon: public wxBitmap
{
public:
wxIcon();
wxIcon(const char* const* bits);
// For compatibility with wxMSW where desired size is sometimes required to
// distinguish between multiple icons in a resource.
wxIcon( const wxString& filename,
wxBitmapType type = wxICON_DEFAULT_TYPE,
int WXUNUSED(desiredWidth)=-1, int WXUNUSED(desiredHeight)=-1 ) :
wxBitmap(filename, type)
{
}
wxIcon(const wxIconLocation& loc)
: wxBitmap(loc.GetFileName(), wxBITMAP_TYPE_ANY)
{
}
bool LoadFile(const wxString& name, wxBitmapType flags,
int WXUNUSED(desiredWidth), int WXUNUSED(desiredHeight))
{ return wxBitmap::LoadFile(name, flags); }
// unhide the base class version
virtual bool LoadFile(const wxString& name,
wxBitmapType flags = wxICON_DEFAULT_TYPE) wxOVERRIDE
{ return wxBitmap::LoadFile(name, flags); }
// create from bitmap (which should have a mask unless it's monochrome):
// there shouldn't be any implicit bitmap -> icon conversion (i.e. no
// ctors, assignment operators...), but it's ok to have such function
void CopyFromBitmap(const wxBitmap& bmp);
private:
wxDECLARE_DYNAMIC_CLASS(wxIcon);
};
#endif // _WX_GENERIC_ICON_H_
#endif
#else
// iOS and others
#define wxICON_DEFAULT_TYPE wxBITMAP_TYPE_PNG_RESOURCE

865
wxheaders/wxext/bitmap_ext.h Normal file
View file

@ -0,0 +1,865 @@
#ifndef _WX_BITMAP_H_EXT_
#define _WX_BITMAP_H_EXT_
#include <wx/wx.h>
#include <wx/vidmode.h>
#include <stdexcept>
class wxMaskBaseExt;
typedef wxObjectRefData* (*wxMaskBaseExtCloneRefData__wxObjectRefDataCPFunc)(const wxMaskBaseExt* self, wxObjectRefData const* data, wxObjectRefData* res);
typedef wxObjectRefData* (*wxMaskBaseExtCreateRefDataFunc)(const wxMaskBaseExt* self, wxObjectRefData* res);
typedef void (*wxMaskBaseExtFreeDataFunc)(const wxMaskBaseExt* self);
typedef wxClassInfo* (*wxMaskBaseExtGetClassInfoFunc)(const wxMaskBaseExt* self, wxClassInfo* res);
typedef bool (*wxMaskBaseExtInitFromColour__wxBitmapCRwxColourCRFunc)(const wxMaskBaseExt* self, wxBitmap const& bitmap, wxColour const& colour);
typedef bool (*wxMaskBaseExtInitFromMonoBitmap__wxBitmapCRFunc)(const wxMaskBaseExt* self, wxBitmap const& bitmap);
class wxBitmapHandlerExt;
typedef wxObjectRefData* (*wxBitmapHandlerExtCloneRefData__wxObjectRefDataCPFunc)(const wxBitmapHandlerExt* self, wxObjectRefData const* data, wxObjectRefData* res);
typedef bool (*wxBitmapHandlerExtCreate__wxBitmapPvoidCPwxBitmapTypeintintintFunc)(const wxBitmapHandlerExt* self, wxBitmap* bitmap, void const* data, wxBitmapType type, int width, int height, int depth, bool res);
typedef wxObjectRefData* (*wxBitmapHandlerExtCreateRefDataFunc)(const wxBitmapHandlerExt* self, wxObjectRefData* res);
typedef wxClassInfo* (*wxBitmapHandlerExtGetClassInfoFunc)(const wxBitmapHandlerExt* self, wxClassInfo* res);
typedef bool (*wxBitmapHandlerExtLoadFile__wxBitmapPwxStringCRwxBitmapTypeintintFunc)(const wxBitmapHandlerExt* self, wxBitmap* bitmap, wxString const& name, wxBitmapType type, int desiredWidth, int desiredHeight, bool res);
typedef bool (*wxBitmapHandlerExtSaveFile__wxBitmapCPwxStringCRwxBitmapTypewxPaletteCPFunc)(const wxBitmapHandlerExt* self, wxBitmap const* bitmap, wxString const& name, wxBitmapType type, wxPalette const* palette, bool res);
class wxBitmapBaseExt;
typedef wxImage (*wxBitmapBaseExtConvertToImageFunc)(const wxBitmapBaseExt* self);
typedef bool (*wxBitmapBaseExtCreate__intintintFunc)(const wxBitmapBaseExt* self, int width, int height, int depth);
typedef bool (*wxBitmapBaseExtCreate__wxSizeCRintFunc)(const wxBitmapBaseExt* self, wxSize const& sz, int depth);
typedef bool (*wxBitmapBaseExtDoCreate__wxSizeCRdoubleintFunc)(const wxBitmapBaseExt* self, wxSize const& sz, double scale, int depth, bool res);
typedef wxClassInfo* (*wxBitmapBaseExtGetClassInfoFunc)(const wxBitmapBaseExt* self, wxClassInfo* res);
typedef int (*wxBitmapBaseExtGetDepthFunc)(const wxBitmapBaseExt* self);
typedef int (*wxBitmapBaseExtGetHeightFunc)(const wxBitmapBaseExt* self);
typedef wxMask* (*wxBitmapBaseExtGetMaskFunc)(const wxBitmapBaseExt* self);
typedef wxPalette* (*wxBitmapBaseExtGetPaletteFunc)(const wxBitmapBaseExt* self);
typedef double (*wxBitmapBaseExtGetScaleFactorFunc)(const wxBitmapBaseExt* self, double res);
typedef wxBitmap (*wxBitmapBaseExtGetSubBitmap__wxRectCRFunc)(const wxBitmapBaseExt* self, wxRect const& rect);
typedef int (*wxBitmapBaseExtGetWidthFunc)(const wxBitmapBaseExt* self);
typedef bool (*wxBitmapBaseExtHasAlphaFunc)(const wxBitmapBaseExt* self, bool res);
typedef bool (*wxBitmapBaseExtLoadFile__wxStringCRwxBitmapTypeFunc)(const wxBitmapBaseExt* self, wxString const& name, wxBitmapType type);
typedef wxColour (*wxBitmapBaseExtQuantizeColour__wxColourCRFunc)(const wxBitmapBaseExt* self, wxColour const& colour, wxColour res);
typedef bool (*wxBitmapBaseExtSaveFile__wxStringCRwxBitmapTypewxPaletteCPFunc)(const wxBitmapBaseExt* self, wxString const& name, wxBitmapType type, wxPalette const* palette);
typedef void (*wxBitmapBaseExtSetDepth__intFunc)(const wxBitmapBaseExt* self, int depth);
typedef void (*wxBitmapBaseExtSetHeight__intFunc)(const wxBitmapBaseExt* self, int height);
typedef void (*wxBitmapBaseExtSetMask__wxMaskPFunc)(const wxBitmapBaseExt* self, wxMask* mask);
typedef void (*wxBitmapBaseExtSetPalette__wxPaletteCRFunc)(const wxBitmapBaseExt* self, wxPalette const& palette);
typedef void (*wxBitmapBaseExtSetScaleFactor__doubleFunc)(const wxBitmapBaseExt* self, double scale);
typedef void (*wxBitmapBaseExtSetWidth__intFunc)(const wxBitmapBaseExt* self, int width);
typedef bool (*wxBitmapBaseExtUseAlpha__boolFunc)(const wxBitmapBaseExt* self, bool use, bool res);
class wxMaskExt;
typedef wxObjectRefData* (*wxMaskExtCloneRefData__wxObjectRefDataCPFunc)(const wxMaskExt* self, wxObjectRefData const* data, wxObjectRefData* res);
typedef wxObjectRefData* (*wxMaskExtCreateRefDataFunc)(const wxMaskExt* self, wxObjectRefData* res);
typedef void (*wxMaskExtFreeDataFunc)(const wxMaskExt* self);
typedef wxClassInfo* (*wxMaskExtGetClassInfoFunc)(const wxMaskExt* self, wxClassInfo* res);
typedef bool (*wxMaskExtInitFromColour__wxBitmapCRwxColourCRFunc)(const wxMaskExt* self, wxBitmap const& bitmap, wxColour const& colour);
typedef bool (*wxMaskExtInitFromMonoBitmap__wxBitmapCRFunc)(const wxMaskExt* self, wxBitmap const& bitmap);
class wxBitmapExt;
typedef wxGDIRefData* (*wxBitmapExtCloneGDIRefData__wxGDIRefDataCPFunc)(const wxBitmapExt* self, wxGDIRefData const* data, wxGDIRefData* res);
typedef wxImage (*wxBitmapExtConvertToImageFunc)(const wxBitmapExt* self);
typedef bool (*wxBitmapExtCreate__intintintFunc)(const wxBitmapExt* self, int width, int height, int depth);
typedef bool (*wxBitmapExtCreate__voidCPwxBitmapTypeintintintFunc)(const wxBitmapExt* self, void const* data, wxBitmapType type, int width, int height, int depth, bool res);
typedef bool (*wxBitmapExtCreate__wxSizeCRintFunc)(const wxBitmapExt* self, wxSize const& sz, int depth);
typedef wxGDIRefData* (*wxBitmapExtCreateGDIRefDataFunc)(const wxBitmapExt* self, wxGDIRefData* res);
typedef bool (*wxBitmapExtDoCreate__wxSizeCRdoubleintFunc)(const wxBitmapExt* self, wxSize const& sz, double scale, int depth, bool res);
typedef wxClassInfo* (*wxBitmapExtGetClassInfoFunc)(const wxBitmapExt* self, wxClassInfo* res);
typedef int (*wxBitmapExtGetDepthFunc)(const wxBitmapExt* self);
typedef int (*wxBitmapExtGetHeightFunc)(const wxBitmapExt* self);
typedef wxMask* (*wxBitmapExtGetMaskFunc)(const wxBitmapExt* self);
typedef wxPalette* (*wxBitmapExtGetPaletteFunc)(const wxBitmapExt* self);
typedef double (*wxBitmapExtGetScaleFactorFunc)(const wxBitmapExt* self, double res);
typedef wxBitmap (*wxBitmapExtGetSubBitmap__wxRectCRFunc)(const wxBitmapExt* self, wxRect const& rect);
typedef int (*wxBitmapExtGetWidthFunc)(const wxBitmapExt* self);
typedef bool (*wxBitmapExtHasAlphaFunc)(const wxBitmapExt* self, bool res);
typedef bool (*wxBitmapExtLoadFile__wxStringCRwxBitmapTypeFunc)(const wxBitmapExt* self, wxString const& name, wxBitmapType type);
typedef wxColour (*wxBitmapExtQuantizeColour__wxColourCRFunc)(const wxBitmapExt* self, wxColour const& colour, wxColour res);
typedef bool (*wxBitmapExtSaveFile__wxStringCRwxBitmapTypewxPaletteCPFunc)(const wxBitmapExt* self, wxString const& name, wxBitmapType type, wxPalette const* palette);
typedef void (*wxBitmapExtSetDepth__intFunc)(const wxBitmapExt* self, int depth);
typedef void (*wxBitmapExtSetHeight__intFunc)(const wxBitmapExt* self, int height);
typedef void (*wxBitmapExtSetMask__wxMaskPFunc)(const wxBitmapExt* self, wxMask* mask);
typedef void (*wxBitmapExtSetPalette__wxPaletteCRFunc)(const wxBitmapExt* self, wxPalette const& palette);
typedef void (*wxBitmapExtSetScaleFactor__doubleFunc)(const wxBitmapExt* self, double scale);
typedef void (*wxBitmapExtSetWidth__intFunc)(const wxBitmapExt* self, int width);
typedef bool (*wxBitmapExtUseAlpha__boolFunc)(const wxBitmapExt* self, bool use, bool res);
class wxMaskBaseExt: public wxMaskBase
{
public:
wxMaskBaseExtCloneRefData__wxObjectRefDataCPFunc m_wxMaskBaseExtCloneRefData__wxObjectRefDataCP = NULL;
virtual wxObjectRefData* CloneRefData(wxObjectRefData const* data) const override
{
wxObjectRefData* res = wxMaskBase::CloneRefData(data);
if (*m_wxMaskBaseExtCloneRefData__wxObjectRefDataCP != NULL){
return m_wxMaskBaseExtCloneRefData__wxObjectRefDataCP(this, data, res);
}
else {
return res;
}
}
wxMaskBaseExtCreateRefDataFunc m_wxMaskBaseExtCreateRefData = NULL;
virtual wxObjectRefData* CreateRefData() const override
{
wxObjectRefData* res = wxMaskBase::CreateRefData();
if (*m_wxMaskBaseExtCreateRefData != NULL){
return m_wxMaskBaseExtCreateRefData(this, res);
}
else {
return res;
}
}
wxMaskBaseExtFreeDataFunc m_wxMaskBaseExtFreeData = NULL;
virtual void FreeData() override
{
if (*m_wxMaskBaseExtFreeData != NULL){
return m_wxMaskBaseExtFreeData(this);
}
}
wxMaskBaseExtGetClassInfoFunc m_wxMaskBaseExtGetClassInfo = NULL;
virtual wxClassInfo* GetClassInfo() const override
{
wxClassInfo* res = wxMaskBase::GetClassInfo();
if (*m_wxMaskBaseExtGetClassInfo != NULL){
return m_wxMaskBaseExtGetClassInfo(this, res);
}
else {
return res;
}
}
wxMaskBaseExtInitFromColour__wxBitmapCRwxColourCRFunc m_wxMaskBaseExtInitFromColour__wxBitmapCRwxColourCR = NULL;
virtual bool InitFromColour(wxBitmap const& bitmap, wxColour const& colour) override
{
if (*m_wxMaskBaseExtInitFromColour__wxBitmapCRwxColourCR != NULL){
return m_wxMaskBaseExtInitFromColour__wxBitmapCRwxColourCR(this, bitmap, colour);
}
else {
return false;
}
}
wxMaskBaseExtInitFromMonoBitmap__wxBitmapCRFunc m_wxMaskBaseExtInitFromMonoBitmap__wxBitmapCR = NULL;
virtual bool InitFromMonoBitmap(wxBitmap const& bitmap) override
{
if (*m_wxMaskBaseExtInitFromMonoBitmap__wxBitmapCR != NULL){
return m_wxMaskBaseExtInitFromMonoBitmap__wxBitmapCR(this, bitmap);
}
else {
return false;
}
}
wxMaskBaseExt(wxMaskBaseExtCloneRefData__wxObjectRefDataCPFunc a_CloneRefData__wxObjectRefDataCP, wxMaskBaseExtCreateRefDataFunc a_CreateRefData, wxMaskBaseExtFreeDataFunc a_FreeData, wxMaskBaseExtGetClassInfoFunc a_GetClassInfo, wxMaskBaseExtInitFromColour__wxBitmapCRwxColourCRFunc a_InitFromColour__wxBitmapCRwxColourCR, wxMaskBaseExtInitFromMonoBitmap__wxBitmapCRFunc a_InitFromMonoBitmap__wxBitmapCR) {
m_wxMaskBaseExtCloneRefData__wxObjectRefDataCP = a_CloneRefData__wxObjectRefDataCP;
m_wxMaskBaseExtCreateRefData = a_CreateRefData;
m_wxMaskBaseExtFreeData = a_FreeData;
m_wxMaskBaseExtGetClassInfo = a_GetClassInfo;
m_wxMaskBaseExtInitFromColour__wxBitmapCRwxColourCR = a_InitFromColour__wxBitmapCRwxColourCR;
m_wxMaskBaseExtInitFromMonoBitmap__wxBitmapCR = a_InitFromMonoBitmap__wxBitmapCR;
}
};
class wxBitmapHandlerExt: public wxBitmapHandler
{
public:
wxBitmapHandlerExt(): wxBitmapHandler() { }
virtual ~wxBitmapHandlerExt() { }
wxBitmapHandlerExtCloneRefData__wxObjectRefDataCPFunc m_wxBitmapHandlerExtCloneRefData__wxObjectRefDataCP = NULL;
virtual wxObjectRefData* CloneRefData(wxObjectRefData const* data) const override
{
wxObjectRefData* res = wxBitmapHandler::CloneRefData(data);
if (*m_wxBitmapHandlerExtCloneRefData__wxObjectRefDataCP != NULL){
return m_wxBitmapHandlerExtCloneRefData__wxObjectRefDataCP(this, data, res);
}
else {
return res;
}
}
wxBitmapHandlerExtCreate__wxBitmapPvoidCPwxBitmapTypeintintintFunc m_wxBitmapHandlerExtCreate__wxBitmapPvoidCPwxBitmapTypeintintint = NULL;
virtual bool Create(wxBitmap* bitmap, void const* data, wxBitmapType type, int width, int height, int depth = 1) override
{
bool res = wxBitmapHandler::Create(bitmap, data, type, width, height, depth);
if (*m_wxBitmapHandlerExtCreate__wxBitmapPvoidCPwxBitmapTypeintintint != NULL){
return m_wxBitmapHandlerExtCreate__wxBitmapPvoidCPwxBitmapTypeintintint(this, bitmap, data, type, width, height, depth, res);
}
else {
return res;
}
}
wxBitmapHandlerExtCreateRefDataFunc m_wxBitmapHandlerExtCreateRefData = NULL;
virtual wxObjectRefData* CreateRefData() const override
{
wxObjectRefData* res = wxBitmapHandler::CreateRefData();
if (*m_wxBitmapHandlerExtCreateRefData != NULL){
return m_wxBitmapHandlerExtCreateRefData(this, res);
}
else {
return res;
}
}
wxBitmapHandlerExtGetClassInfoFunc m_wxBitmapHandlerExtGetClassInfo = NULL;
virtual wxClassInfo* GetClassInfo() const override
{
wxClassInfo* res = wxBitmapHandler::GetClassInfo();
if (*m_wxBitmapHandlerExtGetClassInfo != NULL){
return m_wxBitmapHandlerExtGetClassInfo(this, res);
}
else {
return res;
}
}
wxBitmapHandlerExtLoadFile__wxBitmapPwxStringCRwxBitmapTypeintintFunc m_wxBitmapHandlerExtLoadFile__wxBitmapPwxStringCRwxBitmapTypeintint = NULL;
virtual bool LoadFile(wxBitmap* bitmap, wxString const& name, wxBitmapType type, int desiredWidth, int desiredHeight) override
{
bool res = wxBitmapHandler::LoadFile(bitmap, name, type, desiredWidth, desiredHeight);
if (*m_wxBitmapHandlerExtLoadFile__wxBitmapPwxStringCRwxBitmapTypeintint != NULL){
return m_wxBitmapHandlerExtLoadFile__wxBitmapPwxStringCRwxBitmapTypeintint(this, bitmap, name, type, desiredWidth, desiredHeight, res);
}
else {
return res;
}
}
wxBitmapHandlerExtSaveFile__wxBitmapCPwxStringCRwxBitmapTypewxPaletteCPFunc m_wxBitmapHandlerExtSaveFile__wxBitmapCPwxStringCRwxBitmapTypewxPaletteCP = NULL;
virtual bool SaveFile(wxBitmap const* bitmap, wxString const& name, wxBitmapType type, wxPalette const* palette = __null) const override
{
bool res = wxBitmapHandler::SaveFile(bitmap, name, type, palette);
if (*m_wxBitmapHandlerExtSaveFile__wxBitmapCPwxStringCRwxBitmapTypewxPaletteCP != NULL){
return m_wxBitmapHandlerExtSaveFile__wxBitmapCPwxStringCRwxBitmapTypewxPaletteCP(this, bitmap, name, type, palette, res);
}
else {
return res;
}
}
wxBitmapHandlerExt(wxBitmapHandlerExtCloneRefData__wxObjectRefDataCPFunc a_CloneRefData__wxObjectRefDataCP, wxBitmapHandlerExtCreate__wxBitmapPvoidCPwxBitmapTypeintintintFunc a_Create__wxBitmapPvoidCPwxBitmapTypeintintint, wxBitmapHandlerExtCreateRefDataFunc a_CreateRefData, wxBitmapHandlerExtGetClassInfoFunc a_GetClassInfo, wxBitmapHandlerExtLoadFile__wxBitmapPwxStringCRwxBitmapTypeintintFunc a_LoadFile__wxBitmapPwxStringCRwxBitmapTypeintint, wxBitmapHandlerExtSaveFile__wxBitmapCPwxStringCRwxBitmapTypewxPaletteCPFunc a_SaveFile__wxBitmapCPwxStringCRwxBitmapTypewxPaletteCP): wxBitmapHandler() {
m_wxBitmapHandlerExtCloneRefData__wxObjectRefDataCP = a_CloneRefData__wxObjectRefDataCP;
m_wxBitmapHandlerExtCreate__wxBitmapPvoidCPwxBitmapTypeintintint = a_Create__wxBitmapPvoidCPwxBitmapTypeintintint;
m_wxBitmapHandlerExtCreateRefData = a_CreateRefData;
m_wxBitmapHandlerExtGetClassInfo = a_GetClassInfo;
m_wxBitmapHandlerExtLoadFile__wxBitmapPwxStringCRwxBitmapTypeintint = a_LoadFile__wxBitmapPwxStringCRwxBitmapTypeintint;
m_wxBitmapHandlerExtSaveFile__wxBitmapCPwxStringCRwxBitmapTypewxPaletteCP = a_SaveFile__wxBitmapCPwxStringCRwxBitmapTypewxPaletteCP;
}
};
class wxBitmapBaseExt: public wxBitmapBase
{
public:
wxBitmapBaseExtConvertToImageFunc m_wxBitmapBaseExtConvertToImage = NULL;
virtual wxImage ConvertToImage() const override
{
if (*m_wxBitmapBaseExtConvertToImage != NULL){
return m_wxBitmapBaseExtConvertToImage(this);
}
else {
throw std::runtime_error("ConvertToImage is not implemented.");
}
}
wxBitmapBaseExtCreate__intintintFunc m_wxBitmapBaseExtCreate__intintint = NULL;
virtual bool Create(int width, int height, int depth = (-1)) override
{
if (*m_wxBitmapBaseExtCreate__intintint != NULL){
return m_wxBitmapBaseExtCreate__intintint(this, width, height, depth);
}
else {
return false;
}
}
wxBitmapBaseExtCreate__wxSizeCRintFunc m_wxBitmapBaseExtCreate__wxSizeCRint = NULL;
virtual bool Create(wxSize const& sz, int depth = (-1)) override
{
if (*m_wxBitmapBaseExtCreate__wxSizeCRint != NULL){
return m_wxBitmapBaseExtCreate__wxSizeCRint(this, sz, depth);
}
else {
return false;
}
}
wxBitmapBaseExtDoCreate__wxSizeCRdoubleintFunc m_wxBitmapBaseExtDoCreate__wxSizeCRdoubleint = NULL;
virtual bool DoCreate(wxSize const& sz, double scale, int depth) override
{
bool res = wxBitmapBase::DoCreate(sz, scale, depth);
if (*m_wxBitmapBaseExtDoCreate__wxSizeCRdoubleint != NULL){
return m_wxBitmapBaseExtDoCreate__wxSizeCRdoubleint(this, sz, scale, depth, res);
}
else {
return res;
}
}
wxBitmapBaseExtGetClassInfoFunc m_wxBitmapBaseExtGetClassInfo = NULL;
virtual wxClassInfo* GetClassInfo() const override
{
wxClassInfo* res = wxBitmapBase::GetClassInfo();
if (*m_wxBitmapBaseExtGetClassInfo != NULL){
return m_wxBitmapBaseExtGetClassInfo(this, res);
}
else {
return res;
}
}
wxBitmapBaseExtGetDepthFunc m_wxBitmapBaseExtGetDepth = NULL;
virtual int GetDepth() const override
{
if (*m_wxBitmapBaseExtGetDepth != NULL){
return m_wxBitmapBaseExtGetDepth(this);
}
else {
return 0;
}
}
wxBitmapBaseExtGetHeightFunc m_wxBitmapBaseExtGetHeight = NULL;
virtual int GetHeight() const override
{
if (*m_wxBitmapBaseExtGetHeight != NULL){
return m_wxBitmapBaseExtGetHeight(this);
}
else {
return 0;
}
}
wxBitmapBaseExtGetMaskFunc m_wxBitmapBaseExtGetMask = NULL;
virtual wxMask* GetMask() const override
{
if (*m_wxBitmapBaseExtGetMask != NULL){
return m_wxBitmapBaseExtGetMask(this);
}
else {
return NULL;
}
}
wxBitmapBaseExtGetPaletteFunc m_wxBitmapBaseExtGetPalette = NULL;
virtual wxPalette* GetPalette() const override
{
if (*m_wxBitmapBaseExtGetPalette != NULL){
return m_wxBitmapBaseExtGetPalette(this);
}
else {
return NULL;
}
}
wxBitmapBaseExtGetScaleFactorFunc m_wxBitmapBaseExtGetScaleFactor = NULL;
virtual double GetScaleFactor() const override
{
double res = wxBitmapBase::GetScaleFactor();
if (*m_wxBitmapBaseExtGetScaleFactor != NULL){
return m_wxBitmapBaseExtGetScaleFactor(this, res);
}
else {
return res;
}
}
wxBitmapBaseExtGetSubBitmap__wxRectCRFunc m_wxBitmapBaseExtGetSubBitmap__wxRectCR = NULL;
virtual wxBitmap GetSubBitmap(wxRect const& rect) const override
{
if (*m_wxBitmapBaseExtGetSubBitmap__wxRectCR != NULL){
return m_wxBitmapBaseExtGetSubBitmap__wxRectCR(this, rect);
}
else {
throw std::runtime_error("GetSubBitmap is not implemented.");
}
}
wxBitmapBaseExtGetWidthFunc m_wxBitmapBaseExtGetWidth = NULL;
virtual int GetWidth() const override
{
if (*m_wxBitmapBaseExtGetWidth != NULL){
return m_wxBitmapBaseExtGetWidth(this);
}
else {
return 0;
}
}
wxBitmapBaseExtHasAlphaFunc m_wxBitmapBaseExtHasAlpha = NULL;
virtual bool HasAlpha() const override
{
bool res = wxBitmapBase::HasAlpha();
if (*m_wxBitmapBaseExtHasAlpha != NULL){
return m_wxBitmapBaseExtHasAlpha(this, res);
}
else {
return res;
}
}
wxBitmapBaseExtLoadFile__wxStringCRwxBitmapTypeFunc m_wxBitmapBaseExtLoadFile__wxStringCRwxBitmapType = NULL;
virtual bool LoadFile(wxString const& name, wxBitmapType type) override
{
if (*m_wxBitmapBaseExtLoadFile__wxStringCRwxBitmapType != NULL){
return m_wxBitmapBaseExtLoadFile__wxStringCRwxBitmapType(this, name, type);
}
else {
return false;
}
}
wxBitmapBaseExtQuantizeColour__wxColourCRFunc m_wxBitmapBaseExtQuantizeColour__wxColourCR = NULL;
virtual wxColour QuantizeColour(wxColour const& colour) const override
{
wxColour res = wxBitmapBase::QuantizeColour(colour);
if (*m_wxBitmapBaseExtQuantizeColour__wxColourCR != NULL){
return m_wxBitmapBaseExtQuantizeColour__wxColourCR(this, colour, res);
}
else {
return res;
}
}
wxBitmapBaseExtSaveFile__wxStringCRwxBitmapTypewxPaletteCPFunc m_wxBitmapBaseExtSaveFile__wxStringCRwxBitmapTypewxPaletteCP = NULL;
virtual bool SaveFile(wxString const& name, wxBitmapType type, wxPalette const* palette = __null) const override
{
if (*m_wxBitmapBaseExtSaveFile__wxStringCRwxBitmapTypewxPaletteCP != NULL){
return m_wxBitmapBaseExtSaveFile__wxStringCRwxBitmapTypewxPaletteCP(this, name, type, palette);
}
else {
return false;
}
}
wxBitmapBaseExtSetDepth__intFunc m_wxBitmapBaseExtSetDepth__int = NULL;
virtual void SetDepth(int depth) override
{
if (*m_wxBitmapBaseExtSetDepth__int != NULL){
return m_wxBitmapBaseExtSetDepth__int(this, depth);
}
}
wxBitmapBaseExtSetHeight__intFunc m_wxBitmapBaseExtSetHeight__int = NULL;
virtual void SetHeight(int height) override
{
if (*m_wxBitmapBaseExtSetHeight__int != NULL){
return m_wxBitmapBaseExtSetHeight__int(this, height);
}
}
wxBitmapBaseExtSetMask__wxMaskPFunc m_wxBitmapBaseExtSetMask__wxMaskP = NULL;
virtual void SetMask(wxMask* mask) override
{
if (*m_wxBitmapBaseExtSetMask__wxMaskP != NULL){
return m_wxBitmapBaseExtSetMask__wxMaskP(this, mask);
}
}
wxBitmapBaseExtSetPalette__wxPaletteCRFunc m_wxBitmapBaseExtSetPalette__wxPaletteCR = NULL;
virtual void SetPalette(wxPalette const& palette) override
{
if (*m_wxBitmapBaseExtSetPalette__wxPaletteCR != NULL){
return m_wxBitmapBaseExtSetPalette__wxPaletteCR(this, palette);
}
}
wxBitmapBaseExtSetScaleFactor__doubleFunc m_wxBitmapBaseExtSetScaleFactor__double = NULL;
virtual void SetScaleFactor(double scale) override
{
wxBitmapBase::SetScaleFactor(scale);
if (*m_wxBitmapBaseExtSetScaleFactor__double != NULL){
return m_wxBitmapBaseExtSetScaleFactor__double(this, scale);
}
}
wxBitmapBaseExtSetWidth__intFunc m_wxBitmapBaseExtSetWidth__int = NULL;
virtual void SetWidth(int width) override
{
if (*m_wxBitmapBaseExtSetWidth__int != NULL){
return m_wxBitmapBaseExtSetWidth__int(this, width);
}
}
wxBitmapBaseExtUseAlpha__boolFunc m_wxBitmapBaseExtUseAlpha__bool = NULL;
virtual bool UseAlpha(bool use = true) override
{
bool res = wxBitmapBase::UseAlpha(use);
if (*m_wxBitmapBaseExtUseAlpha__bool != NULL){
return m_wxBitmapBaseExtUseAlpha__bool(this, use, res);
}
else {
return res;
}
}
wxBitmapBaseExt(wxBitmapBaseExtConvertToImageFunc a_ConvertToImage, wxBitmapBaseExtCreate__intintintFunc a_Create__intintint, wxBitmapBaseExtCreate__wxSizeCRintFunc a_Create__wxSizeCRint, wxBitmapBaseExtDoCreate__wxSizeCRdoubleintFunc a_DoCreate__wxSizeCRdoubleint, wxBitmapBaseExtGetClassInfoFunc a_GetClassInfo, wxBitmapBaseExtGetDepthFunc a_GetDepth, wxBitmapBaseExtGetHeightFunc a_GetHeight, wxBitmapBaseExtGetMaskFunc a_GetMask, wxBitmapBaseExtGetPaletteFunc a_GetPalette, wxBitmapBaseExtGetScaleFactorFunc a_GetScaleFactor, wxBitmapBaseExtGetSubBitmap__wxRectCRFunc a_GetSubBitmap__wxRectCR, wxBitmapBaseExtGetWidthFunc a_GetWidth, wxBitmapBaseExtHasAlphaFunc a_HasAlpha, wxBitmapBaseExtLoadFile__wxStringCRwxBitmapTypeFunc a_LoadFile__wxStringCRwxBitmapType, wxBitmapBaseExtQuantizeColour__wxColourCRFunc a_QuantizeColour__wxColourCR, wxBitmapBaseExtSaveFile__wxStringCRwxBitmapTypewxPaletteCPFunc a_SaveFile__wxStringCRwxBitmapTypewxPaletteCP, wxBitmapBaseExtSetDepth__intFunc a_SetDepth__int, wxBitmapBaseExtSetHeight__intFunc a_SetHeight__int, wxBitmapBaseExtSetMask__wxMaskPFunc a_SetMask__wxMaskP, wxBitmapBaseExtSetPalette__wxPaletteCRFunc a_SetPalette__wxPaletteCR, wxBitmapBaseExtSetScaleFactor__doubleFunc a_SetScaleFactor__double, wxBitmapBaseExtSetWidth__intFunc a_SetWidth__int, wxBitmapBaseExtUseAlpha__boolFunc a_UseAlpha__bool) {
m_wxBitmapBaseExtConvertToImage = a_ConvertToImage;
m_wxBitmapBaseExtCreate__intintint = a_Create__intintint;
m_wxBitmapBaseExtCreate__wxSizeCRint = a_Create__wxSizeCRint;
m_wxBitmapBaseExtDoCreate__wxSizeCRdoubleint = a_DoCreate__wxSizeCRdoubleint;
m_wxBitmapBaseExtGetClassInfo = a_GetClassInfo;
m_wxBitmapBaseExtGetDepth = a_GetDepth;
m_wxBitmapBaseExtGetHeight = a_GetHeight;
m_wxBitmapBaseExtGetMask = a_GetMask;
m_wxBitmapBaseExtGetPalette = a_GetPalette;
m_wxBitmapBaseExtGetScaleFactor = a_GetScaleFactor;
m_wxBitmapBaseExtGetSubBitmap__wxRectCR = a_GetSubBitmap__wxRectCR;
m_wxBitmapBaseExtGetWidth = a_GetWidth;
m_wxBitmapBaseExtHasAlpha = a_HasAlpha;
m_wxBitmapBaseExtLoadFile__wxStringCRwxBitmapType = a_LoadFile__wxStringCRwxBitmapType;
m_wxBitmapBaseExtQuantizeColour__wxColourCR = a_QuantizeColour__wxColourCR;
m_wxBitmapBaseExtSaveFile__wxStringCRwxBitmapTypewxPaletteCP = a_SaveFile__wxStringCRwxBitmapTypewxPaletteCP;
m_wxBitmapBaseExtSetDepth__int = a_SetDepth__int;
m_wxBitmapBaseExtSetHeight__int = a_SetHeight__int;
m_wxBitmapBaseExtSetMask__wxMaskP = a_SetMask__wxMaskP;
m_wxBitmapBaseExtSetPalette__wxPaletteCR = a_SetPalette__wxPaletteCR;
m_wxBitmapBaseExtSetScaleFactor__double = a_SetScaleFactor__double;
m_wxBitmapBaseExtSetWidth__int = a_SetWidth__int;
m_wxBitmapBaseExtUseAlpha__bool = a_UseAlpha__bool;
}
};
class wxMaskExt: public wxMask
{
public:
wxMaskExt(): wxMask() { }
wxMaskExt(wxMask const& mask): wxMask(mask) { }
wxMaskExt(wxBitmap const& bitmap, wxColour const& colour): wxMask(bitmap, colour) { }
wxMaskExt(wxBitmap const& bitmap): wxMask(bitmap) { }
virtual ~wxMaskExt() override { }
wxMaskExtCloneRefData__wxObjectRefDataCPFunc m_wxMaskExtCloneRefData__wxObjectRefDataCP = NULL;
virtual wxObjectRefData* CloneRefData(wxObjectRefData const* data) const override
{
wxObjectRefData* res = wxMask::CloneRefData(data);
if (*m_wxMaskExtCloneRefData__wxObjectRefDataCP != NULL){
return m_wxMaskExtCloneRefData__wxObjectRefDataCP(this, data, res);
}
else {
return res;
}
}
wxMaskExtCreateRefDataFunc m_wxMaskExtCreateRefData = NULL;
virtual wxObjectRefData* CreateRefData() const override
{
wxObjectRefData* res = wxMask::CreateRefData();
if (*m_wxMaskExtCreateRefData != NULL){
return m_wxMaskExtCreateRefData(this, res);
}
else {
return res;
}
}
wxMaskExtFreeDataFunc m_wxMaskExtFreeData = NULL;
virtual void FreeData() override
{
if (*m_wxMaskExtFreeData != NULL){
return m_wxMaskExtFreeData(this);
}
}
wxMaskExtGetClassInfoFunc m_wxMaskExtGetClassInfo = NULL;
virtual wxClassInfo* GetClassInfo() const override
{
wxClassInfo* res = wxMask::GetClassInfo();
if (*m_wxMaskExtGetClassInfo != NULL){
return m_wxMaskExtGetClassInfo(this, res);
}
else {
return res;
}
}
wxMaskExtInitFromColour__wxBitmapCRwxColourCRFunc m_wxMaskExtInitFromColour__wxBitmapCRwxColourCR = NULL;
virtual bool InitFromColour(wxBitmap const& bitmap, wxColour const& colour) override
{
if (*m_wxMaskExtInitFromColour__wxBitmapCRwxColourCR != NULL){
return m_wxMaskExtInitFromColour__wxBitmapCRwxColourCR(this, bitmap, colour);
}
else {
return false;
}
}
wxMaskExtInitFromMonoBitmap__wxBitmapCRFunc m_wxMaskExtInitFromMonoBitmap__wxBitmapCR = NULL;
virtual bool InitFromMonoBitmap(wxBitmap const& bitmap) override
{
if (*m_wxMaskExtInitFromMonoBitmap__wxBitmapCR != NULL){
return m_wxMaskExtInitFromMonoBitmap__wxBitmapCR(this, bitmap);
}
else {
return false;
}
}
wxMaskExt(wxMaskExtCloneRefData__wxObjectRefDataCPFunc a_CloneRefData__wxObjectRefDataCP, wxMaskExtCreateRefDataFunc a_CreateRefData, wxMaskExtFreeDataFunc a_FreeData, wxMaskExtGetClassInfoFunc a_GetClassInfo, wxMaskExtInitFromColour__wxBitmapCRwxColourCRFunc a_InitFromColour__wxBitmapCRwxColourCR, wxMaskExtInitFromMonoBitmap__wxBitmapCRFunc a_InitFromMonoBitmap__wxBitmapCR): wxMask() {
m_wxMaskExtCloneRefData__wxObjectRefDataCP = a_CloneRefData__wxObjectRefDataCP;
m_wxMaskExtCreateRefData = a_CreateRefData;
m_wxMaskExtFreeData = a_FreeData;
m_wxMaskExtGetClassInfo = a_GetClassInfo;
m_wxMaskExtInitFromColour__wxBitmapCRwxColourCR = a_InitFromColour__wxBitmapCRwxColourCR;
m_wxMaskExtInitFromMonoBitmap__wxBitmapCR = a_InitFromMonoBitmap__wxBitmapCR;
}
};
class wxBitmapExt: public wxBitmap
{
public:
wxBitmapExt(): wxBitmap() { }
wxBitmapExt(char const bits[], int width, int height, int depth = 1): wxBitmap(bits, width, height, depth) { }
wxBitmapExt(char const* const* bits): wxBitmap(bits) { }
wxBitmapExt(wxString const& name, wxBitmapType type = wxBITMAP_TYPE_PICT_RESOURCE): wxBitmap(name, type) { }
wxBitmapExt(void const* data, wxBitmapType type, int width, int height, int depth = 1): wxBitmap(data, type, width, height, depth) { }
wxBitmapExt(CGImageRef image, double scale = 1.0): wxBitmap(image, scale) { }
wxBitmapExt(WXImage image): wxBitmap(image) { }
wxBitmapExt(CGContextRef bitmapcontext): wxBitmap(bitmapcontext) { }
wxBitmapExt(int width, int height, wxDC const& dc): wxBitmap(width, height, dc) { }
wxBitmapExt(int width, int height, int depth = -1): wxBitmap(width, height, depth) { }
wxBitmapExt(wxSize const& sz, int depth = -1): wxBitmap(sz, depth) { }
wxBitmapExt(wxImage const& image, int depth = -1, double scale = 1.0): wxBitmap(image, depth, scale) { }
wxBitmapExt(wxImage const& image, wxDC const& dc): wxBitmap(image, dc) { }
wxBitmapExt(wxIcon const& icon): wxBitmap(icon) { }
wxBitmapExt(wxCursor const& cursor): wxBitmap(cursor) { }
virtual ~wxBitmapExt() { }
wxBitmapExtCloneGDIRefData__wxGDIRefDataCPFunc m_wxBitmapExtCloneGDIRefData__wxGDIRefDataCP = NULL;
virtual wxGDIRefData* CloneGDIRefData(wxGDIRefData const* data) const override
{
wxGDIRefData* res = wxBitmap::CloneGDIRefData(data);
if (*m_wxBitmapExtCloneGDIRefData__wxGDIRefDataCP != NULL){
return m_wxBitmapExtCloneGDIRefData__wxGDIRefDataCP(this, data, res);
}
else {
return res;
}
}
wxBitmapExtConvertToImageFunc m_wxBitmapExtConvertToImage = NULL;
virtual wxImage ConvertToImage() const override
{
if (*m_wxBitmapExtConvertToImage != NULL){
return m_wxBitmapExtConvertToImage(this);
}
else {
throw std::runtime_error("ConvertToImage is not implemented.");
}
}
wxBitmapExtCreate__intintintFunc m_wxBitmapExtCreate__intintint = NULL;
virtual bool Create(int width, int height, int depth = (-1)) override
{
if (*m_wxBitmapExtCreate__intintint != NULL){
return m_wxBitmapExtCreate__intintint(this, width, height, depth);
}
else {
return false;
}
}
wxBitmapExtCreate__voidCPwxBitmapTypeintintintFunc m_wxBitmapExtCreate__voidCPwxBitmapTypeintintint = NULL;
virtual bool Create(void const* data, wxBitmapType type, int width, int height, int depth = 1) override
{
bool res = wxBitmap::Create(data, type, width, height, depth);
if (*m_wxBitmapExtCreate__voidCPwxBitmapTypeintintint != NULL){
return m_wxBitmapExtCreate__voidCPwxBitmapTypeintintint(this, data, type, width, height, depth, res);
}
else {
return res;
}
}
wxBitmapExtCreate__wxSizeCRintFunc m_wxBitmapExtCreate__wxSizeCRint = NULL;
virtual bool Create(wxSize const& sz, int depth = (-1)) override
{
if (*m_wxBitmapExtCreate__wxSizeCRint != NULL){
return m_wxBitmapExtCreate__wxSizeCRint(this, sz, depth);
}
else {
return false;
}
}
wxBitmapExtCreateGDIRefDataFunc m_wxBitmapExtCreateGDIRefData = NULL;
virtual wxGDIRefData* CreateGDIRefData() const override
{
wxGDIRefData* res = wxBitmap::CreateGDIRefData();
if (*m_wxBitmapExtCreateGDIRefData != NULL){
return m_wxBitmapExtCreateGDIRefData(this, res);
}
else {
return res;
}
}
wxBitmapExtDoCreate__wxSizeCRdoubleintFunc m_wxBitmapExtDoCreate__wxSizeCRdoubleint = NULL;
virtual bool DoCreate(wxSize const& sz, double scale, int depth) override
{
bool res = wxBitmap::DoCreate(sz, scale, depth);
if (*m_wxBitmapExtDoCreate__wxSizeCRdoubleint != NULL){
return m_wxBitmapExtDoCreate__wxSizeCRdoubleint(this, sz, scale, depth, res);
}
else {
return res;
}
}
wxBitmapExtGetClassInfoFunc m_wxBitmapExtGetClassInfo = NULL;
virtual wxClassInfo* GetClassInfo() const override
{
wxClassInfo* res = wxBitmap::GetClassInfo();
if (*m_wxBitmapExtGetClassInfo != NULL){
return m_wxBitmapExtGetClassInfo(this, res);
}
else {
return res;
}
}
wxBitmapExtGetDepthFunc m_wxBitmapExtGetDepth = NULL;
virtual int GetDepth() const override
{
if (*m_wxBitmapExtGetDepth != NULL){
return m_wxBitmapExtGetDepth(this);
}
else {
return 0;
}
}
wxBitmapExtGetHeightFunc m_wxBitmapExtGetHeight = NULL;
virtual int GetHeight() const override
{
if (*m_wxBitmapExtGetHeight != NULL){
return m_wxBitmapExtGetHeight(this);
}
else {
return 0;
}
}
wxBitmapExtGetMaskFunc m_wxBitmapExtGetMask = NULL;
virtual wxMask* GetMask() const override
{
if (*m_wxBitmapExtGetMask != NULL){
return m_wxBitmapExtGetMask(this);
}
else {
return NULL;
}
}
wxBitmapExtGetPaletteFunc m_wxBitmapExtGetPalette = NULL;
virtual wxPalette* GetPalette() const override
{
if (*m_wxBitmapExtGetPalette != NULL){
return m_wxBitmapExtGetPalette(this);
}
else {
return NULL;
}
}
wxBitmapExtGetScaleFactorFunc m_wxBitmapExtGetScaleFactor = NULL;
virtual double GetScaleFactor() const override
{
double res = wxBitmap::GetScaleFactor();
if (*m_wxBitmapExtGetScaleFactor != NULL){
return m_wxBitmapExtGetScaleFactor(this, res);
}
else {
return res;
}
}
wxBitmapExtGetSubBitmap__wxRectCRFunc m_wxBitmapExtGetSubBitmap__wxRectCR = NULL;
virtual wxBitmap GetSubBitmap(wxRect const& rect) const override
{
if (*m_wxBitmapExtGetSubBitmap__wxRectCR != NULL){
return m_wxBitmapExtGetSubBitmap__wxRectCR(this, rect);
}
else {
throw std::runtime_error("GetSubBitmap is not implemented.");
}
}
wxBitmapExtGetWidthFunc m_wxBitmapExtGetWidth = NULL;
virtual int GetWidth() const override
{
if (*m_wxBitmapExtGetWidth != NULL){
return m_wxBitmapExtGetWidth(this);
}
else {
return 0;
}
}
wxBitmapExtHasAlphaFunc m_wxBitmapExtHasAlpha = NULL;
virtual bool HasAlpha() const override
{
bool res = wxBitmap::HasAlpha();
if (*m_wxBitmapExtHasAlpha != NULL){
return m_wxBitmapExtHasAlpha(this, res);
}
else {
return res;
}
}
wxBitmapExtLoadFile__wxStringCRwxBitmapTypeFunc m_wxBitmapExtLoadFile__wxStringCRwxBitmapType = NULL;
virtual bool LoadFile(wxString const& name, wxBitmapType type) override
{
if (*m_wxBitmapExtLoadFile__wxStringCRwxBitmapType != NULL){
return m_wxBitmapExtLoadFile__wxStringCRwxBitmapType(this, name, type);
}
else {
return false;
}
}
wxBitmapExtQuantizeColour__wxColourCRFunc m_wxBitmapExtQuantizeColour__wxColourCR = NULL;
virtual wxColour QuantizeColour(wxColour const& colour) const override
{
wxColour res = wxBitmap::QuantizeColour(colour);
if (*m_wxBitmapExtQuantizeColour__wxColourCR != NULL){
return m_wxBitmapExtQuantizeColour__wxColourCR(this, colour, res);
}
else {
return res;
}
}
wxBitmapExtSaveFile__wxStringCRwxBitmapTypewxPaletteCPFunc m_wxBitmapExtSaveFile__wxStringCRwxBitmapTypewxPaletteCP = NULL;
virtual bool SaveFile(wxString const& name, wxBitmapType type, wxPalette const* palette = __null) const override
{
if (*m_wxBitmapExtSaveFile__wxStringCRwxBitmapTypewxPaletteCP != NULL){
return m_wxBitmapExtSaveFile__wxStringCRwxBitmapTypewxPaletteCP(this, name, type, palette);
}
else {
return false;
}
}
wxBitmapExtSetDepth__intFunc m_wxBitmapExtSetDepth__int = NULL;
virtual void SetDepth(int depth) override
{
if (*m_wxBitmapExtSetDepth__int != NULL){
return m_wxBitmapExtSetDepth__int(this, depth);
}
}
wxBitmapExtSetHeight__intFunc m_wxBitmapExtSetHeight__int = NULL;
virtual void SetHeight(int height) override
{
if (*m_wxBitmapExtSetHeight__int != NULL){
return m_wxBitmapExtSetHeight__int(this, height);
}
}
wxBitmapExtSetMask__wxMaskPFunc m_wxBitmapExtSetMask__wxMaskP = NULL;
virtual void SetMask(wxMask* mask) override
{
if (*m_wxBitmapExtSetMask__wxMaskP != NULL){
return m_wxBitmapExtSetMask__wxMaskP(this, mask);
}
}
wxBitmapExtSetPalette__wxPaletteCRFunc m_wxBitmapExtSetPalette__wxPaletteCR = NULL;
virtual void SetPalette(wxPalette const& palette) override
{
if (*m_wxBitmapExtSetPalette__wxPaletteCR != NULL){
return m_wxBitmapExtSetPalette__wxPaletteCR(this, palette);
}
}
wxBitmapExtSetScaleFactor__doubleFunc m_wxBitmapExtSetScaleFactor__double = NULL;
virtual void SetScaleFactor(double scale) override
{
wxBitmap::SetScaleFactor(scale);
if (*m_wxBitmapExtSetScaleFactor__double != NULL){
return m_wxBitmapExtSetScaleFactor__double(this, scale);
}
}
wxBitmapExtSetWidth__intFunc m_wxBitmapExtSetWidth__int = NULL;
virtual void SetWidth(int width) override
{
if (*m_wxBitmapExtSetWidth__int != NULL){
return m_wxBitmapExtSetWidth__int(this, width);
}
}
wxBitmapExtUseAlpha__boolFunc m_wxBitmapExtUseAlpha__bool = NULL;
virtual bool UseAlpha(bool use = true) override
{
bool res = wxBitmap::UseAlpha(use);
if (*m_wxBitmapExtUseAlpha__bool != NULL){
return m_wxBitmapExtUseAlpha__bool(this, use, res);
}
else {
return res;
}
}
wxBitmapExt(wxBitmapExtCloneGDIRefData__wxGDIRefDataCPFunc a_CloneGDIRefData__wxGDIRefDataCP, wxBitmapExtConvertToImageFunc a_ConvertToImage, wxBitmapExtCreate__intintintFunc a_Create__intintint, wxBitmapExtCreate__voidCPwxBitmapTypeintintintFunc a_Create__voidCPwxBitmapTypeintintint, wxBitmapExtCreate__wxSizeCRintFunc a_Create__wxSizeCRint, wxBitmapExtCreateGDIRefDataFunc a_CreateGDIRefData, wxBitmapExtDoCreate__wxSizeCRdoubleintFunc a_DoCreate__wxSizeCRdoubleint, wxBitmapExtGetClassInfoFunc a_GetClassInfo, wxBitmapExtGetDepthFunc a_GetDepth, wxBitmapExtGetHeightFunc a_GetHeight, wxBitmapExtGetMaskFunc a_GetMask, wxBitmapExtGetPaletteFunc a_GetPalette, wxBitmapExtGetScaleFactorFunc a_GetScaleFactor, wxBitmapExtGetSubBitmap__wxRectCRFunc a_GetSubBitmap__wxRectCR, wxBitmapExtGetWidthFunc a_GetWidth, wxBitmapExtHasAlphaFunc a_HasAlpha, wxBitmapExtLoadFile__wxStringCRwxBitmapTypeFunc a_LoadFile__wxStringCRwxBitmapType, wxBitmapExtQuantizeColour__wxColourCRFunc a_QuantizeColour__wxColourCR, wxBitmapExtSaveFile__wxStringCRwxBitmapTypewxPaletteCPFunc a_SaveFile__wxStringCRwxBitmapTypewxPaletteCP, wxBitmapExtSetDepth__intFunc a_SetDepth__int, wxBitmapExtSetHeight__intFunc a_SetHeight__int, wxBitmapExtSetMask__wxMaskPFunc a_SetMask__wxMaskP, wxBitmapExtSetPalette__wxPaletteCRFunc a_SetPalette__wxPaletteCR, wxBitmapExtSetScaleFactor__doubleFunc a_SetScaleFactor__double, wxBitmapExtSetWidth__intFunc a_SetWidth__int, wxBitmapExtUseAlpha__boolFunc a_UseAlpha__bool): wxBitmap() {
m_wxBitmapExtCloneGDIRefData__wxGDIRefDataCP = a_CloneGDIRefData__wxGDIRefDataCP;
m_wxBitmapExtConvertToImage = a_ConvertToImage;
m_wxBitmapExtCreate__intintint = a_Create__intintint;
m_wxBitmapExtCreate__voidCPwxBitmapTypeintintint = a_Create__voidCPwxBitmapTypeintintint;
m_wxBitmapExtCreate__wxSizeCRint = a_Create__wxSizeCRint;
m_wxBitmapExtCreateGDIRefData = a_CreateGDIRefData;
m_wxBitmapExtDoCreate__wxSizeCRdoubleint = a_DoCreate__wxSizeCRdoubleint;
m_wxBitmapExtGetClassInfo = a_GetClassInfo;
m_wxBitmapExtGetDepth = a_GetDepth;
m_wxBitmapExtGetHeight = a_GetHeight;
m_wxBitmapExtGetMask = a_GetMask;
m_wxBitmapExtGetPalette = a_GetPalette;
m_wxBitmapExtGetScaleFactor = a_GetScaleFactor;
m_wxBitmapExtGetSubBitmap__wxRectCR = a_GetSubBitmap__wxRectCR;
m_wxBitmapExtGetWidth = a_GetWidth;
m_wxBitmapExtHasAlpha = a_HasAlpha;
m_wxBitmapExtLoadFile__wxStringCRwxBitmapType = a_LoadFile__wxStringCRwxBitmapType;
m_wxBitmapExtQuantizeColour__wxColourCR = a_QuantizeColour__wxColourCR;
m_wxBitmapExtSaveFile__wxStringCRwxBitmapTypewxPaletteCP = a_SaveFile__wxStringCRwxBitmapTypewxPaletteCP;
m_wxBitmapExtSetDepth__int = a_SetDepth__int;
m_wxBitmapExtSetHeight__int = a_SetHeight__int;
m_wxBitmapExtSetMask__wxMaskP = a_SetMask__wxMaskP;
m_wxBitmapExtSetPalette__wxPaletteCR = a_SetPalette__wxPaletteCR;
m_wxBitmapExtSetScaleFactor__double = a_SetScaleFactor__double;
m_wxBitmapExtSetWidth__int = a_SetWidth__int;
m_wxBitmapExtUseAlpha__bool = a_UseAlpha__bool;
}
};
#endif

343
wxheaders/wxext/icon_ext.h Normal file
View file

@ -0,0 +1,343 @@
#ifndef _WX_ICON_H_EXT_
#define _WX_ICON_H_EXT_
#include <wx/wx.h>
#include <wx/vidmode.h>
#include <stdexcept>
class wxIconExt;
typedef wxGDIRefData* (*wxIconExtCloneGDIRefData__wxGDIRefDataCPFunc)(const wxIconExt* self, wxGDIRefData const* data, wxGDIRefData* res);
typedef wxImage (*wxIconExtConvertToImageFunc)(const wxIconExt* self, wxImage res);
typedef bool (*wxIconExtCreate__intintintFunc)(const wxIconExt* self, int width, int height, int depth, bool res);
typedef bool (*wxIconExtCreate__voidCPwxBitmapTypeintintintFunc)(const wxIconExt* self, void const* data, wxBitmapType type, int width, int height, int depth, bool res);
typedef bool (*wxIconExtCreate__wxSizeCRintFunc)(const wxIconExt* self, wxSize const& sz, int depth, bool res);
typedef wxGDIRefData* (*wxIconExtCreateGDIRefDataFunc)(const wxIconExt* self, wxGDIRefData* res);
typedef bool (*wxIconExtDoCreate__wxSizeCRdoubleintFunc)(const wxIconExt* self, wxSize const& sz, double scale, int depth, bool res);
typedef wxClassInfo* (*wxIconExtGetClassInfoFunc)(const wxIconExt* self, wxClassInfo* res);
typedef int (*wxIconExtGetDepthFunc)(const wxIconExt* self, int res);
typedef int (*wxIconExtGetHeightFunc)(const wxIconExt* self, int res);
typedef wxMask* (*wxIconExtGetMaskFunc)(const wxIconExt* self, wxMask* res);
typedef wxPalette* (*wxIconExtGetPaletteFunc)(const wxIconExt* self, wxPalette* res);
typedef double (*wxIconExtGetScaleFactorFunc)(const wxIconExt* self, double res);
typedef wxBitmap (*wxIconExtGetSubBitmap__wxRectCRFunc)(const wxIconExt* self, wxRect const& rect, wxBitmap res);
typedef int (*wxIconExtGetWidthFunc)(const wxIconExt* self, int res);
typedef bool (*wxIconExtHasAlphaFunc)(const wxIconExt* self, bool res);
typedef bool (*wxIconExtLoadFile__wxStringCRwxBitmapTypeFunc)(const wxIconExt* self, wxString const& name, wxBitmapType type, bool res);
typedef wxColour (*wxIconExtQuantizeColour__wxColourCRFunc)(const wxIconExt* self, wxColour const& colour, wxColour res);
typedef bool (*wxIconExtSaveFile__wxStringCRwxBitmapTypewxPaletteCPFunc)(const wxIconExt* self, wxString const& name, wxBitmapType type, wxPalette const* cmap, bool res);
typedef void (*wxIconExtSetDepth__intFunc)(const wxIconExt* self, int depth);
typedef void (*wxIconExtSetHeight__intFunc)(const wxIconExt* self, int height);
typedef void (*wxIconExtSetMask__wxMaskPFunc)(const wxIconExt* self, wxMask* mask);
typedef void (*wxIconExtSetPalette__wxPaletteCRFunc)(const wxIconExt* self, wxPalette const& palette);
typedef void (*wxIconExtSetScaleFactor__doubleFunc)(const wxIconExt* self, double scale);
typedef void (*wxIconExtSetWidth__intFunc)(const wxIconExt* self, int width);
typedef bool (*wxIconExtUseAlpha__boolFunc)(const wxIconExt* self, bool use, bool res);
class wxIconExt: public wxIcon
{
public:
wxIconExt(): wxIcon() { }
wxIconExt(char const* const* bits): wxIcon(bits) { }
wxIconExt(wxString const& filename, wxBitmapType type = wxBITMAP_TYPE_ICON_RESOURCE, int desiredWidth = -1, int desiredHeight = -1): wxIcon(filename, type, desiredWidth, desiredHeight) { }
wxIconExt(wxIconLocation const& loc): wxIcon(loc) { }
wxIconExtCloneGDIRefData__wxGDIRefDataCPFunc m_wxIconExtCloneGDIRefData__wxGDIRefDataCP = NULL;
virtual wxGDIRefData* CloneGDIRefData(wxGDIRefData const* data) const override
{
wxGDIRefData* res = wxIcon::CloneGDIRefData(data);
if (*m_wxIconExtCloneGDIRefData__wxGDIRefDataCP != NULL){
return m_wxIconExtCloneGDIRefData__wxGDIRefDataCP(this, data, res);
}
else {
return res;
}
}
wxIconExtConvertToImageFunc m_wxIconExtConvertToImage = NULL;
virtual wxImage ConvertToImage() const override
{
wxImage res = wxIcon::ConvertToImage();
if (*m_wxIconExtConvertToImage != NULL){
return m_wxIconExtConvertToImage(this, res);
}
else {
return res;
}
}
wxIconExtCreate__intintintFunc m_wxIconExtCreate__intintint = NULL;
virtual bool Create(int width, int height, int depth = (-1)) override
{
bool res = wxIcon::Create(width, height, depth);
if (*m_wxIconExtCreate__intintint != NULL){
return m_wxIconExtCreate__intintint(this, width, height, depth, res);
}
else {
return res;
}
}
wxIconExtCreate__voidCPwxBitmapTypeintintintFunc m_wxIconExtCreate__voidCPwxBitmapTypeintintint = NULL;
virtual bool Create(void const* data, wxBitmapType type, int width, int height, int depth = 1) override
{
bool res = wxIcon::Create(data, type, width, height, depth);
if (*m_wxIconExtCreate__voidCPwxBitmapTypeintintint != NULL){
return m_wxIconExtCreate__voidCPwxBitmapTypeintintint(this, data, type, width, height, depth, res);
}
else {
return res;
}
}
wxIconExtCreate__wxSizeCRintFunc m_wxIconExtCreate__wxSizeCRint = NULL;
virtual bool Create(wxSize const& sz, int depth = (-1)) override
{
bool res = wxIcon::Create(sz, depth);
if (*m_wxIconExtCreate__wxSizeCRint != NULL){
return m_wxIconExtCreate__wxSizeCRint(this, sz, depth, res);
}
else {
return res;
}
}
wxIconExtCreateGDIRefDataFunc m_wxIconExtCreateGDIRefData = NULL;
virtual wxGDIRefData* CreateGDIRefData() const override
{
wxGDIRefData* res = wxIcon::CreateGDIRefData();
if (*m_wxIconExtCreateGDIRefData != NULL){
return m_wxIconExtCreateGDIRefData(this, res);
}
else {
return res;
}
}
wxIconExtDoCreate__wxSizeCRdoubleintFunc m_wxIconExtDoCreate__wxSizeCRdoubleint = NULL;
virtual bool DoCreate(wxSize const& sz, double scale, int depth) override
{
bool res = wxIcon::DoCreate(sz, scale, depth);
if (*m_wxIconExtDoCreate__wxSizeCRdoubleint != NULL){
return m_wxIconExtDoCreate__wxSizeCRdoubleint(this, sz, scale, depth, res);
}
else {
return res;
}
}
wxIconExtGetClassInfoFunc m_wxIconExtGetClassInfo = NULL;
virtual wxClassInfo* GetClassInfo() const override
{
wxClassInfo* res = wxIcon::GetClassInfo();
if (*m_wxIconExtGetClassInfo != NULL){
return m_wxIconExtGetClassInfo(this, res);
}
else {
return res;
}
}
wxIconExtGetDepthFunc m_wxIconExtGetDepth = NULL;
virtual int GetDepth() const override
{
int res = wxIcon::GetDepth();
if (*m_wxIconExtGetDepth != NULL){
return m_wxIconExtGetDepth(this, res);
}
else {
return res;
}
}
wxIconExtGetHeightFunc m_wxIconExtGetHeight = NULL;
virtual int GetHeight() const override
{
int res = wxIcon::GetHeight();
if (*m_wxIconExtGetHeight != NULL){
return m_wxIconExtGetHeight(this, res);
}
else {
return res;
}
}
wxIconExtGetMaskFunc m_wxIconExtGetMask = NULL;
virtual wxMask* GetMask() const override
{
wxMask* res = wxIcon::GetMask();
if (*m_wxIconExtGetMask != NULL){
return m_wxIconExtGetMask(this, res);
}
else {
return res;
}
}
wxIconExtGetPaletteFunc m_wxIconExtGetPalette = NULL;
virtual wxPalette* GetPalette() const override
{
wxPalette* res = wxIcon::GetPalette();
if (*m_wxIconExtGetPalette != NULL){
return m_wxIconExtGetPalette(this, res);
}
else {
return res;
}
}
wxIconExtGetScaleFactorFunc m_wxIconExtGetScaleFactor = NULL;
virtual double GetScaleFactor() const override
{
double res = wxIcon::GetScaleFactor();
if (*m_wxIconExtGetScaleFactor != NULL){
return m_wxIconExtGetScaleFactor(this, res);
}
else {
return res;
}
}
wxIconExtGetSubBitmap__wxRectCRFunc m_wxIconExtGetSubBitmap__wxRectCR = NULL;
virtual wxBitmap GetSubBitmap(wxRect const& rect) const override
{
wxBitmap res = wxIcon::GetSubBitmap(rect);
if (*m_wxIconExtGetSubBitmap__wxRectCR != NULL){
return m_wxIconExtGetSubBitmap__wxRectCR(this, rect, res);
}
else {
return res;
}
}
wxIconExtGetWidthFunc m_wxIconExtGetWidth = NULL;
virtual int GetWidth() const override
{
int res = wxIcon::GetWidth();
if (*m_wxIconExtGetWidth != NULL){
return m_wxIconExtGetWidth(this, res);
}
else {
return res;
}
}
wxIconExtHasAlphaFunc m_wxIconExtHasAlpha = NULL;
virtual bool HasAlpha() const override
{
bool res = wxIcon::HasAlpha();
if (*m_wxIconExtHasAlpha != NULL){
return m_wxIconExtHasAlpha(this, res);
}
else {
return res;
}
}
wxIconExtLoadFile__wxStringCRwxBitmapTypeFunc m_wxIconExtLoadFile__wxStringCRwxBitmapType = NULL;
virtual bool LoadFile(wxString const& name, wxBitmapType type = wxBITMAP_TYPE_PICT_RESOURCE) override
{
bool res = wxIcon::LoadFile(name, type);
if (*m_wxIconExtLoadFile__wxStringCRwxBitmapType != NULL){
return m_wxIconExtLoadFile__wxStringCRwxBitmapType(this, name, type, res);
}
else {
return res;
}
}
wxIconExtQuantizeColour__wxColourCRFunc m_wxIconExtQuantizeColour__wxColourCR = NULL;
virtual wxColour QuantizeColour(wxColour const& colour) const override
{
wxColour res = wxIcon::QuantizeColour(colour);
if (*m_wxIconExtQuantizeColour__wxColourCR != NULL){
return m_wxIconExtQuantizeColour__wxColourCR(this, colour, res);
}
else {
return res;
}
}
wxIconExtSaveFile__wxStringCRwxBitmapTypewxPaletteCPFunc m_wxIconExtSaveFile__wxStringCRwxBitmapTypewxPaletteCP = NULL;
virtual bool SaveFile(wxString const& name, wxBitmapType type, wxPalette const* cmap = __null) const override
{
bool res = wxIcon::SaveFile(name, type, cmap);
if (*m_wxIconExtSaveFile__wxStringCRwxBitmapTypewxPaletteCP != NULL){
return m_wxIconExtSaveFile__wxStringCRwxBitmapTypewxPaletteCP(this, name, type, cmap, res);
}
else {
return res;
}
}
wxIconExtSetDepth__intFunc m_wxIconExtSetDepth__int = NULL;
virtual void SetDepth(int depth) override
{
wxIcon::SetDepth(depth);
if (*m_wxIconExtSetDepth__int != NULL){
return m_wxIconExtSetDepth__int(this, depth);
}
}
wxIconExtSetHeight__intFunc m_wxIconExtSetHeight__int = NULL;
virtual void SetHeight(int height) override
{
wxIcon::SetHeight(height);
if (*m_wxIconExtSetHeight__int != NULL){
return m_wxIconExtSetHeight__int(this, height);
}
}
wxIconExtSetMask__wxMaskPFunc m_wxIconExtSetMask__wxMaskP = NULL;
virtual void SetMask(wxMask* mask) override
{
wxIcon::SetMask(mask);
if (*m_wxIconExtSetMask__wxMaskP != NULL){
return m_wxIconExtSetMask__wxMaskP(this, mask);
}
}
wxIconExtSetPalette__wxPaletteCRFunc m_wxIconExtSetPalette__wxPaletteCR = NULL;
virtual void SetPalette(wxPalette const& palette) override
{
wxIcon::SetPalette(palette);
if (*m_wxIconExtSetPalette__wxPaletteCR != NULL){
return m_wxIconExtSetPalette__wxPaletteCR(this, palette);
}
}
wxIconExtSetScaleFactor__doubleFunc m_wxIconExtSetScaleFactor__double = NULL;
virtual void SetScaleFactor(double scale) override
{
wxIcon::SetScaleFactor(scale);
if (*m_wxIconExtSetScaleFactor__double != NULL){
return m_wxIconExtSetScaleFactor__double(this, scale);
}
}
wxIconExtSetWidth__intFunc m_wxIconExtSetWidth__int = NULL;
virtual void SetWidth(int width) override
{
wxIcon::SetWidth(width);
if (*m_wxIconExtSetWidth__int != NULL){
return m_wxIconExtSetWidth__int(this, width);
}
}
wxIconExtUseAlpha__boolFunc m_wxIconExtUseAlpha__bool = NULL;
virtual bool UseAlpha(bool use = true) override
{
bool res = wxIcon::UseAlpha(use);
if (*m_wxIconExtUseAlpha__bool != NULL){
return m_wxIconExtUseAlpha__bool(this, use, res);
}
else {
return res;
}
}
wxIconExt(wxIconExtCloneGDIRefData__wxGDIRefDataCPFunc a_CloneGDIRefData__wxGDIRefDataCP, wxIconExtConvertToImageFunc a_ConvertToImage, wxIconExtCreate__intintintFunc a_Create__intintint, wxIconExtCreate__voidCPwxBitmapTypeintintintFunc a_Create__voidCPwxBitmapTypeintintint, wxIconExtCreate__wxSizeCRintFunc a_Create__wxSizeCRint, wxIconExtCreateGDIRefDataFunc a_CreateGDIRefData, wxIconExtDoCreate__wxSizeCRdoubleintFunc a_DoCreate__wxSizeCRdoubleint, wxIconExtGetClassInfoFunc a_GetClassInfo, wxIconExtGetDepthFunc a_GetDepth, wxIconExtGetHeightFunc a_GetHeight, wxIconExtGetMaskFunc a_GetMask, wxIconExtGetPaletteFunc a_GetPalette, wxIconExtGetScaleFactorFunc a_GetScaleFactor, wxIconExtGetSubBitmap__wxRectCRFunc a_GetSubBitmap__wxRectCR, wxIconExtGetWidthFunc a_GetWidth, wxIconExtHasAlphaFunc a_HasAlpha, wxIconExtLoadFile__wxStringCRwxBitmapTypeFunc a_LoadFile__wxStringCRwxBitmapType, wxIconExtQuantizeColour__wxColourCRFunc a_QuantizeColour__wxColourCR, wxIconExtSaveFile__wxStringCRwxBitmapTypewxPaletteCPFunc a_SaveFile__wxStringCRwxBitmapTypewxPaletteCP, wxIconExtSetDepth__intFunc a_SetDepth__int, wxIconExtSetHeight__intFunc a_SetHeight__int, wxIconExtSetMask__wxMaskPFunc a_SetMask__wxMaskP, wxIconExtSetPalette__wxPaletteCRFunc a_SetPalette__wxPaletteCR, wxIconExtSetScaleFactor__doubleFunc a_SetScaleFactor__double, wxIconExtSetWidth__intFunc a_SetWidth__int, wxIconExtUseAlpha__boolFunc a_UseAlpha__bool): wxIcon() {
m_wxIconExtCloneGDIRefData__wxGDIRefDataCP = a_CloneGDIRefData__wxGDIRefDataCP;
m_wxIconExtConvertToImage = a_ConvertToImage;
m_wxIconExtCreate__intintint = a_Create__intintint;
m_wxIconExtCreate__voidCPwxBitmapTypeintintint = a_Create__voidCPwxBitmapTypeintintint;
m_wxIconExtCreate__wxSizeCRint = a_Create__wxSizeCRint;
m_wxIconExtCreateGDIRefData = a_CreateGDIRefData;
m_wxIconExtDoCreate__wxSizeCRdoubleint = a_DoCreate__wxSizeCRdoubleint;
m_wxIconExtGetClassInfo = a_GetClassInfo;
m_wxIconExtGetDepth = a_GetDepth;
m_wxIconExtGetHeight = a_GetHeight;
m_wxIconExtGetMask = a_GetMask;
m_wxIconExtGetPalette = a_GetPalette;
m_wxIconExtGetScaleFactor = a_GetScaleFactor;
m_wxIconExtGetSubBitmap__wxRectCR = a_GetSubBitmap__wxRectCR;
m_wxIconExtGetWidth = a_GetWidth;
m_wxIconExtHasAlpha = a_HasAlpha;
m_wxIconExtLoadFile__wxStringCRwxBitmapType = a_LoadFile__wxStringCRwxBitmapType;
m_wxIconExtQuantizeColour__wxColourCR = a_QuantizeColour__wxColourCR;
m_wxIconExtSaveFile__wxStringCRwxBitmapTypewxPaletteCP = a_SaveFile__wxStringCRwxBitmapTypewxPaletteCP;
m_wxIconExtSetDepth__int = a_SetDepth__int;
m_wxIconExtSetHeight__int = a_SetHeight__int;
m_wxIconExtSetMask__wxMaskP = a_SetMask__wxMaskP;
m_wxIconExtSetPalette__wxPaletteCR = a_SetPalette__wxPaletteCR;
m_wxIconExtSetScaleFactor__double = a_SetScaleFactor__double;
m_wxIconExtSetWidth__int = a_SetWidth__int;
m_wxIconExtUseAlpha__bool = a_UseAlpha__bool;
}
};
#endif