Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1. wxAppBase class appers, wxApp in wxGTK and wxMSW modified accordingly

Browse Source 
(wxMotif not yet, but this change shouldn't break it)
2. GetStdIcon() small fixes
3. #pragma warning removed from dynlib.cpp


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@2957 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1999-07-06 00:44:26 +00:00
parent 4092d6f221
commit 094637f6d6
11 changed files with 491 additions and 544 deletions
Download Patch File Download Diff File Expand all files Collapse all files

308
include/wx/app.h
View File

@@ -1,98 +1,298 @@
/////////////////////////////////////////////////////////////////////////////
// Name: app.h
// Purpose: wxApp inclusion
// Purpose: wxAppBase class and macros used for declaration of wxApp
// derived class in the user code
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows licence
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_APP_H_BASE_
#define _WX_APP_H_BASE_
#ifdef __GNUG__
#pragma interface "appbase.h"
#endif
// ----------------------------------------------------------------------------
// typedefs
// ----------------------------------------------------------------------------
#ifdef __WXMSW__
class WXDLLEXPORT wxApp;
typedef wxApp* (*wxAppInitializerFunction) (void);
class WXDLLEXPORT wxApp;
typedef wxApp* (*wxAppInitializerFunction)();
#else
// returning wxApp* won't work with gcc
#include "wx/object.h"
typedef wxObject* (*wxAppInitializerFunction)();
#endif
#include "wx/object.h"
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
#ifndef __WXMSW__
typedef wxObject* (*wxAppInitializerFunction) (void); // returning wxApp* won't work with gcc
#endif
static const int wxPRINT_WINDOWS = 1;
static const int wxPRINT_POSTSCRIPT = 2;
// ----------------------------------------------------------------------------
// the common part of wxApp implementations for all platforms
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxAppBase : public wxEvtHandler
{
public:
// the virtual functions which may/must be overridden in the derived class
// -----------------------------------------------------------------------
// called during the program initialization, returning FALSE from here
// prevents the program from continuing - it's a good place to create
// the top level program window and return TRUE.
//
// Override: always.
virtual bool OnInit() { return FALSE; };
// a platform-dependent version of OnInit(): the code here is likely to
// depend on the toolkit. default version does nothing.
//
// Override: rarely.
virtual bool OnInitGui() { return TRUE; }
// called to start program execution - the default version just enters
// the main GUI loop in which events are received and processed until
// the last window is not deleted (if GetExitOnFrameDelete) or
// ExitMainLoop() is called.
//
// Override: rarely.
virtual int OnRun() { return MainLoop(); };
// called after the main loop termination. This is a good place for
// cleaning up (it may be too late in dtor) and is also useful if you
// want to return some non-default exit code - this is just the return
// value of this method.
//
// Override: often.
virtual int OnExit() { return 0; }
// called when a fatal exception occurs, this function should take care
// not to do anything which might provoke a nested exception! It may be
// overridden if you wish to react somehow in non-default way (core
// dump under Unix, application crash under Windows) to fatal program
// errors, however extreme care should be taken if you don't want this
// function to crash.
//
// Override: rarely.
virtual void OnFatalException() { }
// the worker functions - usually not used directly by the user code
// -----------------------------------------------------------------
// execute the main GUI loop, the function returns when the loop ends
virtual int MainLoop() = 0;
// exit the main GUI loop during the next iteration (i.e. it does not
// stop the program immediately!)
virtual void ExitMainLoop() = 0;
// returns TRUE if the program is initialized
virtual bool Initialized() = 0;
// returns TRUE if there are unprocessed events in the event queue
virtual bool Pending() = 0;
// process the first event in the event queue (blocks until an event
// apperas if there are none currently)
virtual void Dispatch() = 0;
// application info: name, description, vendor
// -------------------------------------------
// NB: all these should be set by the application itself, there are no
// reasonable default except for the application name which is taken to
// be argv[0]
// set/get the application name
wxString GetAppName() const
{
if ( !m_appName )
return m_className;
else
return m_appName;
}
void SetAppName(const wxString& name) { m_appName = name; }
// set/get the app class name
wxString GetClassName() const { return m_className; }
void SetClassName(const wxString& name) { m_className = name; }
// set/get the vendor name
const wxString& GetVendorName() const { return m_vendorName; }
void SetVendorName(const wxString& name) { m_vendorName = name; }
// top level window functions
// --------------------------
// set the "main" top level window
void SetTopWindow(wxWindow *win) { m_topWindow = win; }
// return the "main" top level window (if it hadn't been set previously
// with SetTopWindow(), will return just some top level window and, if
// there are none, will return NULL)
wxWindow *GetTopWindow() const
{
if (m_topWindow)
return m_topWindow;
else if (wxTopLevelWindows.GetCount() > 0)
return wxTopLevelWindows.GetFirst()->GetData();
else
return (wxWindow *)NULL;
}
// control the exit behaviour: by default, the program will exit the
// main loop (and so, usually, terminate) when the last top-level
// program window is deleted. Beware that if you disabel this (with
// SetExitOnFrameDelete(FALSE)), you'll have to call ExitMainLoop()
// explicitly from somewhere.
void SetExitOnFrameDelete(bool flag) { m_exitOnFrameDelete = flag; }
bool GetExitOnFrameDelete() const { return m_exitOnFrameDelete; }
// miscellaneous customization functions
// -------------------------------------
#if wxUSE_LOG
// override this function to create default log target of arbitrary
// user-defined class (default implementation creates a wxLogGui
// object) - this log object is used by default by all wxLogXXX()
// functions.
virtual wxLog *CreateLogTarget() { return new wxLogGui; }
#endif // wxUSE_LOG
// get the standard icon used by wxWin dialogs - this allows the user
// to customize the standard dialogs. The 'which' parameter is one of
// wxICON_XXX values
virtual wxIcon GetStdIcon(int which) const = 0;
// VZ: what does this do exactly?
void SetWantDebugOutput( bool flag ) { m_wantDebugOutput = flag; }
bool GetWantDebugOutput() const { return m_wantDebugOutput; }
// set/get printing mode: see wxPRINT_XXX constants.
//
// default behaviour is the normal one for Unix: always use PostScript
// printing.
virtual void SetPrintMode(int WXUNUSED(mode)) { }
int GetPrintMode() const { return wxPRINT_POSTSCRIPT; }
// implementation only from now on
// -------------------------------
// helpers for dynamic wxApp construction
static void SetInitializerFunction(wxAppInitializerFunction fn)
{ m_appInitFn = fn; }
static wxAppInitializerFunction GetInitializerFunction()
{ return m_appInitFn; }
// access to the command line arguments
int argc;
char **argv;
//private:
protected:
// function used for dynamic wxApp creation
static wxAppInitializerFunction m_appInitFn;
// application info (must be set from the user code)
wxString m_vendorName, // vendor name (ACME Inc)
m_appName, // app name
m_className; // class name
// if TRUE, exit the main loop when the last top level window is deleted
bool m_exitOnFrameDelete;
// TRUE if the application wants to get debug output
bool m_wantDebugOutput;
// the main top level window - may be NULL
wxWindow *m_topWindow;
};
// ----------------------------------------------------------------------------
// now include the declaration of the real class
// ----------------------------------------------------------------------------
#if defined(__WXMSW__)
#include "wx/msw/app.h"
#include "wx/msw/app.h"
#elif defined(__WXMOTIF__)
#include "wx/motif/app.h"
#include "wx/motif/app.h"
#elif defined(__WXQT__)
#include "wx/qt/app.h"
#include "wx/qt/app.h"
#elif defined(__WXGTK__)
#include "wx/gtk/app.h"
#include "wx/gtk/app.h"
#elif defined(__WXMAC__)
#include "wx/mac/app.h"
#include "wx/mac/app.h"
#elif defined(__WXSTUBS__)
#include "wx/stubs/app.h"
#include "wx/stubs/app.h"
#endif
// Having a global instance of this class allows
// wxApp to be aware of the app creator function.
// wxApp can then call this function to create a new
// app object. Convoluted, but necessary.
// ----------------------------------------------------------------------------
// macros for dynamic creation of the application object
// ----------------------------------------------------------------------------
// Having a global instance of this class allows wxApp to be aware of the app
// creator function. wxApp can then call this function to create a new app
// object. Convoluted, but necessary.
class WXDLLEXPORT wxAppInitializer
{
public:
wxAppInitializer(wxAppInitializerFunction fn)
{
wxApp::SetInitializerFunction(fn);
}
wxAppInitializer(wxAppInitializerFunction fn)
{ wxApp::SetInitializerFunction(fn); }
};
// Here's a macro you can use if your compiler
// really, really wants main() to be in your main program
// (e.g. hello.cpp).
// Now IMPLEMENT_APP should add this code if required.
// Here's a macro you can use if your compiler really, really wants main() to
// be in your main program (e.g. hello.cpp). Now IMPLEMENT_APP should add this
// code if required.
#if defined(__AIX__) || defined(__HPUX__)
#define IMPLEMENT_WXWIN_MAIN \
extern int wxEntry( int argc, char *argv[] ); \
int main(int argc, char *argv[]) { return wxEntry(argc, argv); }
#define IMPLEMENT_WXWIN_MAIN \
extern int wxEntry( int argc, char *argv[] ); \
int main(int argc, char *argv[]) { return wxEntry(argc, argv); }
#elif defined(__WXMSW__) && defined(WXUSINGDLL)
// NT defines APIENTRY, 3.x not
#if !defined(WXAPIENTRY)
#ifdef __WATCOMC__
#define WXAPIENTRY PASCAL
#else
#define WXAPIENTRY FAR PASCAL
#endif
#endif
// NT defines APIENTRY, 3.x not
#if !defined(WXAPIENTRY)
# ifdef __WATCOMC__
# define WXAPIENTRY PASCAL
# else
# define WXAPIENTRY FAR PASCAL
# endif
#endif
#define IMPLEMENT_WXWIN_MAIN \
int WXAPIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,\
LPSTR m_lpCmdLine, int nCmdShow )\
{\
return wxEntry((WXHINSTANCE) hInstance, (WXHINSTANCE) hPrevInstance,\
m_lpCmdLine, nCmdShow);\
}
#define IMPLEMENT_WXWIN_MAIN \
int WXAPIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,\
LPSTR m_lpCmdLine, int nCmdShow )\
{\
return wxEntry((WXHINSTANCE) hInstance, \
(WXHINSTANCE) hPrevInstance,\
m_lpCmdLine, nCmdShow);\
}
#else
#define IMPLEMENT_WXWIN_MAIN
#define IMPLEMENT_WXWIN_MAIN
#endif
// use this macro exactly once, the argument is the name of the wxApp-derived
// class which is the class of your application
#define IMPLEMENT_APP(appname) \
wxApp *wxCreateApp(void) { return new appname; } \
wxAppInitializer wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp); \
appname& wxGetApp(void) { return *(appname *)wxTheApp; } \
IMPLEMENT_WXWIN_MAIN
#define DECLARE_APP(appname) \
extern appname& wxGetApp(void) ;
wxApp *wxCreateApp() { return new appname; } \
wxAppInitializer wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp); \
appname& wxGetApp() { return *(appname *)wxTheApp; } \
IMPLEMENT_WXWIN_MAIN
#define DECLARE_APP(appname) extern appname& wxGetApp();
#endif
// _WX_APP_H_BASE_

86
include/wx/gtk/app.h
View File

@@ -50,72 +50,34 @@ bool wxYield(void);
// wxApp
//-----------------------------------------------------------------------------
class wxApp: public wxEvtHandler
class wxApp: public wxAppBase
{
DECLARE_DYNAMIC_CLASS(wxApp)
public:
DECLARE_DYNAMIC_CLASS(wxApp)
public:
wxApp();
~wxApp();
static void SetInitializerFunction(wxAppInitializerFunction fn) { m_appInitFn = fn; }
static wxAppInitializerFunction GetInitializerFunction() { return m_appInitFn; }
/* override for altering the way wxGTK intializes the GUI (palette/visual/colorcube).
* under wxMSW, OnInitGui() does nothing by default. when overriding this method,
* the code in it is likely to be platform dependent, otherwise use OnInit(). */
/* override for altering the way wxGTK intializes the GUI
* (palette/visual/colorcube). under wxMSW, OnInitGui() does nothing by
* default. when overriding this method, the code in it is likely to be
* platform dependent, otherwise use OnInit(). */
virtual bool OnInitGui();
/* override to create top level frame, display splash screen etc. */
virtual bool OnInit() { return FALSE; }
virtual int OnRun() { return MainLoop(); }
virtual int OnExit() { return 0; }
wxWindow *GetTopWindow();
void SetTopWindow( wxWindow *win );
// override base class (pure) virtuals
virtual int MainLoop();
void ExitMainLoop();
bool Initialized();
virtual void ExitMainLoop();
virtual bool Initialized();
virtual bool Pending();
virtual void Dispatch();
/** Returns the standard icons for the msg dialogs, implemented in
src/generic/msgdlgg.cpp and src/gtk/app.cpp. */
virtual wxIcon GetStdIcon(int which) const;
inline void SetWantDebugOutput( bool flag ) { m_wantDebugOutput = flag; }
inline bool GetWantDebugOutput() { return m_wantDebugOutput; }
// implementation only from now on
void OnIdle( wxIdleEvent &event );
bool SendIdleEvents();
bool SendIdleEvents( wxWindow* win );
inline wxString GetAppName() const
{ if (m_appName != "") return m_appName; else return m_className; }
inline void SetAppName( const wxString& name ) { m_appName = name; }
inline wxString GetClassName() const { return m_className; }
inline void SetClassName( const wxString& name ) { m_className = name; }
const wxString& GetVendorName() const { return m_vendorName; }
void SetVendorName( const wxString& name ) { m_vendorName = name; }
inline void SetExitOnFrameDelete( bool flag ) { m_exitOnFrameDelete = flag; }
inline bool GetExitOnFrameDelete() const { return m_exitOnFrameDelete; }
void SetPrintMode( int WXUNUSED(mode) ) {}
int GetPrintMode() const { return wxPRINT_POSTSCRIPT; }
#if wxUSE_LOG
/* override this function to create default log target of arbitrary
* user-defined classv (default implementation creates a wxLogGui object) */
virtual wxLog *CreateLogTarget();
#endif // wxUSE_LOG
// implementation
static bool Initialize();
static bool InitialzeVisual();
static void CleanUp();
@@ -126,33 +88,23 @@ class wxApp: public wxEvtHandler
#endif
void DeletePendingObjects();
/// This can be used to suppress the generation of Idle events.
inline void SuppressIdleEvents(bool arg = TRUE) { m_suppressIdleEvents = arg; }
inline bool GetSuppressIdleEvents() const { return m_suppressIdleEvents; }
// This can be used to suppress the generation of Idle events.
void SuppressIdleEvents(bool arg = TRUE) { m_suppressIdleEvents = arg; }
bool GetSuppressIdleEvents() const { return m_suppressIdleEvents; }
bool m_initialized;
bool m_exitOnFrameDelete;
bool m_wantDebugOutput;
wxWindow *m_topWindow;
gint m_idleTag;
#if wxUSE_THREADS
gint m_wakeUpTimerTag;
#endif
unsigned char *m_colorCube;
int argc;
char **argv;
wxString m_vendorName;
wxString m_appName;
wxString m_className;
static wxAppInitializerFunction m_appInitFn;
private:
private:
/// Set to TRUE while we are in wxYield().
bool m_suppressIdleEvents;
DECLARE_EVENT_TABLE()
DECLARE_EVENT_TABLE()
};
#endif // __GTKAPPH__

86
include/wx/gtk1/app.h
View File

@@ -50,72 +50,34 @@ bool wxYield(void);
// wxApp
//-----------------------------------------------------------------------------
class wxApp: public wxEvtHandler
class wxApp: public wxAppBase
{
DECLARE_DYNAMIC_CLASS(wxApp)
public:
DECLARE_DYNAMIC_CLASS(wxApp)
public:
wxApp();
~wxApp();
static void SetInitializerFunction(wxAppInitializerFunction fn) { m_appInitFn = fn; }
static wxAppInitializerFunction GetInitializerFunction() { return m_appInitFn; }
/* override for altering the way wxGTK intializes the GUI (palette/visual/colorcube).
* under wxMSW, OnInitGui() does nothing by default. when overriding this method,
* the code in it is likely to be platform dependent, otherwise use OnInit(). */
/* override for altering the way wxGTK intializes the GUI
* (palette/visual/colorcube). under wxMSW, OnInitGui() does nothing by
* default. when overriding this method, the code in it is likely to be
* platform dependent, otherwise use OnInit(). */
virtual bool OnInitGui();
/* override to create top level frame, display splash screen etc. */
virtual bool OnInit() { return FALSE; }
virtual int OnRun() { return MainLoop(); }
virtual int OnExit() { return 0; }
wxWindow *GetTopWindow();
void SetTopWindow( wxWindow *win );
// override base class (pure) virtuals
virtual int MainLoop();
void ExitMainLoop();
bool Initialized();
virtual void ExitMainLoop();
virtual bool Initialized();
virtual bool Pending();
virtual void Dispatch();
/** Returns the standard icons for the msg dialogs, implemented in
src/generic/msgdlgg.cpp and src/gtk/app.cpp. */
virtual wxIcon GetStdIcon(int which) const;
inline void SetWantDebugOutput( bool flag ) { m_wantDebugOutput = flag; }
inline bool GetWantDebugOutput() { return m_wantDebugOutput; }
// implementation only from now on
void OnIdle( wxIdleEvent &event );
bool SendIdleEvents();
bool SendIdleEvents( wxWindow* win );
inline wxString GetAppName() const
{ if (m_appName != "") return m_appName; else return m_className; }
inline void SetAppName( const wxString& name ) { m_appName = name; }
inline wxString GetClassName() const { return m_className; }
inline void SetClassName( const wxString& name ) { m_className = name; }
const wxString& GetVendorName() const { return m_vendorName; }
void SetVendorName( const wxString& name ) { m_vendorName = name; }
inline void SetExitOnFrameDelete( bool flag ) { m_exitOnFrameDelete = flag; }
inline bool GetExitOnFrameDelete() const { return m_exitOnFrameDelete; }
void SetPrintMode( int WXUNUSED(mode) ) {}
int GetPrintMode() const { return wxPRINT_POSTSCRIPT; }
#if wxUSE_LOG
/* override this function to create default log target of arbitrary
* user-defined classv (default implementation creates a wxLogGui object) */
virtual wxLog *CreateLogTarget();
#endif // wxUSE_LOG
// implementation
static bool Initialize();
static bool InitialzeVisual();
static void CleanUp();
@@ -126,33 +88,23 @@ class wxApp: public wxEvtHandler
#endif
void DeletePendingObjects();
/// This can be used to suppress the generation of Idle events.
inline void SuppressIdleEvents(bool arg = TRUE) { m_suppressIdleEvents = arg; }
inline bool GetSuppressIdleEvents() const { return m_suppressIdleEvents; }
// This can be used to suppress the generation of Idle events.
void SuppressIdleEvents(bool arg = TRUE) { m_suppressIdleEvents = arg; }
bool GetSuppressIdleEvents() const { return m_suppressIdleEvents; }
bool m_initialized;
bool m_exitOnFrameDelete;
bool m_wantDebugOutput;
wxWindow *m_topWindow;
gint m_idleTag;
#if wxUSE_THREADS
gint m_wakeUpTimerTag;
#endif
unsigned char *m_colorCube;
int argc;
char **argv;
wxString m_vendorName;
wxString m_appName;
wxString m_className;
static wxAppInitializerFunction m_appInitFn;
private:
private:
/// Set to TRUE while we are in wxYield().
bool m_suppressIdleEvents;
DECLARE_EVENT_TABLE()
DECLARE_EVENT_TABLE()
};
#endif // __GTKAPPH__

156
include/wx/msw/app.h
View File

@@ -27,9 +27,6 @@ class WXDLLEXPORT wxApp ;
class WXDLLEXPORT wxKeyEvent;
class WXDLLEXPORT wxLog;
static const int wxPRINT_WINDOWS = 1;
static const int wxPRINT_POSTSCRIPT = 2;
WXDLLEXPORT_DATA(extern wxApp*) wxTheApp;
// Force an exit from main loop
@@ -40,125 +37,74 @@ bool WXDLLEXPORT wxYield();
// Represents the application. Derive OnInit and declare
// a new App object to start application
class WXDLLEXPORT wxApp: public wxEvtHandler
class WXDLLEXPORT wxApp : public wxAppBase
{
DECLARE_DYNAMIC_CLASS(wxApp)
wxApp();
~wxApp();
static void SetInitializerFunction(wxAppInitializerFunction fn) { m_appInitFn = fn; }
static wxAppInitializerFunction GetInitializerFunction() { return m_appInitFn; }
virtual int MainLoop();
void ExitMainLoop();
bool Initialized();
virtual bool Pending() ;
virtual void Dispatch() ;
void OnIdle(wxIdleEvent& event);
void OnEndSession(wxCloseEvent& event);
void OnQueryEndSession(wxCloseEvent& event);
// Generic
virtual bool OnInit() { return FALSE; };
// No specific tasks to do here.
virtual bool OnInitGui() { return TRUE; }
// Called to set off the main loop
virtual int OnRun() { return MainLoop(); };
virtual int OnExit() { return 0; }
/** Returns the standard icons for the msg dialogs, implemented in
src/generic/msgdlgg.cpp and src/gtk/app.cpp. */
virtual wxIcon GetStdIcon(int which) const;
// called when a fatal exception occurs, this function should take care not
// to do anything which might provoke a nested exception!
virtual void OnFatalException() { }
void SetPrintMode(int mode) { m_printMode = mode; }
int GetPrintMode() const { return m_printMode; }
void SetExitOnFrameDelete(bool flag) { m_exitOnFrameDelete = flag; }
bool GetExitOnFrameDelete() const { return m_exitOnFrameDelete; }
const wxString& GetAppName() const {
if (m_appName != _T(""))
return m_appName;
else return m_className;
}
void SetAppName(const wxString& name) { m_appName = name; };
wxString GetClassName() const { return m_className; }
void SetClassName(const wxString& name) { m_className = name; }
void SetVendorName(const wxString& vendorName) { m_vendorName = vendorName; }
const wxString& GetVendorName() const { return m_vendorName; }
wxWindow *GetTopWindow() const ;
void SetTopWindow(wxWindow *win) { m_topWindow = win; }
void SetWantDebugOutput(bool flag) { m_wantDebugOutput = flag; }
bool GetWantDebugOutput() { return m_wantDebugOutput; }
// Send idle event to all top-level windows.
// Returns TRUE if more idle time is requested.
bool SendIdleEvents();
// Send idle event to window and all subwindows
// Returns TRUE if more idle time is requested.
bool SendIdleEvents(wxWindow* win);
void SetAuto3D(bool flag) { m_auto3D = flag; }
bool GetAuto3D() const { return m_auto3D; }
// Creates a log object
virtual wxLog* CreateLogTarget();
DECLARE_DYNAMIC_CLASS(wxApp)
public:
int argc;
wxChar ** argv;
wxApp();
virtual ~wxApp();
// override base class (pure) virtuals
virtual int MainLoop();
virtual void ExitMainLoop();
virtual bool Initialized();
virtual bool Pending() ;
virtual void Dispatch() ;
virtual wxIcon GetStdIcon(int which) const;
virtual void SetPrintMode(int mode) { m_printMode = mode; }
virtual int GetPrintMode() const { return m_printMode; }
// implementation only
void OnIdle(wxIdleEvent& event);
void OnEndSession(wxCloseEvent& event);
void OnQueryEndSession(wxCloseEvent& event);
// Send idle event to all top-level windows.
// Returns TRUE if more idle time is requested.
bool SendIdleEvents();
// Send idle event to window and all subwindows
// Returns TRUE if more idle time is requested.
bool SendIdleEvents(wxWindow* win);
void SetAuto3D(bool flag) { m_auto3D = flag; }
bool GetAuto3D() const { return m_auto3D; }
protected:
bool m_wantDebugOutput ;
wxString m_className;
wxString m_appName,
m_vendorName;
wxWindow * m_topWindow;
bool m_exitOnFrameDelete;
bool m_showOnInit;
int m_printMode; // wxPRINT_WINDOWS, wxPRINT_POSTSCRIPT
bool m_auto3D ; // Always use 3D controls, except
// where overriden
static wxAppInitializerFunction m_appInitFn;
bool m_showOnInit;
int m_printMode; // wxPRINT_WINDOWS, wxPRINT_POSTSCRIPT
bool m_auto3D ; // Always use 3D controls, except where overriden
/* Windows-specific wxApp definitions */
/* Windows-specific wxApp definitions */
public:
// Implementation
static bool Initialize();
static void CleanUp();
// Implementation
static bool Initialize();
static void CleanUp();
static bool RegisterWindowClasses();
// Convert Windows to argc, argv style
void ConvertToStandardCommandArgs(char* p);
virtual bool DoMessage();
virtual bool ProcessMessage(WXMSG* pMsg);
void DeletePendingObjects();
bool ProcessIdle();
static bool RegisterWindowClasses();
// Convert Windows to argc, argv style
void ConvertToStandardCommandArgs(char* p);
virtual bool DoMessage();
virtual bool ProcessMessage(WXMSG* pMsg);
void DeletePendingObjects();
bool ProcessIdle();
#if wxUSE_THREADS
void ProcessPendingEvents();
void ProcessPendingEvents();
#endif
int GetComCtl32Version() const;
int GetComCtl32Version() const;
public:
int m_nCmdShow;
int m_nCmdShow;
protected:
bool m_keepGoing ;
bool m_keepGoing ;
DECLARE_EVENT_TABLE()
DECLARE_EVENT_TABLE()
};
#if !defined(_WINDLL) || (defined(_WINDLL) && defined(WXMAKINGDLL))