Compare commits
1 Commits
LAST_WITH_
...
wxPython-0
| Author | SHA1 | Date | |
|---|---|---|---|
|
cd630ed42e |
@@ -1,123 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/accel.h
|
||||
// Purpose: wxAcceleratorEntry and wxAcceleratorTable classes
|
||||
// Author: Julian Smart, Robert Roebling, Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 31.05.01 (extracted from other files)
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) wxWindows team
|
||||
// Licence: wxWindows license
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_ACCEL_H_BASE_
|
||||
#define _WX_ACCEL_H_BASE_
|
||||
|
||||
#include "wx/defs.h"
|
||||
|
||||
#if wxUSE_ACCEL
|
||||
|
||||
#include "wx/object.h"
|
||||
|
||||
class WXDLLEXPORT wxAcceleratorTable;
|
||||
class WXDLLEXPORT wxMenuItem;
|
||||
class WXDLLEXPORT wxKeyEvent;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// constants
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// wxAcceleratorEntry flags
|
||||
enum
|
||||
{
|
||||
wxACCEL_NORMAL = 0x0000, // no modifiers
|
||||
wxACCEL_ALT = 0x0001, // hold Alt key down
|
||||
wxACCEL_CTRL = 0x0002, // hold Ctrl key down
|
||||
wxACCEL_SHIFT = 0x0004 // hold Shift key down
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// an entry in wxAcceleratorTable corresponds to one accelerator
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxAcceleratorEntry
|
||||
{
|
||||
public:
|
||||
wxAcceleratorEntry(int flags = 0, int keyCode = 0, int cmd = 0,
|
||||
wxMenuItem *item = NULL)
|
||||
{
|
||||
Set(flags, keyCode, cmd, item);
|
||||
}
|
||||
|
||||
void Set(int flags, int keyCode, int cmd, wxMenuItem *item = NULL)
|
||||
{
|
||||
m_flags = flags;
|
||||
m_keyCode = keyCode;
|
||||
m_command = cmd;
|
||||
m_item = item;
|
||||
}
|
||||
|
||||
void SetMenuItem(wxMenuItem *item) { m_item = item; }
|
||||
|
||||
int GetFlags() const { return m_flags; }
|
||||
int GetKeyCode() const { return m_keyCode; }
|
||||
int GetCommand() const { return m_command; }
|
||||
|
||||
wxMenuItem *GetMenuItem() const { return m_item; }
|
||||
|
||||
bool operator==(const wxAcceleratorEntry& entry) const
|
||||
{
|
||||
return m_flags == entry.m_flags &&
|
||||
m_keyCode == entry.m_keyCode &&
|
||||
m_command == entry.m_command &&
|
||||
m_item == entry.m_item;
|
||||
}
|
||||
|
||||
bool operator!=(const wxAcceleratorEntry& entry) const
|
||||
{ return !(*this == entry); }
|
||||
|
||||
#ifdef __WXMOTIF__
|
||||
// Implementation use only
|
||||
bool MatchesEvent(const wxKeyEvent& event) const ;
|
||||
#endif
|
||||
|
||||
private:
|
||||
int m_flags; // combination of wxACCEL_XXX constants
|
||||
int m_keyCode; // ASCII or virtual keycode
|
||||
int m_command; // Command id to generate
|
||||
|
||||
// the menu item this entry corresponds to, may be NULL
|
||||
wxMenuItem *m_item;
|
||||
|
||||
// for compatibility with old code, use accessors now!
|
||||
friend class WXDLLEXPORT wxMenu;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// include wxAcceleratorTable class declaration, it is only used by the library
|
||||
// and so doesn't have any published user visible interface
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/generic/accel.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/accel.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/accel.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/accel.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/accel.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/accel.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/accel.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/accel.h"
|
||||
#endif
|
||||
|
||||
WXDLLEXPORT_DATA(extern wxAcceleratorTable) wxNullAcceleratorTable;
|
||||
|
||||
#endif // wxUSE_ACCEL
|
||||
|
||||
#endif
|
||||
// _WX_ACCEL_H_BASE_
|
||||
512
include/wx/app.h
512
include/wx/app.h
@@ -1,512 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: app.h
|
||||
// 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
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_APP_H_BASE_
|
||||
#define _WX_APP_H_BASE_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "appbase.h"
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// typedefs
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if (defined(__WXMSW__) && !defined(__WXMICROWIN__)) || defined (__WXPM__)
|
||||
class WXDLLEXPORT wxApp;
|
||||
typedef wxApp* (*wxAppInitializerFunction)();
|
||||
#else
|
||||
// returning wxApp* won't work with gcc
|
||||
#include "wx/object.h"
|
||||
|
||||
typedef wxObject* (*wxAppInitializerFunction)();
|
||||
#endif
|
||||
|
||||
class WXDLLEXPORT wxCmdLineParser;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers we have to include here
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#include "wx/event.h" // for the base class
|
||||
|
||||
#if wxUSE_GUI
|
||||
#include "wx/window.h" // for wxTopLevelWindows
|
||||
#endif // wxUSE_GUI
|
||||
|
||||
#if wxUSE_LOG
|
||||
#include "wx/log.h"
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// constants
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
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:
|
||||
wxAppBase();
|
||||
|
||||
// the virtual functions which may/must be overridden in the derived class
|
||||
// -----------------------------------------------------------------------
|
||||
#ifdef __DARWIN__
|
||||
virtual ~wxAppBase() { }
|
||||
#endif
|
||||
|
||||
// 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 in GUI application, rarely in console ones.
|
||||
virtual bool OnInit();
|
||||
|
||||
#if wxUSE_GUI
|
||||
// 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();
|
||||
#endif // wxUSE_GUI
|
||||
|
||||
// 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. In console mode programs, the execution
|
||||
// of the program really starts here
|
||||
//
|
||||
// Override: rarely in GUI applications, always in console ones.
|
||||
#if wxUSE_GUI
|
||||
virtual int OnRun() { return MainLoop(); };
|
||||
#else // !GUI
|
||||
virtual int OnRun() = 0;
|
||||
#endif // wxUSE_GUI
|
||||
|
||||
// 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();
|
||||
|
||||
// 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
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
#if wxUSE_GUI
|
||||
// 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;
|
||||
#endif // wxUSE_GUI
|
||||
|
||||
// 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; }
|
||||
|
||||
#if wxUSE_GUI
|
||||
// top level window functions
|
||||
// --------------------------
|
||||
|
||||
// return TRUE if our app has focus
|
||||
virtual bool IsActive() const { return m_isActive; }
|
||||
|
||||
// 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)
|
||||
virtual 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; }
|
||||
|
||||
#endif // wxUSE_GUI
|
||||
|
||||
// cmd line parsing stuff
|
||||
// ----------------------
|
||||
|
||||
// all of these methods may be overridden in the derived class to
|
||||
// customize the command line parsing (by default only a few standard
|
||||
// options are handled)
|
||||
//
|
||||
// you also need to call wxApp::OnInit() from YourApp::OnInit() for all
|
||||
// this to work
|
||||
|
||||
#if wxUSE_CMDLINE_PARSER
|
||||
// this one is called from OnInit() to add all supported options
|
||||
// to the given parser
|
||||
virtual void OnInitCmdLine(wxCmdLineParser& parser);
|
||||
|
||||
// called after successfully parsing the command line, return TRUE
|
||||
// to continue and FALSE to exit
|
||||
virtual bool OnCmdLineParsed(wxCmdLineParser& parser);
|
||||
|
||||
// called if "--help" option was specified, return TRUE to continue
|
||||
// and FALSE to exit
|
||||
virtual bool OnCmdLineHelp(wxCmdLineParser& parser);
|
||||
|
||||
// called if incorrect command line options were given, return
|
||||
// FALSE to abort and TRUE to continue
|
||||
virtual bool OnCmdLineError(wxCmdLineParser& parser);
|
||||
#endif // wxUSE_CMDLINE_PARSER
|
||||
|
||||
// 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()
|
||||
#if wxUSE_GUI && wxUSE_LOGGUI && !defined(__WXMICROWIN__)
|
||||
{ return new wxLogGui; }
|
||||
#else // !GUI
|
||||
{ return new wxLogStderr; }
|
||||
#endif // wxUSE_GUI
|
||||
#endif // wxUSE_LOG
|
||||
|
||||
#if wxUSE_GUI
|
||||
// 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 use of best visual flag (see below)
|
||||
void SetUseBestVisual( bool flag ) { m_useBestVisual = flag; }
|
||||
bool GetUseBestVisual() const { return m_useBestVisual; }
|
||||
|
||||
// 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; }
|
||||
|
||||
// called by toolkit-specific code to set the app status: active (we have
|
||||
// focus) or not and also the last window which had focus before we were
|
||||
// deactivated
|
||||
virtual void SetActive(bool isActive, wxWindow *lastFocus);
|
||||
#endif // wxUSE_GUI
|
||||
|
||||
// debugging support
|
||||
// -----------------
|
||||
|
||||
// this function is called when an assert failure occurs, the base class
|
||||
// version does the normal processing (i.e. shows the usual assert failure
|
||||
// dialog box)
|
||||
#ifdef __WXDEBUG__
|
||||
virtual void OnAssert(const wxChar *file, int line, const wxChar *msg);
|
||||
#endif // __WXDEBUG__
|
||||
|
||||
// implementation only from now on
|
||||
// -------------------------------
|
||||
|
||||
// helpers for dynamic wxApp construction
|
||||
static void SetInitializerFunction(wxAppInitializerFunction fn)
|
||||
{ m_appInitFn = fn; }
|
||||
static wxAppInitializerFunction GetInitializerFunction()
|
||||
{ return m_appInitFn; }
|
||||
|
||||
// process all events in the wxPendingEvents list
|
||||
virtual void ProcessPendingEvents();
|
||||
|
||||
// access to the command line arguments
|
||||
int argc;
|
||||
wxChar **argv;
|
||||
|
||||
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
|
||||
|
||||
// TRUE if the application wants to get debug output
|
||||
bool m_wantDebugOutput;
|
||||
|
||||
#if wxUSE_GUI
|
||||
// the main top level window - may be NULL
|
||||
wxWindow *m_topWindow;
|
||||
|
||||
// if TRUE, exit the main loop when the last top level window is deleted
|
||||
bool m_exitOnFrameDelete;
|
||||
|
||||
// TRUE if the apps whats to use the best visual on systems where
|
||||
// more than one are available (Sun, SGI, XFree86 4.0 ?)
|
||||
bool m_useBestVisual;
|
||||
|
||||
// does any of our windows has focus?
|
||||
bool m_isActive;
|
||||
#endif // wxUSE_GUI
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// now include the declaration of the real class
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if wxUSE_GUI
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/app.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/app.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/app.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/app.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/app.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/app.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/app.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/app.h"
|
||||
#endif
|
||||
#else // !GUI
|
||||
// can't use typedef because wxApp forward declared as a class
|
||||
class WXDLLEXPORT wxApp : public wxAppBase
|
||||
{
|
||||
};
|
||||
#endif // GUI/!GUI
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// the global data
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// the one and only application object - use of wxTheApp in application code
|
||||
// is discouraged, consider using DECLARE_APP() after which you may call
|
||||
// wxGetApp() which will return the object of the correct type (i.e. MyApp and
|
||||
// not wxApp)
|
||||
WXDLLEXPORT_DATA(extern wxApp*) wxTheApp;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// global functions
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// event loop related functions only work in GUI programs
|
||||
// ------------------------------------------------------
|
||||
|
||||
// Force an exit from main loop
|
||||
extern void WXDLLEXPORT wxExit();
|
||||
|
||||
// Yield to other apps/messages
|
||||
extern bool WXDLLEXPORT wxYield();
|
||||
|
||||
// Yield to other apps/messages
|
||||
extern void WXDLLEXPORT wxWakeUpIdle();
|
||||
|
||||
// Post a message to the given eventhandler which will be processed during the
|
||||
// next event loop iteration
|
||||
inline void wxPostEvent(wxEvtHandler *dest, wxEvent& event)
|
||||
{
|
||||
wxCHECK_RET( dest, wxT("need an object to post event to in wxPostEvent") );
|
||||
|
||||
#if wxUSE_GUI
|
||||
dest->AddPendingEvent(event);
|
||||
#else
|
||||
dest->ProcessEvent(event);
|
||||
#endif // wxUSE_GUI
|
||||
}
|
||||
|
||||
// console applications may avoid using DECLARE_APP and IMPLEMENT_APP macros
|
||||
// and call these functions instead at the program startup and termination
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
#if !wxUSE_GUI
|
||||
|
||||
// initialize the library (may be called as many times as needed, but each
|
||||
// call to wxInitialize() must be matched by wxUninitialize())
|
||||
extern bool WXDLLEXPORT wxInitialize();
|
||||
|
||||
// clean up - the library can't be used any more after the last call to
|
||||
// wxUninitialize()
|
||||
extern void WXDLLEXPORT wxUninitialize();
|
||||
|
||||
// create an object of this class on stack to initialize/cleanup thel ibrary
|
||||
// automatically
|
||||
class WXDLLEXPORT wxInitializer
|
||||
{
|
||||
public:
|
||||
// initialize the library
|
||||
wxInitializer() { m_ok = wxInitialize(); }
|
||||
|
||||
// has the initialization been successful? (explicit test)
|
||||
bool IsOk() const { return m_ok; }
|
||||
|
||||
// has the initialization been successful? (implicit test)
|
||||
operator bool() const { return m_ok; }
|
||||
|
||||
// dtor only does clean up if we initialized the library properly
|
||||
~wxInitializer() { if ( m_ok ) wxUninitialize(); }
|
||||
|
||||
private:
|
||||
bool m_ok;
|
||||
};
|
||||
|
||||
#endif // !wxUSE_GUI
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// 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); }
|
||||
};
|
||||
|
||||
// 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 !wxUSE_GUI || defined(__WXMOTIF__) || defined(__WXGTK__) || defined(__WXPM__) || defined(__WXMGL__)
|
||||
#define IMPLEMENT_WXWIN_MAIN \
|
||||
extern int wxEntry( int argc, char *argv[] ); \
|
||||
int main(int argc, char *argv[]) { return wxEntry(argc, argv); }
|
||||
#elif defined(__WXMAC__) && defined(__UNIX__)
|
||||
// wxMac seems to have a specific wxEntry prototype
|
||||
#define IMPLEMENT_WXWIN_MAIN \
|
||||
extern int wxEntry( int argc, char *argv[], bool enterLoop = 1 ); \
|
||||
int main(int argc, char *argv[]) { return wxEntry(argc, argv); }
|
||||
#elif defined(__WXMSW__) && defined(WXUSINGDLL)
|
||||
// NT defines APIENTRY, 3.x not
|
||||
#if !defined(WXAPIENTRY)
|
||||
#define WXAPIENTRY WXFAR wxSTDCALL
|
||||
#endif
|
||||
|
||||
#include <windows.h>
|
||||
#include "wx/msw/winundef.h"
|
||||
|
||||
#define IMPLEMENT_WXWIN_MAIN \
|
||||
extern "C" 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
|
||||
#endif
|
||||
|
||||
#ifdef __WXUNIVERSAL__
|
||||
#include "wx/univ/theme.h"
|
||||
|
||||
#define IMPLEMENT_WX_THEME_SUPPORT \
|
||||
WX_USE_THEME(win32); \
|
||||
WX_USE_THEME(gtk);
|
||||
#else
|
||||
#define IMPLEMENT_WX_THEME_SUPPORT
|
||||
#endif
|
||||
|
||||
// Use this macro if you want to define your own main() or WinMain() function
|
||||
// and call wxEntry() from there.
|
||||
#define IMPLEMENT_APP_NO_MAIN(appname) \
|
||||
wxApp *wxCreateApp() { return new appname; } \
|
||||
wxAppInitializer wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp); \
|
||||
appname& wxGetApp() { return *(appname *)wxTheApp; }
|
||||
|
||||
// Same as IMPLEMENT_APP() normally but doesn't include themes support in
|
||||
// wxUniversal builds
|
||||
#define IMPLEMENT_APP_NO_THEMES(appname) \
|
||||
IMPLEMENT_APP_NO_MAIN(appname) \
|
||||
IMPLEMENT_WXWIN_MAIN
|
||||
|
||||
// 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) \
|
||||
IMPLEMENT_APP_NO_THEMES(appname) \
|
||||
IMPLEMENT_WX_THEME_SUPPORT
|
||||
|
||||
// this macro can be used multiple times and just allows you to use wxGetApp()
|
||||
// function
|
||||
#define DECLARE_APP(appname) extern appname& wxGetApp();
|
||||
|
||||
#endif
|
||||
// _WX_APP_H_BASE_
|
||||
@@ -1,175 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/bitmap.h
|
||||
// Purpose: wxBitmap class interface
|
||||
// Author: Vaclav Slavik
|
||||
// Modified by:
|
||||
// Created: 22.04.01
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) wxWindows team
|
||||
// Licence: wxWindows licence
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_BITMAP_H_BASE_
|
||||
#define _WX_BITMAP_H_BASE_
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "bitmapbase.h"
|
||||
#endif
|
||||
|
||||
#include "wx/defs.h"
|
||||
#include "wx/object.h"
|
||||
#include "wx/string.h"
|
||||
#include "wx/gdiobj.h"
|
||||
#include "wx/gdicmn.h" // for wxBitmapType
|
||||
|
||||
class WXDLLEXPORT wxBitmap;
|
||||
class WXDLLEXPORT wxBitmapHandler;
|
||||
class WXDLLEXPORT wxImage;
|
||||
class WXDLLEXPORT wxMask;
|
||||
class WXDLLEXPORT wxPalette;
|
||||
|
||||
#if defined(__WXMGL__) || defined(__WXMAC__)
|
||||
// Only used by some ports
|
||||
// FIXME -- make all ports (but MSW which uses wxGDIImage) use these base classes
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxBitmapHandler: class which knows how to create/load/save bitmaps in
|
||||
// different formats
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxBitmapHandlerBase : public wxObject
|
||||
{
|
||||
public:
|
||||
wxBitmapHandlerBase()
|
||||
{
|
||||
m_type = wxBITMAP_TYPE_INVALID;
|
||||
}
|
||||
|
||||
virtual ~wxBitmapHandlerBase() { }
|
||||
|
||||
virtual bool Create(wxBitmap *bitmap, void *data, long flags,
|
||||
int width, int height, int depth = 1) = 0;
|
||||
virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
|
||||
int desiredWidth, int desiredHeight) = 0;
|
||||
virtual bool SaveFile(const wxBitmap *bitmap, const wxString& name,
|
||||
int type, const wxPalette *palette = NULL) = 0;
|
||||
|
||||
void SetName(const wxString& name) { m_name = name; }
|
||||
void SetExtension(const wxString& ext) { m_extension = ext; }
|
||||
void SetType(wxBitmapType type) { m_type = type; }
|
||||
wxString GetName() const { return m_name; }
|
||||
wxString GetExtension() const { return m_extension; }
|
||||
wxBitmapType GetType() const { return m_type; }
|
||||
|
||||
protected:
|
||||
wxString m_name;
|
||||
wxString m_extension;
|
||||
wxBitmapType m_type;
|
||||
|
||||
DECLARE_ABSTRACT_CLASS(wxBitmapHandlerBase)
|
||||
};
|
||||
|
||||
class WXDLLEXPORT wxBitmapBase : public wxGDIObject
|
||||
{
|
||||
public:
|
||||
wxBitmapBase() : wxGDIObject() {}
|
||||
virtual ~wxBitmapBase() {}
|
||||
|
||||
/*
|
||||
Derived class must implement these:
|
||||
|
||||
wxBitmap();
|
||||
wxBitmap(int width, int height, int depth = -1);
|
||||
wxBitmap(const char bits[], int width, int height, int depth = 1);
|
||||
wxBitmap(const char **bits);
|
||||
wxBitmap(char **bits);
|
||||
wxBitmap(const wxBitmap& bmp);
|
||||
wxBitmap(const wxString &filename, wxBitmapType type = wxBITMAP_TYPE_XPM);
|
||||
wxBitmap(const wxImage& image, int depth = -1);
|
||||
wxBitmap& operator = (const wxBitmap& bmp);
|
||||
bool operator == (const wxBitmap& bmp) const;
|
||||
bool operator != (const wxBitmap& bmp) const;
|
||||
|
||||
bool Create(int width, int height, int depth = -1);
|
||||
|
||||
static void InitStandardHandlers();
|
||||
*/
|
||||
|
||||
virtual bool Ok() const = 0;
|
||||
|
||||
virtual int GetHeight() const = 0;
|
||||
virtual int GetWidth() const = 0;
|
||||
virtual int GetDepth() const = 0;
|
||||
|
||||
virtual wxImage ConvertToImage() const = 0;
|
||||
|
||||
virtual wxMask *GetMask() const = 0;
|
||||
virtual void SetMask(wxMask *mask) = 0;
|
||||
|
||||
virtual wxBitmap GetSubBitmap(const wxRect& rect) const = 0;
|
||||
|
||||
virtual bool SaveFile(const wxString &name, wxBitmapType type,
|
||||
const wxPalette *palette = (wxPalette *)NULL) const = 0;
|
||||
virtual bool LoadFile(const wxString &name, wxBitmapType type) = 0;
|
||||
|
||||
virtual wxPalette *GetPalette() const = 0;
|
||||
virtual void SetPalette(const wxPalette& palette) = 0;
|
||||
|
||||
#if WXWIN_COMPATIBILITY
|
||||
wxPalette *GetColourMap() const { return GetPalette(); }
|
||||
void SetColourMap(wxPalette *cmap) { SetPalette(*cmap); };
|
||||
#endif // WXWIN_COMPATIBILITY
|
||||
|
||||
// copies the contents and mask of the given (colour) icon to the bitmap
|
||||
virtual bool CopyFromIcon(const wxIcon& icon) = 0;
|
||||
|
||||
// implementation:
|
||||
virtual void SetHeight(int height) = 0;
|
||||
virtual void SetWidth(int width) = 0;
|
||||
virtual void SetDepth(int depth) = 0;
|
||||
|
||||
// Format handling
|
||||
static inline wxList& GetHandlers() { return sm_handlers; }
|
||||
static void AddHandler(wxBitmapHandlerBase *handler);
|
||||
static void InsertHandler(wxBitmapHandlerBase *handler);
|
||||
static bool RemoveHandler(const wxString& name);
|
||||
static wxBitmapHandler *FindHandler(const wxString& name);
|
||||
static wxBitmapHandler *FindHandler(const wxString& extension, wxBitmapType bitmapType);
|
||||
static wxBitmapHandler *FindHandler(wxBitmapType bitmapType);
|
||||
|
||||
//static void InitStandardHandlers();
|
||||
// (wxBitmap must implement this one)
|
||||
|
||||
static void CleanUpHandlers();
|
||||
|
||||
protected:
|
||||
static wxList sm_handlers;
|
||||
|
||||
DECLARE_ABSTRACT_CLASS(wxBitmapBase)
|
||||
};
|
||||
#endif
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/bitmap.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/bitmap.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/bitmap.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/bitmap.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/bitmap.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/bitmap.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/bitmap.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/bitmap.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_BITMAP_H_BASE_
|
||||
@@ -1,98 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/bmpbutton.h
|
||||
// Purpose: wxBitmapButton class interface
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 25.08.00
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Vadim Zeitlin
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_BMPBUTTON_H_BASE_
|
||||
#define _WX_BMPBUTTON_H_BASE_
|
||||
|
||||
#if wxUSE_BMPBUTTON
|
||||
|
||||
#include "wx/bitmap.h"
|
||||
#include "wx/button.h"
|
||||
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxButtonNameStr;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxBitmapButton: a button which shows bitmaps instead of the usual string.
|
||||
// It has different bitmaps for different states (focused/disabled/pressed)
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxBitmapButtonBase : public wxButton
|
||||
{
|
||||
public:
|
||||
wxBitmapButtonBase() { m_marginX = m_marginY = 0; }
|
||||
|
||||
// set the bitmaps
|
||||
void SetBitmapLabel(const wxBitmap& bitmap)
|
||||
{ m_bmpNormal = bitmap; OnSetBitmap(); }
|
||||
void SetBitmapSelected(const wxBitmap& sel)
|
||||
{ m_bmpSelected = sel; OnSetBitmap(); };
|
||||
void SetBitmapFocus(const wxBitmap& focus)
|
||||
{ m_bmpFocus = focus; OnSetBitmap(); };
|
||||
void SetBitmapDisabled(const wxBitmap& disabled)
|
||||
{ m_bmpDisabled = disabled; OnSetBitmap(); };
|
||||
void SetLabel(const wxBitmap& bitmap)
|
||||
{ SetBitmapLabel(bitmap); }
|
||||
|
||||
// retrieve the bitmaps
|
||||
const wxBitmap& GetBitmapLabel() const { return m_bmpNormal; }
|
||||
const wxBitmap& GetBitmapSelected() const { return m_bmpSelected; }
|
||||
const wxBitmap& GetBitmapFocus() const { return m_bmpFocus; }
|
||||
const wxBitmap& GetBitmapDisabled() const { return m_bmpDisabled; }
|
||||
wxBitmap& GetBitmapLabel() { return m_bmpNormal; }
|
||||
wxBitmap& GetBitmapSelected() { return m_bmpSelected; }
|
||||
wxBitmap& GetBitmapFocus() { return m_bmpFocus; }
|
||||
wxBitmap& GetBitmapDisabled() { return m_bmpDisabled; }
|
||||
|
||||
// set/get the margins around the button
|
||||
virtual void SetMargins(int x, int y) { m_marginX = x; m_marginY = y; }
|
||||
int GetMarginX() const { return m_marginX; }
|
||||
int GetMarginY() const { return m_marginY; }
|
||||
|
||||
protected:
|
||||
// function called when any of the bitmaps changes
|
||||
virtual void OnSetBitmap() { }
|
||||
|
||||
// the bitmaps for various states
|
||||
wxBitmap m_bmpNormal,
|
||||
m_bmpSelected,
|
||||
m_bmpFocus,
|
||||
m_bmpDisabled;
|
||||
|
||||
// the margins around the bitmap
|
||||
int m_marginX,
|
||||
m_marginY;
|
||||
private:
|
||||
// Prevent Virtual function hiding warnings
|
||||
void SetLabel(const wxString& rsLabel)
|
||||
{ wxWindowBase::SetLabel(rsLabel); }
|
||||
};
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/bmpbuttn.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/bmpbuttn.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/bmpbuttn.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/bmpbuttn.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/bmpbuttn.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/bmpbuttn.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/bmpbuttn.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/bmpbuttn.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_BMPBUTTON
|
||||
|
||||
#endif // _WX_BMPBUTTON_H_BASE_
|
||||
@@ -1,23 +0,0 @@
|
||||
#ifndef _WX_BRUSH_H_BASE_
|
||||
#define _WX_BRUSH_H_BASE_
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/brush.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/brush.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/brush.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/brush.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/brush.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/brush.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/brush.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/brush.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_BRUSH_H_BASE_
|
||||
@@ -1,82 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/button.h
|
||||
// Purpose: wxButtonBase class
|
||||
// Author: Vadim Zetlin
|
||||
// Modified by:
|
||||
// Created: 15.08.00
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Vadim Zetlin
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_BUTTON_H_BASE_
|
||||
#define _WX_BUTTON_H_BASE_
|
||||
|
||||
#if wxUSE_BUTTON
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxButton flags
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// all these flags are obsolete
|
||||
#define wxBU_NOAUTODRAW 0x0000
|
||||
#define wxBU_AUTODRAW 0x0004
|
||||
#define wxBU_LEFT 0x0040
|
||||
#define wxBU_TOP 0x0080
|
||||
#define wxBU_RIGHT 0x0100
|
||||
#define wxBU_BOTTOM 0x0200
|
||||
|
||||
// by default, the buttons will be created with some (system dependent)
|
||||
// minimal size to make them look nicer, giving this style will make them as
|
||||
// small as possible
|
||||
#define wxBU_EXACTFIT 0x0001
|
||||
|
||||
#include "wx/control.h"
|
||||
|
||||
class WXDLLEXPORT wxBitmap;
|
||||
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxButtonNameStr;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxButton: a push button
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxButtonBase : public wxControl
|
||||
{
|
||||
public:
|
||||
// show the image in the button in addition to the label
|
||||
virtual void SetImageLabel(const wxBitmap& WXUNUSED(bitmap)) { }
|
||||
|
||||
// set the margins around the image
|
||||
virtual void SetImageMargins(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y)) { }
|
||||
|
||||
// this wxButton method is called when the button becomes the default one
|
||||
// on its panel
|
||||
virtual void SetDefault() { }
|
||||
|
||||
// returns the default button size for this platform
|
||||
static wxSize GetDefaultSize();
|
||||
};
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/button.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/button.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/button.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/button.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/button.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/button.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/button.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/button.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_BUTTON
|
||||
|
||||
#endif
|
||||
// _WX_BUTTON_H_BASE_
|
||||
@@ -1,56 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/checkbox.h
|
||||
// Purpose: wxCheckBox class interface
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 07.09.00
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) wxWindows team
|
||||
// Licence: wxWindows licence
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_CHECKBOX_H_BASE_
|
||||
#define _WX_CHECKBOX_H_BASE_
|
||||
|
||||
#if wxUSE_CHECKBOX
|
||||
|
||||
#include "wx/control.h"
|
||||
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxCheckBoxNameStr;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxCheckBox: a control which shows a label and a box which may be checked
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxCheckBoxBase : public wxControl
|
||||
{
|
||||
public:
|
||||
// set/get the checked status of the listbox
|
||||
virtual void SetValue(bool value) = 0;
|
||||
virtual bool GetValue() const = 0;
|
||||
|
||||
bool IsChecked() const { return GetValue(); }
|
||||
};
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/checkbox.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/checkbox.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/checkbox.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/checkbox.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/checkbox.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/checkbox.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/checkbox.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/checkbox.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_CHECKBOX
|
||||
|
||||
#endif
|
||||
// _WX_CHECKBOX_H_BASE_
|
||||
@@ -1,52 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/checklst.h
|
||||
// Purpose: wxCheckListBox class interface
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 12.09.00
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Vadim Zeitlin
|
||||
// Licence: wxWindows licence
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_CHECKLST_H_BASE_
|
||||
#define _WX_CHECKLST_H_BASE_
|
||||
|
||||
#if wxUSE_CHECKLISTBOX
|
||||
|
||||
#include "wx/listbox.h"
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxCheckListBox: a listbox whose items may be checked
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxCheckListBoxBase : public wxListBox
|
||||
{
|
||||
public:
|
||||
// check list box specific methods
|
||||
virtual bool IsChecked(size_t item) const = 0;
|
||||
virtual void Check(size_t item, bool check = TRUE) = 0;
|
||||
};
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/checklst.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/checklst.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/checklst.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/checklst.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/checklst.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/checklst.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/checklst.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/checklst.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_CHECKLISTBOX
|
||||
|
||||
#endif
|
||||
// _WX_CHECKLST_H_BASE_
|
||||
@@ -1,85 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/choice.h
|
||||
// Purpose: wxChoice class interface
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 26.07.99
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) wxWindows team
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_CHOICE_H_BASE_
|
||||
#define _WX_CHOICE_H_BASE_
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "choicebase.h"
|
||||
#endif
|
||||
|
||||
#if wxUSE_CHOICE
|
||||
|
||||
#include "wx/ctrlsub.h" // the base class
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// global data
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxChoiceNameStr;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxChoice allows to select one of a non-modifiable list of strings
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxChoiceBase : public wxControlWithItems
|
||||
{
|
||||
public:
|
||||
// all generic methods are in wxControlWithItems
|
||||
#ifdef __DARWIN__
|
||||
virtual ~wxChoiceBase() {}
|
||||
#endif
|
||||
|
||||
// single selection logic
|
||||
virtual void SetSelection(int n) = 0;
|
||||
virtual bool SetStringSelection(const wxString& s);
|
||||
|
||||
// don't override this
|
||||
virtual void Select(int n) { SetSelection(n); }
|
||||
|
||||
// set/get the number of columns in the control (as they're not supporte on
|
||||
// most platforms, they do nothing by default)
|
||||
virtual void SetColumns(int WXUNUSED(n) = 1 ) { }
|
||||
virtual int GetColumns() const { return 1 ; }
|
||||
|
||||
// emulate selecting the item event.GetInt()
|
||||
void Command(wxCommandEvent& event);
|
||||
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// include the platform-dependent class definition
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/choice.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/choice.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/choice.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/choice.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/choice.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/choice.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/choice.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_CHOICE
|
||||
|
||||
#endif
|
||||
// _WX_CHOICE_H_BASE_
|
||||
@@ -1,142 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/clipbrd.h
|
||||
// Purpose: wxClipboad class and clipboard functions
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 19.10.99
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) wxWindows Team
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_CLIPBRD_H_BASE_
|
||||
#define _WX_CLIPBRD_H_BASE_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "clipboardbase.h"
|
||||
#endif
|
||||
|
||||
#include "wx/defs.h"
|
||||
|
||||
#if wxUSE_CLIPBOARD
|
||||
|
||||
|
||||
#include "wx/object.h"
|
||||
#include "wx/wxchar.h"
|
||||
|
||||
class WXDLLEXPORT wxDataFormat;
|
||||
class WXDLLEXPORT wxDataObject;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxClipboard represents the system clipboard. Normally, you should use
|
||||
// wxTheClipboard which is a global pointer to the (unique) clipboard.
|
||||
//
|
||||
// Clipboard can be used to copy data to/paste data from. It works together
|
||||
// with wxDataObject.
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxClipboardBase : public wxObject
|
||||
{
|
||||
public:
|
||||
wxClipboardBase();
|
||||
|
||||
// open the clipboard before Add/SetData() and GetData()
|
||||
virtual bool Open() = 0;
|
||||
|
||||
// close the clipboard after Add/SetData() and GetData()
|
||||
virtual void Close() = 0;
|
||||
|
||||
// query whether the clipboard is opened
|
||||
virtual bool IsOpened() const = 0;
|
||||
|
||||
// add to the clipboard data
|
||||
//
|
||||
// NB: the clipboard owns the pointer and will delete it, so data must be
|
||||
// allocated on the heap
|
||||
virtual bool AddData( wxDataObject *data ) = 0;
|
||||
|
||||
// set the clipboard data, this is the same as Clear() followed by
|
||||
// AddData()
|
||||
virtual bool SetData( wxDataObject *data ) = 0;
|
||||
|
||||
// ask if data in correct format is available
|
||||
virtual bool IsSupported( const wxDataFormat& format ) = 0;
|
||||
|
||||
// fill data with data on the clipboard (if available)
|
||||
virtual bool GetData( wxDataObject& data ) = 0;
|
||||
|
||||
// clears wxTheClipboard and the system's clipboard if possible
|
||||
virtual void Clear() = 0;
|
||||
|
||||
// flushes the clipboard: this means that the data which is currently on
|
||||
// clipboard will stay available even after the application exits (possibly
|
||||
// eating memory), otherwise the clipboard will be emptied on exit
|
||||
virtual bool Flush() { return FALSE; }
|
||||
|
||||
// X11 has two clipboards which get selected by this call. Empty on MSW.
|
||||
virtual void UsePrimarySelection( bool WXUNUSED(primary) = FALSE ) { }
|
||||
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// include platform-specific class declaration
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/clipbrd.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/clipbrd.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/clipbrd.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/clipbrd.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/gtk/clipbrd.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/clipbrd.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/clipbrd.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/clipbrd.h"
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// globals
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// The global clipboard object
|
||||
WXDLLEXPORT_DATA(extern wxClipboard *) wxTheClipboard;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// helpful class for opening the clipboard and automatically closing it
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxClipboardLocker
|
||||
{
|
||||
public:
|
||||
wxClipboardLocker(wxClipboard *clipboard = (wxClipboard *)NULL)
|
||||
{
|
||||
m_clipboard = clipboard ? clipboard : wxTheClipboard;
|
||||
if ( m_clipboard )
|
||||
{
|
||||
m_clipboard->Open();
|
||||
}
|
||||
}
|
||||
|
||||
bool operator!() const { return !m_clipboard->IsOpened(); }
|
||||
|
||||
~wxClipboardLocker()
|
||||
{
|
||||
if ( m_clipboard )
|
||||
{
|
||||
m_clipboard->Close();
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
wxClipboard *m_clipboard;
|
||||
};
|
||||
|
||||
#endif // wxUSE_CLIPBOARD
|
||||
|
||||
#endif // _WX_CLIPBRD_H_BASE_
|
||||
@@ -1,25 +0,0 @@
|
||||
#ifndef _WX_COLOUR_H_BASE_
|
||||
#define _WX_COLOUR_H_BASE_
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/colour.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/colour.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/colour.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/colour.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/colour.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/colour.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/colour.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/colour.h"
|
||||
#endif
|
||||
|
||||
#define wxColor wxColour
|
||||
|
||||
#endif
|
||||
// _WX_COLOUR_H_BASE_
|
||||
@@ -1,75 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/combobox.h
|
||||
// Purpose: wxComboBox declaration
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 24.12.00
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 1996-2000 wxWindows team
|
||||
// Licence: wxWindows licence
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_COMBOBOX_H_BASE_
|
||||
#define _WX_COMBOBOX_H_BASE_
|
||||
|
||||
#include "wx/defs.h"
|
||||
|
||||
#if wxUSE_COMBOBOX
|
||||
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxComboBoxNameStr;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxComboBoxBase: this interface defines the methods wxComboBox must implement
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#include "wx/ctrlsub.h"
|
||||
|
||||
class WXDLLEXPORT wxComboBoxBase : public wxItemContainer
|
||||
{
|
||||
public:
|
||||
// wxTextCtrl-like methods wxComboBox must implement
|
||||
virtual wxString GetValue() const = 0;
|
||||
virtual void SetValue(const wxString& value) = 0;
|
||||
|
||||
virtual void Copy() = 0;
|
||||
virtual void Cut() = 0;
|
||||
virtual void Paste() = 0;
|
||||
virtual void SetInsertionPoint(long pos) = 0;
|
||||
virtual long GetInsertionPoint() const = 0;
|
||||
virtual long GetLastPosition() const = 0;
|
||||
virtual void Replace(long from, long to, const wxString& value) = 0;
|
||||
virtual void SetSelection(long from, long to) = 0;
|
||||
virtual void SetEditable(bool editable) = 0;
|
||||
|
||||
virtual void SetInsertionPointEnd()
|
||||
{ SetInsertionPoint(GetLastPosition()); }
|
||||
virtual void Remove(long from, long to)
|
||||
{ Replace(from, to, wxEmptyString); }
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// include the platform-dependent header defining the real class
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/combobox.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/combobox.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/combobox.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/combobox.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/combobox.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/combobox.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/combobox.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/combobox.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_COMBOBOX
|
||||
|
||||
#endif
|
||||
// _WX_COMBOBOX_H_BASE_
|
||||
@@ -1,98 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/control.h
|
||||
// Purpose: wxControl common interface
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 26.07.99
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) wxWindows team
|
||||
// Licence: wxWindows license
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_CONTROL_H_BASE_
|
||||
#define _WX_CONTROL_H_BASE_
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "controlbase.h"
|
||||
#endif
|
||||
|
||||
#if wxUSE_CONTROLS
|
||||
|
||||
#include "wx/window.h" // base class
|
||||
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxControlNameStr;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxControl is the base class for all controls
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxControlBase : public wxWindow
|
||||
{
|
||||
public:
|
||||
// Create() function adds the validator parameter
|
||||
bool Create(wxWindow *parent, wxWindowID id,
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& size = wxDefaultSize,
|
||||
long style = 0,
|
||||
const wxValidator& validator = wxDefaultValidator,
|
||||
const wxString& name = wxControlNameStr);
|
||||
|
||||
// simulates the event of given type (i.e. wxButton::Command() is just as
|
||||
// if the button was clicked)
|
||||
virtual void Command(wxCommandEvent &event);
|
||||
|
||||
// get the control alignment (left/right/centre, top/bottom/centre)
|
||||
int GetAlignment() const { return m_windowStyle & wxALIGN_MASK; }
|
||||
|
||||
#ifdef __DARWIN__
|
||||
virtual ~wxControlBase() { }
|
||||
#endif
|
||||
|
||||
protected:
|
||||
// creates the control (calls wxWindowBase::CreateBase inside) and adds it
|
||||
// to the list of parents children
|
||||
bool CreateControl(wxWindowBase *parent,
|
||||
wxWindowID id,
|
||||
const wxPoint& pos,
|
||||
const wxSize& size,
|
||||
long style,
|
||||
const wxValidator& validator,
|
||||
const wxString& name);
|
||||
|
||||
// inherit colour and font settings from the parent window
|
||||
void InheritAttributes();
|
||||
|
||||
// initialize the common fields of wxCommandEvent
|
||||
void InitCommandEvent(wxCommandEvent& event) const;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// include platform-dependent wxControl declarations
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/control.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/control.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/control.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/control.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/control.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/control.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/control.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/control.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_CONTROLS
|
||||
|
||||
#endif
|
||||
// _WX_CONTROL_H_BASE_
|
||||
@@ -1,60 +0,0 @@
|
||||
#ifndef _WX_CURSOR_H_BASE_
|
||||
#define _WX_CURSOR_H_BASE_
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/cursor.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/cursor.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/cursor.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/cursor.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/cursor.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/cursor.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/cursor.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/cursor.h"
|
||||
#endif
|
||||
|
||||
#include "wx/utils.h"
|
||||
|
||||
/* This is a small class which can be used by all ports
|
||||
to temporarily suspend the busy cursor. Useful in modal
|
||||
dialogs.
|
||||
|
||||
Actually that is not (any longer) quite true.. currently it is
|
||||
only used in wxGTK Dialog::ShowModal() and now uses static
|
||||
wxBusyCursor methods that are only implemented for wxGTK so far.
|
||||
The BusyCursor handling code should probably be implemented in
|
||||
common code somewhere instead of the separate implementations we
|
||||
currently have. Also the name BusyCursorSuspender is a little
|
||||
misleading since it doesn't actually suspend the BusyCursor, just
|
||||
masks one that is already showing.
|
||||
If another call to wxBeginBusyCursor is made while this is active
|
||||
the Busy Cursor will again be shown. But at least now it doesn't
|
||||
interfere with the state of wxIsBusy() -- RL
|
||||
|
||||
*/
|
||||
class wxBusyCursorSuspender
|
||||
{
|
||||
public:
|
||||
wxBusyCursorSuspender()
|
||||
{
|
||||
if( wxIsBusy() )
|
||||
{
|
||||
wxSetCursor( wxBusyCursor::GetStoredCursor() );
|
||||
}
|
||||
}
|
||||
~wxBusyCursorSuspender()
|
||||
{
|
||||
if( wxIsBusy() )
|
||||
{
|
||||
wxSetCursor( wxBusyCursor::GetBusyCursor() );
|
||||
}
|
||||
}
|
||||
};
|
||||
#endif
|
||||
// _WX_CURSOR_H_BASE_
|
||||
@@ -1,467 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/dataobj.h
|
||||
// Purpose: common data object classes
|
||||
// Author: Vadim Zeitlin, Robert Roebling
|
||||
// Modified by:
|
||||
// Created: 26.05.99
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) wxWindows Team
|
||||
// Licence: wxWindows license
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_DATAOBJ_H_BASE_
|
||||
#define _WX_DATAOBJ_H_BASE_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "dataobjbase.h"
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#include "wx/defs.h"
|
||||
#include "wx/string.h"
|
||||
#include "wx/bitmap.h"
|
||||
#include "wx/list.h"
|
||||
|
||||
// ============================================================================
|
||||
/*
|
||||
Generic data transfer related classes. The class hierarchy is as follows:
|
||||
|
||||
- wxDataObject-
|
||||
/ \
|
||||
/ \
|
||||
wxDataObjectSimple wxDataObjectComposite
|
||||
/ | \
|
||||
/ | \
|
||||
wxTextDataObject | wxBitmapDataObject
|
||||
|
|
||||
wxCustomDataObject
|
||||
|
||||
*/
|
||||
// ============================================================================
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxDataFormat class is declared in platform-specific headers: it represents
|
||||
// a format for data which may be either one of the standard ones (text,
|
||||
// bitmap, ...) or a custom one which is then identified by a unique string.
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
/* the class interface looks like this (pseudo code):
|
||||
|
||||
class wxDataFormat
|
||||
{
|
||||
public:
|
||||
typedef <integral type> NativeFormat;
|
||||
|
||||
wxDataFormat(NativeFormat format = wxDF_INVALID);
|
||||
wxDataFormat(const wxChar *format);
|
||||
|
||||
wxDataFormat& operator=(NativeFormat format);
|
||||
wxDataFormat& operator=(const wxDataFormat& format);
|
||||
|
||||
bool operator==(NativeFormat format) const;
|
||||
bool operator!=(NativeFormat format) const;
|
||||
|
||||
void SetType(NativeFormat format);
|
||||
NativeFormat GetType() const;
|
||||
|
||||
wxString GetId() const;
|
||||
void SetId(const wxChar *format);
|
||||
};
|
||||
|
||||
*/
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/ole/dataform.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/dataform.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/dataform.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/dataform.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/dataform.h"
|
||||
#endif
|
||||
|
||||
// the value for default argument to some functions (corresponds to
|
||||
// wxDF_INVALID)
|
||||
extern WXDLLEXPORT const wxDataFormat& wxFormatInvalid;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxDataObject represents a piece of data which knows which formats it
|
||||
// supports and knows how to render itself in each of them - GetDataHere(),
|
||||
// and how to restore data from the buffer (SetData()).
|
||||
//
|
||||
// Although this class may be used directly (i.e. custom classes may be
|
||||
// derived from it), in many cases it might be simpler to use either
|
||||
// wxDataObjectSimple or wxDataObjectComposite classes.
|
||||
//
|
||||
// A data object may be "read only", i.e. support only GetData() functions or
|
||||
// "read-write", i.e. support both GetData() and SetData() (in principle, it
|
||||
// might be "write only" too, but this is rare). Moreover, it doesn't have to
|
||||
// support the same formats in Get() and Set() directions: for example, a data
|
||||
// object containing JPEG image might accept BMPs in GetData() because JPEG
|
||||
// image may be easily transformed into BMP but not in SetData(). Accordingly,
|
||||
// all methods dealing with formats take an additional "direction" argument
|
||||
// which is either SET or GET and which tells the function if the format needs
|
||||
// to be supported by SetData() or GetDataHere().
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxDataObjectBase
|
||||
{
|
||||
public:
|
||||
enum Direction
|
||||
{
|
||||
Get = 0x01, // format is supported by GetDataHere()
|
||||
Set = 0x02, // format is supported by SetData()
|
||||
Both = 0x03 // format is supported by both (unused currently)
|
||||
};
|
||||
|
||||
// this class is polymorphic, hence it needs a virtual dtor
|
||||
virtual ~wxDataObjectBase();
|
||||
|
||||
// get the best suited format for rendering our data
|
||||
virtual wxDataFormat GetPreferredFormat(Direction dir = Get) const = 0;
|
||||
|
||||
// get the number of formats we support
|
||||
virtual size_t GetFormatCount(Direction dir = Get) const = 0;
|
||||
|
||||
// return all formats in the provided array (of size GetFormatCount())
|
||||
virtual void GetAllFormats(wxDataFormat *formats,
|
||||
Direction dir = Get) const = 0;
|
||||
|
||||
// get the (total) size of data for the given format
|
||||
virtual size_t GetDataSize(const wxDataFormat& format) const = 0;
|
||||
|
||||
// copy raw data (in the specified format) to the provided buffer, return
|
||||
// TRUE if data copied successfully, FALSE otherwise
|
||||
virtual bool GetDataHere(const wxDataFormat& format, void *buf) const = 0;
|
||||
|
||||
// get data from the buffer of specified length (in the given format),
|
||||
// return TRUE if the data was read successfully, FALSE otherwise
|
||||
virtual bool SetData(const wxDataFormat& WXUNUSED(format),
|
||||
size_t WXUNUSED(len), const void * WXUNUSED(buf))
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// returns TRUE if this format is supported
|
||||
bool IsSupported(const wxDataFormat& format, Direction dir = Get) const;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// include the platform-specific declarations of wxDataObject
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/ole/dataobj.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/dataobj.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/dataobj.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/dnd.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/dataobj.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/dataobj.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/dnd.h"
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxDataObjectSimple is a wxDataObject which only supports one format (in
|
||||
// both Get and Set directions, but you may return FALSE from GetDataHere() or
|
||||
// SetData() if one of them is not supported). This is the simplest possible
|
||||
// wxDataObject implementation.
|
||||
//
|
||||
// This is still an "abstract base class" (although it doesn't have any pure
|
||||
// virtual functions), to use it you should derive from it and implement
|
||||
// GetDataSize(), GetDataHere() and SetData() functions because the base class
|
||||
// versions don't do anything - they just return "not implemented".
|
||||
//
|
||||
// This class should be used when you provide data in only one format (no
|
||||
// conversion to/from other formats), either a standard or a custom one.
|
||||
// Otherwise, you should use wxDataObjectComposite or wxDataObject directly.
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxDataObjectSimple : public wxDataObject
|
||||
{
|
||||
public:
|
||||
// ctor takes the format we support, but it can also be set later with
|
||||
// SetFormat()
|
||||
wxDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
|
||||
: m_format(format)
|
||||
{
|
||||
}
|
||||
|
||||
// get/set the format we support
|
||||
const wxDataFormat& GetFormat() const { return m_format; }
|
||||
void SetFormat(const wxDataFormat& format) { m_format = format; }
|
||||
|
||||
// virtual functions to override in derived class (the base class versions
|
||||
// just return "not implemented")
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
// get the size of our data
|
||||
virtual size_t GetDataSize() const
|
||||
{ return 0; }
|
||||
|
||||
// copy our data to the buffer
|
||||
virtual bool GetDataHere(void *WXUNUSED(buf)) const
|
||||
{ return FALSE; }
|
||||
|
||||
// copy data from buffer to our data
|
||||
virtual bool SetData(size_t WXUNUSED(len), const void *WXUNUSED(buf))
|
||||
{ return FALSE; }
|
||||
|
||||
// implement base class pure virtuals
|
||||
// ----------------------------------
|
||||
virtual wxDataFormat GetPreferredFormat(wxDataObjectBase::Direction WXUNUSED(dir) = Get) const
|
||||
{ return m_format; }
|
||||
virtual size_t GetFormatCount(wxDataObjectBase::Direction WXUNUSED(dir) = Get) const
|
||||
{ return 1; }
|
||||
virtual void GetAllFormats(wxDataFormat *formats,
|
||||
wxDataObjectBase::Direction WXUNUSED(dir) = Get) const
|
||||
{ *formats = m_format; }
|
||||
virtual size_t GetDataSize(const wxDataFormat& WXUNUSED(format)) const
|
||||
{ return GetDataSize(); }
|
||||
virtual bool GetDataHere(const wxDataFormat& WXUNUSED(format),
|
||||
void *buf) const
|
||||
{ return GetDataHere(buf); }
|
||||
virtual bool SetData(const wxDataFormat& WXUNUSED(format),
|
||||
size_t len, const void *buf)
|
||||
{ return SetData(len, buf); }
|
||||
|
||||
private:
|
||||
// the one and only format we support
|
||||
wxDataFormat m_format;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxDataObjectComposite is the simplest way to implement wxDataObject
|
||||
// supporting multiple formats. It contains several wxDataObjectSimple and
|
||||
// supports all formats supported by any of them.
|
||||
//
|
||||
// This class shouldn't be (normally) derived from, but may be used directly.
|
||||
// If you need more flexibility than what it provides, you should probably use
|
||||
// wxDataObject directly.
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
WX_DECLARE_EXPORTED_LIST(wxDataObjectSimple, wxSimpleDataObjectList);
|
||||
|
||||
class WXDLLEXPORT wxDataObjectComposite : public wxDataObject
|
||||
{
|
||||
public:
|
||||
// ctor
|
||||
wxDataObjectComposite() { m_preferred = 0; }
|
||||
|
||||
// add data object (it will be deleted by wxDataObjectComposite, hence it
|
||||
// must be allocated on the heap) whose format will become the preferred
|
||||
// one if preferred == TRUE
|
||||
void Add(wxDataObjectSimple *dataObject, bool preferred = FALSE);
|
||||
|
||||
// implement base class pure virtuals
|
||||
// ----------------------------------
|
||||
virtual wxDataFormat GetPreferredFormat(wxDataObjectBase::Direction dir = Get) const;
|
||||
virtual size_t GetFormatCount(wxDataObjectBase::Direction dir = Get) const;
|
||||
virtual void GetAllFormats(wxDataFormat *formats, wxDataObjectBase::Direction dir = Get) const;
|
||||
virtual size_t GetDataSize(const wxDataFormat& format) const;
|
||||
virtual bool GetDataHere(const wxDataFormat& format, void *buf) const;
|
||||
virtual bool SetData(const wxDataFormat& format, size_t len, const void *buf);
|
||||
|
||||
protected:
|
||||
// returns the pointer to the object which supports this format or NULL
|
||||
wxDataObjectSimple *GetObject(const wxDataFormat& format) const;
|
||||
|
||||
private:
|
||||
// the list of all (simple) data objects whose formats we support
|
||||
wxSimpleDataObjectList m_dataObjects;
|
||||
|
||||
// the index of the preferred one (0 initially, so by default the first
|
||||
// one is the preferred)
|
||||
size_t m_preferred;
|
||||
};
|
||||
|
||||
// ============================================================================
|
||||
// Standard implementations of wxDataObjectSimple which can be used directly
|
||||
// (i.e. without having to derive from them) for standard data type transfers.
|
||||
//
|
||||
// Note that although all of them can work with provided data, you can also
|
||||
// override their virtual GetXXX() functions to only provide data on demand.
|
||||
// ============================================================================
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxTextDataObject contains text data
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxTextDataObject : public wxDataObjectSimple
|
||||
{
|
||||
public:
|
||||
// ctor: you can specify the text here or in SetText(), or override
|
||||
// GetText()
|
||||
wxTextDataObject(const wxString& text = wxEmptyString)
|
||||
: wxDataObjectSimple(wxDF_TEXT), m_text(text)
|
||||
{
|
||||
}
|
||||
|
||||
// virtual functions which you may override if you want to provide text on
|
||||
// demand only - otherwise, the trivial default versions will be used
|
||||
virtual size_t GetTextLength() const { return m_text.Len() + 1; }
|
||||
virtual wxString GetText() const { return m_text; }
|
||||
virtual void SetText(const wxString& text) { m_text = text; }
|
||||
|
||||
// implement base class pure virtuals
|
||||
// ----------------------------------
|
||||
virtual size_t GetDataSize() const;
|
||||
virtual bool GetDataHere(void *buf) const;
|
||||
virtual bool SetData(size_t len, const void *buf);
|
||||
|
||||
private:
|
||||
wxString m_text;
|
||||
|
||||
// virtual function hiding supression
|
||||
size_t GetDataSize(const wxDataFormat& format) const
|
||||
{ return(wxDataObjectSimple::GetDataSize(format)); }
|
||||
bool GetDataHere(const wxDataFormat& format, void *pBuf) const
|
||||
{ return(wxDataObjectSimple::GetDataHere(format, pBuf)); }
|
||||
bool SetData(const wxDataFormat& format, size_t nLen, const void* pBuf)
|
||||
{ return(wxDataObjectSimple::SetData(format, nLen, pBuf)); }
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxBitmapDataObject contains a bitmap
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxBitmapDataObjectBase : public wxDataObjectSimple
|
||||
{
|
||||
public:
|
||||
// ctor: you can specify the bitmap here or in SetBitmap(), or override
|
||||
// GetBitmap()
|
||||
wxBitmapDataObjectBase(const wxBitmap& bitmap = wxNullBitmap)
|
||||
: wxDataObjectSimple(wxDF_BITMAP), m_bitmap(bitmap)
|
||||
{
|
||||
}
|
||||
|
||||
// virtual functions which you may override if you want to provide data on
|
||||
// demand only - otherwise, the trivial default versions will be used
|
||||
virtual wxBitmap GetBitmap() const { return m_bitmap; }
|
||||
virtual void SetBitmap(const wxBitmap& bitmap) { m_bitmap = bitmap; }
|
||||
|
||||
protected:
|
||||
wxBitmap m_bitmap;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxFileDataObject contains a list of filenames
|
||||
//
|
||||
// NB: notice that this is a "write only" object, it can only be filled with
|
||||
// data from drag and drop operation.
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxFileDataObjectBase : public wxDataObjectSimple
|
||||
{
|
||||
public:
|
||||
// ctor: use AddFile() later to fill the array
|
||||
wxFileDataObjectBase() : wxDataObjectSimple(wxDF_FILENAME) { }
|
||||
|
||||
// get a reference to our array
|
||||
const wxArrayString& GetFilenames() const { return m_filenames; }
|
||||
|
||||
// the Get() functions do nothing for us
|
||||
virtual size_t GetDataSize() const { return 0; }
|
||||
virtual bool GetDataHere(void *WXUNUSED(buf)) const { return FALSE; }
|
||||
|
||||
protected:
|
||||
wxArrayString m_filenames;
|
||||
|
||||
private:
|
||||
// Virtual function hiding supression
|
||||
size_t GetDataSize(const wxDataFormat& format) const
|
||||
{ return(wxDataObjectSimple::GetDataSize(format)); }
|
||||
bool GetDataHere(const wxDataFormat& format, void* pBuf) const
|
||||
{ return(wxDataObjectSimple::GetDataHere(format, pBuf)); }
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxCustomDataObject contains arbitrary untyped user data.
|
||||
//
|
||||
// It is understood that this data can be copied bitwise.
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxCustomDataObject : public wxDataObjectSimple
|
||||
{
|
||||
public:
|
||||
// if you don't specify the format in the ctor, you can still use
|
||||
// SetFormat() later
|
||||
wxCustomDataObject(const wxDataFormat& format = wxFormatInvalid);
|
||||
|
||||
// the dtor calls Free()
|
||||
virtual ~wxCustomDataObject();
|
||||
|
||||
// you can call SetData() to set m_data: it will make a copy of the data
|
||||
// you pass - or you can use TakeData() which won't copy anything, but
|
||||
// will take ownership of data (i.e. will call Free() on it later)
|
||||
void TakeData(size_t size, void *data);
|
||||
|
||||
// this function is called to allocate "size" bytes of memory from
|
||||
// SetData(). The default version uses operator new[].
|
||||
virtual void *Alloc(size_t size);
|
||||
|
||||
// this function is called when the data is freed, you may override it to
|
||||
// anything you want (or may be nothing at all). The default version calls
|
||||
// operator delete[] on m_data
|
||||
virtual void Free();
|
||||
|
||||
// get data: you may override these functions if you wish to provide data
|
||||
// only when it's requested
|
||||
virtual size_t GetSize() const { return m_size; }
|
||||
virtual void *GetData() const { return m_data; }
|
||||
|
||||
// implement base class pure virtuals
|
||||
// ----------------------------------
|
||||
virtual size_t GetDataSize() const;
|
||||
virtual bool GetDataHere(void *buf) const;
|
||||
virtual bool SetData(size_t size, const void *buf);
|
||||
|
||||
private:
|
||||
size_t m_size;
|
||||
void *m_data;
|
||||
|
||||
// virtual function hiding supression
|
||||
size_t GetDataSize(const wxDataFormat& format) const
|
||||
{ return(wxDataObjectSimple::GetDataSize(format)); }
|
||||
bool GetDataHere(const wxDataFormat& format, void* pBuf) const
|
||||
{ return(wxDataObjectSimple::GetDataHere(format, pBuf)); }
|
||||
bool SetData(const wxDataFormat& format, size_t nLen, const void* pBuf)
|
||||
{ return(wxDataObjectSimple::SetData(format, nLen, pBuf)); }
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// include platform-specific declarations of wxXXXBase classes
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/ole/dataobj2.h"
|
||||
|
||||
// wxURLDataObject defined in msw/ole/dataobj2.h
|
||||
#else // !__WXMSW__
|
||||
#if defined(__WXGTK__)
|
||||
#include "wx/gtk/dataobj2.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/dataobj2.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/dataobj2.h"
|
||||
#endif
|
||||
|
||||
// wxURLDataObject is simply wxTextDataObject with a different name
|
||||
class WXDLLEXPORT wxURLDataObject : public wxTextDataObject
|
||||
{
|
||||
public:
|
||||
wxString GetURL() const { return GetText(); }
|
||||
};
|
||||
#endif // __WXMSW__/!__WXMSW__
|
||||
|
||||
#endif // _WX_DATAOBJ_H_BASE_
|
||||
812
include/wx/dc.h
812
include/wx/dc.h
@@ -1,812 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: dc.h
|
||||
// Purpose: wxDC class
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 05/25/99
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) wxWindows team
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_DC_H_BASE_
|
||||
#define _WX_DC_H_BASE_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "dcbase.h"
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers which we must include here
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#include "wx/object.h" // the base class
|
||||
|
||||
#include "wx/cursor.h" // we have member variables of these classes
|
||||
#include "wx/font.h" // so we can't do without them
|
||||
#include "wx/colour.h"
|
||||
#include "wx/brush.h"
|
||||
#include "wx/pen.h"
|
||||
#include "wx/palette.h"
|
||||
|
||||
#include "wx/list.h" // we use wxList in inline functions
|
||||
|
||||
class WXDLLEXPORT wxDCBase;
|
||||
|
||||
class WXDLLEXPORT wxDrawObject
|
||||
{
|
||||
public:
|
||||
|
||||
wxDrawObject()
|
||||
{
|
||||
ResetBoundingBox();
|
||||
}
|
||||
|
||||
virtual ~wxDrawObject() { }
|
||||
|
||||
virtual void Draw(wxDCBase&) const { }
|
||||
|
||||
virtual void CalcBoundingBox(wxCoord x, wxCoord y)
|
||||
{
|
||||
if ( m_isBBoxValid )
|
||||
{
|
||||
if ( x < m_minX ) m_minX = x;
|
||||
if ( y < m_minY ) m_minY = y;
|
||||
if ( x > m_maxX ) m_maxX = x;
|
||||
if ( y > m_maxY ) m_maxY = y;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_isBBoxValid = TRUE;
|
||||
|
||||
m_minX = x;
|
||||
m_minY = y;
|
||||
m_maxX = x;
|
||||
m_maxY = y;
|
||||
}
|
||||
}
|
||||
|
||||
void ResetBoundingBox()
|
||||
{
|
||||
m_isBBoxValid = FALSE;
|
||||
|
||||
m_minX = m_maxX = m_minY = m_maxY = 0;
|
||||
}
|
||||
|
||||
// Get the final bounding box of the PostScript or Metafile picture.
|
||||
|
||||
wxCoord MinX() const { return m_minX; }
|
||||
wxCoord MaxX() const { return m_maxX; }
|
||||
wxCoord MinY() const { return m_minY; }
|
||||
wxCoord MaxY() const { return m_maxY; }
|
||||
|
||||
//to define the type of object for derived objects
|
||||
virtual int GetType()=0;
|
||||
|
||||
protected:
|
||||
//for boundingbox calculation
|
||||
bool m_isBBoxValid:1;
|
||||
//for boundingbox calculation
|
||||
wxCoord m_minX, m_minY, m_maxX, m_maxY;
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// global variables
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
WXDLLEXPORT_DATA(extern int) wxPageNumber;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// wxDC is the device context - object on which any drawing is done
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxDCBase : public wxObject
|
||||
{
|
||||
public:
|
||||
wxDCBase()
|
||||
{
|
||||
m_clipping = FALSE;
|
||||
m_ok = TRUE;
|
||||
|
||||
ResetBoundingBox();
|
||||
|
||||
m_signX = m_signY = 1;
|
||||
|
||||
m_logicalOriginX = m_logicalOriginY =
|
||||
m_deviceOriginX = m_deviceOriginY = 0;
|
||||
|
||||
m_logicalScaleX = m_logicalScaleY =
|
||||
m_userScaleX = m_userScaleY =
|
||||
m_scaleX = m_scaleY = 1.0;
|
||||
|
||||
m_logicalFunction = wxCOPY;
|
||||
|
||||
m_backgroundMode = wxTRANSPARENT;
|
||||
|
||||
m_mappingMode = wxMM_TEXT;
|
||||
|
||||
m_backgroundBrush = *wxTRANSPARENT_BRUSH;
|
||||
|
||||
m_textForegroundColour = *wxBLACK;
|
||||
m_textBackgroundColour = *wxWHITE;
|
||||
|
||||
m_colour = wxColourDisplay();
|
||||
}
|
||||
|
||||
~wxDCBase() { }
|
||||
|
||||
virtual void BeginDrawing() { }
|
||||
virtual void EndDrawing() { }
|
||||
|
||||
// graphic primitives
|
||||
// ------------------
|
||||
|
||||
virtual void DrawObject(wxDrawObject* drawobject)
|
||||
{
|
||||
drawobject->Draw(*this);
|
||||
CalcBoundingBox(drawobject->MinX(),drawobject->MinY());
|
||||
CalcBoundingBox(drawobject->MaxX(),drawobject->MaxY());
|
||||
}
|
||||
|
||||
void FloodFill(wxCoord x, wxCoord y, const wxColour& col,
|
||||
int style = wxFLOOD_SURFACE)
|
||||
{ DoFloodFill(x, y, col, style); }
|
||||
void FloodFill(const wxPoint& pt, const wxColour& col,
|
||||
int style = wxFLOOD_SURFACE)
|
||||
{ DoFloodFill(pt.x, pt.y, col, style); }
|
||||
|
||||
bool GetPixel(wxCoord x, wxCoord y, wxColour *col) const
|
||||
{ return DoGetPixel(x, y, col); }
|
||||
bool GetPixel(const wxPoint& pt, wxColour *col) const
|
||||
{ return DoGetPixel(pt.x, pt.y, col); }
|
||||
|
||||
void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
|
||||
{ DoDrawLine(x1, y1, x2, y2); }
|
||||
void DrawLine(const wxPoint& pt1, const wxPoint& pt2)
|
||||
{ DoDrawLine(pt1.x, pt1.y, pt2.x, pt2.y); }
|
||||
|
||||
void CrossHair(wxCoord x, wxCoord y)
|
||||
{ DoCrossHair(x, y); }
|
||||
void CrossHair(const wxPoint& pt)
|
||||
{ DoCrossHair(pt.x, pt.y); }
|
||||
|
||||
void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
|
||||
wxCoord xc, wxCoord yc)
|
||||
{ DoDrawArc(x1, y1, x2, y2, xc, yc); }
|
||||
void DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& centre)
|
||||
{ DoDrawArc(pt1.x, pt1.y, pt2.x, pt2.y, centre.x, centre.y); }
|
||||
|
||||
void DrawCheckMark(wxCoord x, wxCoord y,
|
||||
wxCoord width, wxCoord height)
|
||||
{ DoDrawCheckMark(x, y, width, height); }
|
||||
void DrawCheckMark(const wxRect& rect)
|
||||
{ DoDrawCheckMark(rect.x, rect.y, rect.width, rect.height); }
|
||||
|
||||
void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
|
||||
double sa, double ea)
|
||||
{ DoDrawEllipticArc(x, y, w, h, sa, ea); }
|
||||
void DrawEllipticArc(const wxPoint& pt, const wxSize& sz,
|
||||
double sa, double ea)
|
||||
{ DoDrawEllipticArc(pt.x, pt.y, sz.x, sz.y, sa, ea); }
|
||||
|
||||
void DrawPoint(wxCoord x, wxCoord y)
|
||||
{ DoDrawPoint(x, y); }
|
||||
void DrawPoint(const wxPoint& pt)
|
||||
{ DoDrawPoint(pt.x, pt.y); }
|
||||
|
||||
void DrawLines(int n, wxPoint points[],
|
||||
wxCoord xoffset = 0, wxCoord yoffset = 0)
|
||||
{ DoDrawLines(n, points, xoffset, yoffset); }
|
||||
void DrawLines(const wxList *list,
|
||||
wxCoord xoffset = 0, wxCoord yoffset = 0);
|
||||
|
||||
void DrawPolygon(int n, wxPoint points[],
|
||||
wxCoord xoffset = 0, wxCoord yoffset = 0,
|
||||
int fillStyle = wxODDEVEN_RULE)
|
||||
{ DoDrawPolygon(n, points, xoffset, yoffset, fillStyle); }
|
||||
|
||||
void DrawPolygon(const wxList *list,
|
||||
wxCoord xoffset = 0, wxCoord yoffset = 0,
|
||||
int fillStyle = wxODDEVEN_RULE);
|
||||
|
||||
void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
|
||||
{ DoDrawRectangle(x, y, width, height); }
|
||||
void DrawRectangle(const wxPoint& pt, const wxSize& sz)
|
||||
{ DoDrawRectangle(pt.x, pt.y, sz.x, sz.y); }
|
||||
void DrawRectangle(const wxRect& rect)
|
||||
{ DoDrawRectangle(rect.x, rect.y, rect.width, rect.height); }
|
||||
|
||||
void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height,
|
||||
double radius)
|
||||
{ DoDrawRoundedRectangle(x, y, width, height, radius); }
|
||||
void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz,
|
||||
double radius)
|
||||
{ DoDrawRoundedRectangle(pt.x, pt.y, sz.x, sz.y, radius); }
|
||||
void DrawRoundedRectangle(const wxRect& r, double radius)
|
||||
{ DoDrawRoundedRectangle(r.x, r.y, r.width, r.height, radius); }
|
||||
|
||||
void DrawCircle(wxCoord x, wxCoord y, wxCoord radius)
|
||||
{ DoDrawEllipse(x - radius, y - radius, 2*radius, 2*radius); }
|
||||
void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
|
||||
{ DoDrawEllipse(x, y, width, height); }
|
||||
void DrawEllipse(const wxPoint& pt, const wxSize& sz)
|
||||
{ DoDrawEllipse(pt.x, pt.y, sz.x, sz.y); }
|
||||
void DrawEllipse(const wxRect& rect)
|
||||
{ DoDrawEllipse(rect.x, rect.y, rect.width, rect.height); }
|
||||
|
||||
void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
|
||||
{ DoDrawIcon(icon, x, y); }
|
||||
void DrawIcon(const wxIcon& icon, const wxPoint& pt)
|
||||
{ DoDrawIcon(icon, pt.x, pt.y); }
|
||||
|
||||
void DrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
|
||||
bool useMask = FALSE)
|
||||
{ DoDrawBitmap(bmp, x, y, useMask); }
|
||||
void DrawBitmap(const wxBitmap &bmp, const wxPoint& pt,
|
||||
bool useMask = FALSE)
|
||||
{ DoDrawBitmap(bmp, pt.x, pt.y, useMask); }
|
||||
|
||||
void DrawText(const wxString& text, wxCoord x, wxCoord y)
|
||||
{ DoDrawText(text, x, y); }
|
||||
void DrawText(const wxString& text, const wxPoint& pt)
|
||||
{ DoDrawText(text, pt.x, pt.y); }
|
||||
|
||||
void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle)
|
||||
{ DoDrawRotatedText(text, x, y, angle); }
|
||||
void DrawRotatedText(const wxString& text, const wxPoint& pt, double angle)
|
||||
{ DoDrawRotatedText(text, pt.x, pt.y, angle); }
|
||||
|
||||
// this version puts both optional bitmap and the text into the given
|
||||
// rectangle and aligns is as specified by alignment parameter; it also
|
||||
// will emphasize the character with the given index if it is != -1 and
|
||||
// return the bounding rectangle if required
|
||||
virtual void DrawLabel(const wxString& text,
|
||||
const wxBitmap& image,
|
||||
const wxRect& rect,
|
||||
int alignment = wxALIGN_LEFT | wxALIGN_TOP,
|
||||
int indexAccel = -1,
|
||||
wxRect *rectBounding = NULL);
|
||||
|
||||
void DrawLabel(const wxString& text, const wxRect& rect,
|
||||
int alignment = wxALIGN_LEFT | wxALIGN_TOP,
|
||||
int indexAccel = -1)
|
||||
{ DrawLabel(text, wxNullBitmap, rect, alignment, indexAccel); }
|
||||
|
||||
bool Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
|
||||
wxDC *source, wxCoord xsrc, wxCoord ysrc,
|
||||
int rop = wxCOPY, bool useMask = FALSE, wxCoord xsrcMask = -1, wxCoord ysrcMask = -1)
|
||||
{
|
||||
return DoBlit(xdest, ydest, width, height,
|
||||
source, xsrc, ysrc, rop, useMask, xsrcMask, ysrcMask);
|
||||
}
|
||||
bool Blit(const wxPoint& destPt, const wxSize& sz,
|
||||
wxDC *source, const wxPoint& srcPt,
|
||||
int rop = wxCOPY, bool useMask = FALSE, const wxPoint& srcPtMask = wxPoint(-1, -1))
|
||||
{
|
||||
return DoBlit(destPt.x, destPt.y, sz.x, sz.y,
|
||||
source, srcPt.x, srcPt.y, rop, useMask, srcPtMask.x, srcPtMask.y);
|
||||
}
|
||||
|
||||
#if wxUSE_SPLINES
|
||||
// TODO: this API needs fixing (wxPointList, why (!const) "wxList *"?)
|
||||
void DrawSpline(wxCoord x1, wxCoord y1,
|
||||
wxCoord x2, wxCoord y2,
|
||||
wxCoord x3, wxCoord y3);
|
||||
void DrawSpline(int n, wxPoint points[]);
|
||||
|
||||
void DrawSpline(wxList *points) { DoDrawSpline(points); }
|
||||
#endif // wxUSE_SPLINES
|
||||
|
||||
// global DC operations
|
||||
// --------------------
|
||||
|
||||
virtual void Clear() = 0;
|
||||
|
||||
virtual bool StartDoc(const wxString& WXUNUSED(message)) { return TRUE; }
|
||||
virtual void EndDoc() { }
|
||||
|
||||
virtual void StartPage() { }
|
||||
virtual void EndPage() { }
|
||||
|
||||
// set objects to use for drawing
|
||||
// ------------------------------
|
||||
|
||||
virtual void SetFont(const wxFont& font) = 0;
|
||||
virtual void SetPen(const wxPen& pen) = 0;
|
||||
virtual void SetBrush(const wxBrush& brush) = 0;
|
||||
virtual void SetBackground(const wxBrush& brush) = 0;
|
||||
virtual void SetBackgroundMode(int mode) = 0;
|
||||
virtual void SetPalette(const wxPalette& palette) = 0;
|
||||
|
||||
// clipping region
|
||||
// ---------------
|
||||
|
||||
void SetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
|
||||
{ DoSetClippingRegion(x, y, width, height); }
|
||||
void SetClippingRegion(const wxPoint& pt, const wxSize& sz)
|
||||
{ DoSetClippingRegion(pt.x, pt.y, sz.x, sz.y); }
|
||||
void SetClippingRegion(const wxRect& rect)
|
||||
{ DoSetClippingRegion(rect.x, rect.y, rect.width, rect.height); }
|
||||
void SetClippingRegion(const wxRegion& region)
|
||||
{ DoSetClippingRegionAsRegion(region); }
|
||||
|
||||
virtual void DestroyClippingRegion() = 0;
|
||||
|
||||
void GetClippingBox(wxCoord *x, wxCoord *y, wxCoord *w, wxCoord *h) const
|
||||
{ DoGetClippingBox(x, y, w, h); }
|
||||
void GetClippingBox(wxRect& rect) const
|
||||
{
|
||||
// Necessary to use intermediate variables for 16-bit compilation
|
||||
wxCoord x, y, w, h;
|
||||
DoGetClippingBox(&x, &y, &w, &h);
|
||||
rect.x = x; rect.y = y; rect.width = w; rect.height = h;
|
||||
}
|
||||
|
||||
// text extent
|
||||
// -----------
|
||||
|
||||
virtual wxCoord GetCharHeight() const = 0;
|
||||
virtual wxCoord GetCharWidth() const = 0;
|
||||
|
||||
// only works for single line strings
|
||||
void GetTextExtent(const wxString& string,
|
||||
wxCoord *x, wxCoord *y,
|
||||
wxCoord *descent = NULL,
|
||||
wxCoord *externalLeading = NULL,
|
||||
wxFont *theFont = NULL) const
|
||||
{ DoGetTextExtent(string, x, y, descent, externalLeading, theFont); }
|
||||
|
||||
// works for single as well as multi-line strings
|
||||
virtual void GetMultiLineTextExtent(const wxString& text,
|
||||
wxCoord *width,
|
||||
wxCoord *height,
|
||||
wxCoord *heightLine = NULL,
|
||||
wxFont *font = NULL);
|
||||
|
||||
// size and resolution
|
||||
// -------------------
|
||||
|
||||
// in device units
|
||||
void GetSize(int *width, int *height) const
|
||||
{ DoGetSize(width, height); }
|
||||
wxSize GetSize() const
|
||||
{
|
||||
int w, h;
|
||||
DoGetSize(&w, &h);
|
||||
|
||||
return wxSize(w, h);
|
||||
}
|
||||
|
||||
// in mm
|
||||
void GetSizeMM(int* width, int* height) const
|
||||
{ DoGetSizeMM(width, height); }
|
||||
wxSize GetSizeMM() const
|
||||
{
|
||||
int w, h;
|
||||
DoGetSizeMM(&w, &h);
|
||||
|
||||
return wxSize(w, h);
|
||||
}
|
||||
|
||||
// coordinates conversions
|
||||
// -----------------------
|
||||
|
||||
// This group of functions does actual conversion of the input, as you'd
|
||||
// expect.
|
||||
wxCoord DeviceToLogicalX(wxCoord x) const;
|
||||
wxCoord DeviceToLogicalY(wxCoord y) const;
|
||||
wxCoord DeviceToLogicalXRel(wxCoord x) const;
|
||||
wxCoord DeviceToLogicalYRel(wxCoord y) const;
|
||||
wxCoord LogicalToDeviceX(wxCoord x) const;
|
||||
wxCoord LogicalToDeviceY(wxCoord y) const;
|
||||
wxCoord LogicalToDeviceXRel(wxCoord x) const;
|
||||
wxCoord LogicalToDeviceYRel(wxCoord y) const;
|
||||
|
||||
// query DC capabilities
|
||||
// ---------------------
|
||||
|
||||
virtual bool CanDrawBitmap() const = 0;
|
||||
virtual bool CanGetTextExtent() const = 0;
|
||||
|
||||
// colour depth
|
||||
virtual int GetDepth() const = 0;
|
||||
|
||||
// Resolution in Pixels per inch
|
||||
virtual wxSize GetPPI() const = 0;
|
||||
|
||||
virtual bool Ok() const { return m_ok; }
|
||||
|
||||
// accessors
|
||||
// ---------
|
||||
|
||||
// const...
|
||||
int GetBackgroundMode() const { return m_backgroundMode; }
|
||||
const wxBrush& GetBackground() const { return m_backgroundBrush; }
|
||||
const wxBrush& GetBrush() const { return m_brush; }
|
||||
const wxFont& GetFont() const { return m_font; }
|
||||
const wxPen& GetPen() const { return m_pen; }
|
||||
const wxColour& GetTextBackground() const { return m_textBackgroundColour; }
|
||||
const wxColour& GetTextForeground() const { return m_textForegroundColour; }
|
||||
|
||||
// ... and non const
|
||||
wxBrush& GetBackground() { return m_backgroundBrush; }
|
||||
wxBrush& GetBrush() { return m_brush; }
|
||||
wxFont& GetFont() { return m_font; }
|
||||
wxPen& GetPen() { return m_pen; }
|
||||
wxColour& GetTextBackground() { return m_textBackgroundColour; }
|
||||
wxColour& GetTextForeground() { return m_textForegroundColour; }
|
||||
|
||||
virtual void SetTextForeground(const wxColour& colour)
|
||||
{ m_textForegroundColour = colour; }
|
||||
virtual void SetTextBackground(const wxColour& colour)
|
||||
{ m_textBackgroundColour = colour; }
|
||||
|
||||
int GetMapMode() const { return m_mappingMode; }
|
||||
virtual void SetMapMode(int mode) = 0;
|
||||
|
||||
virtual void GetUserScale(double *x, double *y) const
|
||||
{
|
||||
if ( x ) *x = m_userScaleX;
|
||||
if ( y ) *y = m_userScaleY;
|
||||
}
|
||||
virtual void SetUserScale(double x, double y) = 0;
|
||||
|
||||
virtual void GetLogicalScale(double *x, double *y)
|
||||
{
|
||||
if ( x ) *x = m_logicalScaleX;
|
||||
if ( y ) *y = m_logicalScaleY;
|
||||
}
|
||||
virtual void SetLogicalScale(double x, double y)
|
||||
{
|
||||
m_logicalScaleX = x;
|
||||
m_logicalScaleY = y;
|
||||
}
|
||||
|
||||
void GetLogicalOrigin(wxCoord *x, wxCoord *y) const
|
||||
{ DoGetLogicalOrigin(x, y); }
|
||||
wxPoint GetLogicalOrigin() const
|
||||
{ wxCoord x, y; DoGetLogicalOrigin(&x, &y); return wxPoint(x, y); }
|
||||
virtual void SetLogicalOrigin(wxCoord x, wxCoord y) = 0;
|
||||
|
||||
void GetDeviceOrigin(wxCoord *x, wxCoord *y) const
|
||||
{ DoGetDeviceOrigin(x, y); }
|
||||
wxPoint GetDeviceOrigin() const
|
||||
{ wxCoord x, y; DoGetDeviceOrigin(&x, &y); return wxPoint(x, y); }
|
||||
virtual void SetDeviceOrigin(wxCoord x, wxCoord y) = 0;
|
||||
|
||||
virtual void SetAxisOrientation(bool xLeftRight, bool yBottomUp) = 0;
|
||||
|
||||
int GetLogicalFunction() const { return m_logicalFunction; }
|
||||
virtual void SetLogicalFunction(int function) = 0;
|
||||
|
||||
// Sometimes we need to override optimization, e.g. if other software is
|
||||
// drawing onto our surface and we can't be sure of who's done what.
|
||||
//
|
||||
// FIXME: is this (still) used?
|
||||
virtual void SetOptimization(bool WXUNUSED(opt)) { }
|
||||
virtual bool GetOptimization() { return FALSE; }
|
||||
|
||||
// Some platforms have a DC cache, which should be cleared
|
||||
// at appropriate points such as after a series of DC operations.
|
||||
// Put ClearCache in the wxDC implementation class, since it has to be
|
||||
// static.
|
||||
// static void ClearCache() ;
|
||||
#if 0 // wxUSE_DC_CACHEING
|
||||
static void EnableCache(bool cacheing) { sm_cacheing = cacheing; }
|
||||
static bool CacheEnabled() { return sm_cacheing ; }
|
||||
#endif
|
||||
|
||||
// bounding box
|
||||
// ------------
|
||||
|
||||
virtual void CalcBoundingBox(wxCoord x, wxCoord y)
|
||||
{
|
||||
if ( m_isBBoxValid )
|
||||
{
|
||||
if ( x < m_minX ) m_minX = x;
|
||||
if ( y < m_minY ) m_minY = y;
|
||||
if ( x > m_maxX ) m_maxX = x;
|
||||
if ( y > m_maxY ) m_maxY = y;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_isBBoxValid = TRUE;
|
||||
|
||||
m_minX = x;
|
||||
m_minY = y;
|
||||
m_maxX = x;
|
||||
m_maxY = y;
|
||||
}
|
||||
}
|
||||
|
||||
void ResetBoundingBox()
|
||||
{
|
||||
m_isBBoxValid = FALSE;
|
||||
|
||||
m_minX = m_maxX = m_minY = m_maxY = 0;
|
||||
}
|
||||
|
||||
// Get the final bounding box of the PostScript or Metafile picture.
|
||||
wxCoord MinX() const { return m_minX; }
|
||||
wxCoord MaxX() const { return m_maxX; }
|
||||
wxCoord MinY() const { return m_minY; }
|
||||
wxCoord MaxY() const { return m_maxY; }
|
||||
|
||||
// misc old functions
|
||||
// ------------------
|
||||
|
||||
// for compatibility with the old code when wxCoord was long everywhere
|
||||
#ifndef __WIN16__
|
||||
void GetTextExtent(const wxString& string,
|
||||
long *x, long *y,
|
||||
long *descent = NULL,
|
||||
long *externalLeading = NULL,
|
||||
wxFont *theFont = NULL) const
|
||||
{
|
||||
wxCoord x2, y2, descent2, externalLeading2;
|
||||
DoGetTextExtent(string, &x2, &y2,
|
||||
&descent2, &externalLeading2,
|
||||
theFont);
|
||||
if ( x )
|
||||
*x = x2;
|
||||
if ( y )
|
||||
*y = y2;
|
||||
if ( descent )
|
||||
*descent = descent2;
|
||||
if ( externalLeading )
|
||||
*externalLeading = externalLeading2;
|
||||
}
|
||||
|
||||
void GetLogicalOrigin(long *x, long *y) const
|
||||
{
|
||||
wxCoord x2, y2;
|
||||
DoGetLogicalOrigin(&x2, &y2);
|
||||
if ( x )
|
||||
*x = x2;
|
||||
if ( y )
|
||||
*y = y2;
|
||||
}
|
||||
|
||||
void GetDeviceOrigin(long *x, long *y) const
|
||||
{
|
||||
wxCoord x2, y2;
|
||||
DoGetDeviceOrigin(&x2, &y2);
|
||||
if ( x )
|
||||
*x = x2;
|
||||
if ( y )
|
||||
*y = y2;
|
||||
}
|
||||
void GetClippingBox(long *x, long *y, long *w, long *h) const
|
||||
{
|
||||
wxCoord xx,yy,ww,hh;
|
||||
DoGetClippingBox(&xx, &yy, &ww, &hh);
|
||||
if (x) *x = xx;
|
||||
if (y) *y = yy;
|
||||
if (w) *w = ww;
|
||||
if (h) *h = hh;
|
||||
}
|
||||
#endif // !Win16
|
||||
|
||||
#if WXWIN_COMPATIBILITY
|
||||
virtual void SetColourMap(const wxPalette& palette) { SetPalette(palette); }
|
||||
void GetTextExtent(const wxString& string, float *x, float *y,
|
||||
float *descent = NULL, float *externalLeading = NULL,
|
||||
wxFont *theFont = NULL, bool use16bit = FALSE) const ;
|
||||
void GetSize(float* width, float* height) const { int w, h; GetSize(& w, & h); *width = w; *height = h; }
|
||||
void GetSizeMM(float *width, float *height) const { long w, h; GetSizeMM(& w, & h); *width = (float) w; *height = (float) h; }
|
||||
#endif // WXWIN_COMPATIBILITY
|
||||
|
||||
protected:
|
||||
// the pure virtual functions which should be implemented by wxDC
|
||||
virtual void DoFloodFill(wxCoord x, wxCoord y, const wxColour& col,
|
||||
int style = wxFLOOD_SURFACE) = 0;
|
||||
|
||||
virtual bool DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const = 0;
|
||||
|
||||
virtual void DoDrawPoint(wxCoord x, wxCoord y) = 0;
|
||||
virtual void DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2) = 0;
|
||||
|
||||
virtual void DoDrawArc(wxCoord x1, wxCoord y1,
|
||||
wxCoord x2, wxCoord y2,
|
||||
wxCoord xc, wxCoord yc) = 0;
|
||||
virtual void DoDrawCheckMark(wxCoord x, wxCoord y,
|
||||
wxCoord width, wxCoord height);
|
||||
virtual void DoDrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
|
||||
double sa, double ea) = 0;
|
||||
|
||||
virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height) = 0;
|
||||
virtual void DoDrawRoundedRectangle(wxCoord x, wxCoord y,
|
||||
wxCoord width, wxCoord height,
|
||||
double radius) = 0;
|
||||
virtual void DoDrawEllipse(wxCoord x, wxCoord y,
|
||||
wxCoord width, wxCoord height) = 0;
|
||||
|
||||
virtual void DoCrossHair(wxCoord x, wxCoord y) = 0;
|
||||
|
||||
virtual void DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y) = 0;
|
||||
virtual void DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
|
||||
bool useMask = FALSE) = 0;
|
||||
|
||||
virtual void DoDrawText(const wxString& text, wxCoord x, wxCoord y) = 0;
|
||||
virtual void DoDrawRotatedText(const wxString& text,
|
||||
wxCoord x, wxCoord y, double angle) = 0;
|
||||
|
||||
virtual bool DoBlit(wxCoord xdest, wxCoord ydest,
|
||||
wxCoord width, wxCoord height,
|
||||
wxDC *source, wxCoord xsrc, wxCoord ysrc,
|
||||
int rop = wxCOPY, bool useMask = FALSE, wxCoord xsrcMask = -1, wxCoord ysrcMask = -1) = 0;
|
||||
|
||||
virtual void DoGetSize(int *width, int *height) const = 0;
|
||||
virtual void DoGetSizeMM(int* width, int* height) const = 0;
|
||||
|
||||
virtual void DoDrawLines(int n, wxPoint points[],
|
||||
wxCoord xoffset, wxCoord yoffset) = 0;
|
||||
virtual void DoDrawPolygon(int n, wxPoint points[],
|
||||
wxCoord xoffset, wxCoord yoffset,
|
||||
int fillStyle = wxODDEVEN_RULE) = 0;
|
||||
|
||||
virtual void DoSetClippingRegionAsRegion(const wxRegion& region) = 0;
|
||||
virtual void DoSetClippingRegion(wxCoord x, wxCoord y,
|
||||
wxCoord width, wxCoord height) = 0;
|
||||
|
||||
// FIXME are these functions really different?
|
||||
virtual void DoGetClippingRegion(wxCoord *x, wxCoord *y,
|
||||
wxCoord *w, wxCoord *h)
|
||||
{ DoGetClippingBox(x, y, w, h); }
|
||||
virtual void DoGetClippingBox(wxCoord *x, wxCoord *y,
|
||||
wxCoord *w, wxCoord *h) const
|
||||
{
|
||||
if ( m_clipping )
|
||||
{
|
||||
if ( x ) *x = m_clipX1;
|
||||
if ( y ) *y = m_clipY1;
|
||||
if ( w ) *w = m_clipX2 - m_clipX1;
|
||||
if ( h ) *h = m_clipY2 - m_clipY1;
|
||||
}
|
||||
else
|
||||
{
|
||||
*x = *y = *w = *h = 0;
|
||||
}
|
||||
}
|
||||
|
||||
virtual void DoGetLogicalOrigin(wxCoord *x, wxCoord *y) const
|
||||
{
|
||||
if ( x ) *x = m_logicalOriginX;
|
||||
if ( y ) *y = m_logicalOriginY;
|
||||
}
|
||||
|
||||
virtual void DoGetDeviceOrigin(wxCoord *x, wxCoord *y) const
|
||||
{
|
||||
if ( x ) *x = m_deviceOriginX;
|
||||
if ( y ) *y = m_deviceOriginY;
|
||||
}
|
||||
|
||||
virtual void DoGetTextExtent(const wxString& string,
|
||||
wxCoord *x, wxCoord *y,
|
||||
wxCoord *descent = NULL,
|
||||
wxCoord *externalLeading = NULL,
|
||||
wxFont *theFont = NULL) const = 0;
|
||||
|
||||
#if wxUSE_SPLINES
|
||||
virtual void DoDrawSpline(wxList *points);
|
||||
#endif
|
||||
|
||||
protected:
|
||||
// flags
|
||||
bool m_colour:1;
|
||||
bool m_ok:1;
|
||||
bool m_clipping:1;
|
||||
bool m_isInteractive:1;
|
||||
bool m_isBBoxValid:1;
|
||||
#if wxUSE_DC_CACHEING
|
||||
// static bool sm_cacheing;
|
||||
#endif
|
||||
|
||||
// coordinate system variables
|
||||
|
||||
// TODO short descriptions of what exactly they are would be nice...
|
||||
|
||||
wxCoord m_logicalOriginX, m_logicalOriginY;
|
||||
wxCoord m_deviceOriginX, m_deviceOriginY;
|
||||
|
||||
double m_logicalScaleX, m_logicalScaleY;
|
||||
double m_userScaleX, m_userScaleY;
|
||||
double m_scaleX, m_scaleY;
|
||||
|
||||
// Used by SetAxisOrientation() to invert the axes
|
||||
int m_signX, m_signY;
|
||||
|
||||
// bounding and clipping boxes
|
||||
wxCoord m_minX, m_minY, m_maxX, m_maxY;
|
||||
wxCoord m_clipX1, m_clipY1, m_clipX2, m_clipY2;
|
||||
|
||||
int m_logicalFunction;
|
||||
int m_backgroundMode;
|
||||
int m_mappingMode;
|
||||
|
||||
// GDI objects
|
||||
wxPen m_pen;
|
||||
wxBrush m_brush;
|
||||
wxBrush m_backgroundBrush;
|
||||
wxColour m_textForegroundColour;
|
||||
wxColour m_textBackgroundColour;
|
||||
wxFont m_font;
|
||||
wxPalette m_palette;
|
||||
|
||||
private:
|
||||
DECLARE_NO_COPY_CLASS(wxDCBase)
|
||||
DECLARE_ABSTRACT_CLASS(wxDCBase)
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// now include the declaration of wxDC class
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/dc.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/dc.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/dc.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/dc.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/dc.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/dc.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/dc.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/dc.h"
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// helper class: you can use it to temporarily change the DC text colour and
|
||||
// restore it automatically when the object goes out of scope
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxDCTextColourChanger
|
||||
{
|
||||
public:
|
||||
wxDCTextColourChanger(wxDC& dc) : m_dc(dc) { }
|
||||
|
||||
~wxDCTextColourChanger()
|
||||
{
|
||||
if ( m_colFgOld.Ok() )
|
||||
m_dc.SetTextForeground(m_colFgOld);
|
||||
}
|
||||
|
||||
void Set(const wxColour& col)
|
||||
{
|
||||
if ( !m_colFgOld.Ok() )
|
||||
m_colFgOld = m_dc.GetTextForeground();
|
||||
m_dc.SetTextForeground(col);
|
||||
}
|
||||
|
||||
private:
|
||||
wxDC& m_dc;
|
||||
|
||||
wxColour m_colFgOld;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// another small helper class: sets the clipping region in its ctor and
|
||||
// destroys it in the dtor
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxDCClipper
|
||||
{
|
||||
public:
|
||||
wxDCClipper(wxDC& dc, const wxRect& r) : m_dc(dc)
|
||||
{ dc.SetClippingRegion(r.x, r.y, r.width, r.height); }
|
||||
wxDCClipper(wxDC& dc, wxCoord x, wxCoord y, wxCoord w, wxCoord h) : m_dc(dc)
|
||||
{ dc.SetClippingRegion(x, y, w, h); }
|
||||
|
||||
~wxDCClipper() { m_dc.DestroyClippingRegion(); }
|
||||
|
||||
private:
|
||||
wxDC& m_dc;
|
||||
};
|
||||
|
||||
#endif
|
||||
// _WX_DC_H_BASE_
|
||||
@@ -1,23 +0,0 @@
|
||||
#ifndef _WX_DCCLIENT_H_BASE_
|
||||
#define _WX_DCCLIENT_H_BASE_
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/dcclient.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/dcclient.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/dcclient.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/dcclient.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/dcclient.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/dcclient.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/dcclient.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/dcclient.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_DCCLIENT_H_BASE_
|
||||
@@ -1,23 +0,0 @@
|
||||
#ifndef _WX_DCMEMORY_H_BASE_
|
||||
#define _WX_DCMEMORY_H_BASE_
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/dcmemory.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/dcmemory.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/dcmemory.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/dcmemory.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/dcmemory.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/dcmemory.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/dcmemory.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/dcmemory.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_DCMEMORY_H_BASE_
|
||||
@@ -1,23 +0,0 @@
|
||||
#ifndef _WX_DCSCREEN_H_BASE_
|
||||
#define _WX_DCSCREEN_H_BASE_
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/dcscreen.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/dcscreen.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/dcscreen.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/dcscreen.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/dcscreen.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/dcscreen.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/dcscreen.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/dcscreen.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_DCSCREEN_H_BASE_
|
||||
@@ -1,21 +0,0 @@
|
||||
#ifndef _WX_DDE_H_BASE_
|
||||
#define _WX_DDE_H_BASE_
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/dde.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/dde.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/dde.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/dde.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/dde.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/dde.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/dde.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_DDE_H_BASE_
|
||||
2094
include/wx/defs.h
2094
include/wx/defs.h
File diff suppressed because it is too large
Load Diff
@@ -1,69 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/dialog.h
|
||||
// Purpose: wxDialogBase class
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 29.06.99
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Vadim Zeitlin
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_DIALOG_H_BASE_
|
||||
#define _WX_DIALOG_H_BASE_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "dialogbase.h"
|
||||
#endif
|
||||
|
||||
#include "wx/defs.h"
|
||||
#include "wx/panel.h"
|
||||
|
||||
class WXDLLEXPORT wxDialogBase : public wxPanel
|
||||
{
|
||||
public:
|
||||
#ifdef __DARWIN__
|
||||
~wxDialogBase() { }
|
||||
#endif
|
||||
// the modal dialogs have a return code - usually the id of the last
|
||||
// pressed button
|
||||
void SetReturnCode(int returnCode) { m_returnCode = returnCode; }
|
||||
int GetReturnCode() const { return m_returnCode; }
|
||||
|
||||
#if wxUSE_STATTEXT && wxUSE_TEXTCTRL
|
||||
// splits text up at newlines and places the
|
||||
// lines into a vertical wxBoxSizer
|
||||
wxSizer *CreateTextSizer( const wxString &message );
|
||||
#endif // wxUSE_STATTEXT && wxUSE_TEXTCTRL
|
||||
|
||||
#if wxUSE_BUTTON
|
||||
// places buttons into a horizontal wxBoxSizer
|
||||
wxSizer *CreateButtonSizer( long flags );
|
||||
#endif // wxUSE_BUTTON
|
||||
|
||||
protected:
|
||||
// the return code from modal dialog
|
||||
int m_returnCode;
|
||||
};
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/dialog.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/dialog.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/dialog.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/dialog.h"
|
||||
// FIXME_MGL -- belongs to wxUniv
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/dialog.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/dialog.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/dialog.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/dialog.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_DIALOG_H_BASE_
|
||||
@@ -1,41 +0,0 @@
|
||||
#ifndef _WX_DIRDLG_H_BASE_
|
||||
#define _WX_DIRDLG_H_BASE_
|
||||
|
||||
#if wxUSE_DIRDLG
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// constants
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxDirDialogNameStr;
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxDirDialogDefaultFolderStr;
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString;
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#if defined(__WIN16__) || (defined(__GNUWIN32__) && !wxUSE_NORLANDER_HEADERS) || defined(__SALFORDC__)
|
||||
#include "wx/generic/dirdlgg.h"
|
||||
#else
|
||||
#include "wx/msw/dirdlg.h"
|
||||
#endif
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/generic/dirdlgg.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/generic/dirdlgg.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/dirdlg.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#ifdef __DARWIN__
|
||||
#include "wx/generic/dirdlgg.h"
|
||||
#else
|
||||
#include "wx/mac/dirdlg.h"
|
||||
#endif
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/dirdlg.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/dirdlg.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_DIRDLG
|
||||
|
||||
#endif
|
||||
// _WX_DIRDLG_H_BASE_
|
||||
232
include/wx/dnd.h
232
include/wx/dnd.h
@@ -1,232 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/dnd.h
|
||||
// Purpose: Drag and drop classes declarations
|
||||
// Author: Vadim Zeitlin, Robert Roebling
|
||||
// Modified by:
|
||||
// Created: 26.05.99
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) wxWindows Team
|
||||
// Licence: wxWindows license
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_DND_H_BASE_
|
||||
#define _WX_DND_H_BASE_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "dndbase.h"
|
||||
#endif
|
||||
|
||||
#include "wx/defs.h"
|
||||
|
||||
#if wxUSE_DRAG_AND_DROP
|
||||
|
||||
#include "wx/dataobj.h"
|
||||
#include "wx/cursor.h"
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// constants
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// result of wxDropSource::DoDragDrop() call
|
||||
enum wxDragResult
|
||||
{
|
||||
wxDragError, // error prevented the d&d operation from completing
|
||||
wxDragNone, // drag target didn't accept the data
|
||||
wxDragCopy, // the data was successfully copied
|
||||
wxDragMove, // the data was successfully moved (MSW only)
|
||||
wxDragCancel // the operation was cancelled by user (not an error)
|
||||
};
|
||||
|
||||
inline WXDLLEXPORT bool wxIsDragResultOk(wxDragResult res)
|
||||
{
|
||||
return res == wxDragCopy || res == wxDragMove;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxDropSource is the object you need to create (and call DoDragDrop on it)
|
||||
// to initiate a drag-and-drop operation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxDropSourceBase
|
||||
{
|
||||
public:
|
||||
wxDropSourceBase(const wxCursor &cursorCopy = wxNullCursor,
|
||||
const wxCursor &cursorMove = wxNullCursor,
|
||||
const wxCursor &cursorStop = wxNullCursor)
|
||||
: m_cursorCopy(cursorCopy),
|
||||
m_cursorMove(cursorMove),
|
||||
m_cursorStop(cursorStop)
|
||||
{ m_data = (wxDataObject *)NULL; }
|
||||
virtual ~wxDropSourceBase() { }
|
||||
|
||||
// set the data which is transfered by drag and drop
|
||||
void SetData(wxDataObject& data)
|
||||
{ m_data = &data; }
|
||||
|
||||
wxDataObject *GetDataObject()
|
||||
{ return m_data; }
|
||||
|
||||
// set the icon corresponding to given drag result
|
||||
void SetCursor(wxDragResult res, const wxCursor& cursor)
|
||||
{
|
||||
if ( res == wxDragCopy )
|
||||
m_cursorCopy = cursor;
|
||||
else if ( res == wxDragMove )
|
||||
m_cursorMove = cursor;
|
||||
else
|
||||
m_cursorStop = cursor;
|
||||
}
|
||||
|
||||
// start drag action, see enum wxDragResult for return value description
|
||||
//
|
||||
// if bAllowMove is TRUE, data can be moved, if not - only copied
|
||||
virtual wxDragResult DoDragDrop(bool bAllowMove = FALSE) = 0;
|
||||
|
||||
// override to give feedback depending on the current operation result
|
||||
// "effect" and return TRUE if you did something, FALSE to let the library
|
||||
// give the default feedback
|
||||
virtual bool GiveFeedback(wxDragResult WXUNUSED(effect)) { return FALSE; }
|
||||
|
||||
protected:
|
||||
const wxCursor& GetCursor(wxDragResult res) const
|
||||
{
|
||||
if ( res == wxDragCopy )
|
||||
return m_cursorCopy;
|
||||
else if ( res == wxDragMove )
|
||||
return m_cursorMove;
|
||||
else
|
||||
return m_cursorStop;
|
||||
}
|
||||
|
||||
wxDataObject *m_data;
|
||||
|
||||
// the cursors to use for feedback
|
||||
wxCursor m_cursorCopy, m_cursorMove, m_cursorStop;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxDropTarget should be associated with a window if it wants to be able to
|
||||
// receive data via drag and drop.
|
||||
//
|
||||
// To use this class, you should derive from wxDropTarget and implement
|
||||
// OnData() pure virtual method. You may also wish to override OnDrop() if you
|
||||
// want to accept the data only inside some region of the window (this may
|
||||
// avoid having to copy the data to this application which happens only when
|
||||
// OnData() is called)
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxDropTargetBase
|
||||
{
|
||||
public:
|
||||
// ctor takes a pointer to heap-allocated wxDataObject which will be owned
|
||||
// by wxDropTarget and deleted by it automatically. If you don't give it
|
||||
// here, you can use SetDataObject() later.
|
||||
wxDropTargetBase(wxDataObject *dataObject = (wxDataObject*)NULL)
|
||||
{ m_dataObject = dataObject; }
|
||||
// dtor deletes our data object
|
||||
virtual ~wxDropTargetBase()
|
||||
{ delete m_dataObject; }
|
||||
|
||||
// get/set the associated wxDataObject
|
||||
wxDataObject *GetDataObject() const
|
||||
{ return m_dataObject; }
|
||||
void SetDataObject(wxDataObject *dataObject)
|
||||
{ if (m_dataObject) delete m_dataObject;
|
||||
m_dataObject = dataObject; }
|
||||
|
||||
// these functions are called when data is moved over position (x, y) and
|
||||
// may return either wxDragCopy, wxDragMove or wxDragNone depending on
|
||||
// what would happen if the data were dropped here.
|
||||
//
|
||||
// the last parameter is what would happen by default and is determined by
|
||||
// the platform-specific logic (for example, under Windows it's wxDragCopy
|
||||
// if Ctrl key is pressed and wxDragMove otherwise) except that it will
|
||||
// always be wxDragNone if the carried data is in an unsupported format.
|
||||
|
||||
// called when the mouse enters the window (only once until OnLeave())
|
||||
virtual wxDragResult OnEnter(wxCoord x, wxCoord y, wxDragResult def)
|
||||
{ return OnDragOver(x, y, def); }
|
||||
|
||||
// called when the mouse moves in the window - shouldn't take long to
|
||||
// execute or otherwise mouse movement would be too slow
|
||||
virtual wxDragResult OnDragOver(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
|
||||
wxDragResult def)
|
||||
{ return def; }
|
||||
|
||||
// called when mouse leaves the window: might be used to remove the
|
||||
// feedback which was given in OnEnter()
|
||||
virtual void OnLeave() { }
|
||||
|
||||
// this function is called when data is dropped at position (x, y) - if it
|
||||
// returns TRUE, OnData() will be called immediately afterwards which will
|
||||
// allow to retrieve the data dropped.
|
||||
virtual bool OnDrop(wxCoord x, wxCoord y) = 0;
|
||||
|
||||
// called after OnDrop() returns TRUE: you will usually just call
|
||||
// GetData() from here and, probably, also refresh something to update the
|
||||
// new data and, finally, return the code indicating how did the operation
|
||||
// complete (returning default value in case of success and wxDragError on
|
||||
// failure is usually ok)
|
||||
virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def) = 0;
|
||||
|
||||
// may be called *only* from inside OnData() and will fill m_dataObject
|
||||
// with the data from the drop source if it returns TRUE
|
||||
virtual bool GetData() = 0;
|
||||
|
||||
protected:
|
||||
wxDataObject *m_dataObject;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// include platform dependent class declarations
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/ole/dropsrc.h"
|
||||
#include "wx/msw/ole/droptgt.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/dnd.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/dnd.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/dnd.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/dnd.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/dnd.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/dnd.h"
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// standard wxDropTarget implementations (implemented in common/dobjcmn.cpp)
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// A simple wxDropTarget derived class for text data: you only need to
|
||||
// override OnDropText() to get something working
|
||||
class WXDLLEXPORT wxTextDropTarget : public wxDropTarget
|
||||
{
|
||||
public:
|
||||
wxTextDropTarget();
|
||||
|
||||
virtual bool OnDropText(wxCoord x, wxCoord y, const wxString& text) = 0;
|
||||
|
||||
virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);
|
||||
};
|
||||
|
||||
// A drop target which accepts files (dragged from File Manager or Explorer)
|
||||
class WXDLLEXPORT wxFileDropTarget : public wxDropTarget
|
||||
{
|
||||
public:
|
||||
wxFileDropTarget();
|
||||
|
||||
// parameters are the number of files and the array of file names
|
||||
virtual bool OnDropFiles(wxCoord x, wxCoord y,
|
||||
const wxArrayString& filenames) = 0;
|
||||
|
||||
virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);
|
||||
};
|
||||
|
||||
#endif // wxUSE_DRAG_AND_DROP
|
||||
|
||||
#endif // _WX_DND_H_BASE_
|
||||
@@ -1,50 +0,0 @@
|
||||
#ifndef _WX_DRAGIMAG_H_BASE_
|
||||
#define _WX_DRAGIMAG_H_BASE_
|
||||
|
||||
#if wxUSE_DRAGIMAGE
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#ifdef __WIN16__
|
||||
#include "wx/generic/dragimgg.h"
|
||||
#define wxDragImage wxGenericDragImage
|
||||
#define sm_classwxDragImage sm_classwxGenericDragImage
|
||||
|
||||
#else
|
||||
#include "wx/msw/dragimag.h"
|
||||
#endif
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/generic/dragimgg.h"
|
||||
#define wxDragImage wxGenericDragImage
|
||||
#define sm_classwxDragImage sm_classwxGenericDragImage
|
||||
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/generic/dragimgg.h"
|
||||
#define wxDragImage wxGenericDragImage
|
||||
#define sm_classwxDragImage sm_classwxGenericDragImage
|
||||
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/generic/dragimgg.h"
|
||||
#define wxDragImage wxGenericDragImage
|
||||
#define sm_classwxDragImage sm_classwxGenericDragImage
|
||||
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/generic/dragimgg.h"
|
||||
#define wxDragImage wxGenericDragImage
|
||||
#define sm_classwxDragImage sm_classwxGenericDragImage
|
||||
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/generic/dragimgg.h"
|
||||
#define wxDragImage wxGenericDragImage
|
||||
#define sm_classwxDragImage sm_classwxGenericDragImage
|
||||
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/generic/dragimgg.h"
|
||||
#define wxDragImage wxGenericDragImage
|
||||
#define sm_classwxDragImage sm_classwxGenericDragImage
|
||||
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_DRAGIMAGE
|
||||
|
||||
#endif
|
||||
// _WX_DRAGIMAG_H_BASE_
|
||||
@@ -1,40 +0,0 @@
|
||||
#ifndef _WX_FILEDLG_H_BASE_
|
||||
#define _WX_FILEDLG_H_BASE_
|
||||
|
||||
#if wxUSE_FILEDLG
|
||||
|
||||
enum
|
||||
{
|
||||
wxOPEN = 0x0001,
|
||||
wxSAVE = 0x0002,
|
||||
wxOVERWRITE_PROMPT = 0x0004,
|
||||
wxHIDE_READONLY = 0x0008,
|
||||
wxFILE_MUST_EXIST = 0x0010,
|
||||
wxMULTIPLE = 0x0020,
|
||||
wxCHANGE_DIR = 0x0040
|
||||
};
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/filedlg.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/filedlg.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/generic/filedlgg.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/filedlg.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#ifdef __DARWIN__
|
||||
#include "wx/generic/filedlgg.h"
|
||||
#else
|
||||
#include "wx/mac/filedlg.h"
|
||||
#endif
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/filedlg.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/filedlg.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_FILEDLG
|
||||
|
||||
#endif
|
||||
// _WX_FILEDLG_H_BASE_
|
||||
@@ -1,183 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/font.h
|
||||
// Purpose: wxFontBase class: the interface of wxFont
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 20.09.99
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) wxWindows team
|
||||
// Licence: wxWindows license
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_FONT_H_BASE_
|
||||
#define _WX_FONT_H_BASE_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "fontbase.h"
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#include "wx/defs.h" // for wxDEFAULT &c
|
||||
#include "wx/fontenc.h" // the font encoding constants
|
||||
#include "wx/gdiobj.h" // the base class
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// forward declarations
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxFontData;
|
||||
class WXDLLEXPORT wxFontBase;
|
||||
class WXDLLEXPORT wxFont;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// font constants
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// standard font families
|
||||
enum wxFontFamily
|
||||
{
|
||||
wxFONTFAMILY_DEFAULT = wxDEFAULT,
|
||||
wxFONTFAMILY_DECORATIVE = wxDECORATIVE,
|
||||
wxFONTFAMILY_ROMAN = wxROMAN,
|
||||
wxFONTFAMILY_SCRIPT = wxSCRIPT,
|
||||
wxFONTFAMILY_SWISS = wxSWISS,
|
||||
wxFONTFAMILY_MODERN = wxMODERN,
|
||||
wxFONTFAMILY_TELETYPE = wxTELETYPE,
|
||||
wxFONTFAMILY_MAX
|
||||
};
|
||||
|
||||
// font styles
|
||||
enum wxFontStyle
|
||||
{
|
||||
wxFONTSTYLE_NORMAL = wxNORMAL,
|
||||
wxFONTSTYLE_ITALIC = wxITALIC,
|
||||
wxFONTSTYLE_SLANT = wxSLANT,
|
||||
wxFONTSTYLE_MAX
|
||||
};
|
||||
|
||||
// font weights
|
||||
enum wxFontWeight
|
||||
{
|
||||
wxFONTWEIGHT_NORMAL = wxNORMAL,
|
||||
wxFONTWEIGHT_LIGHT = wxLIGHT,
|
||||
wxFONTWEIGHT_BOLD = wxBOLD,
|
||||
wxFONTWEIGHT_MAX
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxFontBase represents a font object
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxFontRefData;
|
||||
struct WXDLLEXPORT wxNativeFontInfo;
|
||||
|
||||
class WXDLLEXPORT wxFontBase : public wxGDIObject
|
||||
{
|
||||
public:
|
||||
// creator function
|
||||
#ifdef __DARWIN__
|
||||
virtual ~wxFontBase() { }
|
||||
#endif
|
||||
|
||||
// from the font components
|
||||
static wxFont *New(
|
||||
int pointSize, // size of the font in points
|
||||
int family, // see wxFontFamily enum
|
||||
int style, // see wxFontStyle enum
|
||||
int weight, // see wxFontWeight enum
|
||||
bool underlined = FALSE, // not underlined by default
|
||||
const wxString& face = wxEmptyString, // facename
|
||||
wxFontEncoding encoding = wxFONTENCODING_DEFAULT); // ISO8859-X, ...
|
||||
|
||||
// from the (opaque) native font description object
|
||||
static wxFont *New(const wxNativeFontInfo& nativeFontDesc);
|
||||
|
||||
// from the string representation of wxNativeFontInfo
|
||||
static wxFont *New(const wxString& strNativeFontDesc);
|
||||
|
||||
// was the font successfully created?
|
||||
bool Ok() const { return m_refData != NULL; }
|
||||
|
||||
// comparison
|
||||
bool operator == (const wxFont& font) const;
|
||||
bool operator != (const wxFont& font) const;
|
||||
|
||||
// accessors: get the font characteristics
|
||||
virtual int GetPointSize() const = 0;
|
||||
virtual int GetFamily() const = 0;
|
||||
virtual int GetStyle() const = 0;
|
||||
virtual int GetWeight() const = 0;
|
||||
virtual bool GetUnderlined() const = 0;
|
||||
virtual wxString GetFaceName() const = 0;
|
||||
virtual wxFontEncoding GetEncoding() const = 0;
|
||||
virtual wxNativeFontInfo *GetNativeFontInfo() const;
|
||||
wxString GetNativeFontInfoDesc() const;
|
||||
|
||||
// change the font characteristics
|
||||
virtual void SetPointSize( int pointSize ) = 0;
|
||||
virtual void SetFamily( int family ) = 0;
|
||||
virtual void SetStyle( int style ) = 0;
|
||||
virtual void SetWeight( int weight ) = 0;
|
||||
virtual void SetFaceName( const wxString& faceName ) = 0;
|
||||
virtual void SetUnderlined( bool underlined ) = 0;
|
||||
virtual void SetEncoding(wxFontEncoding encoding) = 0;
|
||||
virtual void SetNativeFontInfo(const wxNativeFontInfo& info);
|
||||
|
||||
// VZ: there is no void SetNativeFontInfo(const wxString& info), needed?
|
||||
|
||||
// translate the fonts into human-readable string (i.e. GetStyleString()
|
||||
// will return "wxITALIC" for an italic font, ...)
|
||||
wxString GetFamilyString() const;
|
||||
wxString GetStyleString() const;
|
||||
wxString GetWeightString() const;
|
||||
|
||||
// the default encoding is used for creating all fonts with default
|
||||
// encoding parameter
|
||||
static wxFontEncoding GetDefaultEncoding()
|
||||
{ return ms_encodingDefault; }
|
||||
static void SetDefaultEncoding(wxFontEncoding encoding)
|
||||
{ ms_encodingDefault = encoding; }
|
||||
|
||||
protected:
|
||||
// get the internal data
|
||||
wxFontRefData *GetFontData() const
|
||||
{ return (wxFontRefData *)m_refData; }
|
||||
|
||||
private:
|
||||
// the currently default encoding: by default, it's the default system
|
||||
// encoding, but may be changed by the application using
|
||||
// SetDefaultEncoding() to make all subsequent fonts created without
|
||||
// specifing encoding parameter using this encoding
|
||||
static wxFontEncoding ms_encodingDefault;
|
||||
};
|
||||
|
||||
// include the real class declaration
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/font.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/font.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/font.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/font.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/font.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/font.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/font.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/font.h"
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// macros
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#define M_FONTDATA GetFontData()
|
||||
|
||||
#endif
|
||||
// _WX_FONT_H_BASE_
|
||||
@@ -1,102 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/gauge.h
|
||||
// Purpose: wxGauge interface
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 20.02.01
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 1996-2001 wxWindows team
|
||||
// Licence: wxWindows licence
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_GAUGE_H_BASE_
|
||||
#define _WX_GAUGE_H_BASE_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma implementation "gaugebase.h"
|
||||
#endif
|
||||
|
||||
#include "wx/defs.h"
|
||||
|
||||
#if wxUSE_GAUGE
|
||||
|
||||
#include "wx/control.h"
|
||||
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxGaugeNameStr;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxGauge: a progress bar
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxGaugeBase : public wxControl
|
||||
{
|
||||
public:
|
||||
#ifdef __DARWIN__
|
||||
virtual ~wxGaugeBase() { }
|
||||
#endif
|
||||
bool Create(wxWindow *parent,
|
||||
wxWindowID id,
|
||||
int range,
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& size = wxDefaultSize,
|
||||
long style = wxGA_HORIZONTAL,
|
||||
const wxValidator& validator = wxDefaultValidator,
|
||||
const wxString& name = wxGaugeNameStr);
|
||||
|
||||
// set/get the control range
|
||||
virtual void SetRange(int range);
|
||||
virtual int GetRange() const;
|
||||
|
||||
// position
|
||||
virtual void SetValue(int pos);
|
||||
virtual int GetValue() const;
|
||||
|
||||
// appearance params (not implemented for most ports)
|
||||
|
||||
virtual void SetShadowWidth(int w);
|
||||
virtual int GetShadowWidth() const;
|
||||
|
||||
virtual void SetBezelFace(int w);
|
||||
virtual int GetBezelFace() const;
|
||||
|
||||
// overriden base class virtuals
|
||||
virtual bool AcceptsFocus() const { return FALSE; }
|
||||
|
||||
protected:
|
||||
// the max position
|
||||
int m_rangeMax;
|
||||
|
||||
// the current position
|
||||
int m_gaugePos;
|
||||
};
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/gauge.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#ifdef __WIN95__
|
||||
#include "wx/msw/gauge95.h"
|
||||
#define wxGauge wxGauge95
|
||||
#define sm_classwxGauge sm_classwxGauge95
|
||||
#else // !__WIN95__
|
||||
#include "wx/msw/gaugemsw.h"
|
||||
#define wxGauge wxGaugeMSW
|
||||
#define sm_classwxGauge sm_classwxGaugeMSW
|
||||
#endif
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/gauge.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/gauge.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/gauge.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/gauge.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/gauge.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/gauge.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_GAUGE
|
||||
|
||||
#endif
|
||||
// _WX_GAUGE_H_BASE_
|
||||
@@ -1,23 +0,0 @@
|
||||
#ifndef _WX_GDIOBJ_H_BASE_
|
||||
#define _WX_GDIOBJ_H_BASE_
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/gdiobj.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/gdiobj.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/gdiobj.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/gdiobj.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/gdiobj.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/gdiobj.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/gdiobj.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/gdiobj.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_GDIOBJ_H_BASE_
|
||||
@@ -1,21 +0,0 @@
|
||||
#ifndef _WX_GLCANVAS_H_BASE_
|
||||
#define _WX_GLCANVAS_H_BASE_
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/glcanvas.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/glcanvas.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/glcanvas.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/glcanvas.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/glcanvas.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/glcanvas.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/glcanvas.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_GLCANVAS_H_BASE_
|
||||
@@ -1,29 +0,0 @@
|
||||
#ifndef _WX_ICON_H_BASE_
|
||||
#define _WX_ICON_H_BASE_
|
||||
|
||||
/* Commenting out since duplicated in gdicmn.h
|
||||
// this is for Unix (i.e. now for anything other than MSW)
|
||||
#undef wxICON
|
||||
#define wxICON(icon_name) wxIcon(icon_name##_xpm)
|
||||
*/
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/icon.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/icon.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/icon.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/icon.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/icon.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/icon.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/icon.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/icon.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_ICON_H_BASE_
|
||||
@@ -1,149 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/listbox.h
|
||||
// Purpose: wxListBox class interface
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 22.10.99
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) wxWindows team
|
||||
// Licence: wxWindows licence
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_LISTBOX_H_BASE_
|
||||
#define _WX_LISTBOX_H_BASE_
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "listboxbase.h"
|
||||
#endif
|
||||
|
||||
#include "wx/defs.h"
|
||||
|
||||
#if wxUSE_LISTBOX
|
||||
|
||||
#include "wx/ctrlsub.h" // base class
|
||||
|
||||
// forward declarations are enough here
|
||||
class WXDLLEXPORT wxArrayInt;
|
||||
class WXDLLEXPORT wxArrayString;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// global data
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxListBoxNameStr;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxListBox interface is defined by the class wxListBoxBase
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxListBoxBase : public wxControlWithItems
|
||||
{
|
||||
public:
|
||||
// all generic methods are in wxControlWithItems, except for the following
|
||||
// ones which are not yet implemented by wxChoice/wxCombobox
|
||||
#ifdef __DARWIN__
|
||||
virtual ~wxListBoxBase() { }
|
||||
#endif
|
||||
|
||||
void Insert(const wxString& item, int pos)
|
||||
{ DoInsert(item, pos); }
|
||||
void Insert(const wxString& item, int pos, void *clientData)
|
||||
{ DoInsert(item, pos); SetClientData(pos, clientData); }
|
||||
void Insert(const wxString& item, int pos, wxClientData *clientData)
|
||||
{ DoInsert(item, pos); SetClientObject(pos, clientData); }
|
||||
|
||||
void InsertItems(int nItems, const wxString *items, int pos);
|
||||
void InsertItems(const wxArrayString& items, int pos)
|
||||
{ DoInsertItems(items, pos); }
|
||||
|
||||
void Set(int n, const wxString* items, void **clientData = NULL);
|
||||
void Set(const wxArrayString& items, void **clientData = NULL)
|
||||
{ DoSetItems(items, clientData); }
|
||||
|
||||
// multiple selection logic
|
||||
virtual bool IsSelected(int n) const = 0;
|
||||
virtual void SetSelection(int n, bool select = TRUE) = 0;
|
||||
virtual void Select(int n) { SetSelection(n, TRUE); }
|
||||
void Deselect(int n) { SetSelection(n, FALSE); }
|
||||
void DeselectAll(int itemToLeaveSelected = -1);
|
||||
|
||||
virtual bool SetStringSelection(const wxString& s, bool select = TRUE);
|
||||
|
||||
// works for single as well as multiple selection listboxes (unlike
|
||||
// GetSelection which only works for listboxes with single selection)
|
||||
virtual int GetSelections(wxArrayInt& aSelections) const = 0;
|
||||
|
||||
// set the specified item at the first visible item or scroll to max
|
||||
// range.
|
||||
void SetFirstItem(int n) { DoSetFirstItem(n); }
|
||||
void SetFirstItem(const wxString& s);
|
||||
|
||||
// ensures that the given item is visible scrolling the listbox if
|
||||
// necessary
|
||||
virtual void EnsureVisible(int n);
|
||||
|
||||
// a combination of Append() and EnsureVisible(): appends the item to the
|
||||
// listbox and ensures that it is visible i.e. not scrolled out of view
|
||||
void AppendAndEnsureVisible(const wxString& s);
|
||||
|
||||
// return TRUE if the listbox allows multiple selection
|
||||
bool HasMultipleSelection() const
|
||||
{
|
||||
return (m_windowStyle & wxLB_MULTIPLE) ||
|
||||
(m_windowStyle & wxLB_EXTENDED);
|
||||
}
|
||||
|
||||
// return TRUE if this listbox is sorted
|
||||
bool IsSorted() const { return (m_windowStyle & wxLB_SORT) != 0; }
|
||||
|
||||
// emulate selecting or deselecting the item event.GetInt() (depending on
|
||||
// event.GetExtraLong())
|
||||
void Command(wxCommandEvent& event);
|
||||
|
||||
// compatibility - these functions are deprecated, use the new ones
|
||||
// instead
|
||||
bool Selected(int n) const { return IsSelected(n); }
|
||||
|
||||
protected:
|
||||
// NB: due to wxGTK implementation details, DoInsert() is implemented
|
||||
// using DoInsertItems() and not the other way round
|
||||
void DoInsert(const wxString& item, int pos)
|
||||
{ InsertItems(1, &item, pos); }
|
||||
|
||||
// to be implemented in derived classes
|
||||
virtual void DoInsertItems(const wxArrayString& items, int pos) = 0;
|
||||
virtual void DoSetItems(const wxArrayString& items, void **clientData) = 0;
|
||||
|
||||
virtual void DoSetFirstItem(int n) = 0;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// include the platform-specific class declaration
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/listbox.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/listbox.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/listbox.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/listbox.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/listbox.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/listbox.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/listbox.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/listbox.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_LISTBOX
|
||||
|
||||
#endif
|
||||
// _WX_LISTBOX_H_BASE_
|
||||
@@ -1,21 +0,0 @@
|
||||
#ifndef _WX_MDI_H_BASE_
|
||||
#define _WX_MDI_H_BASE_
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/mdi.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/mdi.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/mdi.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/mdi.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/mdi.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/mdi.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/mdi.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_MDI_H_BASE_
|
||||
@@ -1,468 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/menu.h
|
||||
// Purpose: wxMenu and wxMenuBar classes
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 26.10.99
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) wxWindows team
|
||||
// Licence: wxWindows license
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_MENU_H_BASE_
|
||||
#define _WX_MENU_H_BASE_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "menubase.h"
|
||||
#endif
|
||||
|
||||
#if wxUSE_MENUS
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#include "wx/list.h" // for "template" list classes
|
||||
#include "wx/window.h" // base class for wxMenuBar
|
||||
|
||||
// also include this one to ensure compatibility with old code which only
|
||||
// included wx/menu.h
|
||||
#include "wx/menuitem.h"
|
||||
|
||||
class WXDLLEXPORT wxMenu;
|
||||
class WXDLLEXPORT wxMenuBarBase;
|
||||
class WXDLLEXPORT wxMenuBar;
|
||||
class WXDLLEXPORT wxMenuItem;
|
||||
|
||||
// pseudo template list classes
|
||||
WX_DECLARE_EXPORTED_LIST(wxMenu, wxMenuList);
|
||||
WX_DECLARE_EXPORTED_LIST(wxMenuItem, wxMenuItemList);
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// conditional compilation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// having callbacks in menus is a wxWin 1.6x feature which should be replaced
|
||||
// with event tables in wxWin 2.xx code - however provide it because many
|
||||
// people like it a lot by default
|
||||
#ifndef wxUSE_MENU_CALLBACK
|
||||
#if WXWIN_COMPATIBILITY_2
|
||||
#define wxUSE_MENU_CALLBACK 1
|
||||
#else
|
||||
#define wxUSE_MENU_CALLBACK 0
|
||||
#endif // WXWIN_COMPATIBILITY_2
|
||||
#endif // !defined(wxUSE_MENU_CALLBACK)
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxMenu
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxMenuBase : public wxEvtHandler
|
||||
{
|
||||
public:
|
||||
// create a menu
|
||||
static wxMenu *New(const wxString& title = wxEmptyString, long style = 0);
|
||||
|
||||
// ctors
|
||||
wxMenuBase(const wxString& title, long style = 0) : m_title(title)
|
||||
{ Init(style); }
|
||||
wxMenuBase(long style = 0)
|
||||
{ Init(style); }
|
||||
|
||||
// dtor deletes all the menu items we own
|
||||
virtual ~wxMenuBase();
|
||||
|
||||
// menu construction
|
||||
// -----------------
|
||||
|
||||
// append a normal item to the menu
|
||||
void Append(int id,
|
||||
const wxString& text,
|
||||
const wxString& help = wxEmptyString,
|
||||
bool isCheckable = FALSE)
|
||||
{
|
||||
DoAppend(wxMenuItem::New((wxMenu *)this, id, text, help, isCheckable));
|
||||
}
|
||||
|
||||
// append a separator to the menu
|
||||
void AppendSeparator() { Append(wxID_SEPARATOR, wxEmptyString); }
|
||||
|
||||
// append a submenu
|
||||
void Append(int id,
|
||||
const wxString& text,
|
||||
wxMenu *submenu,
|
||||
const wxString& help = wxEmptyString)
|
||||
{
|
||||
DoAppend(wxMenuItem::New((wxMenu *)this, id, text, help, FALSE, submenu));
|
||||
}
|
||||
|
||||
// the most generic form of Append() - append anything
|
||||
void Append(wxMenuItem *item) { DoAppend(item); }
|
||||
|
||||
// insert a break in the menu (only works when appending the items, not
|
||||
// inserting them)
|
||||
virtual void Break() { }
|
||||
|
||||
// insert an item before given position
|
||||
bool Insert(size_t pos, wxMenuItem *item);
|
||||
void Insert(size_t pos,
|
||||
int id,
|
||||
const wxString& text,
|
||||
const wxString& help = wxEmptyString,
|
||||
bool isCheckable = FALSE)
|
||||
{
|
||||
Insert(pos, wxMenuItem::New((wxMenu *)this, id, text, help, isCheckable));
|
||||
}
|
||||
|
||||
// insert a separator
|
||||
void InsertSeparator(size_t pos)
|
||||
{
|
||||
Insert(pos, wxMenuItem::New((wxMenu *)this));
|
||||
}
|
||||
|
||||
// insert a submenu
|
||||
void Insert(size_t pos,
|
||||
int id,
|
||||
const wxString& text,
|
||||
wxMenu *submenu,
|
||||
const wxString& help = wxEmptyString)
|
||||
{
|
||||
Insert(pos, wxMenuItem::New((wxMenu *)this, id, text, help, FALSE, submenu));
|
||||
}
|
||||
|
||||
// prepend an item to the menu
|
||||
void Prepend(wxMenuItem *item)
|
||||
{
|
||||
Insert(0u, item);
|
||||
}
|
||||
|
||||
void Prepend(int id,
|
||||
const wxString& text,
|
||||
const wxString& help = wxEmptyString,
|
||||
bool isCheckable = FALSE)
|
||||
{
|
||||
Insert(0u, id, text, help, isCheckable);
|
||||
}
|
||||
|
||||
// insert a separator
|
||||
void PrependSeparator()
|
||||
{
|
||||
InsertSeparator(0u);
|
||||
}
|
||||
|
||||
// insert a submenu
|
||||
void Prepend(int id,
|
||||
const wxString& text,
|
||||
wxMenu *submenu,
|
||||
const wxString& help = wxEmptyString)
|
||||
{
|
||||
Insert(0u, id, text, submenu, help);
|
||||
}
|
||||
|
||||
// detach an item from the menu, but don't delete it so that it can be
|
||||
// added back later (but if it's not, the caller is responsible for
|
||||
// deleting it!)
|
||||
wxMenuItem *Remove(int id) { return Remove(FindChildItem(id)); }
|
||||
wxMenuItem *Remove(wxMenuItem *item);
|
||||
|
||||
// delete an item from the menu (submenus are not destroyed by this
|
||||
// function, see Destroy)
|
||||
bool Delete(int id) { return Delete(FindChildItem(id)); }
|
||||
bool Delete(wxMenuItem *item);
|
||||
|
||||
// delete the item from menu and destroy it (if it's a submenu)
|
||||
bool Destroy(int id) { return Destroy(FindChildItem(id)); }
|
||||
bool Destroy(wxMenuItem *item);
|
||||
|
||||
// menu items access
|
||||
// -----------------
|
||||
|
||||
// get the items
|
||||
size_t GetMenuItemCount() const { return m_items.GetCount(); }
|
||||
|
||||
const wxMenuItemList& GetMenuItems() const { return m_items; }
|
||||
wxMenuItemList& GetMenuItems() { return m_items; }
|
||||
|
||||
// search
|
||||
virtual int FindItem(const wxString& item) const;
|
||||
wxMenuItem* FindItem(int id, wxMenu **menu = NULL) const;
|
||||
|
||||
// get/set items attributes
|
||||
void Enable(int id, bool enable);
|
||||
bool IsEnabled(int id) const;
|
||||
|
||||
void Check(int id, bool check);
|
||||
bool IsChecked(int id) const;
|
||||
|
||||
void SetLabel(int id, const wxString& label);
|
||||
wxString GetLabel(int id) const;
|
||||
|
||||
virtual void SetHelpString(int id, const wxString& helpString);
|
||||
virtual wxString GetHelpString(int id) const;
|
||||
|
||||
// misc accessors
|
||||
// --------------
|
||||
|
||||
// the title
|
||||
virtual void SetTitle(const wxString& title) { m_title = title; }
|
||||
const wxString GetTitle() const { return m_title; }
|
||||
|
||||
// client data
|
||||
void SetClientData(void* clientData) { m_clientData = clientData; }
|
||||
void* GetClientData() const { return m_clientData; }
|
||||
|
||||
// event handler
|
||||
void SetEventHandler(wxEvtHandler *handler) { m_eventHandler = handler; }
|
||||
wxEvtHandler *GetEventHandler() const { return m_eventHandler; }
|
||||
|
||||
// invoking window
|
||||
void SetInvokingWindow(wxWindow *win) { m_invokingWindow = win; }
|
||||
wxWindow *GetInvokingWindow() const { return m_invokingWindow; }
|
||||
|
||||
// style
|
||||
long GetStyle() const { return m_style; }
|
||||
|
||||
// implementation helpers
|
||||
// ----------------------
|
||||
|
||||
// Updates the UI for a menu and all submenus recursively. source is the
|
||||
// object that has the update event handlers defined for it. If NULL, the
|
||||
// menu or associated window will be used.
|
||||
void UpdateUI(wxEvtHandler* source = (wxEvtHandler*)NULL);
|
||||
|
||||
// get the menu bar this menu is attached to (may be NULL, always NULL for
|
||||
// popup menus)
|
||||
wxMenuBar *GetMenuBar() const { return m_menuBar; }
|
||||
|
||||
// called when the menu is attached/detached to/from a menu bar
|
||||
virtual void Attach(wxMenuBarBase *menubar);
|
||||
virtual void Detach();
|
||||
|
||||
// is the menu attached to a menu bar (or is it a popup one)?
|
||||
bool IsAttached() const { return m_menuBar != NULL; }
|
||||
|
||||
// set/get the parent of this menu
|
||||
void SetParent(wxMenu *parent) { m_menuParent = parent; }
|
||||
wxMenu *GetParent() const { return m_menuParent; }
|
||||
|
||||
#if WXWIN_COMPATIBILITY
|
||||
// compatibility: these functions are deprecated, use the new ones instead
|
||||
bool Enabled(int id) const { return IsEnabled(id); }
|
||||
bool Checked(int id) const { return IsChecked(id); }
|
||||
|
||||
wxMenuItem* FindItemForId(int itemId, wxMenu **itemMenu) const
|
||||
{ return FindItem(itemId, itemMenu); }
|
||||
|
||||
wxList& GetItems() const { return (wxList &)m_items; }
|
||||
#endif // WXWIN_COMPATIBILITY
|
||||
|
||||
#if wxUSE_MENU_CALLBACK || defined(__WXMOTIF__)
|
||||
// wxWin 1.6x compatible menu event handling
|
||||
wxFunction GetCallback() const { return m_callback; }
|
||||
void Callback(const wxFunction func) { m_callback = func; }
|
||||
|
||||
wxFunction m_callback;
|
||||
#endif // wxUSE_MENU_CALLBACK
|
||||
|
||||
// unlike FindItem(), this function doesn't recurse but only looks through
|
||||
// our direct children and also may return the index of the found child if
|
||||
// pos != NULL
|
||||
wxMenuItem *FindChildItem(int id, size_t *pos = NULL) const;
|
||||
|
||||
// called to generate a wxCommandEvent, return TRUE if it was processed,
|
||||
// FALSE otherwise
|
||||
//
|
||||
// the checked parameter may have boolean value or -1 for uncheckable items
|
||||
bool SendEvent(int id, int checked = -1);
|
||||
|
||||
protected:
|
||||
// virtuals to override in derived classes
|
||||
// ---------------------------------------
|
||||
|
||||
virtual bool DoAppend(wxMenuItem *item);
|
||||
virtual bool DoInsert(size_t pos, wxMenuItem *item);
|
||||
|
||||
virtual wxMenuItem *DoRemove(wxMenuItem *item);
|
||||
virtual bool DoDelete(wxMenuItem *item);
|
||||
virtual bool DoDestroy(wxMenuItem *item);
|
||||
|
||||
// helpers
|
||||
// -------
|
||||
|
||||
// common part of all ctors
|
||||
void Init(long style);
|
||||
|
||||
// associate the submenu with this menu
|
||||
void AddSubMenu(wxMenu *submenu);
|
||||
|
||||
wxMenuBar *m_menuBar; // menubar we belong to or NULL
|
||||
wxMenu *m_menuParent; // parent menu or NULL
|
||||
|
||||
wxString m_title; // the menu title or label
|
||||
wxMenuItemList m_items; // the list of menu items
|
||||
|
||||
wxWindow *m_invokingWindow; // for popup menus
|
||||
void *m_clientData; // associated with the menu
|
||||
|
||||
long m_style; // combination of wxMENU_XXX flags
|
||||
|
||||
wxEvtHandler *m_eventHandler; // a pluggable in event handler
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxMenuBar
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxMenuBarBase : public wxWindow
|
||||
{
|
||||
public:
|
||||
// default ctor
|
||||
wxMenuBarBase();
|
||||
|
||||
// dtor will delete all menus we own
|
||||
virtual ~wxMenuBarBase();
|
||||
|
||||
// menu bar construction
|
||||
// ---------------------
|
||||
|
||||
// append a menu to the end of menubar, return TRUE if ok
|
||||
virtual bool Append(wxMenu *menu, const wxString& title);
|
||||
|
||||
// insert a menu before the given position into the menubar, return TRUE
|
||||
// if inserted ok
|
||||
virtual bool Insert(size_t pos, wxMenu *menu, const wxString& title);
|
||||
|
||||
// menu bar items access
|
||||
// ---------------------
|
||||
|
||||
// get the number of menus in the menu bar
|
||||
size_t GetMenuCount() const { return m_menus.GetCount(); }
|
||||
|
||||
// get the menu at given position
|
||||
wxMenu *GetMenu(size_t pos) const;
|
||||
|
||||
// replace the menu at given position with another one, returns the
|
||||
// previous menu (which should be deleted by the caller)
|
||||
virtual wxMenu *Replace(size_t pos, wxMenu *menu, const wxString& title);
|
||||
|
||||
// delete the menu at given position from the menu bar, return the pointer
|
||||
// to the menu (which should be deleted by the caller)
|
||||
virtual wxMenu *Remove(size_t pos);
|
||||
|
||||
// enable or disable a submenu
|
||||
virtual void EnableTop(size_t pos, bool enable) = 0;
|
||||
|
||||
// is the menu enabled?
|
||||
virtual bool IsEnabledTop(size_t WXUNUSED(pos)) const { return TRUE; }
|
||||
|
||||
// get or change the label of the menu at given position
|
||||
virtual void SetLabelTop(size_t pos, const wxString& label) = 0;
|
||||
virtual wxString GetLabelTop(size_t pos) const = 0;
|
||||
|
||||
// item search
|
||||
// -----------
|
||||
|
||||
// by menu and item names, returns wxNOT_FOUND if not found or id of the
|
||||
// found item
|
||||
virtual int FindMenuItem(const wxString& menu, const wxString& item) const;
|
||||
|
||||
// find item by id (in any menu), returns NULL if not found
|
||||
//
|
||||
// if menu is !NULL, it will be filled with wxMenu this item belongs to
|
||||
virtual wxMenuItem* FindItem(int id, wxMenu **menu = NULL) const;
|
||||
|
||||
// find menu by its caption, return wxNOT_FOUND on failure
|
||||
int FindMenu(const wxString& title) const;
|
||||
|
||||
// item access
|
||||
// -----------
|
||||
|
||||
// all these functions just use FindItem() and then call an appropriate
|
||||
// method on it
|
||||
//
|
||||
// NB: under MSW, these methods can only be used after the menubar had
|
||||
// been attached to the frame
|
||||
|
||||
void Enable(int id, bool enable);
|
||||
void Check(int id, bool check);
|
||||
bool IsChecked(int id) const;
|
||||
bool IsEnabled(int id) const;
|
||||
|
||||
void SetLabel(int id, const wxString &label);
|
||||
wxString GetLabel(int id) const;
|
||||
|
||||
void SetHelpString(int id, const wxString& helpString);
|
||||
wxString GetHelpString(int id) const;
|
||||
|
||||
// implementation helpers
|
||||
|
||||
// get the frame we are attached to (may return NULL)
|
||||
wxFrame *GetFrame() const { return m_menuBarFrame; }
|
||||
|
||||
// returns TRUE if we're attached to a frame
|
||||
bool IsAttached() const { return GetFrame() != NULL; }
|
||||
|
||||
// associate the menubar with the frame
|
||||
virtual void Attach(wxFrame *frame);
|
||||
|
||||
// called before deleting the menubar normally
|
||||
virtual void Detach();
|
||||
|
||||
// need to override these ones to avoid virtual function hiding
|
||||
virtual bool Enable(bool enable = TRUE) { return wxWindow::Enable(enable); }
|
||||
virtual void SetLabel(const wxString& s) { wxWindow::SetLabel(s); }
|
||||
virtual wxString GetLabel() const { return wxWindow::GetLabel(); }
|
||||
|
||||
// don't want menu bars to accept the focus by tabbing to them
|
||||
virtual bool AcceptsFocusFromKeyboard() const { return FALSE; }
|
||||
|
||||
// compatibility only: these functions are deprecated, use the new ones
|
||||
// instead
|
||||
#if WXWIN_COMPATIBILITY
|
||||
bool Enabled(int id) const { return IsEnabled(id); }
|
||||
bool Checked(int id) const { return IsChecked(id); }
|
||||
|
||||
wxMenuItem* FindMenuItemById(int id) const
|
||||
{ return FindItem(id); }
|
||||
wxMenuItem* FindItemForId(int id, wxMenu **menu = NULL) const
|
||||
{ return FindItem(id, menu); }
|
||||
#endif // WXWIN_COMPATIBILITY
|
||||
|
||||
protected:
|
||||
// the list of all our menus
|
||||
wxMenuList m_menus;
|
||||
|
||||
// the frame we are attached to (may be NULL)
|
||||
wxFrame *m_menuBarFrame;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// include the real class declaration
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#ifdef wxUSE_BASE_CLASSES_ONLY
|
||||
#define wxMenuItem wxMenuItemBase
|
||||
#else // !wxUSE_BASE_CLASSES_ONLY
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/menu.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/menu.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/menu.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/menu.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/menu.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/menu.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/menu.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/menu.h"
|
||||
#endif
|
||||
#endif // wxUSE_BASE_CLASSES_ONLY/!wxUSE_BASE_CLASSES_ONLY
|
||||
|
||||
#endif // wxUSE_MENUS
|
||||
|
||||
#endif
|
||||
// _WX_MENU_H_BASE_
|
||||
@@ -1,157 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/menuitem.h
|
||||
// Purpose: wxMenuItem class
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 25.10.99
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
|
||||
// Licence: wxWindows license
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_MENUITEM_H_BASE_
|
||||
#define _WX_MENUITEM_H_BASE_
|
||||
|
||||
#if wxUSE_MENUS
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#include "wx/object.h" // base class
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// forward declarations
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxAcceleratorEntry;
|
||||
class WXDLLEXPORT wxMenuItem;
|
||||
class WXDLLEXPORT wxMenu;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxMenuItem is an item in the menu which may be either a normal item, a sub
|
||||
// menu or a separator
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxMenuItemBase : public wxObject
|
||||
{
|
||||
public:
|
||||
// creation
|
||||
static wxMenuItem *New(wxMenu *parentMenu = (wxMenu *)NULL,
|
||||
int id = wxID_SEPARATOR,
|
||||
const wxString& text = wxEmptyString,
|
||||
const wxString& help = wxEmptyString,
|
||||
bool isCheckable = FALSE,
|
||||
wxMenu *subMenu = (wxMenu *)NULL);
|
||||
|
||||
// destruction: wxMenuItem will delete its submenu
|
||||
virtual ~wxMenuItemBase();
|
||||
|
||||
// the menu we're in
|
||||
wxMenu *GetMenu() const { return m_parentMenu; }
|
||||
|
||||
// get/set id
|
||||
void SetId(int id) { m_id = id; }
|
||||
int GetId() const { return m_id; }
|
||||
bool IsSeparator() const { return m_id == wxID_SEPARATOR; }
|
||||
|
||||
// the item's text (or name)
|
||||
//
|
||||
// NB: the item's text includes the accelerators and mnemonics info (if
|
||||
// any), i.e. it may contain '&' or '_' or "\t..." and thus is
|
||||
// different from the item's label which only contains the text shown
|
||||
// in the menu
|
||||
virtual void SetText(const wxString& str) { m_text = str; }
|
||||
wxString GetLabel() const { return GetLabelFromText(m_text); }
|
||||
const wxString& GetText() const { return m_text; }
|
||||
|
||||
// get the label from text (implemented in platform-specific code)
|
||||
static wxString GetLabelFromText(const wxString& text);
|
||||
|
||||
// what kind of menu item we are
|
||||
virtual void SetCheckable(bool checkable) { m_isCheckable = checkable; }
|
||||
bool IsCheckable() const { return m_isCheckable; }
|
||||
|
||||
bool IsSubMenu() const { return m_subMenu != NULL; }
|
||||
void SetSubMenu(wxMenu *menu) { m_subMenu = menu; }
|
||||
wxMenu *GetSubMenu() const { return m_subMenu; }
|
||||
|
||||
// state
|
||||
virtual void Enable(bool enable = TRUE) { m_isEnabled = enable; }
|
||||
virtual bool IsEnabled() const { return m_isEnabled; }
|
||||
|
||||
virtual void Check(bool check = TRUE) { m_isChecked = check; }
|
||||
virtual bool IsChecked() const { return m_isChecked; }
|
||||
void Toggle() { Check(!m_isChecked); }
|
||||
|
||||
// help string (displayed in the status bar by default)
|
||||
void SetHelp(const wxString& str) { m_help = str; }
|
||||
const wxString& GetHelp() const { return m_help; }
|
||||
|
||||
#if wxUSE_ACCEL
|
||||
// extract the accelerator from the given menu string, return NULL if none
|
||||
// found
|
||||
static wxAcceleratorEntry *GetAccelFromString(const wxString& label);
|
||||
|
||||
// get our accelerator or NULL (caller must delete the pointer)
|
||||
virtual wxAcceleratorEntry *GetAccel() const;
|
||||
|
||||
// set the accel for this item - this may also be done indirectly with
|
||||
// SetText()
|
||||
virtual void SetAccel(wxAcceleratorEntry *accel);
|
||||
#endif // wxUSE_ACCEL
|
||||
|
||||
// compatibility only, use new functions in the new code
|
||||
void SetName(const wxString& str) { SetText(str); }
|
||||
const wxString& GetName() const { return GetText(); }
|
||||
|
||||
protected:
|
||||
int m_id; // numeric id of the item >= 0 or -1
|
||||
wxMenu *m_parentMenu, // the menu we belong to
|
||||
*m_subMenu; // our sub menu or NULL
|
||||
wxString m_text, // label of the item
|
||||
m_help; // the help string for the item
|
||||
bool m_isCheckable; // can be checked?
|
||||
bool m_isChecked; // is checked?
|
||||
bool m_isEnabled; // is enabled?
|
||||
|
||||
// some compilers need a default constructor here, do not remove
|
||||
wxMenuItemBase() { }
|
||||
|
||||
private:
|
||||
// and, if we have one ctor, compiler won't generate a default copy one, so
|
||||
// declare them ourselves - but don't implement as they shouldn't be used
|
||||
wxMenuItemBase(const wxMenuItemBase& item);
|
||||
wxMenuItemBase& operator=(const wxMenuItemBase& item);
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// include the real class declaration
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#ifdef wxUSE_BASE_CLASSES_ONLY
|
||||
#define wxMenuItem wxMenuItemBase
|
||||
#else // !wxUSE_BASE_CLASSES_ONLY
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/menuitem.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/menuitem.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/menuitem.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/menuitem.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/menuitem.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/menuitem.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/menuitem.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/menuitem.h"
|
||||
#endif
|
||||
#endif // wxUSE_BASE_CLASSES_ONLY/!wxUSE_BASE_CLASSES_ONLY
|
||||
|
||||
#endif // wxUSE_MENUS
|
||||
|
||||
#endif
|
||||
// _WX_MENUITEM_H_BASE_
|
||||
@@ -1,37 +0,0 @@
|
||||
#ifndef _WX_MSGDLG_H_BASE_
|
||||
#define _WX_MSGDLG_H_BASE_
|
||||
|
||||
#if wxUSE_MSGDLG
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/generic/msgdlgg.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/msgdlg.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/msgdlg.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/generic/msgdlgg.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/generic/msgdlgg.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/msgdlg.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/msgdlg.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/generic/msgdlgg.h"
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxMessageBox: the simplest way to use wxMessageDialog
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
int WXDLLEXPORT wxMessageBox(const wxString& message,
|
||||
const wxString& caption = wxMessageBoxCaptionStr,
|
||||
long style = wxOK | wxCENTRE,
|
||||
wxWindow *parent = NULL,
|
||||
int x = -1, int y = -1);
|
||||
|
||||
#endif // wxUSE_MSGDLG
|
||||
|
||||
#endif
|
||||
// _WX_MSGDLG_H_BASE_
|
||||
@@ -1,289 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/notebook.h
|
||||
// Purpose: wxNotebook interface
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 01.02.01
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 1996-2000 wxWindows team
|
||||
// Licence: wxWindows licence
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_NOTEBOOK_H_BASE_
|
||||
#define _WX_NOTEBOOK_H_BASE_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "notebookbase.h"
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#include "wx/defs.h"
|
||||
|
||||
#if wxUSE_NOTEBOOK
|
||||
|
||||
#include "wx/control.h"
|
||||
#include "wx/dynarray.h"
|
||||
|
||||
class WXDLLEXPORT wxImageList;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// types
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// array of notebook pages
|
||||
typedef wxWindow wxNotebookPage; // so far, any window can be a page
|
||||
|
||||
WX_DEFINE_EXPORTED_ARRAY(wxNotebookPage *, wxArrayPages);
|
||||
|
||||
#define wxNOTEBOOK_NAME _T("notebook")
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxNotebookBase: define wxNotebook interface
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxNotebookBase : public wxControl
|
||||
{
|
||||
public:
|
||||
// ctor
|
||||
wxNotebookBase()
|
||||
{
|
||||
Init();
|
||||
}
|
||||
|
||||
// quasi ctor
|
||||
bool Create(wxWindow *parent,
|
||||
wxWindowID id,
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& size = wxDefaultSize,
|
||||
long style = 0,
|
||||
const wxString& name = wxNOTEBOOK_NAME);
|
||||
|
||||
// dtor
|
||||
virtual ~wxNotebookBase();
|
||||
|
||||
// accessors
|
||||
// ---------
|
||||
|
||||
// get number of pages in the dialog
|
||||
int GetPageCount() const { return m_pages.GetCount(); }
|
||||
|
||||
// get the panel which represents the given page
|
||||
wxNotebookPage *GetPage(int nPage) { return m_pages[nPage]; }
|
||||
|
||||
// get the currently selected page
|
||||
virtual int GetSelection() const = 0;
|
||||
|
||||
// set/get the title of a page
|
||||
virtual bool SetPageText(int nPage, const wxString& strText) = 0;
|
||||
virtual wxString GetPageText(int nPage) const = 0;
|
||||
|
||||
// image list stuff: each page may have an image associated with it (all
|
||||
// images belong to the same image list)
|
||||
virtual void SetImageList(wxImageList* imageList);
|
||||
|
||||
// as SetImageList() but we will delete the image list ourselves
|
||||
void AssignImageList(wxImageList* imageList);
|
||||
|
||||
// get pointer (may be NULL) to the associated image list
|
||||
wxImageList* GetImageList() const { return m_imageList; }
|
||||
|
||||
// sets/returns item's image index in the current image list
|
||||
virtual int GetPageImage(int nPage) const = 0;
|
||||
virtual bool SetPageImage(int nPage, int nImage) = 0;
|
||||
|
||||
// get the number of rows for a control with wxNB_MULTILINE style (not all
|
||||
// versions support it - they will always return 1 then)
|
||||
virtual int GetRowCount() const { return 1; }
|
||||
|
||||
// set the size (the same for all pages)
|
||||
virtual void SetPageSize(const wxSize& size) = 0;
|
||||
|
||||
// set the padding between tabs (in pixels)
|
||||
virtual void SetPadding(const wxSize& padding) = 0;
|
||||
|
||||
// set the size of the tabs for wxNB_FIXEDWIDTH controls
|
||||
virtual void SetTabSize(const wxSize& sz) = 0;
|
||||
|
||||
// calculate the size of the notebook from the size of its page
|
||||
virtual wxSize CalcSizeFromPage(const wxSize& sizePage);
|
||||
|
||||
// operations
|
||||
// ----------
|
||||
|
||||
// remove one page from the notebook and delete it
|
||||
virtual bool DeletePage(int nPage);
|
||||
|
||||
// remove one page from the notebook, without deleting it
|
||||
virtual bool RemovePage(int nPage) { return DoRemovePage(nPage) != NULL; }
|
||||
|
||||
// remove all pages and delete them
|
||||
virtual bool DeleteAllPages() { WX_CLEAR_ARRAY(m_pages); return TRUE; }
|
||||
|
||||
// adds a new page to the notebook (it will be deleted by the notebook,
|
||||
// don't delete it yourself) and make it the current one if bSelect
|
||||
virtual bool AddPage(wxNotebookPage *pPage,
|
||||
const wxString& strText,
|
||||
bool bSelect = FALSE,
|
||||
int imageId = -1)
|
||||
{
|
||||
return InsertPage(GetPageCount(), pPage, strText, bSelect, imageId);
|
||||
}
|
||||
|
||||
// the same as AddPage(), but adds the page at the specified position
|
||||
virtual bool InsertPage(int nPage,
|
||||
wxNotebookPage *pPage,
|
||||
const wxString& strText,
|
||||
bool bSelect = FALSE,
|
||||
int imageId = -1) = 0;
|
||||
|
||||
// set the currently selected page, return the index of the previously
|
||||
// selected one (or -1 on error)
|
||||
//
|
||||
// NB: this function will _not_ generate wxEVT_NOTEBOOK_PAGE_xxx events
|
||||
virtual int SetSelection(int nPage) = 0;
|
||||
|
||||
// cycle thru the tabs
|
||||
void AdvanceSelection(bool forward = TRUE)
|
||||
{
|
||||
int nPage = GetNextPage(forward);
|
||||
if ( nPage != -1 )
|
||||
SetSelection(nPage);
|
||||
}
|
||||
|
||||
protected:
|
||||
// remove the page and return a pointer to it
|
||||
virtual wxNotebookPage *DoRemovePage(int page);
|
||||
|
||||
// common part of all ctors
|
||||
void Init();
|
||||
|
||||
// get the next page wrapping if we reached the end
|
||||
int GetNextPage(bool forward) const;
|
||||
|
||||
wxArrayPages m_pages; // array of pages
|
||||
wxImageList *m_imageList; // we can have an associated image list
|
||||
bool m_ownsImageList; // true if we must delete m_imageList
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// notebook event class (used by NOTEBOOK_PAGE_CHANGED/ING events)
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxNotebookEvent : public wxNotifyEvent
|
||||
{
|
||||
public:
|
||||
wxNotebookEvent(wxEventType commandType = wxEVT_NULL, int id = 0,
|
||||
int nSel = -1, int nOldSel = -1)
|
||||
: wxNotifyEvent(commandType, id)
|
||||
{
|
||||
m_nSel = nSel;
|
||||
m_nOldSel = nOldSel;
|
||||
}
|
||||
|
||||
// accessors
|
||||
// the currently selected page (-1 if none)
|
||||
int GetSelection() const { return m_nSel; }
|
||||
void SetSelection(int nSel) { m_nSel = nSel; }
|
||||
// the page that was selected before the change (-1 if none)
|
||||
int GetOldSelection() const { return m_nOldSel; }
|
||||
void SetOldSelection(int nOldSel) { m_nOldSel = nOldSel; }
|
||||
|
||||
private:
|
||||
int m_nSel, // currently selected page
|
||||
m_nOldSel; // previously selected page
|
||||
|
||||
DECLARE_DYNAMIC_CLASS(wxNotebookEvent)
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// event types and macros for them
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if defined(__BORLANDC__) && defined(__WIN16__)
|
||||
// For 16-bit BC++, these 2 would be identical otherwise (truncated)
|
||||
#define wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED wxEVT_COMMAND_NB_PAGE_CHANGED
|
||||
#define wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING wxEVT_COMMAND_NB_PAGE_CHANGING
|
||||
#endif
|
||||
|
||||
BEGIN_DECLARE_EVENT_TYPES()
|
||||
DECLARE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, 802)
|
||||
DECLARE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, 803)
|
||||
END_DECLARE_EVENT_TYPES()
|
||||
|
||||
typedef void (wxEvtHandler::*wxNotebookEventFunction)(wxNotebookEvent&);
|
||||
|
||||
// Truncation in 16-bit BC++ means we need to define these differently
|
||||
#if defined(__BORLANDC__) && defined(__WIN16__)
|
||||
#define EVT_NOTEBOOK_PAGE_CHANGED(id, fn) \
|
||||
DECLARE_EVENT_TABLE_ENTRY( \
|
||||
wxEVT_COMMAND_NB_PAGE_CHANGED, \
|
||||
id, \
|
||||
-1, \
|
||||
(wxObjectEventFunction)(wxEventFunction)(wxNotebookEventFunction) &fn, \
|
||||
NULL \
|
||||
),
|
||||
|
||||
#define EVT_NOTEBOOK_PAGE_CHANGING(id, fn) \
|
||||
DECLARE_EVENT_TABLE_ENTRY( \
|
||||
wxEVT_COMMAND_NB_PAGE_CHANGING, \
|
||||
id, \
|
||||
-1, \
|
||||
(wxObjectEventFunction)(wxEventFunction)(wxNotebookEventFunction) &fn, \
|
||||
NULL \
|
||||
),
|
||||
|
||||
#else
|
||||
|
||||
#define EVT_NOTEBOOK_PAGE_CHANGED(id, fn) \
|
||||
DECLARE_EVENT_TABLE_ENTRY( \
|
||||
wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, \
|
||||
id, \
|
||||
-1, \
|
||||
(wxObjectEventFunction)(wxEventFunction)(wxNotebookEventFunction) &fn, \
|
||||
NULL \
|
||||
),
|
||||
|
||||
#define EVT_NOTEBOOK_PAGE_CHANGING(id, fn) \
|
||||
DECLARE_EVENT_TABLE_ENTRY( \
|
||||
wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, \
|
||||
id, \
|
||||
-1, \
|
||||
(wxObjectEventFunction)(wxEventFunction)(wxNotebookEventFunction) &fn, \
|
||||
NULL \
|
||||
),
|
||||
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxNotebook class itself
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/notebook.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#ifdef __WIN16__
|
||||
#include "wx/generic/notebook.h"
|
||||
#else
|
||||
#include "wx/msw/notebook.h"
|
||||
#endif
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/generic/notebook.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/notebook.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/notebook.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/notebook.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/notebook.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/notebook.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_NOTEBOOK
|
||||
|
||||
#endif
|
||||
// _WX_NOTEBOOK_H_BASE_
|
||||
@@ -1,23 +0,0 @@
|
||||
#ifndef _WX_PALETTE_H_BASE_
|
||||
#define _WX_PALETTE_H_BASE_
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/palette.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/palette.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/generic/paletteg.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/palette.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/palette.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/palette.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/palette.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/palette.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_PALETTE_H_BASE_
|
||||
@@ -1,23 +0,0 @@
|
||||
#ifndef _WX_PEN_H_BASE_
|
||||
#define _WX_PEN_H_BASE_
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/pen.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/pen.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/pen.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/pen.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/pen.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/pen.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/pen.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/pen.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_PEN_H_BASE_
|
||||
@@ -1,32 +0,0 @@
|
||||
#ifndef _WX_PRINTDLG_H_BASE_
|
||||
#define _WX_PRINTDLG_H_BASE_
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/printdlg.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/generic/prntdlgg.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/generic/prntdlgg.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/generic/prntdlgg.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/printdlg.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/generic/prntdlgg.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/generic/prntdlgg.h"
|
||||
#endif
|
||||
|
||||
#if !defined(__WXMSW__) && !defined(__WXMAC__)
|
||||
#define wxPrintDialog wxGenericPrintDialog
|
||||
#define sm_classwxPrintDialog sm_classwxGenericPrintDialog
|
||||
|
||||
#define wxPrintSetupDialog wxGenericPrintSetupDialog
|
||||
#define sm_classwxPrintSetupDialog sm_classwxGenericPrintSetupDialog
|
||||
|
||||
#define wxPageSetupDialog wxGenericPageSetupDialog
|
||||
#define sm_classwxPageSetupDialog sm_classwxGenericPageSetupDialog
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_PRINTDLG_H_BASE_
|
||||
@@ -1,118 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/radiobox.h
|
||||
// Purpose: wxRadioBox declaration
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 10.09.00
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) wxWindows team
|
||||
// Licence: wxWindows license
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_RADIOBOX_H_BASE_
|
||||
#define _WX_RADIOBOX_H_BASE_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "radioboxbase.h"
|
||||
#endif
|
||||
|
||||
#if wxUSE_RADIOBOX
|
||||
|
||||
#include "wx/control.h"
|
||||
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxRadioBoxNameStr;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxRadioBoxBase is not a normal base class, but rather a mix-in because the
|
||||
// real wxRadioBox derives from different classes on different platforms: for
|
||||
// example, it is a wxStaticBox in wxUniv but not in wxMSW
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxRadioBoxBase
|
||||
{
|
||||
public:
|
||||
// selection
|
||||
virtual void SetSelection(int n) = 0;
|
||||
virtual int GetSelection() const = 0;
|
||||
|
||||
virtual wxString GetStringSelection() const
|
||||
{
|
||||
wxString s;
|
||||
int sel = GetSelection();
|
||||
if ( sel != wxNOT_FOUND )
|
||||
s = GetString(sel);
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
virtual bool SetStringSelection(const wxString& s)
|
||||
{
|
||||
int sel = FindString(s);
|
||||
if ( sel != wxNOT_FOUND )
|
||||
{
|
||||
SetSelection(sel);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// string access
|
||||
virtual int GetCount() const = 0;
|
||||
virtual int FindString(const wxString& s) const
|
||||
{
|
||||
int count = GetCount();
|
||||
for ( int n = 0; n < count; n++ )
|
||||
{
|
||||
if ( GetString(n) == s )
|
||||
return n;
|
||||
}
|
||||
|
||||
return wxNOT_FOUND;
|
||||
}
|
||||
|
||||
virtual wxString GetString(int n) const = 0;
|
||||
virtual void SetString(int n, const wxString& label) = 0;
|
||||
|
||||
// change the individual radio button state
|
||||
virtual void Enable(int n, bool enable = TRUE) = 0;
|
||||
virtual void Show(int n, bool show = TRUE) = 0;
|
||||
|
||||
// layout parameters
|
||||
virtual int GetColumnCount() const = 0;
|
||||
virtual int GetRowCount() const = 0;
|
||||
|
||||
// return the item above/below/to the left/right of the given one
|
||||
int GetNextItem(int item, wxDirection dir, long style) const;
|
||||
|
||||
// for compatibility only, don't use these methods in new code!
|
||||
#if WXWIN_COMPATIBILITY_2_2
|
||||
int Number() const { return GetCount(); }
|
||||
wxString GetLabel(int n) const { return GetString(n); }
|
||||
void SetLabel(int n, const wxString& label) { SetString(n, label); }
|
||||
#endif // WXWIN_COMPATIBILITY_2_2
|
||||
};
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/radiobox.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/radiobox.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/radiobox.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/radiobox.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/radiobox.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/radiobox.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/radiobox.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/radiobox.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_RADIOBOX
|
||||
|
||||
#endif
|
||||
// _WX_RADIOBOX_H_BASE_
|
||||
@@ -1,57 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/radiobut.h
|
||||
// Purpose: wxRadioButton declaration
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 07.09.00
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) wxWindows team
|
||||
// Licence: wxWindows license
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_RADIOBUT_H_BASE_
|
||||
#define _WX_RADIOBUT_H_BASE_
|
||||
|
||||
#if wxUSE_RADIOBTN
|
||||
|
||||
/*
|
||||
There is no wxRadioButtonBase class as wxRadioButton interface is the same
|
||||
as of wxCheckBox(Base), but under some platforms wxRadioButton really
|
||||
derives from wxCheckBox and on the others it doesn't.
|
||||
|
||||
The pseudo-declaration of wxRadioButtonBase would look like this:
|
||||
|
||||
class wxRadioButtonBase : public ...
|
||||
{
|
||||
public:
|
||||
virtual void SetValue(bool value);
|
||||
virtual bool GetValue() const;
|
||||
};
|
||||
*/
|
||||
|
||||
#include "wx/control.h"
|
||||
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxRadioButtonNameStr;
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/radiobut.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/radiobut.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/radiobut.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/radiobut.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/radiobut.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/radiobut.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/radiobut.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/radiobut.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_RADIOBTN
|
||||
|
||||
#endif
|
||||
// _WX_RADIOBUT_H_BASE_
|
||||
@@ -1,23 +0,0 @@
|
||||
#ifndef _WX_REGION_H_BASE_
|
||||
#define _WX_REGION_H_BASE_
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/region.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/region.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/region.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/region.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/region.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/region.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/region.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/region.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_REGION_H_BASE_
|
||||
@@ -1,62 +0,0 @@
|
||||
#ifndef _WX_SCROLBAR_H_BASE_
|
||||
#define _WX_SCROLBAR_H_BASE_
|
||||
|
||||
#if wxUSE_SCROLLBAR
|
||||
|
||||
#include "wx/control.h"
|
||||
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxScrollBarNameStr;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxScrollBar: a scroll bar control
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxScrollBarBase : public wxControl
|
||||
{
|
||||
public:
|
||||
// scrollbar construction
|
||||
bool Create(wxWindow *parent,
|
||||
wxWindowID id,
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& size = wxDefaultSize,
|
||||
long style = wxSB_HORIZONTAL,
|
||||
const wxValidator& validator = wxDefaultValidator,
|
||||
const wxString& name = wxScrollBarNameStr);
|
||||
|
||||
// accessors
|
||||
virtual int GetThumbPosition() const = 0;
|
||||
virtual int GetThumbSize() const = 0;
|
||||
virtual int GetPageSize() const = 0;
|
||||
virtual int GetRange() const = 0;
|
||||
|
||||
bool IsVertical() const { return (m_windowStyle & wxVERTICAL) != 0; }
|
||||
|
||||
// operations
|
||||
virtual void SetThumbPosition(int viewStart) = 0;
|
||||
virtual void SetScrollbar(int position, int thumbSize,
|
||||
int range, int pageSize,
|
||||
bool refresh = TRUE) = 0;
|
||||
};
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/scrolbar.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/scrolbar.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/scrolbar.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/scrolbar.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/scrolbar.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/scrolbar.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/scrolbar.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/scrolbar.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_SCROLLBAR
|
||||
|
||||
#endif
|
||||
// _WX_SCROLBAR_H_BASE_
|
||||
@@ -1,129 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: settings.h
|
||||
// Purpose: wxSystemSettings defines; includes platform settings.h
|
||||
// Author: Julian Smart
|
||||
// Modified by:
|
||||
// Created: 01/02/97
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Julian Smart and Markus Holzem
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_SETTINGS_H_BASE_
|
||||
#define _WX_SETTINGS_H_BASE_
|
||||
|
||||
#define wxSYS_WHITE_BRUSH 0
|
||||
#define wxSYS_LTGRAY_BRUSH 1
|
||||
#define wxSYS_GRAY_BRUSH 2
|
||||
#define wxSYS_DKGRAY_BRUSH 3
|
||||
#define wxSYS_BLACK_BRUSH 4
|
||||
#define wxSYS_NULL_BRUSH 5
|
||||
#define wxSYS_HOLLOW_BRUSH wxSYS_NULL_BRUSH
|
||||
#define wxSYS_WHITE_PEN 6
|
||||
#define wxSYS_BLACK_PEN 7
|
||||
#define wxSYS_NULL_PEN 8
|
||||
#define wxSYS_OEM_FIXED_FONT 10
|
||||
#define wxSYS_ANSI_FIXED_FONT 11
|
||||
#define wxSYS_ANSI_VAR_FONT 12
|
||||
#define wxSYS_SYSTEM_FONT 13
|
||||
#define wxSYS_DEVICE_DEFAULT_FONT 14
|
||||
#define wxSYS_DEFAULT_PALETTE 15
|
||||
#define wxSYS_SYSTEM_FIXED_FONT 16
|
||||
#define wxSYS_DEFAULT_GUI_FONT 17
|
||||
|
||||
#define wxSYS_COLOUR_SCROLLBAR 0
|
||||
#define wxSYS_COLOUR_BACKGROUND 1
|
||||
#define wxSYS_COLOUR_ACTIVECAPTION 2
|
||||
#define wxSYS_COLOUR_INACTIVECAPTION 3
|
||||
#define wxSYS_COLOUR_MENU 4
|
||||
#define wxSYS_COLOUR_WINDOW 5
|
||||
#define wxSYS_COLOUR_WINDOWFRAME 6
|
||||
#define wxSYS_COLOUR_MENUTEXT 7
|
||||
#define wxSYS_COLOUR_WINDOWTEXT 8
|
||||
#define wxSYS_COLOUR_CAPTIONTEXT 9
|
||||
#define wxSYS_COLOUR_ACTIVEBORDER 10
|
||||
#define wxSYS_COLOUR_INACTIVEBORDER 11
|
||||
#define wxSYS_COLOUR_APPWORKSPACE 12
|
||||
#define wxSYS_COLOUR_HIGHLIGHT 13
|
||||
#define wxSYS_COLOUR_HIGHLIGHTTEXT 14
|
||||
#define wxSYS_COLOUR_BTNFACE 15
|
||||
#define wxSYS_COLOUR_BTNSHADOW 16
|
||||
#define wxSYS_COLOUR_GRAYTEXT 17
|
||||
#define wxSYS_COLOUR_BTNTEXT 18
|
||||
#define wxSYS_COLOUR_INACTIVECAPTIONTEXT 19
|
||||
#define wxSYS_COLOUR_BTNHIGHLIGHT 20
|
||||
|
||||
#define wxSYS_COLOUR_3DDKSHADOW 21
|
||||
#define wxSYS_COLOUR_3DLIGHT 22
|
||||
#define wxSYS_COLOUR_INFOTEXT 23
|
||||
#define wxSYS_COLOUR_INFOBK 24
|
||||
|
||||
#define wxSYS_COLOUR_LISTBOX 25
|
||||
|
||||
#define wxSYS_COLOUR_DESKTOP wxSYS_COLOUR_BACKGROUND
|
||||
#define wxSYS_COLOUR_3DFACE wxSYS_COLOUR_BTNFACE
|
||||
#define wxSYS_COLOUR_3DSHADOW wxSYS_COLOUR_BTNSHADOW
|
||||
#define wxSYS_COLOUR_3DHIGHLIGHT wxSYS_COLOUR_BTNHIGHLIGHT
|
||||
#define wxSYS_COLOUR_3DHILIGHT wxSYS_COLOUR_BTNHIGHLIGHT
|
||||
#define wxSYS_COLOUR_BTNHILIGHT wxSYS_COLOUR_BTNHIGHLIGHT
|
||||
|
||||
// Metrics
|
||||
#define wxSYS_MOUSE_BUTTONS 1
|
||||
#define wxSYS_BORDER_X 2
|
||||
#define wxSYS_BORDER_Y 3
|
||||
#define wxSYS_CURSOR_X 4
|
||||
#define wxSYS_CURSOR_Y 5
|
||||
#define wxSYS_DCLICK_X 6
|
||||
#define wxSYS_DCLICK_Y 7
|
||||
#define wxSYS_DRAG_X 8
|
||||
#define wxSYS_DRAG_Y 9
|
||||
#define wxSYS_EDGE_X 10
|
||||
#define wxSYS_EDGE_Y 11
|
||||
#define wxSYS_HSCROLL_ARROW_X 12
|
||||
#define wxSYS_HSCROLL_ARROW_Y 13
|
||||
#define wxSYS_HTHUMB_X 14
|
||||
#define wxSYS_ICON_X 15
|
||||
#define wxSYS_ICON_Y 16
|
||||
#define wxSYS_ICONSPACING_X 17
|
||||
#define wxSYS_ICONSPACING_Y 18
|
||||
#define wxSYS_WINDOWMIN_X 19
|
||||
#define wxSYS_WINDOWMIN_Y 20
|
||||
#define wxSYS_SCREEN_X 21
|
||||
#define wxSYS_SCREEN_Y 22
|
||||
#define wxSYS_FRAMESIZE_X 23
|
||||
#define wxSYS_FRAMESIZE_Y 24
|
||||
#define wxSYS_SMALLICON_X 25
|
||||
#define wxSYS_SMALLICON_Y 26
|
||||
#define wxSYS_HSCROLL_Y 27
|
||||
#define wxSYS_VSCROLL_X 28
|
||||
#define wxSYS_VSCROLL_ARROW_X 29
|
||||
#define wxSYS_VSCROLL_ARROW_Y 30
|
||||
#define wxSYS_VTHUMB_Y 31
|
||||
#define wxSYS_CAPTION_Y 32
|
||||
#define wxSYS_MENU_Y 33
|
||||
#define wxSYS_NETWORK_PRESENT 34
|
||||
#define wxSYS_PENWINDOWS_PRESENT 35
|
||||
#define wxSYS_SHOW_SOUNDS 36
|
||||
#define wxSYS_SWAP_BUTTONS 37
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/settings.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/settings.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/settings.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/settings.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/settings.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/settings.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/settings.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/settings.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_SETTINGS_H_BASE_
|
||||
|
||||
@@ -1,84 +0,0 @@
|
||||
/*
|
||||
* The main configuration file for wxWindows.
|
||||
*
|
||||
* NB: this file can be included in .c files, so it must be compileable by a C
|
||||
* compiler - use #ifdef __cplusplus for C++ specific features and avoid
|
||||
* using C++ style comments
|
||||
*/
|
||||
|
||||
#ifndef _WX_SETUP_H_BASE_
|
||||
#define _WX_SETUP_H_BASE_
|
||||
|
||||
/* compatibility code, to be removed asap: */
|
||||
|
||||
#if !defined(__WXBASE__) && !defined(__WXMSW__) && !defined(__WXGTK__) && !defined(__WXMOTIF__) && !defined(__WXQT__) && !defined(__WXSTUBS__) && !defined(__WXMAC__) && !defined(__WXPM__)
|
||||
#error No __WXxxx__ define set! Please define one of __WXBASE__,__WXGTK__,__WXMSW__,__WXMOTIF__,__WXMAC__,__WXQT__,__WXPM__,__WXSTUBS__
|
||||
#endif
|
||||
|
||||
/*
|
||||
wxUniversal is defined together with one of other ports, so test for it
|
||||
first
|
||||
*/
|
||||
#ifdef __WXUNIVERSAL__
|
||||
#if defined(__USE_WXCONFIG__) && defined(__WXDEBUG__)
|
||||
#include "wx/univd/setup.h"
|
||||
#else
|
||||
#include "wx/univ/setup.h"
|
||||
#endif
|
||||
|
||||
#elif defined(__WXBASE__)
|
||||
#if defined(__USE_WXCONFIG__) && defined(__WXDEBUG__)
|
||||
#include "wx/based/setup.h"
|
||||
#else
|
||||
#include "wx/base/setup.h"
|
||||
#endif
|
||||
|
||||
#elif defined(__VMS)
|
||||
#include "wx_root:[wxwindows]setup.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/setup.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/setup.h"
|
||||
|
||||
#elif defined(__WXQT__)
|
||||
#if defined(__USE_WXCONFIG__) && defined(__WXDEBUG__)
|
||||
#include "wx/qtd/setup.h"
|
||||
#else
|
||||
#include "wx/qt/setup.h"
|
||||
#endif
|
||||
|
||||
#elif defined(__WXMOTIF__)
|
||||
#if defined(__USE_WXCONFIG__) && defined(__WXDEBUG__)
|
||||
#include "wx/motifd/setup.h"
|
||||
#else
|
||||
#include "wx/motif/setup.h"
|
||||
#endif
|
||||
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/setup.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/setup.h"
|
||||
|
||||
#elif defined(__WXGTK__)
|
||||
#if defined(__USE_WXCONFIG__) && defined(__WXDEBUG__)
|
||||
#include "wx/gtkd/setup.h"
|
||||
#else
|
||||
#include "wx/gtk/setup.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#include "wx/chkconf.h"
|
||||
|
||||
/*
|
||||
define some constants identifying wxWindows version in more details than
|
||||
just the version number
|
||||
*/
|
||||
|
||||
// wxLogChain class available
|
||||
#define wxHAS_LOG_CHAIN
|
||||
|
||||
// define this when wxDC::Blit() respects SetDeviceOrigin() in wxGTK
|
||||
#undef wxHAS_WORKING_GTK_DC_BLIT
|
||||
|
||||
#endif /* _WX_SETUP_H_BASE_ */
|
||||
@@ -1,114 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/slider.h
|
||||
// Purpose: wxSlider interface
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 09.02.01
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 1996-2001 wxWindows team
|
||||
// Licence: wxWindows licence
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_SLIDER_H_BASE_
|
||||
#define _WX_SLIDER_H_BASE_
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#include "wx/defs.h"
|
||||
|
||||
#if wxUSE_SLIDER
|
||||
|
||||
#include "wx/control.h"
|
||||
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxSliderNameStr;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxSliderBase: define wxSlider interface
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxSliderBase : public wxControl
|
||||
{
|
||||
public:
|
||||
/* the ctor of the derived class should have the following form:
|
||||
|
||||
wxSlider(wxWindow *parent,
|
||||
wxWindowID id,
|
||||
int value, int minValue, int maxValue,
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& size = wxDefaultSize,
|
||||
long style = wxSL_HORIZONTAL,
|
||||
const wxValidator& validator = wxDefaultValidator,
|
||||
const wxString& name = wxSliderNameStr);
|
||||
*/
|
||||
|
||||
// get/set the current slider value (should be in range)
|
||||
virtual int GetValue() const = 0;
|
||||
virtual void SetValue(int value) = 0;
|
||||
|
||||
// retrieve/change the range
|
||||
virtual void SetRange(int minValue, int maxValue) = 0;
|
||||
virtual int GetMin() const = 0;
|
||||
virtual int GetMax() const = 0;
|
||||
|
||||
// the line/page size is the increment by which the slider moves when
|
||||
// cursor arrow key/page up or down are pressed (clicking the mouse is like
|
||||
// pressing PageUp/Down) and are by default set to 1 and 1/10 of the range
|
||||
virtual void SetLineSize(int lineSize) = 0;
|
||||
virtual void SetPageSize(int pageSize) = 0;
|
||||
virtual int GetLineSize() const = 0;
|
||||
virtual int GetPageSize() const = 0;
|
||||
|
||||
// these methods get/set the length of the slider pointer in pixels
|
||||
virtual void SetThumbLength(int lenPixels) = 0;
|
||||
virtual int GetThumbLength() const = 0;
|
||||
|
||||
// warning: most of subsequent methods are currently only implemented in
|
||||
// wxMSW under Win95 and are silently ignored on other platforms
|
||||
|
||||
virtual void SetTickFreq(int WXUNUSED(n), int WXUNUSED(pos)) { }
|
||||
virtual int GetTickFreq() const { return 0; }
|
||||
virtual void ClearTicks() { }
|
||||
virtual void SetTick(int WXUNUSED(tickPos)) { }
|
||||
|
||||
virtual void ClearSel() { }
|
||||
virtual int GetSelEnd() const { return GetMin(); }
|
||||
virtual int GetSelStart() const { return GetMax(); }
|
||||
virtual void SetSelection(int WXUNUSED(min), int WXUNUSED(max)) { }
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// include the real class declaration
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/slider.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#ifdef __WIN95__
|
||||
#include "wx/msw/slider95.h"
|
||||
#define wxSlider wxSlider95
|
||||
#define sm_classwxSlider sm_classwxSlider95
|
||||
#else // Win16
|
||||
#include "wx/msw/slidrmsw.h"
|
||||
#define wxSlider wxSliderMSW
|
||||
#define sm_classwxSlider sm_classwxSliderMSW
|
||||
#endif // Win32/Win16
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/slider.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/slider.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/slider.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/slider.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/slider.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/slider.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_SLIDER
|
||||
|
||||
#endif
|
||||
// _WX_SLIDER_H_BASE_
|
||||
@@ -1,128 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/spinbutt.h
|
||||
// Purpose: wxSpinButtonBase class
|
||||
// Author: Julian Smart, Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 23.07.99
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Julian Smart
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_SPINBUTT_H_BASE_
|
||||
#define _WX_SPINBUTT_H_BASE_
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#include "wx/defs.h"
|
||||
|
||||
#if wxUSE_SPINBTN
|
||||
|
||||
#include "wx/control.h"
|
||||
#include "wx/event.h"
|
||||
|
||||
#define wxSPIN_BUTTON_NAME _T("wxSpinButton")
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// The wxSpinButton is like a small scrollbar than is often placed next
|
||||
// to a text control.
|
||||
//
|
||||
// Styles:
|
||||
// wxSP_HORIZONTAL: horizontal spin button
|
||||
// wxSP_VERTICAL: vertical spin button (the default)
|
||||
// wxSP_ARROW_KEYS: arrow keys increment/decrement value
|
||||
// wxSP_WRAP: value wraps at either end
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxSpinButtonBase : public wxControl
|
||||
{
|
||||
public:
|
||||
wxSpinButtonBase() { InitBase(); }
|
||||
|
||||
// accessors
|
||||
virtual int GetValue() const = 0;
|
||||
virtual int GetMin() const { return m_min; }
|
||||
virtual int GetMax() const { return m_max; }
|
||||
|
||||
// operations
|
||||
virtual void SetValue(int val) = 0;
|
||||
virtual void SetRange(int minVal, int maxVal)
|
||||
{
|
||||
m_min = minVal;
|
||||
m_max = maxVal;
|
||||
}
|
||||
|
||||
// is this spin button vertically oriented?
|
||||
bool IsVertical() const { return (m_windowStyle & wxSP_VERTICAL) != 0; }
|
||||
|
||||
protected:
|
||||
// init the base part of the control
|
||||
void InitBase()
|
||||
{
|
||||
m_min = 0;
|
||||
m_max = 100;
|
||||
}
|
||||
|
||||
// the range value
|
||||
int m_min;
|
||||
int m_max;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// include the declaration of the real class
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/spinbutt.h"
|
||||
#elif defined(__WXMSW__) && defined(__WIN95__)
|
||||
#include "wx/msw/spinbutt.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/spinbutt.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/spinbutt.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/spinbutt.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/spinbutt.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/spinbutt.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/spinbutt.h"
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// the wxSpinButton event
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxSpinEvent : public wxNotifyEvent
|
||||
{
|
||||
public:
|
||||
wxSpinEvent(wxEventType commandType = wxEVT_NULL, int id = 0)
|
||||
: wxNotifyEvent(commandType, id)
|
||||
{
|
||||
}
|
||||
|
||||
// get the current value of the control
|
||||
int GetPosition() const { return m_commandInt; }
|
||||
void SetPosition(int pos) { m_commandInt = pos; }
|
||||
|
||||
private:
|
||||
DECLARE_DYNAMIC_CLASS(wxSpinEvent)
|
||||
};
|
||||
|
||||
typedef void (wxEvtHandler::*wxSpinEventFunction)(wxSpinEvent&);
|
||||
|
||||
// macros for handling spin events
|
||||
#define EVT_SPIN_UP(id, func) \
|
||||
DECLARE_EVENT_TABLE_ENTRY( wxEVT_SCROLL_LINEUP, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func, NULL ),
|
||||
#define EVT_SPIN_DOWN(id, func) \
|
||||
DECLARE_EVENT_TABLE_ENTRY( wxEVT_SCROLL_LINEDOWN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func, NULL ),
|
||||
#define EVT_SPIN(id, func) \
|
||||
DECLARE_EVENT_TABLE_ENTRY( wxEVT_SCROLL_THUMBTRACK, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxSpinEventFunction) & func, NULL ),
|
||||
|
||||
#endif // wxUSE_SPINBTN
|
||||
|
||||
#endif
|
||||
// _WX_SPINBUTT_H_BASE_
|
||||
@@ -1,70 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/statbmp.h
|
||||
// Purpose: wxStaticBitmap class interface
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 25.08.00
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Vadim Zeitlin
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_STATBMP_H_BASE_
|
||||
#define _WX_STATBMP_H_BASE_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "statbmpbase.h"
|
||||
#endif
|
||||
|
||||
#if wxUSE_STATBMP
|
||||
|
||||
#include "wx/control.h"
|
||||
#include "wx/bitmap.h"
|
||||
|
||||
class WXDLLEXPORT wxIcon;
|
||||
class WXDLLEXPORT wxBitmap;
|
||||
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxStaticBitmapNameStr;
|
||||
|
||||
// a control showing an icon or a bitmap
|
||||
class WXDLLEXPORT wxStaticBitmapBase : public wxControl
|
||||
{
|
||||
public:
|
||||
#ifdef __DARWIN__
|
||||
~wxStaticBitmapBase() { }
|
||||
#endif
|
||||
|
||||
// our interface
|
||||
virtual void SetIcon(const wxIcon& icon) = 0;
|
||||
virtual void SetBitmap(const wxBitmap& bitmap) = 0;
|
||||
virtual wxBitmap GetBitmap() const = 0;
|
||||
|
||||
// overriden base class virtuals
|
||||
virtual bool AcceptsFocus() const { return FALSE; }
|
||||
|
||||
protected:
|
||||
virtual wxSize DoGetBestClientSize() const;
|
||||
};
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/statbmp.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/statbmp.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/statbmp.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/statbmp.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/statbmp.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/statbmp.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/statbmp.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/statbmp.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_STATBMP
|
||||
|
||||
#endif
|
||||
// _WX_STATBMP_H_BASE_
|
||||
@@ -1,42 +0,0 @@
|
||||
#ifndef _WX_STATBOX_H_BASE_
|
||||
#define _WX_STATBOX_H_BASE_
|
||||
|
||||
#if wxUSE_STATBOX
|
||||
|
||||
#include "wx/control.h"
|
||||
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxStaticBoxNameStr;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxStaticBox: a grouping box with a label
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxStaticBoxBase : public wxControl
|
||||
{
|
||||
public:
|
||||
// overriden base class virtuals
|
||||
virtual bool AcceptsFocus() const { return FALSE; }
|
||||
};
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/statbox.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/statbox.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/statbox.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/statbox.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/statbox.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/statbox.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/statbox.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/statbox.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_STATBOX
|
||||
|
||||
#endif
|
||||
// _WX_STATBOX_H_BASE_
|
||||
@@ -1,38 +0,0 @@
|
||||
#ifndef _WX_STATTEXT_H_BASE_
|
||||
#define _WX_STATTEXT_H_BASE_
|
||||
|
||||
#if wxUSE_STATTEXT
|
||||
|
||||
#include "wx/control.h"
|
||||
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxStaticTextNameStr;
|
||||
|
||||
class WXDLLEXPORT wxStaticTextBase : public wxControl
|
||||
{
|
||||
public:
|
||||
// overriden base class virtuals
|
||||
virtual bool AcceptsFocus() const { return FALSE; }
|
||||
};
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/stattext.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/stattext.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/stattext.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/stattext.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/stattext.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/stattext.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/stattext.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/stattext.h"
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_STATTEXT
|
||||
|
||||
#endif
|
||||
// _WX_STATTEXT_H_BASE_
|
||||
@@ -1,19 +0,0 @@
|
||||
#ifndef _WX_TASKBAR_H_BASE_
|
||||
#define _WX_TASKBAR_H_BASE_
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/taskbar.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/taskbar.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#elif defined(__WXQT__)
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/taskbar.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/taskbar.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/taskbar.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_TASKBAR_H_BASE_
|
||||
@@ -1,345 +0,0 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Name: textctrl.h
|
||||
// Purpose: wxTextCtrlBase class - the interface of wxTextCtrl
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 13.07.99
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) wxWindows team
|
||||
// Licence: wxWindows licence
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_TEXTCTRL_H_BASE_
|
||||
#define _WX_TEXTCTRL_H_BASE_
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "textctrlbase.h"
|
||||
#endif
|
||||
|
||||
#include "wx/defs.h"
|
||||
|
||||
#if wxUSE_TEXTCTRL
|
||||
|
||||
#include "wx/control.h" // the base class
|
||||
|
||||
// 16-bit Borland 4.0 doesn't seem to allow multiple inheritance with wxWindow
|
||||
// and streambuf: it complains about deriving a huge class from the huge class
|
||||
// streambuf. !! Also, can't use streambuf if making or using a DLL :-(
|
||||
|
||||
#if (defined(__BORLANDC__)) || defined(__MWERKS__) || defined(_WINDLL) || defined(WXUSINGDLL) || defined(WXMAKINGDLL)
|
||||
#define NO_TEXT_WINDOW_STREAM
|
||||
#endif
|
||||
|
||||
// the streambuf which is used in the declaration of wxTextCtrlBase below is not compatible
|
||||
// with the standard-conforming implementation found in newer egcs versions
|
||||
// (that is, the libstdc++ v3 that is shipped with it)
|
||||
#if defined(__GNUC__)&&( (__GNUC__>2) ||( (__GNUC__==2)&&(__GNUC_MINOR__>97) ) )
|
||||
#define NO_TEXT_WINDOW_STREAM
|
||||
#endif
|
||||
|
||||
#ifndef NO_TEXT_WINDOW_STREAM
|
||||
#if wxUSE_STD_IOSTREAM
|
||||
#include "wx/ioswrap.h" // for iostream classes if we need them
|
||||
#else // !wxUSE_STD_IOSTREAM
|
||||
// can't compile this feature in if we don't use streams at all
|
||||
#define NO_TEXT_WINDOW_STREAM
|
||||
#endif // wxUSE_STD_IOSTREAM/!wxUSE_STD_IOSTREAM
|
||||
#endif
|
||||
|
||||
class WXDLLEXPORT wxTextCtrl;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// constants
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxTextCtrlNameStr;
|
||||
WXDLLEXPORT_DATA(extern const wxChar*) wxEmptyString;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxTextCtrl style flags
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// the flag bits 0x0001, 2, 4 and 8 are free but should be used only for the
|
||||
// things which don't make sense for a text control used by wxTextEntryDialog
|
||||
// because they would otherwise conflict with wxOK, wxCANCEL, wxCENTRE
|
||||
#define wxTE_READONLY 0x0010
|
||||
#define wxTE_MULTILINE 0x0020
|
||||
#define wxTE_PROCESS_TAB 0x0040
|
||||
|
||||
// this style means to use RICHEDIT control and does something only under wxMSW
|
||||
// and Win32 and is silently ignored under all other platforms
|
||||
#define wxTE_RICH 0x0080
|
||||
#define wxTE_NO_VSCROLL 0x0100
|
||||
#define wxTE_AUTO_SCROLL 0x0200
|
||||
#define wxTE_PROCESS_ENTER 0x0400
|
||||
#define wxTE_PASSWORD 0x0800
|
||||
|
||||
// automatically detect the URLs and generate the events when mouse is
|
||||
// moved/clicked over an URL
|
||||
//
|
||||
// this is for Win32 richedit controls only so far
|
||||
#define wxTE_AUTO_URL 0x1000
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxTextAttr: a structure containing the visual attributes of a text
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxTextAttr
|
||||
{
|
||||
public:
|
||||
// ctors
|
||||
wxTextAttr() { }
|
||||
wxTextAttr(const wxColour& colText,
|
||||
const wxColour& colBack = wxNullColour,
|
||||
const wxFont& font = wxNullFont)
|
||||
: m_colText(colText), m_colBack(colBack), m_font(font) { }
|
||||
|
||||
// setters
|
||||
void SetTextColour(const wxColour& colText) { m_colText = colText; }
|
||||
void SetBackgroundColour(const wxColour& colBack) { m_colBack = colBack; }
|
||||
void SetFont(const wxFont& font) { m_font = font; }
|
||||
|
||||
// accessors
|
||||
bool HasTextColour() const { return m_colText.Ok(); }
|
||||
bool HasBackgroundColour() const { return m_colBack.Ok(); }
|
||||
bool HasFont() const { return m_font.Ok(); }
|
||||
|
||||
// setters
|
||||
const wxColour& GetTextColour() const { return m_colText; }
|
||||
const wxColour& GetBackgroundColour() const { return m_colBack; }
|
||||
const wxFont& GetFont() const { return m_font; }
|
||||
|
||||
// returns false if we have any attributes set, true otherwise
|
||||
bool IsDefault() const
|
||||
{
|
||||
return !HasTextColour() && !HasBackgroundColour() && !HasFont();
|
||||
}
|
||||
|
||||
private:
|
||||
wxColour m_colText,
|
||||
m_colBack;
|
||||
wxFont m_font;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxTextCtrl: a single or multiple line text zone where user can enter and
|
||||
// edit text
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxTextCtrlBase : public wxControl
|
||||
#ifndef NO_TEXT_WINDOW_STREAM
|
||||
, public wxSTD streambuf
|
||||
#endif
|
||||
|
||||
{
|
||||
public:
|
||||
// creation
|
||||
// --------
|
||||
|
||||
wxTextCtrlBase();
|
||||
~wxTextCtrlBase();
|
||||
|
||||
// accessors
|
||||
// ---------
|
||||
|
||||
virtual wxString GetValue() const = 0;
|
||||
virtual void SetValue(const wxString& value) = 0;
|
||||
|
||||
virtual int GetLineLength(long lineNo) const = 0;
|
||||
virtual wxString GetLineText(long lineNo) const = 0;
|
||||
virtual int GetNumberOfLines() const = 0;
|
||||
|
||||
virtual bool IsModified() const = 0;
|
||||
virtual bool IsEditable() const = 0;
|
||||
|
||||
// If the return values from and to are the same, there is no selection.
|
||||
virtual void GetSelection(long* from, long* to) const = 0;
|
||||
|
||||
// operations
|
||||
// ----------
|
||||
|
||||
// editing
|
||||
virtual void Clear() = 0;
|
||||
virtual void Replace(long from, long to, const wxString& value) = 0;
|
||||
virtual void Remove(long from, long to) = 0;
|
||||
|
||||
// load/save the controls contents from/to the file
|
||||
virtual bool LoadFile(const wxString& file);
|
||||
virtual bool SaveFile(const wxString& file = wxEmptyString);
|
||||
|
||||
// clears the dirty flag
|
||||
virtual void DiscardEdits() = 0;
|
||||
|
||||
// set the max number of characters which may be entered in a single line
|
||||
// text control
|
||||
virtual void SetMaxLength(unsigned long WXUNUSED(len)) { }
|
||||
|
||||
// writing text inserts it at the current position, appending always
|
||||
// inserts it at the end
|
||||
virtual void WriteText(const wxString& text) = 0;
|
||||
virtual void AppendText(const wxString& text) = 0;
|
||||
|
||||
// text control under some platforms supports the text styles: these
|
||||
// methods allow to apply the given text style to the given selection or to
|
||||
// set/get the style which will be used for all appended text
|
||||
virtual bool SetStyle(long start, long end, const wxTextAttr& style);
|
||||
virtual bool SetDefaultStyle(const wxTextAttr& style);
|
||||
virtual const wxTextAttr& GetDefaultStyle() const;
|
||||
|
||||
// translate between the position (which is just an index in the text ctrl
|
||||
// considering all its contents as a single strings) and (x, y) coordinates
|
||||
// which represent column and line.
|
||||
virtual long XYToPosition(long x, long y) const = 0;
|
||||
virtual bool PositionToXY(long pos, long *x, long *y) const = 0;
|
||||
|
||||
virtual void ShowPosition(long pos) = 0;
|
||||
|
||||
// Clipboard operations
|
||||
virtual void Copy() = 0;
|
||||
virtual void Cut() = 0;
|
||||
virtual void Paste() = 0;
|
||||
|
||||
virtual bool CanCopy() const;
|
||||
virtual bool CanCut() const;
|
||||
virtual bool CanPaste() const;
|
||||
|
||||
// Undo/redo
|
||||
virtual void Undo() = 0;
|
||||
virtual void Redo() = 0;
|
||||
|
||||
virtual bool CanUndo() const = 0;
|
||||
virtual bool CanRedo() const = 0;
|
||||
|
||||
// Insertion point
|
||||
virtual void SetInsertionPoint(long pos) = 0;
|
||||
virtual void SetInsertionPointEnd() = 0;
|
||||
virtual long GetInsertionPoint() const = 0;
|
||||
virtual long GetLastPosition() const = 0;
|
||||
|
||||
virtual void SetSelection(long from, long to) = 0;
|
||||
virtual void SelectAll();
|
||||
virtual void SetEditable(bool editable) = 0;
|
||||
|
||||
// streambuf methods
|
||||
#ifndef NO_TEXT_WINDOW_STREAM
|
||||
int overflow(int i);
|
||||
int sync();
|
||||
int underflow();
|
||||
#endif // NO_TEXT_WINDOW_STREAM
|
||||
|
||||
// stream-like insertion operators: these are always available, whether we
|
||||
// were, or not, compiled with streambuf support
|
||||
wxTextCtrl& operator<<(const wxString& s);
|
||||
wxTextCtrl& operator<<(int i);
|
||||
wxTextCtrl& operator<<(long i);
|
||||
wxTextCtrl& operator<<(float f);
|
||||
wxTextCtrl& operator<<(double d);
|
||||
wxTextCtrl& operator<<(const wxChar c);
|
||||
|
||||
// obsolete functions
|
||||
#if WXWIN_COMPATIBILITY
|
||||
bool Modified() const { return IsModified(); }
|
||||
#endif
|
||||
|
||||
protected:
|
||||
// the name of the last file loaded with LoadFile() which will be used by
|
||||
// SaveFile() by default
|
||||
wxString m_filename;
|
||||
|
||||
// the text style which will be used for any new text added to the control
|
||||
wxTextAttr m_defaultStyle;
|
||||
|
||||
private:
|
||||
#ifndef NO_TEXT_WINDOW_STREAM
|
||||
#if !wxUSE_IOSTREAMH
|
||||
char *m_streambuf;
|
||||
#endif
|
||||
#endif
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// include the platform-dependent class definition
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/univ/textctrl.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/textctrl.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/textctrl.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/textctrl.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/textctrl.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/textctrl.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/textctrl.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/textctrl.h"
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxTextCtrl events
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if !WXWIN_COMPATIBILITY_EVENT_TYPES
|
||||
|
||||
BEGIN_DECLARE_EVENT_TYPES()
|
||||
DECLARE_EVENT_TYPE(wxEVT_COMMAND_TEXT_UPDATED, 7)
|
||||
DECLARE_EVENT_TYPE(wxEVT_COMMAND_TEXT_ENTER, 8)
|
||||
DECLARE_EVENT_TYPE(wxEVT_COMMAND_TEXT_URL, 13)
|
||||
DECLARE_EVENT_TYPE(wxEVT_COMMAND_TEXT_MAXLEN, 14)
|
||||
END_DECLARE_EVENT_TYPES()
|
||||
|
||||
#endif // !WXWIN_COMPATIBILITY_EVENT_TYPES
|
||||
|
||||
class WXDLLEXPORT wxTextUrlEvent : public wxCommandEvent
|
||||
{
|
||||
public:
|
||||
wxTextUrlEvent(int id, const wxMouseEvent& evtMouse,
|
||||
long start, long end)
|
||||
: wxCommandEvent(wxEVT_COMMAND_TEXT_URL, id),
|
||||
m_evtMouse(evtMouse)
|
||||
{ m_start = start; m_end = end; }
|
||||
|
||||
// get the mouse event which happend over the URL
|
||||
const wxMouseEvent& GetMouseEvent() const { return m_evtMouse; }
|
||||
|
||||
// get the start of the URL
|
||||
long GetURLStart() const { return m_start; }
|
||||
|
||||
// get the end of the URL
|
||||
long GetURLEnd() const { return m_end; }
|
||||
|
||||
protected:
|
||||
// the corresponding mouse event
|
||||
wxMouseEvent m_evtMouse;
|
||||
|
||||
// the start and end indices of the URL in the text control
|
||||
long m_start,
|
||||
m_end;
|
||||
|
||||
private:
|
||||
DECLARE_DYNAMIC_CLASS(wxTextUrlEvent)
|
||||
|
||||
public:
|
||||
// for wxWin RTTI only, don't use
|
||||
wxTextUrlEvent() { }
|
||||
};
|
||||
|
||||
typedef void (wxEvtHandler::*wxTextUrlEventFunction)(wxTextUrlEvent&);
|
||||
|
||||
#define EVT_TEXT(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_TEXT_UPDATED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_TEXT_ENTER(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_TEXT_ENTER, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_TEXT_URL(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_TEXT_URL, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) (wxTextUrlEventFunction) & fn, (wxObject *) NULL ),
|
||||
#define EVT_TEXT_MAXLEN(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_TEXT_MAXLEN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) & fn, (wxObject *) NULL ),
|
||||
|
||||
#endif // wxUSE_TEXTCTRL
|
||||
|
||||
#endif
|
||||
// _WX_TEXTCTRL_H_BASE_
|
||||
@@ -1,50 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/tglbtn.h
|
||||
// Purpose: This dummy header includes the proper header file for the
|
||||
// system we're compiling under.
|
||||
// Author: John Norris, minor changes by Axel Schlueter
|
||||
// Modified by:
|
||||
// Created: 08.02.01
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2000 Johnny C. Norris II
|
||||
// License: Rocketeer license
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_TOGGLEBUTTON_H_BASE_
|
||||
#define _WX_TOGGLEBUTTON_H_BASE_
|
||||
|
||||
#include "wx/defs.h"
|
||||
|
||||
#if wxUSE_TOGGLEBTN
|
||||
|
||||
#include "wx/event.h"
|
||||
#include "wx/control.h" // base class
|
||||
|
||||
BEGIN_DECLARE_EVENT_TYPES()
|
||||
DECLARE_EVENT_TYPE(wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, 19)
|
||||
END_DECLARE_EVENT_TYPES()
|
||||
|
||||
#define EVT_TOGGLEBUTTON(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction) & fn, (wxObject *) NULL ),
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/tglbtn.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/tglbtn.h"
|
||||
/*
|
||||
# elif defined(__WXMOTIF__)
|
||||
# include "wx/motif/tglbtn.h"
|
||||
# elif defined(__WXQT__)
|
||||
# include "wx/qt/tglbtn.h"
|
||||
# elif defined(__WXMAC__)
|
||||
# include "wx/mac/tglbtn.h"
|
||||
# elif defined(__WXPM__)
|
||||
# include "wx/os2/tglbtn.h"
|
||||
# elif defined(__WXSTUBS__)
|
||||
# include "wx/stubs/tglbtn.h"
|
||||
*/
|
||||
#endif
|
||||
|
||||
#endif // wxUSE_TOGGLEBTN
|
||||
|
||||
#endif // _WX_TOGGLEBUTTON_H_BASE_
|
||||
|
||||
@@ -1,244 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/timer.h
|
||||
// Purpose: wxTimer, wxStopWatch and global time-related functions
|
||||
// Author: Julian Smart (wxTimer), Sylvain Bougnoux (wxStopWatch)
|
||||
// Modified by: Vadim Zeitlin (wxTimerBase)
|
||||
// Guillermo Rodriguez (global clean up)
|
||||
// Created: 04/01/98
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) wxWindows team
|
||||
// Licence: wxWindows license
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_TIMER_H_BASE_
|
||||
#define _WX_TIMER_H_BASE_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "timerbase.h"
|
||||
#endif
|
||||
|
||||
#include "wx/setup.h"
|
||||
#include "wx/object.h"
|
||||
#include "wx/longlong.h"
|
||||
#include "wx/event.h"
|
||||
|
||||
#if wxUSE_GUI && wxUSE_TIMER
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxTimer
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// the interface of wxTimer class
|
||||
class WXDLLEXPORT wxTimerBase : public wxObject
|
||||
{
|
||||
public:
|
||||
// ctors and initializers
|
||||
// ----------------------
|
||||
|
||||
// default: if you don't call SetOwner(), your only chance to get timer
|
||||
// notifications is to override Notify() in the derived class
|
||||
wxTimerBase() { Init(); SetOwner(NULL); }
|
||||
|
||||
// ctor which allows to avoid having to override Notify() in the derived
|
||||
// class: the owner will get timer notifications which can be handled with
|
||||
// EVT_TIMER
|
||||
wxTimerBase(wxEvtHandler *owner, int id = -1)
|
||||
{ Init(); SetOwner(owner, id); }
|
||||
|
||||
// same as ctor above
|
||||
void SetOwner(wxEvtHandler *owner, int id = -1)
|
||||
{ m_owner = owner; m_idTimer = id; }
|
||||
|
||||
#ifdef __DARWIN__
|
||||
virtual ~wxTimerBase() { }
|
||||
#endif
|
||||
|
||||
// working with the timer
|
||||
// ----------------------
|
||||
|
||||
// start the timer: if milliseconds == -1, use the same value as for the
|
||||
// last Start()
|
||||
//
|
||||
// it is now valid to call Start() multiple times: this just restarts the
|
||||
// timer if it is already running
|
||||
virtual bool Start(int milliseconds = -1, bool oneShot = FALSE);
|
||||
|
||||
// stop the timer
|
||||
virtual void Stop() = 0;
|
||||
|
||||
// override this in your wxTimer-derived class if you want to process timer
|
||||
// messages in it, use non default ctor or SetOwner() otherwise
|
||||
virtual void Notify();
|
||||
|
||||
// getting info
|
||||
// ------------
|
||||
|
||||
// return TRUE if the timer is running
|
||||
virtual bool IsRunning() const = 0;
|
||||
|
||||
// get the (last) timer interval in the milliseconds
|
||||
int GetInterval() const { return m_milli; }
|
||||
|
||||
// return TRUE if the timer is one shot
|
||||
bool IsOneShot() const { return m_oneShot; }
|
||||
|
||||
#if WXWIN_COMPATIBILITY_2
|
||||
// deprecated functions
|
||||
int Interval() const { return GetInterval(); };
|
||||
bool OneShot() const { return IsOneShot(); }
|
||||
#endif // WXWIN_COMPATIBILITY_2
|
||||
|
||||
protected:
|
||||
// common part of all ctors
|
||||
void Init() { m_oneShot = FALSE; m_milli = 0; }
|
||||
|
||||
wxEvtHandler *m_owner;
|
||||
int m_idTimer;
|
||||
|
||||
int m_milli; // the timer interval
|
||||
bool m_oneShot; // TRUE if one shot
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxTimer itself
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/timer.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/timer.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/timer.h"
|
||||
#elif defined(__WXMGL__)
|
||||
#include "wx/mgl/timer.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/timer.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/timer.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/timer.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/timer.h"
|
||||
#endif
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxTimerRunner: starts the timer in its ctor, stops in the dtor
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxTimerRunner
|
||||
{
|
||||
public:
|
||||
wxTimerRunner(wxTimer& timer) : m_timer(timer) { }
|
||||
wxTimerRunner(wxTimer& timer, int milli, bool oneShot = FALSE)
|
||||
: m_timer(timer)
|
||||
{
|
||||
m_timer.Start(milli, oneShot);
|
||||
}
|
||||
|
||||
void Start(int milli, bool oneShot = FALSE)
|
||||
{
|
||||
m_timer.Start(milli, oneShot);
|
||||
}
|
||||
|
||||
~wxTimerRunner()
|
||||
{
|
||||
if ( m_timer.IsRunning() )
|
||||
{
|
||||
m_timer.Stop();
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
wxTimer& m_timer;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxTimerEvent
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class WXDLLEXPORT wxTimerEvent : public wxEvent
|
||||
{
|
||||
public:
|
||||
wxTimerEvent(int id = 0, int interval = 0) : wxEvent(id)
|
||||
{
|
||||
m_eventType = wxEVT_TIMER;
|
||||
|
||||
m_interval = interval;
|
||||
}
|
||||
|
||||
// accessors
|
||||
int GetInterval() const { return m_interval; }
|
||||
|
||||
private:
|
||||
int m_interval;
|
||||
|
||||
DECLARE_DYNAMIC_CLASS(wxTimerEvent)
|
||||
};
|
||||
|
||||
typedef void (wxEvtHandler::*wxTimerEventFunction)(wxTimerEvent&);
|
||||
|
||||
#define EVT_TIMER(id, func) \
|
||||
DECLARE_EVENT_TABLE_ENTRY( wxEVT_TIMER, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTimerEventFunction) & func, NULL),
|
||||
|
||||
#endif // wxUSE_GUI && wxUSE_TIMER
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxStopWatch: measure time intervals with up to 1ms resolution
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if wxUSE_STOPWATCH
|
||||
|
||||
class WXDLLEXPORT wxStopWatch
|
||||
{
|
||||
public:
|
||||
// ctor starts the stop watch
|
||||
wxStopWatch() { Start(); }
|
||||
void Start(long t = 0);
|
||||
void Pause() { m_pause = GetElapsedTime(); }
|
||||
void Resume() { Start(m_pause); }
|
||||
|
||||
// get elapsed time since the last Start() or Pause() in milliseconds
|
||||
long Time() const;
|
||||
|
||||
protected:
|
||||
// returns the elapsed time since t0
|
||||
long GetElapsedTime() const;
|
||||
|
||||
private:
|
||||
wxLongLong m_t0; // the time of the last Start()
|
||||
long m_pause; // the time of the last Pause() or 0
|
||||
};
|
||||
|
||||
#endif // wxUSE_STOPWATCH
|
||||
|
||||
#if wxUSE_LONGLONG
|
||||
|
||||
// Starts a global timer
|
||||
// -- DEPRECATED: use wxStopWatch instead
|
||||
void WXDLLEXPORT wxStartTimer();
|
||||
|
||||
// Gets elapsed milliseconds since last wxStartTimer or wxGetElapsedTime
|
||||
// -- DEPRECATED: use wxStopWatch instead
|
||||
long WXDLLEXPORT wxGetElapsedTime(bool resetTimer = TRUE);
|
||||
|
||||
#endif // wxUSE_LONGLONG
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// global time functions
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// Get number of seconds since local time 00:00:00 Jan 1st 1970.
|
||||
extern long WXDLLEXPORT wxGetLocalTime();
|
||||
|
||||
// Get number of seconds since GMT 00:00:00, Jan 1st 1970.
|
||||
extern long WXDLLEXPORT wxGetUTCTime();
|
||||
|
||||
#if wxUSE_LONGLONG
|
||||
// Get number of milliseconds since local time 00:00:00 Jan 1st 1970
|
||||
extern wxLongLong WXDLLEXPORT wxGetLocalTimeMillis();
|
||||
#endif // wxUSE_LONGLONG
|
||||
|
||||
#define wxGetCurrentTime() wxGetLocalTime()
|
||||
|
||||
#endif
|
||||
// _WX_TIMER_H_BASE_
|
||||
@@ -1,59 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: wx/toolbar.h
|
||||
// Purpose: wxToolBar interface declaration
|
||||
// Author: Vadim Zeitlin
|
||||
// Modified by:
|
||||
// Created: 20.11.99
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) wxWindows team
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_TOOLBAR_H_BASE_
|
||||
#define _WX_TOOLBAR_H_BASE_
|
||||
|
||||
#include "wx/tbarbase.h" // the base class for all toolbars
|
||||
|
||||
#if wxUSE_TOOLBAR
|
||||
#if !wxUSE_TOOLBAR_NATIVE || defined(__WXUNIVERSAL__)
|
||||
#include "wx/tbarsmpl.h"
|
||||
|
||||
class WXDLLEXPORT wxToolBar : public wxToolBarSimple
|
||||
{
|
||||
public:
|
||||
wxToolBar() { }
|
||||
|
||||
wxToolBar(wxWindow *parent,
|
||||
wxWindowID id,
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& size = wxDefaultSize,
|
||||
long style = wxNO_BORDER | wxTB_HORIZONTAL,
|
||||
const wxString& name = wxToolBarNameStr)
|
||||
: wxToolBarSimple(parent, id, pos, size, style, name) { }
|
||||
|
||||
private:
|
||||
DECLARE_DYNAMIC_CLASS(wxToolBar)
|
||||
};
|
||||
#else // wxUSE_TOOLBAR_NATIVE
|
||||
#if defined(__WXMSW__) && defined(__WIN95__)
|
||||
#include "wx/msw/tbar95.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#include "wx/msw/tbarmsw.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/motif/toolbar.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/tbargtk.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/tbarqt.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/toolbar.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/toolbar.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/stubs/toolbar.h"
|
||||
#endif
|
||||
#endif // !wxUSE_TOOLBAR_NATIVE/wxUSE_TOOLBAR_NATIVE
|
||||
#endif // wxUSE_TOOLBAR
|
||||
|
||||
#endif
|
||||
// _WX_TOOLBAR_H_BASE_
|
||||
@@ -1,21 +0,0 @@
|
||||
#ifndef _WX_TOOLTIP_H_BASE_
|
||||
#define _WX_TOOLTIP_H_BASE_
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/tooltip.h"
|
||||
#elif defined(__WXMOTIF__)
|
||||
// #include "wx/motif/tooltip.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/tooltip.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/tooltip.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/tooltip.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/tooltip.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
// #include "wx/stubs/tooltip.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_TOOLTIP_H_BASE_
|
||||
@@ -1,40 +0,0 @@
|
||||
#ifndef _WX_TREECTRL_H_BASE_
|
||||
#define _WX_TREECTRL_H_BASE_
|
||||
|
||||
#include "wx/treebase.h"
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// include the platform-dependent wxTreeCtrl class
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#if defined(__WXUNIVERSAL__)
|
||||
#include "wx/generic/treectlg.h"
|
||||
#elif defined(__WXMSW__)
|
||||
#ifdef __WIN16__
|
||||
#include "wx/generic/treectlg.h"
|
||||
#else
|
||||
#include "wx/msw/treectrl.h"
|
||||
#endif
|
||||
#elif defined(__WXMOTIF__)
|
||||
#include "wx/generic/treectlg.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/generic/treectlg.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/treectrl.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/generic/treectlg.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/generic/treectlg.h"
|
||||
#elif defined(__WXSTUBS__)
|
||||
#include "wx/generic/treectlg.h"
|
||||
#endif
|
||||
|
||||
/*
|
||||
#if !defined(__WXMSW__)
|
||||
#define wxTreeCtrl wxGenericTreeCtrl
|
||||
#define sm_classwxTreeCtrl sm_classwxGenericTreeCtrl
|
||||
#endif
|
||||
*/
|
||||
|
||||
#endif // _WX_TREECTRL_H_BASE_
|
||||
|
||||
@@ -1,19 +0,0 @@
|
||||
#ifndef _WX_WAVE_H_BASE_
|
||||
#define _WX_WAVE_H_BASE_
|
||||
|
||||
#if defined(__WXMSW__)
|
||||
#include "wx/msw/wave.h"
|
||||
#elif defined(__WXGTK__)
|
||||
#include "wx/gtk/wave.h"
|
||||
#elif defined(__WXQT__)
|
||||
#include "wx/qt/wave.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/wave.h"
|
||||
#elif defined(__WXPM__)
|
||||
#include "wx/os2/wave.h"
|
||||
#elif defined(__WXMAC__)
|
||||
#include "wx/mac/wave.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
// _WX_TREECTRL_H_BASE_
|
||||
1080
include/wx/window.h
1080
include/wx/window.h
File diff suppressed because it is too large
Load Diff
97
utils/wxPython/.cvsignore
Normal file
97
utils/wxPython/.cvsignore
Normal file
@@ -0,0 +1,97 @@
|
||||
*.zip
|
||||
.cvsignore
|
||||
.emacs.desktop
|
||||
__init__.py
|
||||
__init__.py
|
||||
__init__.pyc
|
||||
__init__.pyc
|
||||
__init__.pyo
|
||||
__init__.pyo
|
||||
cmndlgs.py
|
||||
cmndlgs.py
|
||||
cmndlgs.pyc
|
||||
cmndlgs.pyc
|
||||
cmndlgs.pyo
|
||||
cmndlgs.pyo
|
||||
controls.py
|
||||
controls.py
|
||||
controls.pyc
|
||||
controls.pyc
|
||||
controls.pyo
|
||||
controls.pyo
|
||||
controls2.py
|
||||
controls2.py
|
||||
controls2.pyc
|
||||
controls2.pyc
|
||||
controls2.pyo
|
||||
controls2.pyo
|
||||
events.py
|
||||
events.py
|
||||
events.pyc
|
||||
events.pyc
|
||||
events.pyo
|
||||
events.pyo
|
||||
frames.py
|
||||
frames.py
|
||||
frames.pyc
|
||||
frames.pyc
|
||||
frames.pyo
|
||||
frames.pyo
|
||||
gdi.py
|
||||
gdi.py
|
||||
gdi.pyc
|
||||
gdi.pyc
|
||||
gdi.pyo
|
||||
gdi.pyo
|
||||
mdi.py
|
||||
mdi.py
|
||||
mdi.pyc
|
||||
mdi.pyc
|
||||
mdi.pyo
|
||||
mdi.pyo
|
||||
misc.py
|
||||
misc.py
|
||||
misc.pyc
|
||||
misc.pyc
|
||||
misc.pyo
|
||||
misc.pyo
|
||||
stattool.py
|
||||
stattool.py
|
||||
stattool.pyc
|
||||
stattool.pyc
|
||||
stattool.pyo
|
||||
stattool.pyo
|
||||
utils.py
|
||||
utils.py
|
||||
utils.pyc
|
||||
utils.pyc
|
||||
utils.pyo
|
||||
windows.py
|
||||
windows.py
|
||||
windows.pyc
|
||||
windows.pyc
|
||||
windows.pyo
|
||||
windows.pyo
|
||||
windows2.py
|
||||
windows2.py
|
||||
windows2.pyc
|
||||
windows2.pyc
|
||||
windows2.pyo
|
||||
windows2.pyo
|
||||
windows3.py
|
||||
windows3.pyc
|
||||
windows3.pyo
|
||||
wx.py
|
||||
wx.py
|
||||
wx.pyc
|
||||
wx.pyc
|
||||
wx.pyo
|
||||
wxc.ilk
|
||||
wxc.pdb
|
||||
wxc.pyd
|
||||
wxp.py
|
||||
wxp.pyc
|
||||
wxp.pyo
|
||||
wxpc.ilk
|
||||
wxpc.pdb
|
||||
wxpc.pyd
|
||||
204
utils/wxPython/README.txt
Normal file
204
utils/wxPython/README.txt
Normal file
@@ -0,0 +1,204 @@
|
||||
wxPython README
|
||||
---------------
|
||||
|
||||
Introduction
|
||||
------------
|
||||
The code in this subtree is a Python Extension Module that enables the
|
||||
use of wxWindows from the Python language. So what is Python? Go to
|
||||
http://www.python.org to learn more but in a nutshell, it's an
|
||||
extremly cool object oriented language. It's easier than Perl and
|
||||
nearly as powerful. It runs on more platforms than Java, and by some
|
||||
reports, is even faster than Java with a JIT compiler!
|
||||
|
||||
So why would you want to use wxPython over just C++ and wxWindows?
|
||||
Personally I prefer using Python for everything. I only use C++ when
|
||||
I absolutly have to eek more performance out of an algorithm, and even
|
||||
then I ususally code it as an extension module and leave the majority
|
||||
of the program in Python. Another good thing to use wxPython for is
|
||||
quick prototyping of your wxWindows apps. With C++ you have to
|
||||
continuously go though the edit-compile-link-run cycle, which can be
|
||||
quite time comsuming. With Python it is only an edit-run cycle. You
|
||||
can easily build an application in a few hours with Python that would
|
||||
normally take a few days with C++. Converting a wxPython app to a
|
||||
C++/wxWindows app should be a straight forward task.
|
||||
|
||||
This extension module attempts to mirror the class heiarchy of
|
||||
wxWindows as closely as possble. This means that there is a wxFrame
|
||||
class in wxPython that looks, smells, tastes and acts almost the same
|
||||
as the wxFrame class in the C++ version. Unfortunatly, I wasn't able
|
||||
to match things exactly because of differences in the languages, but
|
||||
the differences should be easy to absorb because they are natural to
|
||||
Python. For example, some methods that return mutliple values via
|
||||
argument pointers in C++ will return a tuple of values in Python.
|
||||
These differences have not been documented yet so if something isn't
|
||||
working the same as described in the wxWindows documents the best
|
||||
thing to do is to scan through the wxPython sources, especially the .i
|
||||
files, as that is where the interfaces for wxPython are defined.
|
||||
|
||||
Currently this extension module is designed such that the entire
|
||||
application will be written in Python. I havn't tried it yet, but I
|
||||
am sure that attempting to embed wxPython in a C++ wxWindows
|
||||
application will cause problems. However there is a plan to support
|
||||
this in the future.
|
||||
|
||||
|
||||
What's new in 0.5.3
|
||||
-------------------
|
||||
Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
|
||||
|
||||
Various cleanup, tweaks, minor additions, etc. to maintain
|
||||
compatibility with the current wxWindows.
|
||||
|
||||
|
||||
|
||||
What's new in 0.5.0
|
||||
-------------------
|
||||
Changed the import semantics from "from wxPython import *" to "from
|
||||
wxPython.wx import *" This is for people who are worried about
|
||||
namespace pollution, they can use "from wxPython import wx" and then
|
||||
prefix all the wxPython identifiers with "wx."
|
||||
|
||||
Added wxTaskbarIcon for wxMSW.
|
||||
|
||||
Made the events work for wxGrid.
|
||||
|
||||
Added wxConfig.
|
||||
|
||||
Added wxMiniFrame for wxGTK.
|
||||
|
||||
Changed many of the args and return values that were pointers to gdi
|
||||
objects to references to reflect changes in the wxWindows API.
|
||||
|
||||
Other assorted fixes and additions.
|
||||
|
||||
|
||||
|
||||
|
||||
What's new in 0.4.2
|
||||
-------------------
|
||||
|
||||
wxPython on wxGTK works!!! Both dynamic and static on Linux and
|
||||
static on Solaris have been tested. Many thanks go to Harm
|
||||
<H.v.d.Heijden@phys.tue.nl> for his astute detective work on tracking
|
||||
down a nasty DECREF bug. Okay so I have to confess that it was just a
|
||||
DSM (Dumb Stupid Mistake) on my part but it was nasty none the less
|
||||
because the behavior was so different on different platforms.
|
||||
|
||||
|
||||
The dynamicly loaded module on Solaris is still segfaulting, so it
|
||||
must have been a different issue all along...
|
||||
|
||||
|
||||
|
||||
What's New in 0.4
|
||||
-----------------
|
||||
|
||||
1. Worked on wxGTK compatibility. It is partially working. On a
|
||||
Solaris/Sparc box wxPython is working but only when it is statically
|
||||
linked with the Python interpreter. When built as a dyamically loaded
|
||||
extension module, things start acting weirdly and it soon seg-faults.
|
||||
And on Linux both the statically linked and the dynamically linked
|
||||
version segfault shortly after starting up.
|
||||
|
||||
2. Added Toolbar, StatusBar and SplitterWindow classes.
|
||||
|
||||
3. Varioius bug fixes, enhancements, etc.
|
||||
|
||||
|
||||
|
||||
Build Instructions
|
||||
------------------
|
||||
I used SWIG (http://www.swig.org) to create the source code for the
|
||||
extension module. This enabled me to only have to deal with a small
|
||||
amount of code and only have to bother with the exceptional issues.
|
||||
SWIG takes care of the rest and generates all the repetative code for
|
||||
me. You don't need SWIG to build the extension module as all the
|
||||
generated C++ code is included under the src directory.
|
||||
|
||||
I added a few minor features to SWIG to control some of the code
|
||||
generation. If you want to playaround with this the patches are in
|
||||
wxPython/SWIG.patches and they should be applied to the 1.1p5 version
|
||||
of SWIG. These new patches are documented at
|
||||
http://starship.skyport.net/crew/robind/python/#swig, and they should
|
||||
also end up in the 1.2 version of SWIG.
|
||||
|
||||
wxPython is organized as a Python package. This means that the
|
||||
directory containing the results of the build process should be a
|
||||
subdirectory of a directory on the PYTHONPATH. (And preferably should
|
||||
be named wxPython.) You can control where the build process will dump
|
||||
wxPython by setting the TARGETDIR makefile variable. The default is
|
||||
$(WXWIN)/utils/wxPython, where this README.txt is located. If you
|
||||
leave it here then you should add $(WXWIN)/utils to your PYTHONPATH.
|
||||
However, you may prefer to use something that is already on your
|
||||
PYTHONPATH, such as the site-packages directory on Unix systems.
|
||||
|
||||
|
||||
Win32
|
||||
-----
|
||||
|
||||
1. Build wxWindows with wxUSE_RESOURCE_LOADING_IN_MSW set to 1 in
|
||||
include/wx/msw/setup.h so icons can be loaded dynamically. While
|
||||
there, make sure wxUSE_OWNER_DRAWN is also set to 1.
|
||||
|
||||
2. Change into the $(WXWIN)/utils/wxPython/src directory.
|
||||
|
||||
3. Edit makefile.nt and specify where your python installation is at.
|
||||
You may also want to fiddle with the TARGETDIR variable as described
|
||||
above.
|
||||
|
||||
4. Run nmake -f makefile.nt
|
||||
|
||||
5. If it builds successfully, congratulations! Move on to the next
|
||||
step. If not then you can try mailing me for help. Also, I will
|
||||
always have a pre-built win32 version of this extension module at
|
||||
http://starship.skyport.net/crew/robind/python.
|
||||
|
||||
6. Change to the $(WXWIN)/utils/wxPython/tests directory.
|
||||
|
||||
7. Try executing the test programs. Note that some of these print
|
||||
diagnositc or test info to standard output, so they will require the
|
||||
console version of python. For example:
|
||||
|
||||
python test1.py
|
||||
|
||||
To run them without requiring a console, you can use the pythonw.exe
|
||||
version of Python either from the command line or from a shortcut.
|
||||
|
||||
|
||||
|
||||
Unix
|
||||
----
|
||||
|
||||
1. Change into the $(WXWIN)/utils/wxPython/src directory.
|
||||
|
||||
2. Edit Setup.in and ensure that the flags, directories, and toolkit
|
||||
options are correct. See the above commentary about TARGETDIR. There
|
||||
are a few sample Setup.in.[platform] files provided.
|
||||
|
||||
3. Run this command to generate a makefile:
|
||||
|
||||
make -f Makefile.pre.in boot
|
||||
|
||||
4. Run these commands to build and then install the wxPython extension
|
||||
module:
|
||||
|
||||
make
|
||||
make install
|
||||
|
||||
|
||||
5. Change to the $(WXWIN)/utils/wxPython/tests directory.
|
||||
|
||||
6. Try executing the test programs. For example:
|
||||
|
||||
python test1.py
|
||||
|
||||
|
||||
|
||||
------------------------
|
||||
10/20/1998
|
||||
|
||||
Robin Dunn
|
||||
robin@alldunn.com
|
||||
|
||||
|
||||
|
||||
97
utils/wxPython/SWIG.patches/Include.patch
Normal file
97
utils/wxPython/SWIG.patches/Include.patch
Normal file
@@ -0,0 +1,97 @@
|
||||
*** swig.h.old Wed Feb 04 14:59:40 1998
|
||||
--- swig.h Fri Aug 28 14:46:32 1998
|
||||
***************
|
||||
*** 178,185 ****
|
||||
--- 178,211 ----
|
||||
char *firstkey();
|
||||
char *nextkey();
|
||||
};
|
||||
|
||||
+ // -------------------------------------------------------------------
|
||||
+ // Simple Vector class
|
||||
+ // User is responsible for deleting contents before deleteing Vector
|
||||
+ // -------------------------------------------------------------------
|
||||
+
|
||||
+ class Vector {
|
||||
+ public:
|
||||
+ Vector(size_t allocSize=8);
|
||||
+ ~Vector();
|
||||
+
|
||||
+ size_t size() { return m_size; }
|
||||
+ size_t count() { return m_count; }
|
||||
+ size_t append(void* object);
|
||||
+ size_t extend(size_t newSize);
|
||||
+
|
||||
+ void*& operator[] (size_t idx);
|
||||
+
|
||||
+ static void* s_nullPtr;
|
||||
+
|
||||
+ private:
|
||||
+ size_t m_size;
|
||||
+ size_t m_count;
|
||||
+ void** m_data;
|
||||
+ };
|
||||
+
|
||||
+
|
||||
/************************************************************************
|
||||
* class DataType
|
||||
*
|
||||
* Defines the basic datatypes supported by the translator.
|
||||
***************
|
||||
*** 684,691 ****
|
||||
--- 710,761 ----
|
||||
extern char *name_get(char *vname, int suppress=0);
|
||||
extern char *name_set(char *vname, int suppress=0);
|
||||
extern char *name_construct(char *classname, int suppress=0);
|
||||
extern char *name_destroy(char *classname, int suppress=0);
|
||||
+
|
||||
+ // ----------------------------------------------------------------------
|
||||
+ // class CPP_class
|
||||
+ //
|
||||
+ // Class for managing class members (internally)
|
||||
+ // ----------------------------------------------------------------------
|
||||
+
|
||||
+ class CPP_member;
|
||||
+
|
||||
+ class CPP_class {
|
||||
+ public:
|
||||
+ char *classname; // Real class name
|
||||
+ char *classrename; // New name of class (if applicable)
|
||||
+ char *classtype; // class type (struct, union, class)
|
||||
+ int strip; // Strip off class declarator
|
||||
+ int wextern; // Value of extern wrapper variable for this class
|
||||
+ int have_constructor; // Status bit indicating if we've seen a constructor
|
||||
+ int have_destructor; // Status bit indicating if a destructor has been seen
|
||||
+ int is_abstract; // Status bit indicating if this is an abstract class
|
||||
+ int generate_default; // Generate default constructors
|
||||
+ int objective_c; // Set if this is an objective C class
|
||||
+ int error; // Set if this class can't be generated
|
||||
+ int line; // Line number
|
||||
+ char **baseclass; // Base classes (if any)
|
||||
+ Hash *local; // Hash table for local types
|
||||
+ Hash *scope; // Local scope hash table
|
||||
+ DocEntry *de; // Documentation entry of class
|
||||
+ CPP_member *members; // Linked list of members
|
||||
+ CPP_class *next; // Next class
|
||||
+ static CPP_class *classlist; // List of all classes stored
|
||||
+
|
||||
+ Vector addPragmas;
|
||||
+
|
||||
+ CPP_class(char *name, char *ctype);
|
||||
+ void add_member(CPP_member *m);
|
||||
+ CPP_member *search_member(char *name);
|
||||
+ void inherit_decls(int mode);
|
||||
+ void emit_decls();
|
||||
+ static CPP_class *search(char *name);
|
||||
+ void create_default();
|
||||
+ static void create_all();
|
||||
+ };
|
||||
+
|
||||
+ extern CPP_class *current_class;
|
||||
|
||||
/***********************************************************************
|
||||
* -- Revision History
|
||||
* $Log$
|
||||
* Revision 1.1 1998/10/03 05:56:02 RD
|
||||
* *** empty log message ***
|
||||
*
|
||||
136
utils/wxPython/SWIG.patches/Modules.patch
Normal file
136
utils/wxPython/SWIG.patches/Modules.patch
Normal file
@@ -0,0 +1,136 @@
|
||||
*** python.cxx.old Fri Jan 02 22:17:40 1998
|
||||
--- python.cxx Fri Aug 28 14:49:18 1998
|
||||
***************
|
||||
*** 1679,1684 ****
|
||||
--- 1679,1701 ----
|
||||
}
|
||||
}
|
||||
}
|
||||
+ } else if (strcmp(cmd, "addtomethod") == 0) {
|
||||
+ // parse value, expected to be in the form "methodName:line"
|
||||
+ char* txtptr = strchr(value, ':');
|
||||
+ if (txtptr) {
|
||||
+ // add name and line to a list in current_class
|
||||
+ *txtptr = 0;
|
||||
+ txtptr++;
|
||||
+ AddPragmaData* apData = new AddPragmaData(value, txtptr);
|
||||
+ current_class->addPragmas.append(apData);
|
||||
+
|
||||
+ } else {
|
||||
+ fprintf(stderr,"%s : Line %d. Malformed addtomethod pragma. Should be \"methodName:text\"\n",
|
||||
+ input_file, line_number);
|
||||
+ }
|
||||
+ } else if (strcmp(cmd, "addtoclass") == 0) {
|
||||
+ AddPragmaData* apData = new AddPragmaData("__class__", value);
|
||||
+ current_class->addPragmas.append(apData);
|
||||
} else {
|
||||
fprintf(stderr,"%s : Line %d. Unrecognized pragma.\n", input_file, line_number);
|
||||
}
|
||||
*** python.h.old Thu Jul 24 22:18:50 1997
|
||||
--- python.h Fri Aug 28 14:46:08 1998
|
||||
***************
|
||||
*** 185,191 ****
|
||||
--- 185,203 ----
|
||||
void cpp_class_decl(char *, char *,char *);
|
||||
void pragma(char *, char *, char *);
|
||||
void add_typedef(DataType *t, char *name);
|
||||
+
|
||||
+ void emitAddPragmas(String& output, char* name, char* spacing);
|
||||
};
|
||||
|
||||
#define PYSHADOW_MEMBER 0x2
|
||||
+
|
||||
+ struct AddPragmaData {
|
||||
+ String m_method;
|
||||
+ String m_text;
|
||||
+
|
||||
+ AddPragmaData(char* method, char* text)
|
||||
+ : m_method(method),
|
||||
+ m_text(text)
|
||||
+ {}
|
||||
+ };
|
||||
|
||||
*** pycpp.cxx.old Fri Jan 02 20:23:22 1998
|
||||
--- pycpp.cxx Fri Aug 28 16:01:46 1998
|
||||
***************
|
||||
*** 276,281 ****
|
||||
--- 276,282 ----
|
||||
}
|
||||
}
|
||||
// if ((t->type != T_VOID) || (t->is_pointer))
|
||||
+ emitAddPragmas(*pyclass, realname, tab8);
|
||||
*pyclass << tab8 << "return val\n";
|
||||
|
||||
// Change the usage string to reflect our shadow class
|
||||
***************
|
||||
*** 394,399 ****
|
||||
--- 395,401 ----
|
||||
}
|
||||
*construct << ")\n";
|
||||
*construct << tab8 << "self.thisown = 1\n";
|
||||
+ emitAddPragmas(*construct, "__init__", tab8);
|
||||
have_constructor = 1;
|
||||
} else {
|
||||
|
||||
***************
|
||||
*** 494,502 ****
|
||||
*pyclass << tab4 << "def __del__(self):\n"
|
||||
<< tab8 << "if self.thisown == 1 :\n"
|
||||
<< tab8 << tab4 << module << "." << name_destroy(realname) << "(self.this)\n";
|
||||
!
|
||||
have_destructor = 1;
|
||||
-
|
||||
if (doc_entry) {
|
||||
doc_entry->usage = "";
|
||||
doc_entry->usage << "del this";
|
||||
--- 496,503 ----
|
||||
*pyclass << tab4 << "def __del__(self):\n"
|
||||
<< tab8 << "if self.thisown == 1 :\n"
|
||||
<< tab8 << tab4 << module << "." << name_destroy(realname) << "(self.this)\n";
|
||||
! emitAddPragmas(*pyclass, "__del__", tab8);
|
||||
have_destructor = 1;
|
||||
if (doc_entry) {
|
||||
doc_entry->usage = "";
|
||||
doc_entry->usage << "del this";
|
||||
***************
|
||||
*** 552,557 ****
|
||||
--- 553,560 ----
|
||||
<< tab8 << "return \"<C " << class_name <<" instance>\"\n";
|
||||
|
||||
classes << repr;
|
||||
+ emitAddPragmas(classes, "__class__", tab4);
|
||||
+
|
||||
}
|
||||
|
||||
// Now build the real class with a normal constructor
|
||||
***************
|
||||
*** 747,752 ****
|
||||
--- 750,777 ----
|
||||
}
|
||||
}
|
||||
|
||||
+ // --------------------------------------------------------------------------------
|
||||
+ // PYTHON::emitAddPragmas(String& output, char* name, char* spacing);
|
||||
+ //
|
||||
+ // Search the current_class->addPragmas vector for any text belonging to name.
|
||||
+ // Append the text properly spcaed to the output string.
|
||||
+ //
|
||||
+ // --------------------------------------------------------------------------------
|
||||
+
|
||||
+ void PYTHON::emitAddPragmas(String& output, char* name, char* spacing)
|
||||
+ {
|
||||
+ AddPragmaData* apData;
|
||||
+ size_t count;
|
||||
+ int i;
|
||||
+
|
||||
+ count = current_class->addPragmas.count();
|
||||
+ for (i=0; i<count; i++) {
|
||||
+ apData = (AddPragmaData*)current_class->addPragmas[i];
|
||||
+ if (strcmp(apData->m_method, name) == 0) {
|
||||
+ output << spacing << apData->m_text << "\n";
|
||||
+ }
|
||||
+ }
|
||||
+ }
|
||||
|
||||
/*********************************************************************************
|
||||
*
|
||||
488
utils/wxPython/SWIG.patches/SWIG.patch
Normal file
488
utils/wxPython/SWIG.patches/SWIG.patch
Normal file
@@ -0,0 +1,488 @@
|
||||
*** cplus.cxx.old Mon Feb 02 14:55:42 1998
|
||||
--- cplus.cxx Fri Aug 28 12:02:50 1998
|
||||
***************
|
||||
*** 581,612 ****
|
||||
// Class for managing class members (internally)
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
static char *inherit_base_class = 0;
|
||||
|
||||
- class CPP_class {
|
||||
- public:
|
||||
- char *classname; // Real class name
|
||||
- char *classrename; // New name of class (if applicable)
|
||||
- char *classtype; // class type (struct, union, class)
|
||||
- int strip; // Strip off class declarator
|
||||
- int wextern; // Value of extern wrapper variable for this class
|
||||
- int have_constructor; // Status bit indicating if we've seen a constructor
|
||||
- int have_destructor; // Status bit indicating if a destructor has been seen
|
||||
- int is_abstract; // Status bit indicating if this is an abstract class
|
||||
- int generate_default; // Generate default constructors
|
||||
- int objective_c; // Set if this is an objective C class
|
||||
- int error; // Set if this class can't be generated
|
||||
- int line; // Line number
|
||||
- char **baseclass; // Base classes (if any)
|
||||
- Hash *local; // Hash table for local types
|
||||
- Hash *scope; // Local scope hash table
|
||||
- DocEntry *de; // Documentation entry of class
|
||||
- CPP_member *members; // Linked list of members
|
||||
- CPP_class *next; // Next class
|
||||
- static CPP_class *classlist; // List of all classes stored
|
||||
|
||||
! CPP_class(char *name, char *ctype) {
|
||||
CPP_class *c;
|
||||
classname = copy_string(name);
|
||||
classtype = copy_string(ctype);
|
||||
classrename = 0;
|
||||
--- 581,593 ----
|
||||
// Class for managing class members (internally)
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
static char *inherit_base_class = 0;
|
||||
+ CPP_class *CPP_class::classlist = 0;
|
||||
+ CPP_class *current_class;
|
||||
|
||||
|
||||
! CPP_class::CPP_class(char *name, char *ctype) {
|
||||
CPP_class *c;
|
||||
classname = copy_string(name);
|
||||
classtype = copy_string(ctype);
|
||||
classrename = 0;
|
||||
***************
|
||||
*** 642,650 ****
|
||||
// ------------------------------------------------------------------------------
|
||||
// Add a new C++ member to this class
|
||||
// ------------------------------------------------------------------------------
|
||||
|
||||
! void add_member(CPP_member *m) {
|
||||
CPP_member *cm;
|
||||
|
||||
// Set base class where this was defined
|
||||
if (inherit_base_class)
|
||||
--- 623,631 ----
|
||||
// ------------------------------------------------------------------------------
|
||||
// Add a new C++ member to this class
|
||||
// ------------------------------------------------------------------------------
|
||||
|
||||
! void CPP_class::add_member(CPP_member *m) {
|
||||
CPP_member *cm;
|
||||
|
||||
// Set base class where this was defined
|
||||
if (inherit_base_class)
|
||||
***************
|
||||
*** 664,672 ****
|
||||
// ------------------------------------------------------------------------------
|
||||
// Search for a member with the given name. Returns the member on success, 0 on failure
|
||||
// ------------------------------------------------------------------------------
|
||||
|
||||
! CPP_member *search_member(char *name) {
|
||||
CPP_member *m;
|
||||
char *c;
|
||||
m = members;
|
||||
while (m) {
|
||||
--- 645,653 ----
|
||||
// ------------------------------------------------------------------------------
|
||||
// Search for a member with the given name. Returns the member on success, 0 on failure
|
||||
// ------------------------------------------------------------------------------
|
||||
|
||||
! CPP_member *CPP_class::search_member(char *name) {
|
||||
CPP_member *m;
|
||||
char *c;
|
||||
m = members;
|
||||
while (m) {
|
||||
***************
|
||||
*** 680,688 ****
|
||||
// ------------------------------------------------------------------------------
|
||||
// Inherit. Put all the declarations associated with this class into the current
|
||||
// ------------------------------------------------------------------------------
|
||||
|
||||
! void inherit_decls(int mode) {
|
||||
CPP_member *m;
|
||||
m = members;
|
||||
while (m) {
|
||||
inherit_base_class = m->base;
|
||||
--- 661,669 ----
|
||||
// ------------------------------------------------------------------------------
|
||||
// Inherit. Put all the declarations associated with this class into the current
|
||||
// ------------------------------------------------------------------------------
|
||||
|
||||
! void CPP_class::inherit_decls(int mode) {
|
||||
CPP_member *m;
|
||||
m = members;
|
||||
while (m) {
|
||||
inherit_base_class = m->base;
|
||||
***************
|
||||
*** 696,704 ****
|
||||
// ------------------------------------------------------------------------------
|
||||
// Emit all of the declarations associated with this class
|
||||
// ------------------------------------------------------------------------------
|
||||
|
||||
! void emit_decls() {
|
||||
CPP_member *m = members;
|
||||
int last_scope = name_scope(0);
|
||||
abstract = is_abstract;
|
||||
while (m) {
|
||||
--- 677,685 ----
|
||||
// ------------------------------------------------------------------------------
|
||||
// Emit all of the declarations associated with this class
|
||||
// ------------------------------------------------------------------------------
|
||||
|
||||
! void CPP_class::emit_decls() {
|
||||
CPP_member *m = members;
|
||||
int last_scope = name_scope(0);
|
||||
abstract = is_abstract;
|
||||
while (m) {
|
||||
***************
|
||||
*** 713,721 ****
|
||||
// ------------------------------------------------------------------------------
|
||||
// Search for a given class in the list
|
||||
// ------------------------------------------------------------------------------
|
||||
|
||||
! static CPP_class *search(char *name) {
|
||||
CPP_class *c;
|
||||
c = classlist;
|
||||
if (!name) return 0;
|
||||
while (c) {
|
||||
--- 694,702 ----
|
||||
// ------------------------------------------------------------------------------
|
||||
// Search for a given class in the list
|
||||
// ------------------------------------------------------------------------------
|
||||
|
||||
! CPP_class *CPP_class::search(char *name) {
|
||||
CPP_class *c;
|
||||
c = classlist;
|
||||
if (!name) return 0;
|
||||
while (c) {
|
||||
***************
|
||||
*** 729,737 ****
|
||||
// Add default constructors and destructors
|
||||
//
|
||||
// ------------------------------------------------------------------------------
|
||||
|
||||
! void create_default() {
|
||||
if (!generate_default) return;
|
||||
|
||||
// Try to generate a constructor if not available.
|
||||
|
||||
--- 710,718 ----
|
||||
// Add default constructors and destructors
|
||||
//
|
||||
// ------------------------------------------------------------------------------
|
||||
|
||||
! void CPP_class::create_default() {
|
||||
if (!generate_default) return;
|
||||
|
||||
// Try to generate a constructor if not available.
|
||||
|
||||
***************
|
||||
*** 751,764 ****
|
||||
// ------------------------------------------------------------------------------
|
||||
// Dump *all* of the classes saved out to the various
|
||||
// language modules (this does what cplus_close_class used to do)
|
||||
// ------------------------------------------------------------------------------
|
||||
- static void create_all();
|
||||
- };
|
||||
-
|
||||
- CPP_class *CPP_class::classlist = 0;
|
||||
- static CPP_class *current_class;
|
||||
-
|
||||
void CPP_class::create_all() {
|
||||
CPP_class *c;
|
||||
c = classlist;
|
||||
while (c) {
|
||||
--- 732,739 ----
|
||||
*** vector.cxx.old Fri Aug 28 14:23:16 1998
|
||||
--- vector.cxx Fri Aug 28 14:46:52 1998
|
||||
***************
|
||||
*** 0 ****
|
||||
--- 1,182 ----
|
||||
+
|
||||
+ /*******************************************************************************
|
||||
+ * Simplified Wrapper and Interface Generator (SWIG)
|
||||
+ *
|
||||
+ * Dave Beazley
|
||||
+ *
|
||||
+ * Department of Computer Science Theoretical Division (T-11)
|
||||
+ * University of Utah Los Alamos National Laboratory
|
||||
+ * Salt Lake City, Utah 84112 Los Alamos, New Mexico 87545
|
||||
+ * beazley@cs.utah.edu beazley@lanl.gov
|
||||
+ *
|
||||
+ * Copyright (c) 1995-1997
|
||||
+ * The University of Utah and the Regents of the University of California
|
||||
+ * All Rights Reserved
|
||||
+ *
|
||||
+ * Permission is hereby granted, without written agreement and without
|
||||
+ * license or royalty fees, to use, copy, modify, and distribute this
|
||||
+ * software and its documentation for any purpose, provided that
|
||||
+ * (1) The above copyright notice and the following two paragraphs
|
||||
+ * appear in all copies of the source code and (2) redistributions
|
||||
+ * including binaries reproduces these notices in the supporting
|
||||
+ * documentation. Substantial modifications to this software may be
|
||||
+ * copyrighted by their authors and need not follow the licensing terms
|
||||
+ * described here, provided that the new terms are clearly indicated in
|
||||
+ * all files where they apply.
|
||||
+ *
|
||||
+ * IN NO EVENT SHALL THE AUTHOR, THE UNIVERSITY OF CALIFORNIA, THE
|
||||
+ * UNIVERSITY OF UTAH OR DISTRIBUTORS OF THIS SOFTWARE BE LIABLE TO ANY
|
||||
+ * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
|
||||
+ * DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION,
|
||||
+ * EVEN IF THE AUTHORS OR ANY OF THE ABOVE PARTIES HAVE BEEN ADVISED OF
|
||||
+ * THE POSSIBILITY OF SUCH DAMAGE.
|
||||
+ *
|
||||
+ * THE AUTHOR, THE UNIVERSITY OF CALIFORNIA, AND THE UNIVERSITY OF UTAH
|
||||
+ * SPECIFICALLY DISCLAIM ANY WARRANTIES,INCLUDING, BUT NOT LIMITED TO,
|
||||
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
+ * PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND
|
||||
+ * THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE MAINTENANCE,
|
||||
+ * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
|
||||
+ *
|
||||
+ *******************************************************************************/
|
||||
+
|
||||
+ #include "internal.h"
|
||||
+
|
||||
+ /*******************************************************************************
|
||||
+ * $Header$
|
||||
+ *
|
||||
+ * File : vector.cxx
|
||||
+ *
|
||||
+ * A very simple Vector class. Allways assumes that memory allocations are
|
||||
+ * successful. Should be made more robust...
|
||||
+ *
|
||||
+ *******************************************************************************/
|
||||
+
|
||||
+ void* Vector::s_nullPtr = NULL;
|
||||
+
|
||||
+ // -----------------------------------------------------------------------------
|
||||
+ // Vector::Vector(size_t allocSize = 8)
|
||||
+ //
|
||||
+ // Constructor. Creates a new Vector.
|
||||
+ //
|
||||
+ // Inputs : initial allocation size (optional)
|
||||
+ //
|
||||
+ // Output : New Vector object.
|
||||
+ //
|
||||
+ // Side Effects : None
|
||||
+ // -----------------------------------------------------------------------------
|
||||
+
|
||||
+ Vector::Vector(size_t allocSize)
|
||||
+ : m_size(allocSize),
|
||||
+ m_count(0),
|
||||
+ m_data(0)
|
||||
+ {
|
||||
+ if (m_size) {
|
||||
+ m_data = new void*[m_size];
|
||||
+ int i;
|
||||
+ for (i=0; i<m_size;i++)
|
||||
+ m_data[i] = 0;
|
||||
+ }
|
||||
+ }
|
||||
+
|
||||
+
|
||||
+ // -----------------------------------------------------------------------------
|
||||
+ // Vector::~Vector
|
||||
+ //
|
||||
+ // Destructor. Only cleans up the vector, not its contents!
|
||||
+ //
|
||||
+ // -----------------------------------------------------------------------------
|
||||
+
|
||||
+
|
||||
+ Vector::~Vector() {
|
||||
+ if (m_data) {
|
||||
+ delete [] m_data;
|
||||
+ }
|
||||
+
|
||||
+ m_data = 0;
|
||||
+ m_size = m_count = 0;
|
||||
+ }
|
||||
+
|
||||
+
|
||||
+
|
||||
+ // -----------------------------------------------------------------------------
|
||||
+ // size_t Vector::extend(size_t newSize)
|
||||
+ //
|
||||
+ // Extends the vector to at least newSize length. Won't do anything if newSize
|
||||
+ // is smaller than the current size of the vector.
|
||||
+ //
|
||||
+ // Returns the new allocated size.
|
||||
+ //
|
||||
+ // -----------------------------------------------------------------------------
|
||||
+
|
||||
+ #define GRANULARITY 16
|
||||
+
|
||||
+ size_t Vector::extend(size_t newSize) {
|
||||
+
|
||||
+ if (newSize > m_size) {
|
||||
+ newSize = newSize + (GRANULARITY - (newSize % GRANULARITY));
|
||||
+
|
||||
+ void** temp = new void*[newSize];
|
||||
+ memcpy(temp, m_data, m_size*sizeof(void*));
|
||||
+
|
||||
+ int i;
|
||||
+ for (i=m_size; i<newSize; i++)
|
||||
+ temp[i] = 0;
|
||||
+
|
||||
+ delete [] m_data;
|
||||
+ m_data = temp;
|
||||
+ m_size = newSize;
|
||||
+ }
|
||||
+ return m_size;
|
||||
+ }
|
||||
+
|
||||
+
|
||||
+ // -----------------------------------------------------------------------------
|
||||
+ // Vector::append(void* object)
|
||||
+ //
|
||||
+ // Appends the object pointer to vector at index m_count. Increments m_count.
|
||||
+ // Returns the new count.
|
||||
+ // -----------------------------------------------------------------------------
|
||||
+
|
||||
+ size_t Vector::append(void* object) {
|
||||
+ if (m_count >= m_size) {
|
||||
+ extend(m_count + 1);
|
||||
+ }
|
||||
+
|
||||
+ m_data[m_count] = object;
|
||||
+ m_count += 1;
|
||||
+
|
||||
+ return m_count;
|
||||
+ }
|
||||
+
|
||||
+
|
||||
+ // -----------------------------------------------------------------------------
|
||||
+ // Vector::operator[] (size_t idx)
|
||||
+ //
|
||||
+ // Returns a reference to the void pointer at idx. If idx is beyond the range
|
||||
+ // of the vector, returns a reference to s_nullPtr.
|
||||
+ //
|
||||
+ // -----------------------------------------------------------------------------
|
||||
+
|
||||
+ void*& Vector::operator[] (size_t idx) {
|
||||
+ if (idx >= m_size) {
|
||||
+ s_nullPtr = 0;
|
||||
+ return s_nullPtr;
|
||||
+ }
|
||||
+
|
||||
+ return m_data[idx];
|
||||
+ }
|
||||
+
|
||||
+
|
||||
+ /***********************************************************************
|
||||
+ *
|
||||
+ * -- Revision History
|
||||
+ * $Log$
|
||||
+ * Revision 1.1 1998/10/03 05:56:03 RD
|
||||
+ * *** empty log message ***
|
||||
+ *
|
||||
+ *
|
||||
+ ***********************************************************************/
|
||||
+
|
||||
+
|
||||
+
|
||||
+
|
||||
+
|
||||
+
|
||||
*** makefile.msc.old Mon Jun 23 15:15:32 1997
|
||||
--- makefile.msc Fri Aug 28 10:21:58 1998
|
||||
***************
|
||||
*** 33,50 ****
|
||||
# Normally, you shouldn't have to change anything below this point #
|
||||
########################################################################
|
||||
|
||||
LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj emit.obj newdoc.obj ascii.obj \
|
||||
! html.obj latex.obj cplus.obj lang.obj hash.obj sstring.obj wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
|
||||
|
||||
LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
|
||||
! newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
|
||||
sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
|
||||
|
||||
LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
|
||||
LIBNAME = ..\libswig.lib
|
||||
INCLUDE = -I../Include -I$(STD_INC)
|
||||
! CFLAGS = -Zi -nologo -DSWIG_LIB="\"$(SWIG_LIB)\"" -DSWIG_CC="\"$(CC)\"" -DMSDOS -DSTDC_HEADERS=1 -DHAVE_LIBDL=1 $(SWIG_OPTS)
|
||||
LD_FLAGS = -VERBOSE
|
||||
|
||||
|
||||
#
|
||||
--- 33,50 ----
|
||||
# Normally, you shouldn't have to change anything below this point #
|
||||
########################################################################
|
||||
|
||||
LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj emit.obj newdoc.obj ascii.obj \
|
||||
! html.obj latex.obj cplus.obj lang.obj hash.obj vector.obj sstring.obj wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
|
||||
|
||||
LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
|
||||
! newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx vector.cxx \
|
||||
sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
|
||||
|
||||
LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
|
||||
LIBNAME = ..\libswig.lib
|
||||
INCLUDE = -I../Include -I$(STD_INC)
|
||||
! CFLAGS = -Zi -nologo -DSWIG_LIB="\"$(SWIG_LIB)\"" -DSWIG_CC="\"$(CC)\"" -DMSDOS -DSTDC_HEADERS=1 -DHAVE_LIBDL=1 $(SWIG_OPTS) $(OTHERFLAGS)
|
||||
LD_FLAGS = -VERBOSE
|
||||
|
||||
|
||||
#
|
||||
*** makefile.bc.old Sun Jan 04 12:49:24 1998
|
||||
--- makefile.bc Fri Aug 28 14:42:58 1998
|
||||
***************
|
||||
*** 34,47 ****
|
||||
########################################################################
|
||||
|
||||
LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj \
|
||||
emit.obj newdoc.obj ascii.obj \
|
||||
! html.obj latex.obj cplus.obj lang.obj hash.obj sstring.obj \
|
||||
wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
|
||||
|
||||
LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx \
|
||||
emit.cxx newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
|
||||
! sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
|
||||
|
||||
LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
|
||||
LIBNAME = ..\libswig.lib
|
||||
INCLUDE = -I../Include -I$(STD_INC)
|
||||
--- 34,47 ----
|
||||
########################################################################
|
||||
|
||||
LIBOBJS = main.obj scanner.obj symbol.obj include.obj types.obj parms.obj \
|
||||
emit.obj newdoc.obj ascii.obj \
|
||||
! html.obj latex.obj cplus.obj lang.obj hash.obj vector.obj sstring.obj \
|
||||
wrapfunc.obj getopt.obj comment.obj typemap.obj naming.obj
|
||||
|
||||
LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx \
|
||||
emit.cxx newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
|
||||
! vector.cxx sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
|
||||
|
||||
LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
|
||||
LIBNAME = ..\libswig.lib
|
||||
INCLUDE = -I../Include -I$(STD_INC)
|
||||
*** Makefile.in.old Wed May 28 22:56:56 1997
|
||||
--- Makefile.in Fri Aug 28 14:43:36 1998
|
||||
***************
|
||||
*** 51,63 ****
|
||||
# Normally, you shouldn't have to change anything below this point #
|
||||
########################################################################
|
||||
|
||||
LIBOBJS = main.o scanner.o symbol.o include.o types.o parms.o emit.o newdoc.o ascii.o \
|
||||
! html.o latex.o cplus.o lang.o hash.o sstring.o wrapfunc.o getopt.o comment.o \
|
||||
typemap.o naming.o
|
||||
|
||||
LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
|
||||
! newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx \
|
||||
sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
|
||||
|
||||
LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
|
||||
LIB = ../libswig.a
|
||||
--- 51,63 ----
|
||||
# Normally, you shouldn't have to change anything below this point #
|
||||
########################################################################
|
||||
|
||||
LIBOBJS = main.o scanner.o symbol.o include.o types.o parms.o emit.o newdoc.o ascii.o \
|
||||
! html.o latex.o cplus.o lang.o hash.o vector.o sstring.o wrapfunc.o getopt.o comment.o \
|
||||
typemap.o naming.o
|
||||
|
||||
LIBSRCS = main.cxx scanner.cxx symbol.cxx include.cxx types.cxx parms.cxx emit.cxx \
|
||||
! newdoc.cxx ascii.cxx html.cxx latex.cxx cplus.cxx lang.cxx hash.cxx vector.cxx \
|
||||
sstring.cxx wrapfunc.cxx getopt.cxx comment.cxx typemap.cxx naming.cxx
|
||||
|
||||
LIBHEADERS = internal.h ../Include/swig.h latex.h ascii.h html.h nodoc.h
|
||||
LIB = ../libswig.a
|
||||
43
utils/wxPython/TODO.txt
Normal file
43
utils/wxPython/TODO.txt
Normal file
@@ -0,0 +1,43 @@
|
||||
wxPython TODO List
|
||||
------------------
|
||||
|
||||
These are the major tasks to be done on wxPython:
|
||||
|
||||
1. Get it working for wxGTK.
|
||||
|
||||
2. Figure out how to do embedding of wxPython in a wxWindows C++
|
||||
application.
|
||||
|
||||
Actually, now that I think about it it might actually work. We
|
||||
just need to move some of the wxWindows initialization stuff out
|
||||
of wxpcinit, ensure that __wxStart is not called and that a wxApp
|
||||
is not created. So this task becomes: Create a test case for
|
||||
embedding wxPython in a C++ app. Should also create some helper
|
||||
functions for passing window objects into the Python code, etc.
|
||||
|
||||
Test this with M.
|
||||
|
||||
|
||||
3. Add significantly to the tests.
|
||||
|
||||
4. Derived Python classes should have the ability to call the standard
|
||||
On** methods in the base class.
|
||||
|
||||
5. There are some virtual On** and other methods in wxWindows that
|
||||
should end up being callbacks in derived python classes, but they
|
||||
are not called via the standard event system. Is there any way to
|
||||
hook into these and call Python methods (if they exist in the
|
||||
derived class) without having to derive a specialized C++ class?
|
||||
|
||||
6. Add the Doc/View related classes
|
||||
|
||||
7. Add the Printing related classes
|
||||
|
||||
8. Document the differences (method signatures, new methods to
|
||||
compensate for no overloading, etc.) between wxPython and wxWindows.
|
||||
|
||||
9. Create some larger-scale sample application with wxPython to show
|
||||
it can be done and the simplicity that it will provide... Test
|
||||
distribution with Freeze.
|
||||
|
||||
|
||||
38
utils/wxPython/distrib/wxPython.rsp
Normal file
38
utils/wxPython/distrib/wxPython.rsp
Normal file
@@ -0,0 +1,38 @@
|
||||
wxPython\*.pyd
|
||||
wxPython\*.pyc
|
||||
wxPython\*.pyo
|
||||
wxPython\*.py
|
||||
wxPython\*.txt
|
||||
|
||||
wxPython\tests\*.py
|
||||
wxPython\tests\bitmaps
|
||||
|
||||
|
||||
wxPython\src\*.i
|
||||
wxPython\src\*.py
|
||||
wxPython\src\*.cpp
|
||||
wxPython\src\*.h
|
||||
wxPython\src\*.ico
|
||||
wxPython\src\*.def
|
||||
wxPython\src\*.rc
|
||||
wxPython\src\makefile.*
|
||||
wxPython\src\Makefile.pre.in
|
||||
wxPython\src\Setup.in
|
||||
|
||||
wxPython\src\msw\*.cpp
|
||||
wxPython\src\msw\*.h
|
||||
wxPython\src\msw\*.py
|
||||
|
||||
wxPython\src\gtk\*.cpp
|
||||
wxPython\src\gtk\*.h
|
||||
wxPython\src\gtk\*.py
|
||||
|
||||
wxPython\src\motif\*.cpp
|
||||
wxPython\src\motif\*.h
|
||||
wxPython\src\motif\*.py
|
||||
|
||||
wxPython\src\qt\*.cpp
|
||||
wxPython\src\qt\*.h
|
||||
wxPython\src\qt\*.py
|
||||
|
||||
|
||||
8
utils/wxPython/distrib/zipit.bat
Executable file
8
utils/wxPython/distrib/zipit.bat
Executable file
@@ -0,0 +1,8 @@
|
||||
|
||||
@echo off
|
||||
|
||||
rem cd %WXWIN%\utils
|
||||
|
||||
zip -@ -r wxPython\wxPython-%1.zip < wxPython\distrib\wxPython.rsp
|
||||
|
||||
cd -
|
||||
26
utils/wxPython/src/.cvsignore
Normal file
26
utils/wxPython/src/.cvsignore
Normal file
@@ -0,0 +1,26 @@
|
||||
.emacs.desktop
|
||||
Makefile
|
||||
Makefile.pre
|
||||
Setup
|
||||
Setup.save
|
||||
Setup.save
|
||||
config.c
|
||||
make.bat
|
||||
sedscript
|
||||
templates
|
||||
transfer.zip
|
||||
vc50.pdb
|
||||
vc60.pdb
|
||||
wxPython.001
|
||||
wxPython.dsp
|
||||
wxPython.dsw
|
||||
wxPython.ncb
|
||||
wxPython.opt
|
||||
wxc.exp
|
||||
wxc.lib
|
||||
wxc.res
|
||||
wxp.pch
|
||||
wxpc.exp
|
||||
wxpc.lib
|
||||
wxpc.res
|
||||
wxpc.res.save
|
||||
389
utils/wxPython/src/Makefile.pre.in
Normal file
389
utils/wxPython/src/Makefile.pre.in
Normal file
@@ -0,0 +1,389 @@
|
||||
# Universal Unix Makefile for Python extensions
|
||||
# =============================================
|
||||
|
||||
# Short Instructions
|
||||
# ------------------
|
||||
|
||||
# 1. Build and install Python (1.5 or newer).
|
||||
# 2. "make -f Makefile.pre.in boot"
|
||||
# 3. "make"
|
||||
# You should now have a shared library.
|
||||
|
||||
# Long Instructions
|
||||
# -----------------
|
||||
|
||||
# Build *and install* the basic Python 1.5 distribution. See the
|
||||
# Python README for instructions. (This version of Makefile.pre.in
|
||||
# only withs with Python 1.5, alpha 3 or newer.)
|
||||
|
||||
# Create a file Setup.in for your extension. This file follows the
|
||||
# format of the Modules/Setup.in file; see the instructions there.
|
||||
# For a simple module called "spam" on file "spammodule.c", it can
|
||||
# contain a single line:
|
||||
# spam spammodule.c
|
||||
# You can build as many modules as you want in the same directory --
|
||||
# just have a separate line for each of them in the Setup.in file.
|
||||
|
||||
# If you want to build your extension as a shared library, insert a
|
||||
# line containing just the string
|
||||
# *shared*
|
||||
# at the top of your Setup.in file.
|
||||
|
||||
# Note that the build process copies Setup.in to Setup, and then works
|
||||
# with Setup. It doesn't overwrite Setup when Setup.in is changed, so
|
||||
# while you're in the process of debugging your Setup.in file, you may
|
||||
# want to edit Setup instead, and copy it back to Setup.in later.
|
||||
# (All this is done so you can distribute your extension easily and
|
||||
# someone else can select the modules they actually want to build by
|
||||
# commenting out lines in the Setup file, without editing the
|
||||
# original. Editing Setup is also used to specify nonstandard
|
||||
# locations for include or library files.)
|
||||
|
||||
# Copy this file (Misc/Makefile.pre.in) to the directory containing
|
||||
# your extension.
|
||||
|
||||
# Run "make -f Makefile.pre.in boot". This creates Makefile
|
||||
# (producing Makefile.pre and sedscript as intermediate files) and
|
||||
# config.c, incorporating the values for sys.prefix, sys.exec_prefix
|
||||
# and sys.version from the installed Python binary. For this to work,
|
||||
# the python binary must be on your path. If this fails, try
|
||||
# make -f Makefile.pre.in Makefile VERSION=1.5 installdir=<prefix>
|
||||
# where <prefix> is the prefix used to install Python for installdir
|
||||
# (and possibly similar for exec_installdir=<exec_prefix>).
|
||||
|
||||
# Note: "make boot" implies "make clobber" -- it assumes that when you
|
||||
# bootstrap you may have changed platforms so it removes all previous
|
||||
# output files.
|
||||
|
||||
# If you are building your extension as a shared library (your
|
||||
# Setup.in file starts with *shared*), run "make" or "make sharedmods"
|
||||
# to build the shared library files. If you are building a statically
|
||||
# linked Python binary (the only solution of your platform doesn't
|
||||
# support shared libraries, and sometimes handy if you want to
|
||||
# distribute or install the resulting Python binary), run "make
|
||||
# python".
|
||||
|
||||
# Note: Each time you edit Makefile.pre.in or Setup, you must run
|
||||
# "make Makefile" before running "make".
|
||||
|
||||
# Hint: if you want to use VPATH, you can start in an empty
|
||||
# subdirectory and say (e.g.):
|
||||
# make -f ../Makefile.pre.in boot srcdir=.. VPATH=..
|
||||
|
||||
|
||||
# === Bootstrap variables (edited through "make boot") ===
|
||||
|
||||
# The prefix used by "make inclinstall libainstall" of core python
|
||||
installdir= /usr/local
|
||||
|
||||
# The exec_prefix used by the same
|
||||
exec_installdir=$(installdir)
|
||||
|
||||
# Source directory and VPATH in case you want to use VPATH.
|
||||
# (You will have to edit these two lines yourself -- there is no
|
||||
# automatic support as the Makefile is not generated by
|
||||
# config.status.)
|
||||
srcdir= .
|
||||
VPATH= .
|
||||
|
||||
# === Variables that you may want to customize (rarely) ===
|
||||
|
||||
# (Static) build target
|
||||
TARGET= python
|
||||
|
||||
# Installed python binary (used only by boot target)
|
||||
PYTHON= python
|
||||
|
||||
# Add more -I and -D options here
|
||||
CFLAGS= $(OPT) -I$(INCLUDEPY) -I$(EXECINCLUDEPY) $(DEFS)
|
||||
|
||||
# These two variables can be set in Setup to merge extensions.
|
||||
# See example[23].
|
||||
BASELIB=
|
||||
BASESETUP=
|
||||
|
||||
# === Variables set by makesetup ===
|
||||
|
||||
MODOBJS= _MODOBJS_
|
||||
MODLIBS= _MODLIBS_
|
||||
|
||||
# === Definitions added by makesetup ===
|
||||
|
||||
# === Variables from configure (through sedscript) ===
|
||||
|
||||
VERSION= @VERSION@
|
||||
CC= @CC@
|
||||
LINKCC= @LINKCC@
|
||||
SGI_ABI= @SGI_ABI@
|
||||
OPT= @OPT@
|
||||
LDFLAGS= @LDFLAGS@
|
||||
LDLAST= @LDLAST@
|
||||
DEFS= @DEFS@
|
||||
LIBS= @LIBS@
|
||||
LIBM= @LIBM@
|
||||
LIBC= @LIBC@
|
||||
RANLIB= @RANLIB@
|
||||
MACHDEP= @MACHDEP@
|
||||
SO= @SO@
|
||||
LDSHARED= @LDSHARED@
|
||||
CCSHARED= @CCSHARED@
|
||||
LINKFORSHARED= @LINKFORSHARED@
|
||||
#@SET_CCC@
|
||||
|
||||
# Install prefix for architecture-independent files
|
||||
prefix= /usr/local
|
||||
|
||||
# Install prefix for architecture-dependent files
|
||||
exec_prefix= $(prefix)
|
||||
|
||||
# === Fixed definitions ===
|
||||
|
||||
# Shell used by make (some versions default to the login shell, which is bad)
|
||||
SHELL= /bin/sh
|
||||
|
||||
# Expanded directories
|
||||
BINDIR= $(exec_installdir)/bin
|
||||
LIBDIR= $(exec_prefix)/lib
|
||||
MANDIR= $(installdir)/man
|
||||
INCLUDEDIR= $(installdir)/include
|
||||
SCRIPTDIR= $(prefix)/lib
|
||||
|
||||
# Detailed destination directories
|
||||
BINLIBDEST= $(LIBDIR)/python$(VERSION)
|
||||
LIBDEST= $(SCRIPTDIR)/python$(VERSION)
|
||||
INCLUDEPY= $(INCLUDEDIR)/python$(VERSION)
|
||||
EXECINCLUDEPY= $(exec_installdir)/include/python$(VERSION)
|
||||
LIBP= $(exec_installdir)/lib/python$(VERSION)
|
||||
DESTSHARED= $(BINLIBDEST)/site-packages
|
||||
|
||||
LIBPL= $(LIBP)/config
|
||||
|
||||
PYTHONLIBS= $(LIBPL)/libpython$(VERSION).a
|
||||
|
||||
MAKESETUP= $(LIBPL)/makesetup
|
||||
MAKEFILE= $(LIBPL)/Makefile
|
||||
CONFIGC= $(LIBPL)/config.c
|
||||
CONFIGCIN= $(LIBPL)/config.c.in
|
||||
SETUP= $(LIBPL)/Setup
|
||||
|
||||
SYSLIBS= $(LIBM) $(LIBC)
|
||||
|
||||
ADDOBJS= $(LIBPL)/python.o config.o
|
||||
|
||||
# Portable install script (configure doesn't always guess right)
|
||||
INSTALL= $(LIBPL)/install-sh -c
|
||||
# Shared libraries must be installed with executable mode on some systems;
|
||||
# rather than figuring out exactly which, we always give them executable mode.
|
||||
# Also, making them read-only seems to be a good idea...
|
||||
INSTALL_SHARED= ${INSTALL} -m 555
|
||||
|
||||
#---------------------------------------------------
|
||||
# Possibly change some definintions for C++
|
||||
ifdef MY_LDSHARED
|
||||
LDSHARED=$(MY_LDSHARED)
|
||||
endif
|
||||
ifdef MY_LINKCC
|
||||
LINKCC=$(MY_LINKCC)
|
||||
endif
|
||||
|
||||
|
||||
# === Fixed rules ===
|
||||
|
||||
# Default target. This builds shared libraries only
|
||||
default: sharedmods
|
||||
|
||||
# Build everything
|
||||
all: static sharedmods
|
||||
|
||||
# Build shared libraries from our extension modules
|
||||
sharedmods: $(SHAREDMODS)
|
||||
|
||||
# Build a static Python binary containing our extension modules
|
||||
static: $(TARGET)
|
||||
$(TARGET): $(ADDOBJS) lib.a $(PYTHONLIBS) Makefile $(BASELIB)
|
||||
$(LINKCC) $(LDFLAGS) $(LINKFORSHARED) \
|
||||
$(ADDOBJS) lib.a $(PYTHONLIBS) \
|
||||
$(LINKPATH) $(BASELIB) $(MODLIBS) $(LIBS) $(SYSLIBS) \
|
||||
-o $(TARGET) $(LDLAST)
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#------------------------------------------------------------------------
|
||||
# This is a default version of the install target for wxPython. It just
|
||||
# redirects to wxInstall below...
|
||||
|
||||
install: wxInstall
|
||||
|
||||
#install: sharedmods
|
||||
# if test ! -d $(DESTSHARED) ; then \
|
||||
# mkdir $(DESTSHARED) ; else true ; fi
|
||||
# -for i in X $(SHAREDMODS); do \
|
||||
# if test $$i != X; \
|
||||
# then $(INSTALL_SHARED) $$i $(DESTSHARED)/$$i; \
|
||||
# fi; \
|
||||
# done
|
||||
|
||||
|
||||
# Build the library containing our extension modules
|
||||
lib.a: $(MODOBJS)
|
||||
-rm -f lib.a
|
||||
ar cr lib.a $(MODOBJS)
|
||||
-$(RANLIB) lib.a
|
||||
|
||||
# This runs makesetup *twice* to use the BASESETUP definition from Setup
|
||||
config.c Makefile: Makefile.pre Setup $(BASESETUP) $(MAKESETUP)
|
||||
$(MAKESETUP) \
|
||||
-m Makefile.pre -c $(CONFIGCIN) Setup -n $(BASESETUP) $(SETUP)
|
||||
$(MAKE) -f Makefile do-it-again
|
||||
|
||||
# Internal target to run makesetup for the second time
|
||||
do-it-again:
|
||||
$(MAKESETUP) \
|
||||
-m Makefile.pre -c $(CONFIGCIN) Setup -n $(BASESETUP) $(SETUP)
|
||||
|
||||
# Make config.o from the config.c created by makesetup
|
||||
config.o: config.c
|
||||
$(CC) $(CFLAGS) -c config.c
|
||||
|
||||
# Setup is copied from Setup.in *only* if it doesn't yet exist
|
||||
Setup:
|
||||
cp Setup.in Setup
|
||||
|
||||
# Make the intermediate Makefile.pre from Makefile.pre.in
|
||||
Makefile.pre: Makefile.pre.in sedscript
|
||||
sed -f sedscript Makefile.pre.in >Makefile.pre
|
||||
|
||||
# Shortcuts to make the sed arguments on one line
|
||||
P=prefix
|
||||
E=exec_prefix
|
||||
H=Generated automatically from Makefile.pre.in by sedscript.
|
||||
L=LINKFORSHARED
|
||||
|
||||
# Make the sed script used to create Makefile.pre from Makefile.pre.in
|
||||
sedscript: $(MAKEFILE)
|
||||
sed -n \
|
||||
-e '1s/.*/1i\\/p' \
|
||||
-e '2s%.*%# $H%p' \
|
||||
-e '/^VERSION=/s/^VERSION=[ ]*\(.*\)/s%@VERSION[@]%\1%/p' \
|
||||
-e '/^CC=/s/^CC=[ ]*\(.*\)/s%@CC[@]%\1%/p' \
|
||||
-e '/^CCC=/s/^CCC=[ ]*\(.*\)/s%#@SET_CCC[@]%CCC=\1%/p' \
|
||||
-e '/^LINKCC=/s/^LINKCC=[ ]*\(.*\)/s%@LINKCC[@]%\1%/p' \
|
||||
-e '/^OPT=/s/^OPT=[ ]*\(.*\)/s%@OPT[@]%\1%/p' \
|
||||
-e '/^LDFLAGS=/s/^LDFLAGS=[ ]*\(.*\)/s%@LDFLAGS[@]%\1%/p' \
|
||||
-e '/^DEFS=/s/^DEFS=[ ]*\(.*\)/s%@DEFS[@]%\1%/p' \
|
||||
-e '/^LIBS=/s/^LIBS=[ ]*\(.*\)/s%@LIBS[@]%\1%/p' \
|
||||
-e '/^LIBM=/s/^LIBM=[ ]*\(.*\)/s%@LIBM[@]%\1%/p' \
|
||||
-e '/^LIBC=/s/^LIBC=[ ]*\(.*\)/s%@LIBC[@]%\1%/p' \
|
||||
-e '/^RANLIB=/s/^RANLIB=[ ]*\(.*\)/s%@RANLIB[@]%\1%/p' \
|
||||
-e '/^MACHDEP=/s/^MACHDEP=[ ]*\(.*\)/s%@MACHDEP[@]%\1%/p' \
|
||||
-e '/^SO=/s/^SO=[ ]*\(.*\)/s%@SO[@]%\1%/p' \
|
||||
-e '/^LDSHARED=/s/^LDSHARED=[ ]*\(.*\)/s%@LDSHARED[@]%\1%/p' \
|
||||
-e '/^CCSHARED=/s/^CCSHARED=[ ]*\(.*\)/s%@CCSHARED[@]%\1%/p' \
|
||||
-e '/^$L=/s/^$L=[ ]*\(.*\)/s%@$L[@]%\1%/p' \
|
||||
-e '/^$P=/s/^$P=\(.*\)/s%^$P=.*%$P=\1%/p' \
|
||||
-e '/^$E=/s/^$E=\(.*\)/s%^$E=.*%$E=\1%/p' \
|
||||
$(MAKEFILE) >sedscript
|
||||
echo "/^#@SET_CCC@/d" >>sedscript
|
||||
echo "/^installdir=/s%=.*%= $(installdir)%" >>sedscript
|
||||
echo "/^exec_installdir=/s%=.*%=$(exec_installdir)%" >>sedscript
|
||||
echo "/^srcdir=/s%=.*%= $(srcdir)%" >>sedscript
|
||||
echo "/^VPATH=/s%=.*%= $(VPATH)%" >>sedscript
|
||||
echo "/^LINKPATH=/s%=.*%= $(LINKPATH)%" >>sedscript
|
||||
echo "/^BASELIB=/s%=.*%= $(BASELIB)%" >>sedscript
|
||||
echo "/^BASESETUP=/s%=.*%= $(BASESETUP)%" >>sedscript
|
||||
|
||||
# Bootstrap target
|
||||
boot: clobber
|
||||
VERSION=`$(PYTHON) -c "import sys; print sys.version[:3]"`; \
|
||||
installdir=`$(PYTHON) -c "import sys; print sys.prefix"`; \
|
||||
exec_installdir=`$(PYTHON) -c "import sys; print sys.exec_prefix"`; \
|
||||
$(MAKE) -f Makefile.pre.in VPATH=$(VPATH) srcdir=$(srcdir) \
|
||||
VERSION=$$VERSION \
|
||||
installdir=$$installdir \
|
||||
exec_installdir=$$exec_installdir \
|
||||
Makefile
|
||||
|
||||
# Handy target to remove intermediate files and backups
|
||||
clean:
|
||||
-rm -f *.o *~
|
||||
|
||||
# Handy target to remove everything that is easily regenerated
|
||||
clobber: clean
|
||||
-rm -f *.a tags TAGS config.c Makefile.pre $(TARGET) sedscript
|
||||
-rm -f *.so *.sl so_locations
|
||||
|
||||
|
||||
# Handy target to remove everything you don't want to distribute
|
||||
distclean: clobber
|
||||
-rm -f Makefile Setup
|
||||
|
||||
|
||||
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#------------------------------------------------------------------------
|
||||
# Custom rules and dependencies added for wxPython
|
||||
#
|
||||
|
||||
|
||||
SWIGFLAGS=-c++ -shadow -python -dnone -D__WXGTK__
|
||||
|
||||
|
||||
PYMODULES = $(GENCODEDIR)/wx.py $(GENCODEDIR)/events.py \
|
||||
$(GENCODEDIR)/windows.py $(GENCODEDIR)/misc.py \
|
||||
$(GENCODEDIR)/gdi.py $(GENCODEDIR)/mdi.py \
|
||||
$(GENCODEDIR)/controls.py $(GENCODEDIR)/controls2.py \
|
||||
$(GENCODEDIR)/windows2.py $(GENCODEDIR)/cmndlgs.py \
|
||||
$(GENCODEDIR)/frames.py $(GENCODEDIR)/stattool.py \
|
||||
$(GENCODEDIR)/utils.py $(GENCODEDIR)/windows3.py \
|
||||
__init__.py
|
||||
|
||||
|
||||
# Implicit rules to run SWIG
|
||||
$(GENCODEDIR)/%.cpp : %.i
|
||||
swig $(SWIGFLAGS) -c -o $@ $<
|
||||
|
||||
$(GENCODEDIR)/%.py : %.i
|
||||
swig $(SWIGFLAGS) -c -o $@ $<
|
||||
|
||||
|
||||
# This one must leave out the -c flag so we define the whole rule
|
||||
$(GENCODEDIR)/wx.cpp $(GENCODEDIR)/wx.py : wx.i my_typemaps.i _defs.i _extras.py
|
||||
swig $(SWIGFLAGS) -o $(GENCODEDIR)/wx.cpp wx.i
|
||||
|
||||
|
||||
# define some dependencies
|
||||
$(GENCODEDIR)/windows.cpp $(GENCODEDIR)/windows.py : windows.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/windows2.cpp $(GENCODEDIR)/windows2.py : windows2.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/windows3.cpp $(GENCODEDIR)/windows3.py : windows3.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/events.cpp $(GENCODEDIR)/events.py : events.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/misc.cpp $(GENCODEDIR)/misc.py : misc.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/gdi.cpp $(GENCODEDIR)/gdi.py : gdi.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/mdi.cpp $(GENCODEDIR)/mdi.py : mdi.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/controls.cpp $(GENCODEDIR)/controls.py : controls.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/controls2.cpp $(GENCODEDIR)/controls2.py : controls2.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/cmndlgs.cpp $(GENCODEDIR)/cmndlgs.py : cmndlgs.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/frames.cpp $(GENCODEDIR)/frames.py : frames.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/stattool.cpp $(GENCODEDIR)/stattool.py : stattool.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/utils.cpp $(GENCODEDIR)/utils.py : utils.i my_typemaps.i _defs.i
|
||||
|
||||
$(GENCODEDIR)/helpers.cpp:
|
||||
ln -s `pwd`/helpers.cpp $@
|
||||
|
||||
|
||||
wxInstall : sharedmods $(PYMODULES)
|
||||
if test ! -d $(TARGETDIR) ; then \
|
||||
mkdir $(TARGETDIR) ; else true ; fi
|
||||
if [ "$(SHAREDMODS)" != "" ]; then \
|
||||
chmod 755 $(SHAREDMODS); \
|
||||
cp $(SHAREDMODS) $(TARGETDIR); fi
|
||||
-for i in $(PYMODULES); do \
|
||||
cp $$i $(TARGETDIR); \
|
||||
done
|
||||
python $(LIBDEST)/compileall.py -l $(TARGETDIR)
|
||||
python -O $(LIBDEST)/compileall.py -l $(TARGETDIR)
|
||||
|
||||
|
||||
lib : libwxPython.a
|
||||
|
||||
libwxPython.a : lib.a
|
||||
cp $< $@
|
||||
44
utils/wxPython/src/Setup.in
Normal file
44
utils/wxPython/src/Setup.in
Normal file
@@ -0,0 +1,44 @@
|
||||
# This file gives the details of what is needed to build this extension
|
||||
# module so the Makefile can be created.
|
||||
|
||||
###
|
||||
### This file should be created by configure. Currently it is tweaked by hand.
|
||||
###
|
||||
|
||||
*shared*
|
||||
|
||||
CCC=c++
|
||||
WXWIN=../../..
|
||||
GENCODEDIR=gtk
|
||||
srcdir=$(GENCODEDIR)
|
||||
|
||||
# Depending on how your Python was built, you may have to set this
|
||||
# value to use the C++ driver to link with instead of the default
|
||||
# C driver. For example:
|
||||
MY_LDSHARED=$(CCC) -shared
|
||||
|
||||
# Same as above, but for statically linking Python and wxPython together,
|
||||
# in other words, if you comment out the *shared* above. If this is the
|
||||
# case then you should ensure that the main() function is Python's, not
|
||||
# wxWindows'. You can rebuild $(WXWIN)/src/gtk/app.cpp with NOMAIN defined
|
||||
# to force this...
|
||||
MY_LINKCC=$(CCC)
|
||||
|
||||
|
||||
## Pick one of these, or set your own. This is where the
|
||||
## wxPython module should be installed. It should be a
|
||||
## subdirectory named wxPython.
|
||||
TARGETDIR=..
|
||||
#TARGETDIR=$(BINLIBDEST)/site-packages/wxPython
|
||||
|
||||
|
||||
wxc wx.cpp helpers.cpp windows.cpp events.cpp misc.cpp gdi.cpp \
|
||||
mdi.cpp controls.cpp controls2.cpp windows2.cpp cmndlgs.cpp \
|
||||
frames.cpp stattool.cpp utils.cpp windows3.cpp \
|
||||
# CFLAGS
|
||||
-I. -I$(WXWIN)/include -I/usr/lib/glib/include -I$(WXWIN)/src \
|
||||
-I/usr/X11R6/include -DSWIG_GLOBAL -D__WXGTK__ \
|
||||
#-D__WXDEBUG__ \
|
||||
# LFLAGS
|
||||
-L$(WXWIN)/lib/Linux -L/usr/X11R6/lib \
|
||||
-lwx_gtk2 -lgtk -lgdk -lglib -lXext -lX11
|
||||
44
utils/wxPython/src/Setup.in.linux
Normal file
44
utils/wxPython/src/Setup.in.linux
Normal file
@@ -0,0 +1,44 @@
|
||||
# This file gives the details of what is needed to build this extension
|
||||
# module so the Makefile can be created.
|
||||
|
||||
###
|
||||
### This file should be created by configure. Currently it is tweaked by hand.
|
||||
###
|
||||
|
||||
*shared*
|
||||
|
||||
CCC=c++
|
||||
WXWIN=../../..
|
||||
GENCODEDIR=gtk
|
||||
srcdir=$(GENCODEDIR)
|
||||
|
||||
# Depending on how your Python was built, you may have to set this
|
||||
# value to use the C++ driver to link with instead of the default
|
||||
# C driver. For example:
|
||||
MY_LDSHARED=$(CCC) -shared
|
||||
|
||||
# Same as above, but for statically linking Python and wxPython together,
|
||||
# in other words, if you comment out the *shared* above. If this is the
|
||||
# case then you should ensure that the main() function is Python's, not
|
||||
# wxWindows'. You can rebuild $(WXWIN)/src/gtk/app.cpp with NOMAIN defined
|
||||
# to force this...
|
||||
MY_LINKCC=$(CCC)
|
||||
|
||||
|
||||
## Pick one of these, or set your own. This is where the
|
||||
## wxPython module should be installed. It should be a
|
||||
## subdirectory named wxPython.
|
||||
TARGETDIR=..
|
||||
#TARGETDIR=$(BINLIBDEST)/site-packages/wxPython
|
||||
|
||||
|
||||
wxc wx.cpp helpers.cpp windows.cpp events.cpp misc.cpp gdi.cpp \
|
||||
mdi.cpp controls.cpp controls2.cpp windows2.cpp cmndlgs.cpp \
|
||||
frames.cpp stattool.cpp utils.cpp windows3.cpp \
|
||||
# CFLAGS
|
||||
-I. -I$(WXWIN)/include -I/usr/lib/glib/include -I$(WXWIN)/src \
|
||||
-I/usr/X11R6/include -DSWIG_GLOBAL -D__WXGTK__ \
|
||||
#-D__WXDEBUG__ \
|
||||
# LFLAGS
|
||||
-L$(WXWIN)/lib/Linux -L/usr/X11R6/lib \
|
||||
-lwx_gtk2 -lgtk -lgdk -lglib -lXext -lX11
|
||||
45
utils/wxPython/src/Setup.in.solaris
Normal file
45
utils/wxPython/src/Setup.in.solaris
Normal file
@@ -0,0 +1,45 @@
|
||||
# This file gives the details of what is needed to build this extension
|
||||
# module so the Makefile can be created.
|
||||
|
||||
###
|
||||
### This file should be created by configure. Currently it is tweaked by hand.
|
||||
###
|
||||
|
||||
#*shared*
|
||||
|
||||
CCC=c++
|
||||
WXWIN=../../..
|
||||
GENCODEDIR=gtk
|
||||
srcdir=$(GENCODEDIR)
|
||||
|
||||
# Depending on how your Python was built, you may have to set this
|
||||
# value to use the C++ driver to link with instead of the default
|
||||
# C driver. For example:
|
||||
#MY_LDSHARED=$(CCC) -shared
|
||||
|
||||
# Same as above, but for statically linking Python and wxPython together,
|
||||
# in other words, if you comment out the *shared* above. If this is the
|
||||
# case then you should ensure that the main() function is Python's, not
|
||||
# wxWindows'. You can rebuild $(WXWIN)/src/gtk/app.cpp with NOMAIN defined
|
||||
# to force this...
|
||||
MY_LINKCC=$(CCC)
|
||||
|
||||
|
||||
## Pick one of these, or set your own. This is where the
|
||||
## wxPython module should be installed. It should be a
|
||||
## subdirectory named wxPython.
|
||||
TARGETDIR=..
|
||||
#TARGETDIR=$(BINLIBDEST)/site-packages/wxPython
|
||||
|
||||
|
||||
wxc wx.cpp helpers.cpp windows.cpp events.cpp misc.cpp gdi.cpp \
|
||||
mdi.cpp controls.cpp controls2.cpp windows2.cpp cmndlgs.cpp \
|
||||
frames.cpp stattool.cpp utils.cpp windows3.cpp \
|
||||
# CFLAGS
|
||||
-I. -I$(WXWIN)/include -I/usr/local/lib/glib/include -I$(WXWIN)/src \
|
||||
-I/usr/X/include -DSWIG_GLOBAL -D__WXGTK__ \
|
||||
#-D__WXDEBUG__ \
|
||||
# LFLAGS
|
||||
-L$(WXWIN)/lib/solaris2.6 -L/usr/X/lib \
|
||||
-L/usr/local/lib/gcc-lib/sparc-sun-solaris2.6/2.8.1 \
|
||||
-lwx_gtk2 -lgtk -lgdk -lglib -lXext -lX11 -lstdc++ -lgcc
|
||||
43
utils/wxPython/src/__init__.py
Normal file
43
utils/wxPython/src/__init__.py
Normal file
@@ -0,0 +1,43 @@
|
||||
#----------------------------------------------------------------------------
|
||||
# Name: __init__.py
|
||||
# Purpose: The presence of this file turns this directory into a
|
||||
# Python package.
|
||||
#
|
||||
# Author: Robin Dunn
|
||||
#
|
||||
# Created: 8/8/98
|
||||
# RCS-ID: $Id$
|
||||
# Copyright: (c) 1998 by Total Control Software
|
||||
# Licence: wxWindows license
|
||||
#----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#----------------------------------------------------------------------------
|
||||
#
|
||||
# $Log$
|
||||
# Revision 1.3 1998/12/15 20:41:12 RD
|
||||
# Changed the import semantics from "from wxPython import *" to "from
|
||||
# wxPython.wx import *" This is for people who are worried about
|
||||
# namespace pollution, they can use "from wxPython import wx" and then
|
||||
# prefix all the wxPython identifiers with "wx."
|
||||
#
|
||||
# Added wxTaskbarIcon for wxMSW.
|
||||
#
|
||||
# Made the events work for wxGrid.
|
||||
#
|
||||
# Added wxConfig.
|
||||
#
|
||||
# Added wxMiniFrame for wxGTK, (untested.)
|
||||
#
|
||||
# Changed many of the args and return values that were pointers to gdi
|
||||
# objects to references to reflect changes in the wxWindows API.
|
||||
#
|
||||
# Other assorted fixes and additions.
|
||||
#
|
||||
# Revision 1.2 1998/10/07 07:34:32 RD
|
||||
# Version 0.4.1 for wxGTK
|
||||
#
|
||||
# Revision 1.1 1998/08/09 08:25:49 RD
|
||||
# Initial version
|
||||
#
|
||||
#
|
||||
763
utils/wxPython/src/_defs.i
Normal file
763
utils/wxPython/src/_defs.i
Normal file
@@ -0,0 +1,763 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: _defs.i
|
||||
// Purpose: Definitions and stuff
|
||||
//
|
||||
// Author: Robin Dunn
|
||||
//
|
||||
// Created: 6/24/97
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 1998 by Total Control Software
|
||||
// Licence: wxWindows license
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
// Forward declares...
|
||||
|
||||
class wxPyApp;
|
||||
class wxEvtHandler;
|
||||
class wxWindow;
|
||||
class wxFrame;
|
||||
class wxMiniFrame;
|
||||
class wxPanel;
|
||||
class wxDialog;
|
||||
class wxMenu;
|
||||
class wxPyMenu;
|
||||
class wxMenuBar;
|
||||
class wxMenuItem;
|
||||
class wxEvent;
|
||||
class wxSizeEvent;
|
||||
class wxCloseEvent;
|
||||
class wxCommandEvent;
|
||||
class wxScrollEvent;
|
||||
class wxMouseEvent;
|
||||
class wxKeyEvent;
|
||||
class wxMoveEvent;
|
||||
class wxPaintEvent;
|
||||
class wxEraseEvent;
|
||||
class wxFocusEvent;
|
||||
class wxActivateEvent;
|
||||
class wxInitDialogEvent;
|
||||
class wxMenuEvent;
|
||||
class wxShowEvent;
|
||||
class wxIconizeEvent;
|
||||
class wxMaximizeEvent;
|
||||
class wxJoystickEvent;
|
||||
class wxDropFilesEvent;
|
||||
class wxIdleEvent;
|
||||
class wxUpdateUIEvent;
|
||||
class wxSysColourChangedEvent;
|
||||
class wxSize;
|
||||
class wxRealPoint;
|
||||
class wxPoint;
|
||||
class wxRect;
|
||||
class wxBitmap;
|
||||
class wxMask;
|
||||
class wxIcon;
|
||||
class wxCursor;
|
||||
class wxFont;
|
||||
class wxColour;
|
||||
class wxPen;
|
||||
class wxBrush;
|
||||
class wxDC;
|
||||
class wxMemoryDC;
|
||||
class wxScreenDC;
|
||||
class wxClientDC;
|
||||
class wxPaintDC;
|
||||
class wxPostScriptDC;
|
||||
class wxPrinterDC;
|
||||
class wxMetaFileDC;
|
||||
class wxMDIParentFrame;
|
||||
class wxMDIChildFrame;
|
||||
class wxMDIClientWindow;
|
||||
class wxControl;
|
||||
class wxButton;
|
||||
class wxBitmapButton;
|
||||
class wxCheckBox;
|
||||
class wxChoice;
|
||||
class wxComboBox;
|
||||
class wxGauge;
|
||||
class wxStaticBox;
|
||||
class wxStaticText;
|
||||
class wxListBox;
|
||||
class wxTextCtrl;
|
||||
class wxScrollBar;
|
||||
class wxSpinButton;
|
||||
class wxStaticBitmap;
|
||||
class wxRadioBox;
|
||||
class wxRadioButton;
|
||||
class wxSlider;
|
||||
|
||||
class wxPyTimer;
|
||||
class wxIndividualLayoutConstraint;
|
||||
class wxLayoutConstraints;
|
||||
class wxToolBar;
|
||||
class wxStatusBar;
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
// some definitions for SWIG only
|
||||
typedef unsigned char byte;
|
||||
typedef short int WXTYPE;
|
||||
typedef int wxWindowID;
|
||||
typedef unsigned int uint;
|
||||
typedef signed int EBool;
|
||||
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
// General numeric #define's and etc. Making them all enums makes SWIG use the
|
||||
// real macro when making the Python Int
|
||||
|
||||
enum {
|
||||
wxMAJOR_VERSION,
|
||||
wxMINOR_VERSION,
|
||||
wxRELEASE_NUMBER,
|
||||
|
||||
wxNOT_FOUND,
|
||||
|
||||
wxVSCROLL,
|
||||
wxHSCROLL,
|
||||
wxCAPTION,
|
||||
wxDOUBLE_BORDER,
|
||||
wxSUNKEN_BORDER,
|
||||
wxRAISED_BORDER,
|
||||
wxBORDER,
|
||||
wxSIMPLE_BORDER,
|
||||
wxSTATIC_BORDER,
|
||||
wxTRANSPARENT_WINDOW,
|
||||
wxNO_BORDER,
|
||||
wxUSER_COLOURS,
|
||||
wxNO_3D,
|
||||
//wxOVERRIDE_KEY_TRANSLATIONS,
|
||||
wxTAB_TRAVERSAL,
|
||||
wxHORIZONTAL,
|
||||
wxVERTICAL,
|
||||
wxBOTH,
|
||||
wxCENTER_FRAME,
|
||||
wxSTAY_ON_TOP,
|
||||
wxICONIZE,
|
||||
wxMINIMIZE,
|
||||
wxMAXIMIZE,
|
||||
wxTHICK_FRAME,
|
||||
wxSYSTEM_MENU,
|
||||
wxMINIMIZE_BOX,
|
||||
wxMAXIMIZE_BOX,
|
||||
wxTINY_CAPTION_HORIZ,
|
||||
wxTINY_CAPTION_VERT,
|
||||
wxRESIZE_BOX,
|
||||
wxRESIZE_BORDER,
|
||||
wxDIALOG_MODAL,
|
||||
wxDIALOG_MODELESS,
|
||||
wxDEFAULT_FRAME_STYLE,
|
||||
wxDEFAULT_DIALOG_STYLE,
|
||||
|
||||
wxFRAME_TOOL_WINDOW,
|
||||
wxCLIP_CHILDREN,
|
||||
|
||||
wxRETAINED,
|
||||
wxBACKINGSTORE,
|
||||
wxTB_3DBUTTONS,
|
||||
wxTB_HORIZONTAL,
|
||||
wxTB_VERTICAL,
|
||||
wxTB_FLAT,
|
||||
wxCOLOURED,
|
||||
wxFIXED_LENGTH,
|
||||
wxALIGN_LEFT,
|
||||
wxALIGN_CENTER,
|
||||
wxALIGN_CENTRE,
|
||||
wxALIGN_RIGHT,
|
||||
wxLB_NEEDED_SB,
|
||||
wxLB_ALWAYS_SB,
|
||||
wxLB_SORT,
|
||||
wxLB_SINGLE,
|
||||
wxLB_MULTIPLE,
|
||||
wxLB_EXTENDED,
|
||||
wxLB_OWNERDRAW,
|
||||
wxLB_HSCROLL,
|
||||
wxPROCESS_ENTER,
|
||||
wxPASSWORD,
|
||||
wxTE_PROCESS_ENTER,
|
||||
wxTE_PASSWORD,
|
||||
wxTE_READONLY,
|
||||
wxTE_MULTILINE,
|
||||
wxCB_SIMPLE,
|
||||
wxCB_DROPDOWN,
|
||||
wxCB_SORT,
|
||||
wxCB_READONLY,
|
||||
wxRA_HORIZONTAL,
|
||||
wxRA_VERTICAL,
|
||||
wxRB_GROUP,
|
||||
wxGA_PROGRESSBAR,
|
||||
wxGA_HORIZONTAL,
|
||||
wxGA_VERTICAL,
|
||||
wxSL_HORIZONTAL,
|
||||
wxSL_VERTICAL,
|
||||
wxSL_AUTOTICKS,
|
||||
wxSL_LABELS,
|
||||
wxSL_LEFT,
|
||||
wxSL_TOP,
|
||||
wxSL_RIGHT,
|
||||
wxSL_BOTTOM,
|
||||
wxSL_BOTH,
|
||||
wxSL_SELRANGE,
|
||||
wxSB_HORIZONTAL,
|
||||
wxSB_VERTICAL,
|
||||
wxBU_AUTODRAW,
|
||||
wxBU_NOAUTODRAW,
|
||||
wxTR_HAS_BUTTONS,
|
||||
wxTR_EDIT_LABELS,
|
||||
wxTR_LINES_AT_ROOT,
|
||||
wxLC_ICON,
|
||||
wxLC_SMALL_ICON,
|
||||
wxLC_LIST,
|
||||
wxLC_REPORT,
|
||||
wxLC_ALIGN_TOP,
|
||||
wxLC_ALIGN_LEFT,
|
||||
wxLC_AUTOARRANGE,
|
||||
wxLC_USER_TEXT,
|
||||
wxLC_EDIT_LABELS,
|
||||
wxLC_NO_HEADER,
|
||||
wxLC_NO_SORT_HEADER,
|
||||
wxLC_SINGLE_SEL,
|
||||
wxLC_SORT_ASCENDING,
|
||||
wxLC_SORT_DESCENDING,
|
||||
wxLC_MASK_TYPE,
|
||||
wxLC_MASK_ALIGN,
|
||||
wxLC_MASK_SORT,
|
||||
wxSP_VERTICAL,
|
||||
wxSP_HORIZONTAL,
|
||||
wxSP_ARROW_KEYS,
|
||||
wxSP_WRAP,
|
||||
wxSP_NOBORDER,
|
||||
wxSP_3D,
|
||||
wxSP_BORDER,
|
||||
wxTAB_MULTILINE,
|
||||
wxTAB_RIGHTJUSTIFY,
|
||||
wxTAB_FIXEDWIDTH,
|
||||
wxTAB_OWNERDRAW,
|
||||
// wxSB_SIZEGRIP,
|
||||
wxFLOOD_SURFACE,
|
||||
wxFLOOD_BORDER,
|
||||
wxODDEVEN_RULE,
|
||||
wxWINDING_RULE,
|
||||
wxTOOL_TOP,
|
||||
wxTOOL_BOTTOM,
|
||||
wxTOOL_LEFT,
|
||||
wxTOOL_RIGHT,
|
||||
wxOK,
|
||||
wxYES_NO,
|
||||
wxCANCEL,
|
||||
wxYES,
|
||||
wxNO,
|
||||
wxICON_EXCLAMATION,
|
||||
wxICON_HAND,
|
||||
wxICON_QUESTION,
|
||||
wxICON_INFORMATION,
|
||||
wxICON_STOP,
|
||||
wxICON_ASTERISK,
|
||||
wxICON_MASK,
|
||||
wxCENTRE,
|
||||
wxCENTER,
|
||||
wxSIZE_AUTO_WIDTH,
|
||||
wxSIZE_AUTO_HEIGHT,
|
||||
wxSIZE_AUTO,
|
||||
wxSIZE_USE_EXISTING,
|
||||
wxSIZE_ALLOW_MINUS_ONE,
|
||||
#ifndef __WXGTK__
|
||||
wxDF_TEXT,
|
||||
wxDF_BITMAP,
|
||||
wxDF_METAFILE,
|
||||
wxDF_DIB,
|
||||
wxDF_OEMTEXT,
|
||||
wxDF_FILENAME,
|
||||
#endif
|
||||
wxPORTRAIT,
|
||||
wxLANDSCAPE,
|
||||
wxID_OPEN,
|
||||
wxID_CLOSE,
|
||||
wxID_NEW,
|
||||
wxID_SAVE,
|
||||
wxID_SAVEAS,
|
||||
wxID_REVERT,
|
||||
wxID_EXIT,
|
||||
wxID_UNDO,
|
||||
wxID_REDO,
|
||||
wxID_HELP,
|
||||
wxID_PRINT,
|
||||
wxID_PRINT_SETUP,
|
||||
wxID_PREVIEW,
|
||||
wxID_ABOUT,
|
||||
wxID_HELP_CONTENTS,
|
||||
wxID_HELP_COMMANDS,
|
||||
wxID_HELP_PROCEDURES,
|
||||
wxID_HELP_CONTEXT,
|
||||
wxID_CUT,
|
||||
wxID_COPY,
|
||||
wxID_PASTE,
|
||||
wxID_CLEAR,
|
||||
wxID_FIND,
|
||||
wxID_FILE1,
|
||||
wxID_FILE2,
|
||||
wxID_FILE3,
|
||||
wxID_FILE4,
|
||||
wxID_FILE5,
|
||||
wxID_FILE6,
|
||||
wxID_FILE7,
|
||||
wxID_FILE8,
|
||||
wxID_FILE9,
|
||||
wxID_OK,
|
||||
wxID_CANCEL,
|
||||
wxID_APPLY,
|
||||
wxID_YES,
|
||||
wxID_NO,
|
||||
wxBITMAP_TYPE_BMP,
|
||||
wxBITMAP_TYPE_BMP_RESOURCE,
|
||||
wxBITMAP_TYPE_ICO,
|
||||
wxBITMAP_TYPE_ICO_RESOURCE,
|
||||
wxBITMAP_TYPE_CUR,
|
||||
wxBITMAP_TYPE_CUR_RESOURCE,
|
||||
wxBITMAP_TYPE_XBM,
|
||||
wxBITMAP_TYPE_XBM_DATA,
|
||||
wxBITMAP_TYPE_XPM,
|
||||
wxBITMAP_TYPE_XPM_DATA,
|
||||
wxBITMAP_TYPE_TIF,
|
||||
wxBITMAP_TYPE_TIF_RESOURCE,
|
||||
wxBITMAP_TYPE_GIF,
|
||||
wxBITMAP_TYPE_GIF_RESOURCE,
|
||||
wxBITMAP_TYPE_PNG,
|
||||
wxBITMAP_TYPE_PNG_RESOURCE,
|
||||
wxBITMAP_TYPE_ANY,
|
||||
wxBITMAP_TYPE_RESOURCE,
|
||||
|
||||
wxOPEN,
|
||||
wxSAVE,
|
||||
wxHIDE_READONLY,
|
||||
wxOVERWRITE_PROMPT,
|
||||
|
||||
wxACCEL_ALT,
|
||||
wxACCEL_CTRL,
|
||||
wxACCEL_SHIFT,
|
||||
};
|
||||
|
||||
|
||||
/// Standard error codes
|
||||
enum ErrCode
|
||||
{
|
||||
ERR_PARAM = (-4000),
|
||||
ERR_NODATA,
|
||||
ERR_CANCEL,
|
||||
ERR_SUCCESS = 0
|
||||
};
|
||||
|
||||
|
||||
enum {
|
||||
wxDEFAULT ,
|
||||
wxDECORATIVE,
|
||||
wxROMAN,
|
||||
wxSCRIPT,
|
||||
wxSWISS,
|
||||
wxMODERN,
|
||||
wxTELETYPE,
|
||||
wxVARIABLE,
|
||||
wxFIXED,
|
||||
wxNORMAL,
|
||||
wxLIGHT,
|
||||
wxBOLD,
|
||||
wxITALIC,
|
||||
wxSLANT,
|
||||
wxSOLID,
|
||||
wxDOT,
|
||||
wxLONG_DASH,
|
||||
wxSHORT_DASH,
|
||||
wxDOT_DASH,
|
||||
wxUSER_DASH,
|
||||
wxTRANSPARENT,
|
||||
wxSTIPPLE,
|
||||
wxBDIAGONAL_HATCH,
|
||||
wxCROSSDIAG_HATCH,
|
||||
wxFDIAGONAL_HATCH,
|
||||
wxCROSS_HATCH,
|
||||
wxHORIZONTAL_HATCH,
|
||||
wxVERTICAL_HATCH,
|
||||
wxJOIN_BEVEL,
|
||||
wxJOIN_MITER,
|
||||
wxJOIN_ROUND,
|
||||
wxCAP_ROUND,
|
||||
wxCAP_PROJECTING,
|
||||
wxCAP_BUTT
|
||||
};
|
||||
|
||||
typedef enum {
|
||||
wxCLEAR, // 0
|
||||
wxXOR, // src XOR dst
|
||||
wxINVERT, // NOT dst
|
||||
wxOR_REVERSE, // src OR (NOT dst)
|
||||
wxAND_REVERSE,// src AND (NOT dst)
|
||||
wxCOPY, // src
|
||||
wxAND, // src AND dst
|
||||
wxAND_INVERT, // (NOT src) AND dst
|
||||
wxNO_OP, // dst
|
||||
wxNOR, // (NOT src) AND (NOT dst)
|
||||
wxEQUIV, // (NOT src) XOR dst
|
||||
wxSRC_INVERT, // (NOT src)
|
||||
wxOR_INVERT, // (NOT src) OR dst
|
||||
wxNAND, // (NOT src) OR (NOT dst)
|
||||
wxOR, // src OR dst
|
||||
wxSET, // 1
|
||||
wxSRC_OR, // source _bitmap_ OR destination
|
||||
wxSRC_AND // source _bitmap_ AND destination
|
||||
} form_ops_t;
|
||||
|
||||
enum _Virtual_keycodes {
|
||||
WXK_BACK = 8,
|
||||
WXK_TAB = 9,
|
||||
WXK_RETURN = 13,
|
||||
WXK_ESCAPE = 27,
|
||||
WXK_SPACE = 32,
|
||||
WXK_DELETE = 127,
|
||||
|
||||
WXK_START = 300,
|
||||
WXK_LBUTTON,
|
||||
WXK_RBUTTON,
|
||||
WXK_CANCEL,
|
||||
WXK_MBUTTON,
|
||||
WXK_CLEAR,
|
||||
WXK_SHIFT,
|
||||
WXK_CONTROL,
|
||||
WXK_MENU,
|
||||
WXK_PAUSE,
|
||||
WXK_CAPITAL,
|
||||
WXK_PRIOR, // Page up
|
||||
WXK_NEXT, // Page down
|
||||
WXK_END,
|
||||
WXK_HOME,
|
||||
WXK_LEFT,
|
||||
WXK_UP,
|
||||
WXK_RIGHT,
|
||||
WXK_DOWN,
|
||||
WXK_SELECT,
|
||||
WXK_PRINT,
|
||||
WXK_EXECUTE,
|
||||
WXK_SNAPSHOT,
|
||||
WXK_INSERT,
|
||||
WXK_HELP,
|
||||
WXK_NUMPAD0,
|
||||
WXK_NUMPAD1,
|
||||
WXK_NUMPAD2,
|
||||
WXK_NUMPAD3,
|
||||
WXK_NUMPAD4,
|
||||
WXK_NUMPAD5,
|
||||
WXK_NUMPAD6,
|
||||
WXK_NUMPAD7,
|
||||
WXK_NUMPAD8,
|
||||
WXK_NUMPAD9,
|
||||
WXK_MULTIPLY,
|
||||
WXK_ADD,
|
||||
WXK_SEPARATOR,
|
||||
WXK_SUBTRACT,
|
||||
WXK_DECIMAL,
|
||||
WXK_DIVIDE,
|
||||
WXK_F1,
|
||||
WXK_F2,
|
||||
WXK_F3,
|
||||
WXK_F4,
|
||||
WXK_F5,
|
||||
WXK_F6,
|
||||
WXK_F7,
|
||||
WXK_F8,
|
||||
WXK_F9,
|
||||
WXK_F10,
|
||||
WXK_F11,
|
||||
WXK_F12,
|
||||
WXK_F13,
|
||||
WXK_F14,
|
||||
WXK_F15,
|
||||
WXK_F16,
|
||||
WXK_F17,
|
||||
WXK_F18,
|
||||
WXK_F19,
|
||||
WXK_F20,
|
||||
WXK_F21,
|
||||
WXK_F22,
|
||||
WXK_F23,
|
||||
WXK_F24,
|
||||
WXK_NUMLOCK,
|
||||
WXK_SCROLL,
|
||||
WXK_PAGEUP,
|
||||
WXK_PAGEDOWN
|
||||
};
|
||||
|
||||
typedef enum {
|
||||
wxCURSOR_NONE = 0,
|
||||
wxCURSOR_ARROW = 1,
|
||||
wxCURSOR_BULLSEYE,
|
||||
wxCURSOR_CHAR,
|
||||
wxCURSOR_CROSS,
|
||||
wxCURSOR_HAND,
|
||||
wxCURSOR_IBEAM,
|
||||
wxCURSOR_LEFT_BUTTON,
|
||||
wxCURSOR_MAGNIFIER,
|
||||
wxCURSOR_MIDDLE_BUTTON,
|
||||
wxCURSOR_NO_ENTRY,
|
||||
wxCURSOR_PAINT_BRUSH,
|
||||
wxCURSOR_PENCIL,
|
||||
wxCURSOR_POINT_LEFT,
|
||||
wxCURSOR_POINT_RIGHT,
|
||||
wxCURSOR_QUESTION_ARROW,
|
||||
wxCURSOR_RIGHT_BUTTON,
|
||||
wxCURSOR_SIZENESW,
|
||||
wxCURSOR_SIZENS,
|
||||
wxCURSOR_SIZENWSE,
|
||||
wxCURSOR_SIZEWE,
|
||||
wxCURSOR_SIZING,
|
||||
wxCURSOR_SPRAYCAN,
|
||||
wxCURSOR_WAIT,
|
||||
wxCURSOR_WATCH,
|
||||
wxCURSOR_BLANK
|
||||
// #ifndef __WXMSW__
|
||||
// /* Not yet implemented for Windows */
|
||||
// , wxCURSOR_CROSS_REVERSE,
|
||||
// wxCURSOR_DOUBLE_ARROW,
|
||||
// wxCURSOR_BASED_ARROW_UP,
|
||||
// wxCURSOR_BASED_ARROW_DOWN
|
||||
// #endif
|
||||
} _standard_cursors_t;
|
||||
|
||||
|
||||
#define FALSE 0
|
||||
#define false 0
|
||||
#define TRUE 1
|
||||
#define true 1
|
||||
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
/*
|
||||
* Event types
|
||||
*
|
||||
*/
|
||||
enum wxEventType {
|
||||
wxEVT_NULL = 0,
|
||||
wxEVT_FIRST = 10000,
|
||||
|
||||
// New names
|
||||
wxEVT_COMMAND_BUTTON_CLICKED,
|
||||
wxEVT_COMMAND_CHECKBOX_CLICKED,
|
||||
wxEVT_COMMAND_CHOICE_SELECTED,
|
||||
wxEVT_COMMAND_LISTBOX_SELECTED,
|
||||
wxEVT_COMMAND_LISTBOX_DOUBLECLICKED,
|
||||
wxEVT_COMMAND_CHECKLISTBOX_TOGGLED,
|
||||
wxEVT_COMMAND_TEXT_UPDATED,
|
||||
wxEVT_COMMAND_TEXT_ENTER,
|
||||
wxEVT_COMMAND_MENU_SELECTED,
|
||||
wxEVT_COMMAND_SLIDER_UPDATED,
|
||||
wxEVT_COMMAND_RADIOBOX_SELECTED,
|
||||
wxEVT_COMMAND_RADIOBUTTON_SELECTED,
|
||||
// wxEVT_COMMAND_SCROLLBAR_UPDATED is now obsolete since we use wxEVT_SCROLL... events
|
||||
wxEVT_COMMAND_SCROLLBAR_UPDATED,
|
||||
wxEVT_COMMAND_VLBOX_SELECTED,
|
||||
wxEVT_COMMAND_COMBOBOX_SELECTED,
|
||||
wxEVT_COMMAND_TOOL_CLICKED,
|
||||
wxEVT_COMMAND_TOOL_RCLICKED,
|
||||
wxEVT_COMMAND_TOOL_ENTER,
|
||||
wxEVT_SET_FOCUS,
|
||||
wxEVT_KILL_FOCUS,
|
||||
|
||||
/* Mouse event types */
|
||||
wxEVT_LEFT_DOWN,
|
||||
wxEVT_LEFT_UP,
|
||||
wxEVT_MIDDLE_DOWN,
|
||||
wxEVT_MIDDLE_UP,
|
||||
wxEVT_RIGHT_DOWN,
|
||||
wxEVT_RIGHT_UP,
|
||||
wxEVT_MOTION,
|
||||
wxEVT_ENTER_WINDOW,
|
||||
wxEVT_LEAVE_WINDOW,
|
||||
wxEVT_LEFT_DCLICK,
|
||||
wxEVT_MIDDLE_DCLICK,
|
||||
wxEVT_RIGHT_DCLICK,
|
||||
|
||||
// Non-client mouse events
|
||||
wxEVT_NC_LEFT_DOWN = wxEVT_FIRST + 100,
|
||||
wxEVT_NC_LEFT_UP,
|
||||
wxEVT_NC_MIDDLE_DOWN,
|
||||
wxEVT_NC_MIDDLE_UP,
|
||||
wxEVT_NC_RIGHT_DOWN,
|
||||
wxEVT_NC_RIGHT_UP,
|
||||
wxEVT_NC_MOTION,
|
||||
wxEVT_NC_ENTER_WINDOW,
|
||||
wxEVT_NC_LEAVE_WINDOW,
|
||||
wxEVT_NC_LEFT_DCLICK,
|
||||
wxEVT_NC_MIDDLE_DCLICK,
|
||||
wxEVT_NC_RIGHT_DCLICK,
|
||||
|
||||
/* Character input event type */
|
||||
wxEVT_CHAR,
|
||||
|
||||
/*
|
||||
* Scrollbar event identifiers
|
||||
*/
|
||||
wxEVT_SCROLL_TOP,
|
||||
wxEVT_SCROLL_BOTTOM,
|
||||
wxEVT_SCROLL_LINEUP,
|
||||
wxEVT_SCROLL_LINEDOWN,
|
||||
wxEVT_SCROLL_PAGEUP,
|
||||
wxEVT_SCROLL_PAGEDOWN,
|
||||
wxEVT_SCROLL_THUMBTRACK,
|
||||
|
||||
wxEVT_SIZE = wxEVT_FIRST + 200,
|
||||
wxEVT_MOVE,
|
||||
wxEVT_CLOSE_WINDOW,
|
||||
wxEVT_END_SESSION,
|
||||
wxEVT_QUERY_END_SESSION,
|
||||
wxEVT_ACTIVATE_APP,
|
||||
wxEVT_POWER,
|
||||
wxEVT_CHAR_HOOK,
|
||||
wxEVT_KEY_UP,
|
||||
wxEVT_ACTIVATE,
|
||||
wxEVT_CREATE,
|
||||
wxEVT_DESTROY,
|
||||
wxEVT_SHOW,
|
||||
wxEVT_ICONIZE,
|
||||
wxEVT_MAXIMIZE,
|
||||
wxEVT_MOUSE_CAPTURE_CHANGED,
|
||||
wxEVT_PAINT,
|
||||
wxEVT_ERASE_BACKGROUND,
|
||||
wxEVT_NC_PAINT,
|
||||
wxEVT_PAINT_ICON,
|
||||
wxEVT_MENU_CHAR,
|
||||
wxEVT_MENU_INIT,
|
||||
wxEVT_MENU_HIGHLIGHT,
|
||||
wxEVT_POPUP_MENU_INIT,
|
||||
wxEVT_CONTEXT_MENU,
|
||||
wxEVT_SYS_COLOUR_CHANGED,
|
||||
wxEVT_SETTING_CHANGED,
|
||||
wxEVT_QUERY_NEW_PALETTE,
|
||||
wxEVT_PALETTE_CHANGED,
|
||||
wxEVT_JOY_BUTTON_DOWN,
|
||||
wxEVT_JOY_BUTTON_UP,
|
||||
wxEVT_JOY_MOVE,
|
||||
wxEVT_JOY_ZMOVE,
|
||||
wxEVT_DROP_FILES,
|
||||
wxEVT_DRAW_ITEM,
|
||||
wxEVT_MEASURE_ITEM,
|
||||
wxEVT_COMPARE_ITEM,
|
||||
wxEVT_INIT_DIALOG,
|
||||
wxEVT_IDLE,
|
||||
wxEVT_UPDATE_UI,
|
||||
|
||||
/* Generic command events */
|
||||
// Note: a click is a higher-level event
|
||||
// than button down/up
|
||||
wxEVT_COMMAND_LEFT_CLICK,
|
||||
wxEVT_COMMAND_LEFT_DCLICK,
|
||||
wxEVT_COMMAND_RIGHT_CLICK,
|
||||
wxEVT_COMMAND_RIGHT_DCLICK,
|
||||
wxEVT_COMMAND_SET_FOCUS,
|
||||
wxEVT_COMMAND_KILL_FOCUS,
|
||||
wxEVT_COMMAND_ENTER,
|
||||
|
||||
/* Tree control event types */
|
||||
wxEVT_COMMAND_TREE_BEGIN_DRAG,
|
||||
wxEVT_COMMAND_TREE_BEGIN_RDRAG,
|
||||
wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT,
|
||||
wxEVT_COMMAND_TREE_END_LABEL_EDIT,
|
||||
wxEVT_COMMAND_TREE_DELETE_ITEM,
|
||||
wxEVT_COMMAND_TREE_GET_INFO,
|
||||
wxEVT_COMMAND_TREE_SET_INFO,
|
||||
wxEVT_COMMAND_TREE_ITEM_EXPANDED,
|
||||
wxEVT_COMMAND_TREE_ITEM_EXPANDING,
|
||||
wxEVT_COMMAND_TREE_ITEM_COLLAPSED,
|
||||
wxEVT_COMMAND_TREE_ITEM_COLLAPSING,
|
||||
wxEVT_COMMAND_TREE_SEL_CHANGED,
|
||||
wxEVT_COMMAND_TREE_SEL_CHANGING,
|
||||
wxEVT_COMMAND_TREE_KEY_DOWN,
|
||||
|
||||
/* List control event types */
|
||||
wxEVT_COMMAND_LIST_BEGIN_DRAG,
|
||||
wxEVT_COMMAND_LIST_BEGIN_RDRAG,
|
||||
wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT,
|
||||
wxEVT_COMMAND_LIST_END_LABEL_EDIT,
|
||||
wxEVT_COMMAND_LIST_DELETE_ITEM,
|
||||
wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS,
|
||||
wxEVT_COMMAND_LIST_GET_INFO,
|
||||
wxEVT_COMMAND_LIST_SET_INFO,
|
||||
wxEVT_COMMAND_LIST_ITEM_SELECTED,
|
||||
wxEVT_COMMAND_LIST_ITEM_DESELECTED,
|
||||
wxEVT_COMMAND_LIST_KEY_DOWN,
|
||||
wxEVT_COMMAND_LIST_INSERT_ITEM,
|
||||
wxEVT_COMMAND_LIST_COL_CLICK,
|
||||
|
||||
/* Tab and notebook control event types */
|
||||
wxEVT_COMMAND_TAB_SEL_CHANGED,
|
||||
wxEVT_COMMAND_TAB_SEL_CHANGING,
|
||||
wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED,
|
||||
wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// $Log$
|
||||
// Revision 1.10 1999/01/30 07:30:08 RD
|
||||
// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
|
||||
//
|
||||
// Various cleanup, tweaks, minor additions, etc. to maintain
|
||||
// compatibility with the current wxWindows.
|
||||
//
|
||||
// Revision 1.9 1998/12/15 20:41:13 RD
|
||||
// Changed the import semantics from "from wxPython import *" to "from
|
||||
// wxPython.wx import *" This is for people who are worried about
|
||||
// namespace pollution, they can use "from wxPython import wx" and then
|
||||
// prefix all the wxPython identifiers with "wx."
|
||||
//
|
||||
// Added wxTaskbarIcon for wxMSW.
|
||||
//
|
||||
// Made the events work for wxGrid.
|
||||
//
|
||||
// Added wxConfig.
|
||||
//
|
||||
// Added wxMiniFrame for wxGTK, (untested.)
|
||||
//
|
||||
// Changed many of the args and return values that were pointers to gdi
|
||||
// objects to references to reflect changes in the wxWindows API.
|
||||
//
|
||||
// Other assorted fixes and additions.
|
||||
//
|
||||
// Revision 1.8 1998/11/15 23:03:42 RD
|
||||
// Removing some ifdef's for wxGTK
|
||||
//
|
||||
// Revision 1.7 1998/11/11 03:12:24 RD
|
||||
//
|
||||
// Additions for wxTreeCtrl
|
||||
//
|
||||
// Revision 1.6 1998/10/20 06:43:53 RD
|
||||
// New wxTreeCtrl wrappers (untested)
|
||||
// some changes in helpers
|
||||
// etc.
|
||||
//
|
||||
// Revision 1.5 1998/10/02 06:40:32 RD
|
||||
//
|
||||
// Version 0.4 of wxPython for MSW.
|
||||
//
|
||||
// Revision 1.4 1998/08/18 19:48:11 RD
|
||||
// more wxGTK compatibility things.
|
||||
//
|
||||
// It builds now but there are serious runtime problems...
|
||||
//
|
||||
// Revision 1.3 1998/08/14 23:36:33 RD
|
||||
// Beginings of wxGTK compatibility
|
||||
//
|
||||
// Revision 1.2 1998/08/14 03:16:35 RD
|
||||
// removed some definitions that got removed from defs.h
|
||||
//
|
||||
// Revision 1.1 1998/08/09 08:25:49 RD
|
||||
// Initial version
|
||||
//
|
||||
//
|
||||
662
utils/wxPython/src/_extras.py
Normal file
662
utils/wxPython/src/_extras.py
Normal file
@@ -0,0 +1,662 @@
|
||||
#----------------------------------------------------------------------------
|
||||
# Name: _extra.py
|
||||
# Purpose: This file is appended to the shadow class file generated
|
||||
# by SWIG. We add some unSWIGable things here.
|
||||
#
|
||||
# Author: Robin Dunn
|
||||
#
|
||||
# Created: 6/30/97
|
||||
# RCS-ID: $Id$
|
||||
# Copyright: (c) 1998 by Total Control Software
|
||||
# Licence: wxWindows license
|
||||
#----------------------------------------------------------------------------
|
||||
|
||||
import sys
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
# This gives this module's dictionary to the C++ extension code...
|
||||
|
||||
_wxSetDictionary(vars())
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
#----------------------------------------------------------------------
|
||||
# Helper function to link python methods to wxWindows virtual
|
||||
# functions by name.
|
||||
|
||||
def _checkForCallback(obj, name, event, theID=-1):
|
||||
try: cb = getattr(obj, name)
|
||||
except: pass
|
||||
else: obj.Connect(theID, -1, event, cb)
|
||||
|
||||
def _StdWindowCallbacks(win):
|
||||
_checkForCallback(win, "OnChar", wxEVT_CHAR)
|
||||
_checkForCallback(win, "OnSize", wxEVT_SIZE)
|
||||
_checkForCallback(win, "OnEraseBackground", wxEVT_ERASE_BACKGROUND)
|
||||
_checkForCallback(win, "OnSysColourChanged", wxEVT_SYS_COLOUR_CHANGED)
|
||||
_checkForCallback(win, "OnInitDialog", wxEVT_INIT_DIALOG)
|
||||
_checkForCallback(win, "OnIdle", wxEVT_IDLE)
|
||||
_checkForCallback(win, "OnPaint", wxEVT_PAINT)
|
||||
|
||||
def _StdFrameCallbacks(win):
|
||||
_StdWindowCallbacks(win)
|
||||
_checkForCallback(win, "OnActivate", wxEVT_ACTIVATE)
|
||||
_checkForCallback(win, "OnMenuHighlight", wxEVT_MENU_HIGHLIGHT)
|
||||
_checkForCallback(win, "OnCloseWindow", wxEVT_CLOSE_WINDOW)
|
||||
|
||||
|
||||
def _StdDialogCallbacks(win):
|
||||
_StdWindowCallbacks(win)
|
||||
_checkForCallback(win, "OnOk", wxEVT_COMMAND_BUTTON_CLICKED, wxID_OK)
|
||||
_checkForCallback(win, "OnApply", wxEVT_COMMAND_BUTTON_CLICKED, wxID_APPLY)
|
||||
_checkForCallback(win, "OnCancel", wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL)
|
||||
_checkForCallback(win, "OnCloseWindow", wxEVT_CLOSE_WINDOW)
|
||||
_checkForCallback(win, "OnCharHook", wxEVT_CHAR_HOOK)
|
||||
|
||||
|
||||
def _StdOnScrollCallback(win):
|
||||
try: cb = getattr(win, "OnScroll")
|
||||
except: pass
|
||||
else: EVT_SCROLL(win, cb)
|
||||
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
#----------------------------------------------------------------------
|
||||
# functions that look and act like the C++ Macros of the same name
|
||||
|
||||
|
||||
# Miscellaneous
|
||||
def EVT_SIZE(win, func):
|
||||
win.Connect(-1, -1, wxEVT_SIZE, func)
|
||||
|
||||
def EVT_MOVE(win, func):
|
||||
win.Connect(-1, -1, wxEVT_MOVE, func)
|
||||
|
||||
def EVT_CLOSE(win, func):
|
||||
win.Connect(-1, -1, wxEVT_CLOSE_WINDOW, func)
|
||||
|
||||
def EVT_PAINT(win, func):
|
||||
win.Connect(-1, -1, wxEVT_PAINT, func)
|
||||
|
||||
def EVT_ERASE_BACKGROUND(win, func):
|
||||
win.Connect(-1, -1, wxEVT_ERASE_BACKGROUND, func)
|
||||
|
||||
def EVT_CHAR(win, func):
|
||||
win.Connect(-1, -1, wxEVT_CHAR, func)
|
||||
|
||||
def EVT_CHAR_HOOK(win, func):
|
||||
win.Connect(-1, -1, wxEVT_CHAR_HOOK, func)
|
||||
|
||||
def EVT_MENU_HIGHLIGHT(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_MENU_HIGHLIGHT, func)
|
||||
|
||||
def EVT_MENU_HIGHLIGHT_ALL(win, func):
|
||||
win.Connect(-1, -1, wxEVT_MENU_HIGHLIGHT, func)
|
||||
|
||||
def EVT_SET_FOCUS(win, func):
|
||||
win.Connect(-1, -1, wxEVT_SET_FOCUS, func)
|
||||
|
||||
def EVT_KILL_FOCUS(win, func):
|
||||
win.Connect(-1, -1, wxEVT_KILL_FOCUS, func)
|
||||
|
||||
def EVT_ACTIVATE(win, func):
|
||||
win.Connect(-1, -1, wxEVT_ACTIVATE, func)
|
||||
|
||||
def EVT_ACTIVATE_APP(win, func):
|
||||
win.Connect(-1, -1, wxEVT_ACTIVATE_APP, func)
|
||||
|
||||
def EVT_END_SESSION(win, func):
|
||||
win.Connect(-1, -1, wxEVT_END_SESSION, func)
|
||||
|
||||
def EVT_QUERY_END_SESSION(win, func):
|
||||
win.Connect(-1, -1, wxEVT_QUERY_END_SESSION, func)
|
||||
|
||||
def EVT_DROP_FILES(win, func):
|
||||
win.Connect(-1, -1, wxEVT_DROP_FILES, func)
|
||||
|
||||
def EVT_INIT_DIALOG(win, func):
|
||||
win.Connect(-1, -1, wxEVT_INIT_DIALOG, func)
|
||||
|
||||
def EVT_SYS_COLOUR_CHANGED(win, func):
|
||||
win.Connect(-1, -1, wxEVT_SYS_COLOUR_CHANGED, func)
|
||||
|
||||
def EVT_SHOW(win, func):
|
||||
win.Connect(-1, -1, wxEVT_SHOW, func)
|
||||
|
||||
def EVT_MAXIMIZE(win, func):
|
||||
win.Connect(-1, -1, wxEVT_MAXIMIZE, func)
|
||||
|
||||
def EVT_ICONIZE(win, func):
|
||||
win.Connect(-1, -1, wxEVT_ICONIZE, func)
|
||||
|
||||
def EVT_NAVIGATION_KEY(win, func):
|
||||
win.Connect(-1, -1, wxEVT_NAVIGATION_KEY, func)
|
||||
|
||||
|
||||
# Mouse Events
|
||||
def EVT_LEFT_DOWN(win, func):
|
||||
win.Connect(-1, -1, wxEVT_LEFT_DOWN, func)
|
||||
|
||||
def EVT_LEFT_UP(win, func):
|
||||
win.Connect(-1, -1, wxEVT_LEFT_UP, func)
|
||||
|
||||
def EVT_MIDDLE_DOWN(win, func):
|
||||
win.Connect(-1, -1, wxEVT_MIDDLE_DOWN, func)
|
||||
|
||||
def EVT_MIDDLE_UP(win, func):
|
||||
win.Connect(-1, -1, wxEVT_MIDDLE_UP, func)
|
||||
|
||||
def EVT_RIGHT_DOWN(win, func):
|
||||
win.Connect(-1, -1, wxEVT_RIGHT_DOWN, func)
|
||||
|
||||
def EVT_RIGHT_UP(win, func):
|
||||
win.Connect(-1, -1, wxEVT_RIGHT_UP, func)
|
||||
|
||||
def EVT_MOTION(win, func):
|
||||
win.Connect(-1, -1, wxEVT_MOTION, func)
|
||||
|
||||
def EVT_LEFT_DCLICK(win, func):
|
||||
win.Connect(-1, -1, wxEVT_LEFT_DCLICK, func)
|
||||
|
||||
def EVT_MIDDLE_DCLICK(win, func):
|
||||
win.Connect(-1, -1, wxEVT_MIDDLE_DCLICK, func)
|
||||
|
||||
def EVT_RIGHT_DCLICK(win, func):
|
||||
win.Connect(-1, -1, wxEVT_RIGHT_DCLICK, func)
|
||||
|
||||
def EVT_LEAVE_WINDOW(win, func):
|
||||
win.Connect(-1, -1, wxEVT_LEAVE_WINDOW, func)
|
||||
|
||||
def EVT_ENTER_WINDOW(win, func):
|
||||
win.Connect(-1, -1, wxEVT_ENTER_WINDOW, func)
|
||||
|
||||
|
||||
# all mouse events
|
||||
def EVT_MOUSE_EVENTS(win, func):
|
||||
win.Connect(-1, -1, wxEVT_LEFT_DOWN, func)
|
||||
win.Connect(-1, -1, wxEVT_LEFT_UP, func)
|
||||
win.Connect(-1, -1, wxEVT_MIDDLE_DOWN, func)
|
||||
win.Connect(-1, -1, wxEVT_MIDDLE_UP, func)
|
||||
win.Connect(-1, -1, wxEVT_RIGHT_DOWN, func)
|
||||
win.Connect(-1, -1, wxEVT_RIGHT_UP, func)
|
||||
win.Connect(-1, -1, wxEVT_MOTION, func)
|
||||
win.Connect(-1, -1, wxEVT_LEFT_DCLICK, func)
|
||||
win.Connect(-1, -1, wxEVT_MIDDLE_DCLICK, func)
|
||||
win.Connect(-1, -1, wxEVT_RIGHT_DCLICK, func)
|
||||
win.Connect(-1, -1, wxEVT_LEAVE_WINDOW, func)
|
||||
win.Connect(-1, -1, wxEVT_ENTER_WINDOW, func)
|
||||
|
||||
# EVT_COMMAND
|
||||
def EVT_COMMAND(win, id, cmd, func):
|
||||
win.Connect(id, -1, cmd, func)
|
||||
|
||||
def EVT_COMMAND_RANGE(win, id1, id2, cmd, func):
|
||||
win.Connect(id1, id2, cmd, func)
|
||||
|
||||
# Scrolling
|
||||
def EVT_SCROLL(win, func):
|
||||
win.Connect(-1, -1, wxEVT_SCROLL_TOP, func)
|
||||
win.Connect(-1, -1, wxEVT_SCROLL_BOTTOM, func)
|
||||
win.Connect(-1, -1, wxEVT_SCROLL_LINEUP, func)
|
||||
win.Connect(-1, -1, wxEVT_SCROLL_LINEDOWN, func)
|
||||
win.Connect(-1, -1, wxEVT_SCROLL_PAGEUP, func)
|
||||
win.Connect(-1, -1, wxEVT_SCROLL_PAGEDOWN, func)
|
||||
win.Connect(-1, -1, wxEVT_SCROLL_THUMBTRACK,func)
|
||||
|
||||
def EVT_SCROLL_TOP(win, func):
|
||||
win.Connect(-1, -1, wxEVT_SCROLL_TOP, func)
|
||||
|
||||
def EVT_SCROLL_BOTTOM(win, func):
|
||||
win.Connect(-1, -1, wxEVT_SCROLL_BOTTOM, func)
|
||||
|
||||
def EVT_SCROLL_LINEUP(win, func):
|
||||
win.Connect(-1, -1, wxEVT_SCROLL_LINEUP, func)
|
||||
|
||||
def EVT_SCROLL_LINEDOWN(win, func):
|
||||
win.Connect(-1, -1, wxEVT_SCROLL_LINEDOWN, func)
|
||||
|
||||
def EVT_SCROLL_PAGEUP(win, func):
|
||||
win.Connect(-1, -1, wxEVT_SCROLL_PAGEUP, func)
|
||||
|
||||
def EVT_SCROLL_PAGEDOWN(win, func):
|
||||
win.Connect(-1, -1, wxEVT_SCROLL_PAGEDOWN, func)
|
||||
|
||||
def EVT_SCROLL_THUMBTRACK(win, func):
|
||||
win.Connect(-1, -1, wxEVT_SCROLL_THUMBTRACK, func)
|
||||
|
||||
|
||||
|
||||
# Scrolling, with an id
|
||||
def EVT_COMMAND_SCROLL(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_SCROLL_TOP, func)
|
||||
win.Connect(id, -1, wxEVT_SCROLL_BOTTOM, func)
|
||||
win.Connect(id, -1, wxEVT_SCROLL_LINEUP, func)
|
||||
win.Connect(id, -1, wxEVT_SCROLL_LINEDOWN, func)
|
||||
win.Connect(id, -1, wxEVT_SCROLL_PAGEUP, func)
|
||||
win.Connect(id, -1, wxEVT_SCROLL_PAGEDOWN, func)
|
||||
win.Connect(id, -1, wxEVT_SCROLL_THUMBTRACK,func)
|
||||
|
||||
def EVT_COMMAND_SCROLL_TOP(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_SCROLL_TOP, func)
|
||||
|
||||
def EVT_COMMAND_SCROLL_BOTTOM(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_SCROLL_BOTTOM, func)
|
||||
|
||||
def EVT_COMMAND_SCROLL_LINEUP(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_SCROLL_LINEUP, func)
|
||||
|
||||
def EVT_COMMAND_SCROLL_LINEDOWN(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_SCROLL_LINEDOWN, func)
|
||||
|
||||
def EVT_COMMAND_SCROLL_PAGEUP(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_SCROLL_PAGEUP, func)
|
||||
|
||||
def EVT_COMMAND_SCROLL_PAGEDOWN(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_SCROLL_PAGEDOWN, func)
|
||||
|
||||
def EVT_COMMAND_SCROLL_THUMBTRACK(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_SCROLL_THUMBTRACK, func)
|
||||
|
||||
|
||||
# Convenience commands
|
||||
def EVT_BUTTON(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_BUTTON_CLICKED, func)
|
||||
|
||||
def EVT_CHECKBOX(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_CHECKBOX_CLICKED, func)
|
||||
|
||||
def EVT_CHOICE(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_CHOICE_SELECTED, func)
|
||||
|
||||
def EVT_LISTBOX(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_LISTBOX_SELECTED, func)
|
||||
|
||||
def EVT_LISTBOX_DCLICK(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, func)
|
||||
|
||||
def EVT_TEXT(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TEXT_UPDATED, func)
|
||||
|
||||
def EVT_TEXT_ENTER(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TEXT_ENTER, func)
|
||||
|
||||
def EVT_MENU(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_MENU_SELECTED, func)
|
||||
|
||||
def EVT_MENU_RANGE(win, id1, id2, func):
|
||||
win.Connect(id1, id2, wxEVT_COMMAND_MENU_SELECTED, func)
|
||||
|
||||
def EVT_SLIDER(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_SLIDER_UPDATED, func)
|
||||
|
||||
def EVT_RADIOBOX(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_RADIOBOX_SELECTED, func)
|
||||
|
||||
def EVT_RADIOBUTTON(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_RADIOBUTTON_SELECTED, func)
|
||||
|
||||
def EVT_VLBOX(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_VLBOX_SELECTED, func)
|
||||
|
||||
def EVT_COMBOBOX(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_COMBOBOX_SELECTED, func)
|
||||
|
||||
def EVT_TOOL(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TOOL_CLICKED, func)
|
||||
|
||||
def EVT_TOOL_RCLICKED(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TOOL_RCLICKED, func)
|
||||
|
||||
def EVT_TOOL_ENTER(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TOOL_ENTER, func)
|
||||
|
||||
def EVT_CHECKLISTBOX(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, func)
|
||||
|
||||
|
||||
# Generic command events
|
||||
|
||||
def EVT_COMMAND_LEFT_CLICK(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_LEFT_CLICK, func)
|
||||
|
||||
def EVT_COMMAND_LEFT_DCLICK(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_LEFT_DCLICK, func)
|
||||
|
||||
def EVT_COMMAND_RIGHT_CLICK(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_RIGHT_CLICK, func)
|
||||
|
||||
def EVT_COMMAND_RIGHT_DCLICK(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_RIGHT_DCLICK, func)
|
||||
|
||||
def EVT_COMMAND_SET_FOCUS(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_SET_FOCUS, func)
|
||||
|
||||
def EVT_COMMAND_KILL_FOCUS(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_KILL_FOCUS, func)
|
||||
|
||||
def EVT_COMMAND_ENTER(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_ENTER, func)
|
||||
|
||||
|
||||
# wxNotebook events
|
||||
def EVT_NOTEBOOK_PAGE_CHANGED(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, func)
|
||||
|
||||
def EVT_NOTEBOOK_PAGE_CHANGING(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, func)
|
||||
|
||||
|
||||
# wxTreeCtrl events
|
||||
def EVT_TREE_BEGIN_DRAG(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TREE_BEGIN_DRAG, func)
|
||||
|
||||
def EVT_TREE_BEGIN_RDRAG(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TREE_BEGIN_RDRAG, func)
|
||||
|
||||
def EVT_TREE_BEGIN_LABEL_EDIT(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, func)
|
||||
|
||||
def EVT_TREE_END_LABEL_EDIT(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TREE_END_LABEL_EDIT, func)
|
||||
|
||||
def EVT_TREE_GET_INFO(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TREE_GET_INFO, func)
|
||||
|
||||
def EVT_TREE_SET_INFO(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TREE_SET_INFO, func)
|
||||
|
||||
def EVT_TREE_ITEM_EXPANDED(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TREE_ITEM_EXPANDED, func)
|
||||
|
||||
def EVT_TREE_ITEM_EXPANDING(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TREE_ITEM_EXPANDING, func)
|
||||
|
||||
def EVT_TREE_ITEM_COLLAPSED(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TREE_ITEM_COLLAPSED, func)
|
||||
|
||||
def EVT_TREE_ITEM_COLLAPSING(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TREE_ITEM_COLLAPSING, func)
|
||||
|
||||
def EVT_TREE_SEL_CHANGED(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TREE_SEL_CHANGED, func)
|
||||
|
||||
def EVT_TREE_SEL_CHANGING(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TREE_SEL_CHANGING, func)
|
||||
|
||||
def EVT_TREE_KEY_DOWN(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TREE_KEY_DOWN, func)
|
||||
|
||||
def EVT_TREE_DELETE_ITEM(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_TREE_DELETE_ITEM, func)
|
||||
|
||||
|
||||
# wxSpinButton
|
||||
def EVT_SPIN_UP(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_SCROLL_LINEUP, func)
|
||||
|
||||
def EVT_SPIN_DOWN(win, id, func):
|
||||
win.Connect(id, -1,wxEVT_SCROLL_LINEDOWN, func)
|
||||
|
||||
def EVT_SPIN(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_SCROLL_TOP, func)
|
||||
win.Connect(id, -1, wxEVT_SCROLL_BOTTOM, func)
|
||||
win.Connect(id, -1, wxEVT_SCROLL_LINEUP, func)
|
||||
win.Connect(id, -1, wxEVT_SCROLL_LINEDOWN, func)
|
||||
win.Connect(id, -1, wxEVT_SCROLL_PAGEUP, func)
|
||||
win.Connect(id, -1, wxEVT_SCROLL_PAGEDOWN, func)
|
||||
win.Connect(id, -1, wxEVT_SCROLL_THUMBTRACK,func)
|
||||
|
||||
|
||||
|
||||
|
||||
# wxTaskBarIcon
|
||||
def EVT_TASKBAR_MOVE(win, func):
|
||||
win.Connect(-1, -1, wxEVT_TASKBAR_MOVE, func)
|
||||
|
||||
def EVT_TASKBAR_LEFT_DOWN(win, func):
|
||||
win.Connect(-1, -1, wxEVT_TASKBAR_LEFT_DOWN, func)
|
||||
|
||||
def EVT_TASKBAR_LEFT_UP(win, func):
|
||||
win.Connect(-1, -1, wxEVT_TASKBAR_LEFT_UP, func)
|
||||
|
||||
def EVT_TASKBAR_RIGHT_DOWN(win, func):
|
||||
win.Connect(-1, -1, wxEVT_TASKBAR_RIGHT_DOWN, func)
|
||||
|
||||
def EVT_TASKBAR_RIGHT_UP(win, func):
|
||||
win.Connect(-1, -1, wxEVT_TASKBAR_RIGHT_UP, func)
|
||||
|
||||
def EVT_TASKBAR_LEFT_DCLICK(win, func):
|
||||
win.Connect(-1, -1, wxEVT_TASKBAR_LEFT_DCLICK, func)
|
||||
|
||||
def EVT_TASKBAR_RIGHT_DCLICK(win, func):
|
||||
win.Connect(-1, -1, wxEVT_TASKBAR_RIGHT_DCLICK, func)
|
||||
|
||||
|
||||
# wxGrid
|
||||
def EVT_GRID_SELECT_CELL(win, fn):
|
||||
win.Connect(-1, -1, wxEVT_GRID_SELECT_CELL, fn)
|
||||
|
||||
def EVT_GRID_CREATE_CELL(win, fn):
|
||||
win.Connect(-1, -1, wxEVT_GRID_CREATE_CELL, fn)
|
||||
|
||||
def EVT_GRID_CHANGE_LABELS(win, fn):
|
||||
win.Connect(-1, -1, wxEVT_GRID_CHANGE_LABELS, fn)
|
||||
|
||||
def EVT_GRID_CHANGE_SEL_LABEL(win, fn):
|
||||
win.Connect(-1, -1, wxEVT_GRID_CHANGE_SEL_LABEL, fn)
|
||||
|
||||
def EVT_GRID_CELL_CHANGE(win, fn):
|
||||
win.Connect(-1, -1, wxEVT_GRID_CELL_CHANGE, fn)
|
||||
|
||||
def EVT_GRID_CELL_LCLICK(win, fn):
|
||||
win.Connect(-1, -1, wxEVT_GRID_CELL_LCLICK, fn)
|
||||
|
||||
def EVT_GRID_CELL_RCLICK(win, fn):
|
||||
win.Connect(-1, -1, wxEVT_GRID_CELL_RCLICK, fn)
|
||||
|
||||
def EVT_GRID_LABEL_LCLICK(win, fn):
|
||||
win.Connect(-1, -1, wxEVT_GRID_LABEL_LCLICK, fn)
|
||||
|
||||
def EVT_GRID_LABEL_RCLICK(win, fn):
|
||||
win.Connect(-1, -1, wxEVT_GRID_LABEL_RCLICK, fn)
|
||||
|
||||
|
||||
# wxSashWindow
|
||||
def EVT_SASH_DRAGGED(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_SASH_DRAGGED, func)
|
||||
|
||||
def EVT_SASH_DRAGGED_RANGE(win, id1, id2, func):
|
||||
win.Connect(id1, id2, wxEVT_SASH_DRAGGED, func)
|
||||
|
||||
def EVT_QUERY_LAYOUT_INFO(win, func):
|
||||
win.Connect(-1, -1, wxEVT_EVT_QUERY_LAYOUT_INFO, func)
|
||||
|
||||
def EVT_CALCULATE_LAYOUT(win, func):
|
||||
win.Connect(-1, -1, wxEVT_EVT_CALCULATE_LAYOUT, func)
|
||||
|
||||
|
||||
# wxListCtrl
|
||||
def EVT_LIST_BEGIN_DRAG(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_LIST_BEGIN_DRAG, func)
|
||||
|
||||
def EVT_LIST_BEGIN_RDRAG(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_LIST_BEGIN_RDRAG, func)
|
||||
|
||||
def EVT_LIST_BEGIN_LABEL_EDIT(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT, func)
|
||||
|
||||
def EVT_LIST_END_LABEL_EDIT(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_LIST_END_LABEL_EDIT, func)
|
||||
|
||||
def EVT_LIST_DELETE_ITEM(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_LIST_DELETE_ITEM, func)
|
||||
|
||||
def EVT_LIST_DELETE_ALL_ITEMS(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS, func)
|
||||
|
||||
def EVT_LIST_GET_INFO(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_LIST_GET_INFO, func)
|
||||
|
||||
def EVT_LIST_SET_INFO(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_LIST_SET_INFO, func)
|
||||
|
||||
def EVT_LIST_ITEM_SELECTED(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_LIST_ITEM_SELECTED, func)
|
||||
|
||||
def EVT_LIST_ITEM_DESELECTED(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_LIST_ITEM_DESELECTED, func)
|
||||
|
||||
def EVT_LIST_KEY_DOWN(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_LIST_KEY_DOWN, func)
|
||||
|
||||
def EVT_LIST_INSERT_ITEM(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_LIST_INSERT_ITEM, func)
|
||||
|
||||
def EVT_LIST_COL_CLICK(win, id, func):
|
||||
win.Connect(id, -1, wxEVT_COMMAND_LIST_COL_CLICK, func)
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
class wxTimer(wxPyTimer):
|
||||
def __init__(self):
|
||||
wxPyTimer.__init__(self, self.Notify) # derived class must provide
|
||||
# Notify(self) method.
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
# Some wxWin methods can take "NULL" as parameters, but the shadow classes
|
||||
# expect an object with the SWIG pointer as a 'this' member. This class
|
||||
# and instance fools the shadow into passing the NULL pointer.
|
||||
|
||||
class NullObj:
|
||||
this = 'NULL' # SWIG converts this to (void*)0
|
||||
|
||||
NULL = NullObj()
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
# aliases
|
||||
|
||||
wxColor = wxColour
|
||||
wxNamedColor = wxNamedColour
|
||||
|
||||
wxPyDefaultPosition.Set(-1,-1)
|
||||
wxPyDefaultSize.Set(-1,-1)
|
||||
|
||||
# aliases so that C++ documentation applies:
|
||||
wxDefaultPosition = wxPyDefaultPosition
|
||||
wxDefaultSize = wxPyDefaultSize
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
## class wxPyStdOutWindow(wxFrame):
|
||||
## def __init__(self, title = "wxPython: stdout/stderr"):
|
||||
## wxFrame.__init__(self, NULL, title)
|
||||
## self.title = title
|
||||
## self.text = wxTextWindow(self)
|
||||
## self.text.SetFont(wxFont(10, wxMODERN, wxNORMAL, wxBOLD))
|
||||
## self.SetSize(-1,-1,400,200)
|
||||
## self.Show(false)
|
||||
## self.isShown = false
|
||||
|
||||
## def write(self, str): # with this method,
|
||||
## if not self.isShown:
|
||||
## self.Show(true)
|
||||
## self.isShown = true
|
||||
## self.text.WriteText(str)
|
||||
|
||||
## def OnCloseWindow(self, event): # doesn't allow the window to close, just hides it
|
||||
## self.Show(false)
|
||||
## self.isShown = false
|
||||
|
||||
|
||||
_defRedirect = (wxPlatform == '__WXMSW__')
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
# The main application class. Derive from this and implement an OnInit
|
||||
# method that creates a frame and then calls self.SetTopWindow(frame)
|
||||
|
||||
class wxApp(wxPyApp):
|
||||
error = 'wxApp.error'
|
||||
|
||||
def __init__(self, redirect=_defRedirect, filename=None):
|
||||
wxPyApp.__init__(self)
|
||||
self.stdioWin = None
|
||||
self.saveStdio = (sys.stdout, sys.stderr)
|
||||
if redirect:
|
||||
self.RedirectStdio(filename)
|
||||
|
||||
# this initializes wxWindows and then calls our OnInit
|
||||
_wxStart(self.OnInit)
|
||||
|
||||
|
||||
def __del__(self):
|
||||
try:
|
||||
self.RestoreStdio()
|
||||
except:
|
||||
pass
|
||||
|
||||
def RedirectStdio(self, filename):
|
||||
if filename:
|
||||
sys.stdout = sys.stderr = open(filename, 'a')
|
||||
else:
|
||||
raise self.error, 'wxPyStdOutWindow not yet implemented.'
|
||||
#self.stdioWin = sys.stdout = sys.stderr = wxPyStdOutWindow()
|
||||
|
||||
def RestoreStdio(self):
|
||||
sys.stdout, sys.stderr = self.saveStdio
|
||||
if self.stdioWin != None:
|
||||
self.stdioWin.Show(false)
|
||||
self.stdioWin.Destroy()
|
||||
self.stdioWin = None
|
||||
|
||||
|
||||
#----------------------------------------------------------------------------
|
||||
#
|
||||
# $Log$
|
||||
# Revision 1.10 1999/02/01 00:10:39 RD
|
||||
# Added the missing EVT_LIST_ITEM_SELECTED and friends.
|
||||
#
|
||||
# Revision 1.9 1999/01/30 07:30:09 RD
|
||||
#
|
||||
# Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
|
||||
#
|
||||
# Various cleanup, tweaks, minor additions, etc. to maintain
|
||||
# compatibility with the current wxWindows.
|
||||
#
|
||||
# Revision 1.8 1999/01/29 21:13:42 HH
|
||||
# Added aliases for wxDefaultPosition and wxDefaultSize (from wxPy..) in _extras,
|
||||
# so that C++ documentation applies.
|
||||
#
|
||||
# Revision 1.7 1998/11/25 08:45:21 RD
|
||||
#
|
||||
# Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
|
||||
# Added events for wxGrid
|
||||
# Other various fixes and additions
|
||||
#
|
||||
# Revision 1.6 1998/11/16 00:00:52 RD
|
||||
# Generic treectrl for wxPython/GTK compiles...
|
||||
#
|
||||
# Revision 1.5 1998/10/20 07:38:02 RD
|
||||
# bug fix
|
||||
#
|
||||
# Revision 1.4 1998/10/20 06:43:54 RD
|
||||
# New wxTreeCtrl wrappers (untested)
|
||||
# some changes in helpers
|
||||
# etc.
|
||||
#
|
||||
# Revision 1.3 1998/10/02 06:40:33 RD
|
||||
#
|
||||
# Version 0.4 of wxPython for MSW.
|
||||
#
|
||||
# Revision 1.2 1998/08/18 19:48:12 RD
|
||||
# more wxGTK compatibility things.
|
||||
#
|
||||
# It builds now but there are serious runtime problems...
|
||||
#
|
||||
# Revision 1.1 1998/08/09 08:25:49 RD
|
||||
# Initial version
|
||||
#
|
||||
#
|
||||
|
||||
359
utils/wxPython/src/cmndlgs.i
Normal file
359
utils/wxPython/src/cmndlgs.i
Normal file
@@ -0,0 +1,359 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: cmndlgs.i
|
||||
// Purpose: SWIG definitions for the Common Dialog Classes
|
||||
//
|
||||
// Author: Robin Dunn
|
||||
//
|
||||
// Created: 7/25/98
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 1998 by Total Control Software
|
||||
// Licence: wxWindows license
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
%module cmndlgs
|
||||
|
||||
%{
|
||||
#include "helpers.h"
|
||||
#include <wx/colordlg.h>
|
||||
#include <wx/dirdlg.h>
|
||||
#include <wx/fontdlg.h>
|
||||
#include <wx/printdlg.h>
|
||||
%}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
%include typemaps.i
|
||||
%include my_typemaps.i
|
||||
|
||||
// Import some definitions of other classes, etc.
|
||||
%import _defs.i
|
||||
%import misc.i
|
||||
%import gdi.i
|
||||
%import windows.i
|
||||
|
||||
%pragma(python) code = "import wx"
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxColourData {
|
||||
public:
|
||||
wxColourData();
|
||||
~wxColourData();
|
||||
|
||||
bool GetChooseFull();
|
||||
wxColour& GetColour();
|
||||
wxColour GetCustomColour(int i);
|
||||
void SetChooseFull(int flag);
|
||||
void SetColour(const wxColour& colour);
|
||||
void SetCustomColour(int i, const wxColour& colour);
|
||||
};
|
||||
|
||||
|
||||
class wxColourDialog : public wxDialog {
|
||||
public:
|
||||
wxColourDialog(wxWindow* parent, wxColourData* data = NULL);
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
|
||||
|
||||
wxColourData& GetColourData();
|
||||
int ShowModal();
|
||||
};
|
||||
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxDirDialog : public wxDialog {
|
||||
public:
|
||||
wxDirDialog(wxWindow* parent,
|
||||
char* message = "Choose a directory",
|
||||
char* defaultPath = "",
|
||||
long style = 0,
|
||||
const wxPoint& pos = wxPyDefaultPosition);
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
|
||||
|
||||
wxString GetPath();
|
||||
wxString GetMessage();
|
||||
long GetStyle();
|
||||
void SetMessage(const wxString& message);
|
||||
void SetPath(const wxString& path);
|
||||
int ShowModal();
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxFileDialog : public wxDialog {
|
||||
public:
|
||||
wxFileDialog(wxWindow* parent,
|
||||
char* message = "Choose a file",
|
||||
char* defaultDir = "",
|
||||
char* defaultFile = "",
|
||||
char* wildcard = "*.*",
|
||||
long style = 0,
|
||||
const wxPoint& pos = wxPyDefaultPosition);
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
|
||||
|
||||
wxString GetDirectory();
|
||||
wxString GetFilename();
|
||||
int GetFilterIndex();
|
||||
wxString GetMessage();
|
||||
wxString GetPath();
|
||||
long GetStyle();
|
||||
wxString GetWildcard();
|
||||
void SetDirectory(const wxString& directory);
|
||||
void SetFilename(const wxString& setfilename);
|
||||
void SetFilterIndex(int filterIndex);
|
||||
void SetMessage(const wxString& message);
|
||||
void SetPath(const wxString& path);
|
||||
void SetStyle(long style);
|
||||
void SetWildcard(const wxString& wildCard);
|
||||
int ShowModal();
|
||||
};
|
||||
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
//TODO: wxMultipleChoiceDialog
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxSingleChoiceDialog : public wxDialog {
|
||||
public:
|
||||
%addmethods {
|
||||
// TODO: ignoring clientData for now...
|
||||
// SWIG is messing up the &/*'s for some reason.
|
||||
wxSingleChoiceDialog(wxWindow* parent,
|
||||
wxString* message,
|
||||
wxString* caption,
|
||||
int LCOUNT, wxString* LIST,
|
||||
//char** clientData = NULL,
|
||||
long style = wxOK | wxCANCEL | wxCENTRE,
|
||||
wxPoint* pos = &wxPyDefaultPosition) {
|
||||
return new wxSingleChoiceDialog(parent, *message, *caption,
|
||||
LCOUNT, LIST, NULL, style, *pos);
|
||||
}
|
||||
}
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
|
||||
|
||||
int GetSelection();
|
||||
wxString GetStringSelection();
|
||||
void SetSelection(int sel);
|
||||
int ShowModal();
|
||||
};
|
||||
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxTextEntryDialog : public wxDialog {
|
||||
public:
|
||||
wxTextEntryDialog(wxWindow* parent,
|
||||
char* message,
|
||||
char* caption = "Input Text",
|
||||
char* defaultValue = "",
|
||||
long style = wxOK | wxCANCEL | wxCENTRE,
|
||||
const wxPoint& pos = wxPyDefaultPosition);
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
|
||||
|
||||
wxString GetValue();
|
||||
void SetValue(const wxString& value);
|
||||
int ShowModal();
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxFontData {
|
||||
public:
|
||||
wxFontData();
|
||||
~wxFontData();
|
||||
|
||||
void EnableEffects(bool enable);
|
||||
bool GetAllowSymbols();
|
||||
wxColour& GetColour();
|
||||
wxFont GetChosenFont();
|
||||
bool GetEnableEffects();
|
||||
wxFont GetInitialFont();
|
||||
bool GetShowHelp();
|
||||
void SetAllowSymbols(bool allowSymbols);
|
||||
void SetChosenFont(const wxFont& font);
|
||||
void SetColour(const wxColour& colour);
|
||||
void SetInitialFont(const wxFont& font);
|
||||
void SetRange(int min, int max);
|
||||
void SetShowHelp(bool showHelp);
|
||||
};
|
||||
|
||||
|
||||
class wxFontDialog : public wxDialog {
|
||||
public:
|
||||
wxFontDialog(wxWindow* parent, wxFontData* data = NULL);
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
|
||||
|
||||
wxFontData& GetFontData();
|
||||
int ShowModal();
|
||||
};
|
||||
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxPageSetupData {
|
||||
public:
|
||||
wxPageSetupData();
|
||||
~wxPageSetupData();
|
||||
|
||||
void EnableHelp(bool flag);
|
||||
void EnableMargins(bool flag);
|
||||
void EnableOrientation(bool flag);
|
||||
void EnablePaper(bool flag);
|
||||
void EnablePrinter(bool flag);
|
||||
wxPoint GetPaperSize();
|
||||
wxPoint GetMarginTopLeft();
|
||||
wxPoint GetMarginBottomRight();
|
||||
wxPoint GetMinMarginTopLeft();
|
||||
wxPoint GetMinMarginBottomRight();
|
||||
int GetOrientation();
|
||||
bool GetDefaultMinMargins();
|
||||
bool GetEnableMargins();
|
||||
bool GetEnableOrientation();
|
||||
bool GetEnablePaper();
|
||||
bool GetEnablePrinter();
|
||||
bool GetEnableHelp();
|
||||
bool GetDefaultInfo();
|
||||
void SetPaperSize(const wxPoint& size);
|
||||
void SetMarginTopLeft(const wxPoint& pt);
|
||||
void SetMarginBottomRight(const wxPoint& pt);
|
||||
void SetMinMarginTopLeft(const wxPoint& pt);
|
||||
void SetMinMarginBottomRight(const wxPoint& pt);
|
||||
void SetOrientation(int orientation);
|
||||
void SetDefaultMinMargins(bool flag);
|
||||
void SetDefaultInfo(bool flag);
|
||||
};
|
||||
|
||||
|
||||
class wxPageSetupDialog : public wxDialog {
|
||||
public:
|
||||
wxPageSetupDialog(wxWindow* parent, wxPageSetupData* data = NULL);
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
|
||||
|
||||
wxPageSetupData& GetPageSetupData();
|
||||
int ShowModal();
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxPrintData {
|
||||
public:
|
||||
wxPrintData();
|
||||
~wxPrintData();
|
||||
|
||||
void EnableHelp(bool flag);
|
||||
void EnablePageNumbers(bool flag);
|
||||
void EnablePrintToFile(bool flag);
|
||||
void EnableSelection(bool flag);
|
||||
bool GetAllPages();
|
||||
bool GetCollate();
|
||||
int GetFromPage();
|
||||
int GetMaxPage();
|
||||
int GetMinPage();
|
||||
int GetNoCopies();
|
||||
int GetOrientation();
|
||||
int GetToPage();
|
||||
void SetCollate(bool flag);
|
||||
void SetFromPage(int page);
|
||||
void SetMaxPage(int page);
|
||||
void SetMinPage(int page);
|
||||
void SetOrientation(int orientation);
|
||||
void SetNoCopies(int n);
|
||||
void SetPrintToFile(bool flag);
|
||||
void SetSetupDialog(bool flag);
|
||||
void SetToPage(int page);
|
||||
};
|
||||
|
||||
|
||||
class wxPrintDialog : public wxDialog {
|
||||
public:
|
||||
wxPrintDialog(wxWindow* parent, wxPrintData* data = NULL);
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
|
||||
|
||||
wxPrintData& GetPrintData();
|
||||
%new wxDC* GetPrintDC();
|
||||
int ShowModal();
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxMessageDialog : public wxDialog {
|
||||
public:
|
||||
wxMessageDialog(wxWindow* parent,
|
||||
char* message,
|
||||
char* caption = "Message box",
|
||||
long style = wxOK | wxCANCEL | wxCENTRE,
|
||||
const wxPoint& pos = wxPyDefaultPosition);
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdDialogCallbacks(self)"
|
||||
|
||||
int ShowModal();
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// $Log$
|
||||
// Revision 1.8 1998/12/17 14:07:25 RR
|
||||
// Removed minor differences between wxMSW and wxGTK
|
||||
//
|
||||
// Revision 1.7 1998/12/15 20:41:14 RD
|
||||
// Changed the import semantics from "from wxPython import *" to "from
|
||||
// wxPython.wx import *" This is for people who are worried about
|
||||
// namespace pollution, they can use "from wxPython import wx" and then
|
||||
// prefix all the wxPython identifiers with "wx."
|
||||
//
|
||||
// Added wxTaskbarIcon for wxMSW.
|
||||
//
|
||||
// Made the events work for wxGrid.
|
||||
//
|
||||
// Added wxConfig.
|
||||
//
|
||||
// Added wxMiniFrame for wxGTK, (untested.)
|
||||
//
|
||||
// Changed many of the args and return values that were pointers to gdi
|
||||
// objects to references to reflect changes in the wxWindows API.
|
||||
//
|
||||
// Other assorted fixes and additions.
|
||||
//
|
||||
// Revision 1.6 1998/11/25 08:45:22 RD
|
||||
//
|
||||
// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
|
||||
// Added events for wxGrid
|
||||
// Other various fixes and additions
|
||||
//
|
||||
// Revision 1.5 1998/11/15 23:03:43 RD
|
||||
// Removing some ifdef's for wxGTK
|
||||
//
|
||||
// Revision 1.4 1998/10/02 06:40:34 RD
|
||||
//
|
||||
// Version 0.4 of wxPython for MSW.
|
||||
//
|
||||
// Revision 1.3 1998/08/18 19:48:13 RD
|
||||
// more wxGTK compatibility things.
|
||||
//
|
||||
// It builds now but there are serious runtime problems...
|
||||
//
|
||||
// Revision 1.2 1998/08/15 07:36:25 RD
|
||||
// - Moved the header in the .i files out of the code that gets put into
|
||||
// the .cpp files. It caused CVS conflicts because of the RCS ID being
|
||||
// different each time.
|
||||
//
|
||||
// - A few minor fixes.
|
||||
//
|
||||
// Revision 1.1 1998/08/09 08:25:49 RD
|
||||
// Initial version
|
||||
//
|
||||
//
|
||||
|
||||
543
utils/wxPython/src/controls.i
Normal file
543
utils/wxPython/src/controls.i
Normal file
@@ -0,0 +1,543 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: controls.i
|
||||
// Purpose: Control (widget) classes for wxPython
|
||||
//
|
||||
// Author: Robin Dunn
|
||||
//
|
||||
// Created: 6/10/98
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 1998 by Total Control Software
|
||||
// Licence: wxWindows license
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
%module controls
|
||||
|
||||
%{
|
||||
#include "helpers.h"
|
||||
#include <wx/slider.h>
|
||||
#include <wx/spinbutt.h>
|
||||
|
||||
#ifdef __WXMSW__
|
||||
#if wxUSE_OWNER_DRAWN
|
||||
#include <wx/checklst.h>
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef __WXGTK__
|
||||
#include <wx/checklst.h>
|
||||
#endif
|
||||
%}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
%include typemaps.i
|
||||
%include my_typemaps.i
|
||||
|
||||
// Import some definitions of other classes, etc.
|
||||
%import _defs.i
|
||||
%import misc.i
|
||||
%import windows.i
|
||||
%import gdi.i
|
||||
%import events.i
|
||||
|
||||
%pragma(python) code = "import wx"
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
%{
|
||||
wxValidator wxPyDefaultValidator; // Non-const default because of SWIG
|
||||
%}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxControl : public wxWindow {
|
||||
public:
|
||||
void Command(wxCommandEvent& event);
|
||||
wxString GetLabel();
|
||||
void SetLabel(const wxString& label);
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxButton : public wxControl {
|
||||
public:
|
||||
wxButton(wxWindow* parent, wxWindowID id, const wxString& label,
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
long style = 0,
|
||||
const wxValidator& validator = wxPyDefaultValidator,
|
||||
char* name = "button");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
|
||||
|
||||
void SetDefault();
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxBitmapButton : public wxButton {
|
||||
public:
|
||||
wxBitmapButton(wxWindow* parent, wxWindowID id, const wxBitmap& bitmap,
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
long style = wxBU_AUTODRAW,
|
||||
const wxValidator& validator = wxPyDefaultValidator,
|
||||
char* name = "button");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
|
||||
|
||||
wxBitmap& GetBitmapLabel();
|
||||
wxBitmap& GetBitmapDisabled();
|
||||
wxBitmap& GetBitmapFocus();
|
||||
wxBitmap& GetBitmapSelected();
|
||||
void SetBitmapDisabled(const wxBitmap& bitmap);
|
||||
void SetBitmapFocus(const wxBitmap& bitmap);
|
||||
void SetBitmapSelected(const wxBitmap& bitmap);
|
||||
void SetBitmapLabel(const wxBitmap& bitmap);
|
||||
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxCheckBox : public wxControl {
|
||||
public:
|
||||
wxCheckBox(wxWindow* parent, wxWindowID id, const wxString& label,
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
long style = 0,
|
||||
const wxValidator& val = wxPyDefaultValidator,
|
||||
char* name = "checkBox");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
|
||||
|
||||
bool GetValue();
|
||||
void SetValue(const bool state);
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxChoice : public wxControl {
|
||||
public:
|
||||
wxChoice(wxWindow *parent, wxWindowID id,
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
int LCOUNT=0, wxString* LIST=NULL,
|
||||
long style = 0,
|
||||
const wxValidator& validator = wxPyDefaultValidator,
|
||||
char* name = "choice");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
|
||||
|
||||
void Append(const wxString& item);
|
||||
void Clear();
|
||||
int FindString(const wxString& string);
|
||||
int GetColumns();
|
||||
int GetSelection();
|
||||
wxString GetString(const int n);
|
||||
wxString GetStringSelection();
|
||||
int Number();
|
||||
void SetColumns(const int n = 1);
|
||||
void SetSelection(const int n);
|
||||
void SetStringSelection(const wxString& string);
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxComboBox : public wxControl {
|
||||
public:
|
||||
wxComboBox(wxWindow* parent, wxWindowID id, char* value = "",
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
int LCOUNT=0, wxString* LIST=NULL,
|
||||
long style = 0,
|
||||
const wxValidator& validator = wxPyDefaultValidator,
|
||||
char* name = "comboBox");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
|
||||
|
||||
void Append(const wxString& item);
|
||||
// TODO: void Append(const wxString& item, char* clientData);
|
||||
void Clear();
|
||||
void Copy();
|
||||
void Cut();
|
||||
void Delete(int n);
|
||||
// NotMember??: void Deselect(int n);
|
||||
int FindString(const wxString& string);
|
||||
// TODO: char* GetClientData(const int n);
|
||||
long GetInsertionPoint();
|
||||
long GetLastPosition();
|
||||
int GetSelection();
|
||||
wxString GetString(int n);
|
||||
wxString GetStringSelection();
|
||||
wxString GetValue();
|
||||
int Number();
|
||||
void Paste();
|
||||
void Replace(long from, long to, const wxString& text);
|
||||
void Remove(long from, long to);
|
||||
// TODO: void SetClientData(const int n, char* data);
|
||||
void SetInsertionPoint(long pos);
|
||||
void SetInsertionPointEnd();
|
||||
void SetSelection(int n, bool select = TRUE);
|
||||
%name(SetMark)void SetSelection(long from, long to);
|
||||
void SetValue(const wxString& text);
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxGauge : public wxControl {
|
||||
public:
|
||||
wxGauge(wxWindow* parent, wxWindowID id, int range,
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
long style = wxGA_HORIZONTAL,
|
||||
const wxValidator& validator = wxPyDefaultValidator,
|
||||
char* name = "gauge");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
|
||||
|
||||
int GetBezelFace();
|
||||
int GetRange();
|
||||
int GetShadowWidth();
|
||||
int GetValue();
|
||||
void SetBezelFace(int width);
|
||||
void SetRange(int range);
|
||||
void SetShadowWidth(int width);
|
||||
void SetValue(int pos);
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxStaticBox : public wxControl {
|
||||
public:
|
||||
wxStaticBox(wxWindow* parent, wxWindowID id, const wxString& label,
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
long style = 0,
|
||||
char* name = "staticBox");
|
||||
};
|
||||
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxStaticText : public wxControl {
|
||||
public:
|
||||
wxStaticText(wxWindow* parent, wxWindowID id, const wxString& label,
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
long style = 0,
|
||||
char* name = "staticText");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
|
||||
|
||||
wxString GetLabel();
|
||||
void SetLabel(const wxString& label);
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxListBox : public wxControl {
|
||||
public:
|
||||
wxListBox(wxWindow* parent, wxWindowID id,
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
int LCOUNT, wxString* LIST = NULL,
|
||||
long style = 0,
|
||||
const wxValidator& validator = wxPyDefaultValidator,
|
||||
char* name = "listBox");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
|
||||
|
||||
void Append(const wxString& item);
|
||||
// TODO: void Append(const wxString& item, char* clientData);
|
||||
void Clear();
|
||||
void Delete(int n);
|
||||
void Deselect(int n);
|
||||
int FindString(const wxString& string);
|
||||
// TODO: char* GetClientData(const int n);
|
||||
int GetSelection();
|
||||
// TODO: int GetSelections(int **selections);
|
||||
wxString GetString(int n);
|
||||
wxString GetStringSelection();
|
||||
int Number();
|
||||
bool Selected(const int n);
|
||||
void Set(int LCOUNT, wxString* LIST);
|
||||
// TODO: void SetClientData(const int n, char* data);
|
||||
void SetFirstItem(int n);
|
||||
%name(SetFirstItemStr)void SetFirstItem(const wxString& string);
|
||||
void SetSelection(int n, bool select = TRUE);
|
||||
void SetString(int n, const wxString& string);
|
||||
void SetStringSelection(const wxString& string, bool select = TRUE);
|
||||
};
|
||||
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxCheckListBox : public wxListBox {
|
||||
public:
|
||||
wxCheckListBox(wxWindow *parent, wxWindowID id,
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
int LCOUNT = 0,
|
||||
wxString* LIST = NULL,
|
||||
long style = 0,
|
||||
const wxValidator& validator = wxPyDefaultValidator,
|
||||
char* name = "listBox");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
|
||||
|
||||
bool IsChecked(int uiIndex);
|
||||
void Check(int uiIndex, bool bCheck = TRUE);
|
||||
|
||||
int GetItemHeight();
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxTextCtrl : public wxControl {
|
||||
public:
|
||||
wxTextCtrl(wxWindow* parent, wxWindowID id, char* value = "",
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
long style = 0,
|
||||
const wxValidator& validator = wxPyDefaultValidator,
|
||||
char* name = "text");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
|
||||
|
||||
void Clear();
|
||||
void Copy();
|
||||
void Cut();
|
||||
void DiscardEdits();
|
||||
long GetInsertionPoint();
|
||||
long GetLastPosition();
|
||||
int GetLineLength(long lineNo);
|
||||
wxString GetLineText(long lineNo);
|
||||
int GetNumberOfLines();
|
||||
wxString GetValue();
|
||||
bool IsModified();
|
||||
bool LoadFile(const wxString& filename);
|
||||
void Paste();
|
||||
void PositionToXY(long pos, long *OUTPUT, long *OUTPUT);
|
||||
void Remove(long from, long to);
|
||||
void Replace(long from, long to, const wxString& value);
|
||||
bool SaveFile(const wxString& filename);
|
||||
void SetEditable(bool editable);
|
||||
void SetInsertionPoint(long pos);
|
||||
void SetInsertionPointEnd();
|
||||
void SetSelection(long from, long to);
|
||||
void SetValue(const wxString& value);
|
||||
void ShowPosition(long pos);
|
||||
void WriteText(const wxString& text);
|
||||
long XYToPosition(long x, long y);
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxScrollBar : public wxControl {
|
||||
public:
|
||||
wxScrollBar(wxWindow* parent, wxWindowID id = -1,
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
long style = wxSB_HORIZONTAL,
|
||||
const wxValidator& validator = wxPyDefaultValidator,
|
||||
char* name = "scrollBar");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
|
||||
|
||||
int GetRange();
|
||||
int GetPageSize();
|
||||
int GetThumbPosition();
|
||||
int GetThumbSize();
|
||||
void SetThumbPosition(int viewStart);
|
||||
void SetScrollbar(int position, int thumbSize,
|
||||
int range, int pageSize,
|
||||
bool refresh = TRUE);
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxSpinButton : public wxControl {
|
||||
public:
|
||||
wxSpinButton(wxWindow* parent, wxWindowID id = -1,
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
long style = wxSP_HORIZONTAL,
|
||||
char* name = "spinButton");
|
||||
|
||||
int GetMax();
|
||||
int GetMin();
|
||||
int GetValue();
|
||||
void SetRange(int min, int max);
|
||||
void SetValue(int value);
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxStaticBitmap : public wxControl {
|
||||
public:
|
||||
wxStaticBitmap(wxWindow* parent, wxWindowID id,
|
||||
const wxBitmap& bitmap,
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
long style = 0,
|
||||
char* name = "staticBitmap");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
|
||||
|
||||
wxBitmap& GetBitmap();
|
||||
void SetBitmap(const wxBitmap& bitmap);
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxRadioBox : public wxControl {
|
||||
public:
|
||||
wxRadioBox(wxWindow* parent, wxWindowID id,
|
||||
const wxString& label,
|
||||
const wxPoint& point = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
int LCOUNT = 0, wxString* LIST = NULL,
|
||||
int majorDimension = 0,
|
||||
long style = wxRA_HORIZONTAL,
|
||||
const wxValidator& validator = wxPyDefaultValidator,
|
||||
char* name = "radioBox");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
|
||||
|
||||
%name(EnableBox)void Enable(bool enable);
|
||||
void Enable(int n, bool enable);
|
||||
int FindString(const wxString& string);
|
||||
#ifdef __WXMSW__
|
||||
%name(GetBoxLabel)wxString GetLabel();
|
||||
#endif
|
||||
wxString GetLabel(int n);
|
||||
int GetSelection();
|
||||
wxString GetString(int n);
|
||||
wxString GetStringSelection();
|
||||
int Number();
|
||||
%name(SetBoxLabel)void SetLabel(const wxString& label);
|
||||
void SetLabel(int n, const wxString& label);
|
||||
void SetSelection(int n);
|
||||
void SetStringSelection(const wxString& string);
|
||||
void Show(bool show);
|
||||
%name(ShowItem)void Show(int item, bool show);
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxRadioButton : public wxControl {
|
||||
public:
|
||||
wxRadioButton(wxWindow* parent, wxWindowID id,
|
||||
const wxString& label,
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
long style = 0,
|
||||
const wxValidator& validator = wxPyDefaultValidator,
|
||||
char* name = "radioButton");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
|
||||
|
||||
bool GetValue();
|
||||
void SetValue(bool value);
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxSlider : public wxControl {
|
||||
public:
|
||||
wxSlider(wxWindow* parent, wxWindowID id,
|
||||
int value, int minValue, int maxValue,
|
||||
const wxPoint& point = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
long style = wxSL_HORIZONTAL,
|
||||
const wxValidator& validator = wxPyDefaultValidator,
|
||||
char* name = "slider");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
|
||||
|
||||
void ClearSel();
|
||||
void ClearTicks();
|
||||
int GetLineSize();
|
||||
int GetMax();
|
||||
int GetMin();
|
||||
int GetPageSize();
|
||||
int GetSelEnd();
|
||||
int GetSelStart();
|
||||
int GetThumbLength();
|
||||
int GetTickFreq();
|
||||
int GetValue();
|
||||
void SetRange(int minValue, int maxValue);
|
||||
void SetTickFreq(int n, int pos);
|
||||
void SetLineSize(int lineSize);
|
||||
void SetPageSize(int pageSize);
|
||||
void SetSelection(int startPos, int endPos);
|
||||
void SetThumbLength(int len);
|
||||
void SetTick(int tickPos);
|
||||
void SetValue(int value);
|
||||
};
|
||||
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// $Log$
|
||||
// Revision 1.10 1998/12/17 17:52:19 RD
|
||||
// wxPython 0.5.2
|
||||
// Minor fixes and SWIG code generation for RR's changes. MSW and GTK
|
||||
// versions are much closer now!
|
||||
//
|
||||
// Revision 1.9 1998/12/17 14:07:29 RR
|
||||
//
|
||||
// Removed minor differences between wxMSW and wxGTK
|
||||
//
|
||||
// Revision 1.8 1998/12/15 20:41:15 RD
|
||||
// Changed the import semantics from "from wxPython import *" to "from
|
||||
// wxPython.wx import *" This is for people who are worried about
|
||||
// namespace pollution, they can use "from wxPython import wx" and then
|
||||
// prefix all the wxPython identifiers with "wx."
|
||||
//
|
||||
// Added wxTaskbarIcon for wxMSW.
|
||||
//
|
||||
// Made the events work for wxGrid.
|
||||
//
|
||||
// Added wxConfig.
|
||||
//
|
||||
// Added wxMiniFrame for wxGTK, (untested.)
|
||||
//
|
||||
// Changed many of the args and return values that were pointers to gdi
|
||||
// objects to references to reflect changes in the wxWindows API.
|
||||
//
|
||||
// Other assorted fixes and additions.
|
||||
//
|
||||
// Revision 1.7 1998/11/16 00:00:53 RD
|
||||
// Generic treectrl for wxPython/GTK compiles...
|
||||
//
|
||||
// Revision 1.6 1998/11/15 23:03:43 RD
|
||||
// Removing some ifdef's for wxGTK
|
||||
//
|
||||
// Revision 1.5 1998/10/07 07:34:32 RD
|
||||
// Version 0.4.1 for wxGTK
|
||||
//
|
||||
// Revision 1.4 1998/10/02 06:40:35 RD
|
||||
//
|
||||
// Version 0.4 of wxPython for MSW.
|
||||
//
|
||||
// Revision 1.3 1998/08/18 19:48:14 RD
|
||||
// more wxGTK compatibility things.
|
||||
//
|
||||
// It builds now but there are serious runtime problems...
|
||||
//
|
||||
// Revision 1.2 1998/08/15 07:36:28 RD
|
||||
// - Moved the header in the .i files out of the code that gets put into
|
||||
// the .cpp files. It caused CVS conflicts because of the RCS ID being
|
||||
// different each time.
|
||||
//
|
||||
// - A few minor fixes.
|
||||
//
|
||||
// Revision 1.1 1998/08/09 08:25:49 RD
|
||||
// Initial version
|
||||
//
|
||||
//
|
||||
|
||||
451
utils/wxPython/src/controls2.i
Normal file
451
utils/wxPython/src/controls2.i
Normal file
@@ -0,0 +1,451 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: controls2.i
|
||||
// Purpose: More control (widget) classes for wxPython
|
||||
//
|
||||
// Author: Robin Dunn
|
||||
//
|
||||
// Created: 6/10/98
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 1998 by Total Control Software
|
||||
// Licence: wxWindows license
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
%module controls2
|
||||
|
||||
%{
|
||||
#include "helpers.h"
|
||||
#include <wx/listctrl.h>
|
||||
#include <wx/treectrl.h>
|
||||
%}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
%include typemaps.i
|
||||
%include my_typemaps.i
|
||||
|
||||
// Import some definitions of other classes, etc.
|
||||
%import _defs.i
|
||||
%import misc.i
|
||||
%import windows.i
|
||||
%import gdi.i
|
||||
%import events.i
|
||||
%import controls.i
|
||||
|
||||
%pragma(python) code = "import wx"
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
%{
|
||||
extern wxValidator wxPyDefaultValidator;
|
||||
%}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxListItem {
|
||||
public:
|
||||
long m_mask; // Indicates what fields are valid
|
||||
long m_itemId; // The zero-based item position
|
||||
int m_col; // Zero-based column, if in report mode
|
||||
long m_state; // The state of the item
|
||||
long m_stateMask; // Which flags of m_state are valid (uses same flags)
|
||||
wxString m_text; // The label/header text
|
||||
int m_image; // The zero-based index into an image list
|
||||
long m_data; // App-defined data
|
||||
// wxColour *m_colour; // only wxGLC, not supported by Windows ;->
|
||||
|
||||
// For columns only
|
||||
int m_format; // left, right, centre
|
||||
int m_width; // width of column
|
||||
|
||||
wxListItem();
|
||||
~wxListItem();
|
||||
};
|
||||
|
||||
class wxListEvent: public wxCommandEvent {
|
||||
public:
|
||||
int m_code;
|
||||
long m_itemIndex;
|
||||
long m_oldItemIndex;
|
||||
int m_col;
|
||||
bool m_cancelled;
|
||||
wxPoint m_pointDrag;
|
||||
wxListItem m_item;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
class wxListCtrl : public wxControl {
|
||||
public:
|
||||
wxListCtrl(wxWindow* parent, wxWindowID id,
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
long style = wxLC_ICON,
|
||||
const wxValidator& validator = wxPyDefaultValidator,
|
||||
char* name = "listCtrl");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
|
||||
|
||||
bool Arrange(int flag = wxLIST_ALIGN_DEFAULT);
|
||||
bool DeleteItem(long item);
|
||||
bool DeleteAllItems();
|
||||
bool DeleteColumn(int col);
|
||||
bool DeleteAllColumns(void);
|
||||
void ClearAll(void);
|
||||
#ifdef __WXMSW__
|
||||
wxTextCtrl* EditLabel(long item);
|
||||
bool EndEditLabel(bool cancel);
|
||||
wxTextCtrl* GetEditControl();
|
||||
#endif
|
||||
bool EnsureVisible(long item);
|
||||
long FindItem(long start, const wxString& str, bool partial = FALSE);
|
||||
%name(FindItemData)long FindItem(long start, long data);
|
||||
%name(FindItemAtPos)long FindItem(long start, const wxPoint& pt,
|
||||
int direction);
|
||||
bool GetColumn(int col, wxListItem& item);
|
||||
int GetColumnWidth(int col);
|
||||
int GetCountPerPage();
|
||||
wxImageList* GetImageList(int which);
|
||||
long GetItemData(long item);
|
||||
|
||||
%addmethods {
|
||||
%new wxListItem* GetItem() {
|
||||
wxListItem* info = new wxListItem;
|
||||
self->GetItem(*info);
|
||||
return info;
|
||||
}
|
||||
%new wxPoint* GetItemPosition(long item) {
|
||||
wxPoint* pos = new wxPoint;
|
||||
self->GetItemPosition(item, *pos);
|
||||
return pos;
|
||||
}
|
||||
%new wxRect* GetItemRect(long item, int code = wxLIST_RECT_BOUNDS) {
|
||||
wxRect* rect= new wxRect;
|
||||
self->GetItemRect(item, *rect, code);
|
||||
return rect;
|
||||
}
|
||||
}
|
||||
|
||||
int GetItemState(long item, long stateMask);
|
||||
int GetItemCount();
|
||||
int GetItemSpacing(bool isSmall);
|
||||
wxString GetItemText(long item);
|
||||
long GetNextItem(long item,
|
||||
int geometry = wxLIST_NEXT_ALL,
|
||||
int state = wxLIST_STATE_DONTCARE);
|
||||
int GetSelectedItemCount();
|
||||
#ifdef __WXMSW__
|
||||
wxColour GetTextColour();
|
||||
void SetTextColour(const wxColour& col);
|
||||
#endif
|
||||
long GetTopItem();
|
||||
long HitTest(const wxPoint& point, int& OUTPUT);
|
||||
%name(InsertColumnWithInfo)long InsertColumn(long col, wxListItem& info);
|
||||
long InsertColumn(long col, const wxString& heading,
|
||||
int format = wxLIST_FORMAT_LEFT,
|
||||
int width = -1);
|
||||
|
||||
long InsertItem(wxListItem& info);
|
||||
%name(InsertStringItem) long InsertItem(long index, const wxString& label);
|
||||
%name(InsertImageItem) long InsertItem(long index, int imageIndex);
|
||||
%name(InsertImageStringItem)long InsertItem(long index, const wxString& label,
|
||||
int imageIndex);
|
||||
|
||||
bool ScrollList(int dx, int dy);
|
||||
void SetBackgroundColour(const wxColour& col);
|
||||
bool SetColumn(int col, wxListItem& item);
|
||||
bool SetColumnWidth(int col, int width);
|
||||
void SetImageList(wxImageList* imageList, int which);
|
||||
bool SetItem(wxListItem& info);
|
||||
%name(SetItemString)long SetItem(long index, int col, const wxString& label,
|
||||
int imageId = -1);
|
||||
bool SetItemData(long item, long data);
|
||||
bool SetItemImage(long item, int image, int selImage);
|
||||
bool SetItemPosition(long item, const wxPoint& pos);
|
||||
bool SetItemState(long item, long state, long stateMask);
|
||||
void SetItemText(long item, const wxString& text);
|
||||
void SetSingleStyle(long style, bool add = TRUE);
|
||||
void SetWindowStyleFlag(long style);
|
||||
// TODO: bool SortItems(wxListCtrlCompare fn, long data);
|
||||
};
|
||||
|
||||
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
|
||||
class wxTreeItemId {
|
||||
public:
|
||||
wxTreeItemId();
|
||||
~wxTreeItemId();
|
||||
bool IsOk() const { return m_itemId != 0; }
|
||||
|
||||
// %addmethods {
|
||||
// long GetId() { return (long)(*self); }
|
||||
// }
|
||||
};
|
||||
|
||||
|
||||
|
||||
// **** This isn't very useful yet. This needs to be specialized to enable
|
||||
// derived Python classes...
|
||||
class wxTreeItemData {
|
||||
public:
|
||||
wxTreeItemData();
|
||||
~wxTreeItemData();
|
||||
|
||||
const wxTreeItemId& GetId();
|
||||
void SetId(const wxTreeItemId& id);
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
class wxTreeEvent : public wxCommandEvent {
|
||||
public:
|
||||
wxTreeItemId GetItem();
|
||||
wxTreeItemId GetOldItem();
|
||||
wxPoint GetPoint();
|
||||
int GetCode();
|
||||
void Veto();
|
||||
};
|
||||
|
||||
|
||||
// These are for the GetFirstChild/GetNextChild methods below
|
||||
%typemap(python, in) long& INOUT = long* INOUT;
|
||||
%typemap(python, argout) long& INOUT = long* INOUT;
|
||||
|
||||
|
||||
class wxTreeCtrl : public wxControl {
|
||||
public:
|
||||
wxTreeCtrl(wxWindow *parent, wxWindowID id = -1,
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
long style = wxTR_HAS_BUTTONS | wxTR_LINES_AT_ROOT,
|
||||
const wxValidator& validator = wxPyDefaultValidator,
|
||||
char* name = "wxTreeCtrl");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
|
||||
|
||||
size_t GetCount();
|
||||
unsigned int GetIndent();
|
||||
void SetIndent(unsigned int indent);
|
||||
wxImageList *GetImageList();
|
||||
wxImageList *GetStateImageList();
|
||||
void SetImageList(wxImageList *imageList);
|
||||
void SetStateImageList(wxImageList *imageList);
|
||||
|
||||
wxString GetItemText(const wxTreeItemId& item);
|
||||
int GetItemImage(const wxTreeItemId& item);
|
||||
int GetItemSelectedImage(const wxTreeItemId& item);
|
||||
wxTreeItemData *GetItemData(const wxTreeItemId& item);
|
||||
|
||||
void SetItemText(const wxTreeItemId& item, const wxString& text);
|
||||
void SetItemImage(const wxTreeItemId& item, int image);
|
||||
void SetItemSelectedImage(const wxTreeItemId& item, int image);
|
||||
void SetItemData(const wxTreeItemId& item, wxTreeItemData *data);
|
||||
void SetItemHasChildren(const wxTreeItemId& item, bool hasChildren = TRUE);
|
||||
|
||||
bool IsVisible(const wxTreeItemId& item);
|
||||
bool ItemHasChildren(const wxTreeItemId& item);
|
||||
bool IsExpanded(const wxTreeItemId& item);
|
||||
bool IsSelected(const wxTreeItemId& item);
|
||||
|
||||
wxTreeItemId GetRootItem();
|
||||
wxTreeItemId GetSelection();
|
||||
wxTreeItemId GetParent(const wxTreeItemId& item);
|
||||
|
||||
wxTreeItemId GetFirstChild(const wxTreeItemId& item, long& INOUT);
|
||||
wxTreeItemId GetNextChild(const wxTreeItemId& item, long& INOUT);
|
||||
wxTreeItemId GetNextSibling(const wxTreeItemId& item);
|
||||
wxTreeItemId GetPrevSibling(const wxTreeItemId& item);
|
||||
wxTreeItemId GetFirstVisibleItem();
|
||||
wxTreeItemId GetNextVisible(const wxTreeItemId& item);
|
||||
wxTreeItemId GetPrevVisible(const wxTreeItemId& item);
|
||||
|
||||
|
||||
wxTreeItemId AddRoot(const wxString& text,
|
||||
int image = -1, int selectedImage = -1,
|
||||
wxTreeItemData *data = NULL);
|
||||
wxTreeItemId PrependItem(const wxTreeItemId& parent,
|
||||
const wxString& text,
|
||||
int image = -1, int selectedImage = -1,
|
||||
wxTreeItemData *data = NULL);
|
||||
wxTreeItemId InsertItem(const wxTreeItemId& parent,
|
||||
const wxTreeItemId& idPrevious,
|
||||
const wxString& text,
|
||||
int image = -1, int selectedImage = -1,
|
||||
wxTreeItemData *data = NULL);
|
||||
wxTreeItemId AppendItem(const wxTreeItemId& parent,
|
||||
const wxString& text,
|
||||
int image = -1, int selectedImage = -1,
|
||||
wxTreeItemData *data = NULL);
|
||||
|
||||
void Delete(const wxTreeItemId& item);
|
||||
void DeleteChildren(const wxTreeItemId& item);
|
||||
void DeleteAllItems();
|
||||
|
||||
void Expand(const wxTreeItemId& item);
|
||||
void Collapse(const wxTreeItemId& item);
|
||||
void CollapseAndReset(const wxTreeItemId& item);
|
||||
void Toggle(const wxTreeItemId& item);
|
||||
|
||||
void Unselect();
|
||||
void SelectItem(const wxTreeItemId& item);
|
||||
void EnsureVisible(const wxTreeItemId& item);
|
||||
void ScrollTo(const wxTreeItemId& item);
|
||||
|
||||
wxTextCtrl* EditLabel(const wxTreeItemId& item);
|
||||
// **** figure out how to do this
|
||||
// wxClassInfo* textCtrlClass = CLASSINFO(wxTextCtrl));
|
||||
wxTextCtrl* GetEditControl();
|
||||
void EndEditLabel(const wxTreeItemId& item, bool discardChanges = FALSE);
|
||||
|
||||
// void SortChildren(const wxTreeItemId& item);
|
||||
// **** And this too
|
||||
// wxTreeItemCmpFunc *cmpFunction = NULL);
|
||||
|
||||
void SetItemBold(const wxTreeItemId& item, bool bold = TRUE);
|
||||
bool IsBold(const wxTreeItemId& item) const;
|
||||
wxTreeItemId HitTest(const wxPoint& point);
|
||||
};
|
||||
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
#ifdef SKIPTHIS
|
||||
#ifdef __WXMSW__
|
||||
class wxTabEvent : public wxCommandEvent {
|
||||
public:
|
||||
};
|
||||
|
||||
|
||||
|
||||
class wxTabCtrl : public wxControl {
|
||||
public:
|
||||
wxTabCtrl(wxWindow* parent, wxWindowID id,
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
long style = 0,
|
||||
char* name = "tabCtrl");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdWindowCallbacks(self)"
|
||||
|
||||
bool DeleteAllItems();
|
||||
bool DeleteItem(int item);
|
||||
wxImageList* GetImageList();
|
||||
int GetItemCount();
|
||||
// TODO: void* GetItemData();
|
||||
int GetItemImage(int item);
|
||||
|
||||
%addmethods {
|
||||
%new wxRect* GetItemRect(int item) {
|
||||
wxRect* rect = new wxRect;
|
||||
self->GetItemRect(item, *rect);
|
||||
return rect;
|
||||
}
|
||||
}
|
||||
|
||||
wxString GetItemText(int item);
|
||||
bool GetRowCount();
|
||||
int GetSelection();
|
||||
int HitTest(const wxPoint& pt, long& OUTPUT);
|
||||
void InsertItem(int item, const wxString& text,
|
||||
int imageId = -1, void* clientData = NULL);
|
||||
// TODO: bool SetItemData(int item, void* data);
|
||||
bool SetItemImage(int item, int image);
|
||||
void SetImageList(wxImageList* imageList);
|
||||
void SetItemSize(const wxSize& size);
|
||||
bool SetItemText(int item, const wxString& text);
|
||||
void SetPadding(const wxSize& padding);
|
||||
int SetSelection(int item);
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// $Log$
|
||||
// Revision 1.14 1999/01/30 07:30:10 RD
|
||||
// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
|
||||
//
|
||||
// Various cleanup, tweaks, minor additions, etc. to maintain
|
||||
// compatibility with the current wxWindows.
|
||||
//
|
||||
// Revision 1.13 1998/12/17 14:07:34 RR
|
||||
//
|
||||
// Removed minor differences between wxMSW and wxGTK
|
||||
//
|
||||
// Revision 1.12 1998/12/16 22:10:52 RD
|
||||
//
|
||||
// Tweaks needed to be able to build wxPython with wxGTK.
|
||||
//
|
||||
// Revision 1.11 1998/12/15 20:41:16 RD
|
||||
// Changed the import semantics from "from wxPython import *" to "from
|
||||
// wxPython.wx import *" This is for people who are worried about
|
||||
// namespace pollution, they can use "from wxPython import wx" and then
|
||||
// prefix all the wxPython identifiers with "wx."
|
||||
//
|
||||
// Added wxTaskbarIcon for wxMSW.
|
||||
//
|
||||
// Made the events work for wxGrid.
|
||||
//
|
||||
// Added wxConfig.
|
||||
//
|
||||
// Added wxMiniFrame for wxGTK, (untested.)
|
||||
//
|
||||
// Changed many of the args and return values that were pointers to gdi
|
||||
// objects to references to reflect changes in the wxWindows API.
|
||||
//
|
||||
// Other assorted fixes and additions.
|
||||
//
|
||||
// Revision 1.10 1998/11/25 08:45:23 RD
|
||||
//
|
||||
// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
|
||||
// Added events for wxGrid
|
||||
// Other various fixes and additions
|
||||
//
|
||||
// Revision 1.9 1998/11/16 00:00:54 RD
|
||||
// Generic treectrl for wxPython/GTK compiles...
|
||||
//
|
||||
// Revision 1.8 1998/11/11 04:40:20 RD
|
||||
// wxTreeCtrl now works (sort of) for wxPython-GTK. This is the new
|
||||
// TreeCtrl in src/gtk/treectrl.cpp not the old generic one.
|
||||
//
|
||||
// Revision 1.7 1998/11/11 03:12:25 RD
|
||||
//
|
||||
// Additions for wxTreeCtrl
|
||||
//
|
||||
// Revision 1.6 1998/10/20 06:43:55 RD
|
||||
// New wxTreeCtrl wrappers (untested)
|
||||
// some changes in helpers
|
||||
// etc.
|
||||
//
|
||||
// Revision 1.5 1998/10/07 07:34:33 RD
|
||||
// Version 0.4.1 for wxGTK
|
||||
//
|
||||
// Revision 1.4 1998/10/02 06:40:36 RD
|
||||
//
|
||||
// Version 0.4 of wxPython for MSW.
|
||||
//
|
||||
// Revision 1.3 1998/08/18 19:48:15 RD
|
||||
// more wxGTK compatibility things.
|
||||
//
|
||||
// It builds now but there are serious runtime problems...
|
||||
//
|
||||
// Revision 1.2 1998/08/15 07:36:30 RD
|
||||
// - Moved the header in the .i files out of the code that gets put into
|
||||
// the .cpp files. It caused CVS conflicts because of the RCS ID being
|
||||
// different each time.
|
||||
//
|
||||
// - A few minor fixes.
|
||||
//
|
||||
// Revision 1.1 1998/08/09 08:25:49 RD
|
||||
// Initial version
|
||||
//
|
||||
//
|
||||
341
utils/wxPython/src/events.i
Normal file
341
utils/wxPython/src/events.i
Normal file
@@ -0,0 +1,341 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: events.i
|
||||
// Purpose: SWIGgable Event classes for wxPython
|
||||
//
|
||||
// Author: Robin Dunn
|
||||
//
|
||||
// Created: 5/24/98
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 1998 by Total Control Software
|
||||
// Licence: wxWindows license
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
%module events
|
||||
|
||||
%{
|
||||
#include "helpers.h"
|
||||
#include <wx/spinbutt.h>
|
||||
%}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
%include typemaps.i
|
||||
%include my_typemaps.i
|
||||
|
||||
// Import some definitions of other classes, etc.
|
||||
%import _defs.i
|
||||
%import misc.i
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxEvent {
|
||||
public:
|
||||
wxObject* GetEventObject();
|
||||
wxEventType GetEventType();
|
||||
int GetId();
|
||||
bool GetSkipped();
|
||||
long GetTimestamp();
|
||||
void SetEventObject(wxObject* object);
|
||||
void SetEventType(wxEventType typ);
|
||||
void SetId(int id);
|
||||
void SetTimestamp(long timeStamp);
|
||||
void Skip(bool skip = TRUE);
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxSizeEvent : public wxEvent {
|
||||
public:
|
||||
wxSize GetSize();
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxCloseEvent : public wxEvent {
|
||||
public:
|
||||
bool CanVeto();
|
||||
// **** bool GetSessionEnding();
|
||||
bool GetLoggingOff();
|
||||
void Veto(bool veto = TRUE);
|
||||
bool GetVeto();
|
||||
void SetForce(bool force);
|
||||
void SetCanVeto(bool canVeto);
|
||||
void SetLoggingOff(bool loggingOff);
|
||||
bool GetForce();
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxCommandEvent : public wxEvent {
|
||||
public:
|
||||
bool Checked();
|
||||
long GetExtraLong();
|
||||
int GetInt();
|
||||
int GetSelection();
|
||||
char* GetString();
|
||||
bool IsSelection();
|
||||
|
||||
};
|
||||
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxScrollEvent: public wxCommandEvent {
|
||||
public:
|
||||
int GetOrientation();
|
||||
int GetPosition();
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxSpinEvent : public wxScrollEvent {
|
||||
public:
|
||||
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxMouseEvent: public wxEvent {
|
||||
public:
|
||||
bool IsButton();
|
||||
bool ButtonDown(int but = -1);
|
||||
bool ButtonDClick(int but = -1);
|
||||
bool ButtonUp(int but = -1);
|
||||
bool Button(int but);
|
||||
bool ButtonIsDown(int but);
|
||||
bool ControlDown();
|
||||
bool MetaDown();
|
||||
bool AltDown();
|
||||
bool ShiftDown();
|
||||
bool LeftDown();
|
||||
bool MiddleDown();
|
||||
bool RightDown();
|
||||
bool LeftUp();
|
||||
bool MiddleUp();
|
||||
bool RightUp();
|
||||
bool LeftDClick();
|
||||
bool MiddleDClick();
|
||||
bool RightDClick();
|
||||
bool LeftIsDown();
|
||||
bool MiddleIsDown();
|
||||
bool RightIsDown();
|
||||
bool Dragging();
|
||||
bool Moving();
|
||||
bool Entering();
|
||||
bool Leaving();
|
||||
void Position(long *OUTPUT, long *OUTPUT);
|
||||
wxPoint GetPosition();
|
||||
wxPoint GetLogicalPosition(const wxDC& dc);
|
||||
long GetX();
|
||||
long GetY();
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxKeyEvent: public wxEvent {
|
||||
public:
|
||||
bool ControlDown();
|
||||
bool MetaDown();
|
||||
bool AltDown();
|
||||
bool ShiftDown();
|
||||
long KeyCode();
|
||||
void Position(float *OUTPUT, float *OUTPUT);
|
||||
float GetX();
|
||||
float GetY();
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxMoveEvent: public wxEvent {
|
||||
public:
|
||||
wxPoint GetPosition();
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxPaintEvent: public wxEvent {
|
||||
public:
|
||||
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxEraseEvent: public wxEvent {
|
||||
public:
|
||||
wxDC *GetDC();
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxFocusEvent: public wxEvent {
|
||||
public:
|
||||
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxActivateEvent: public wxEvent{
|
||||
public:
|
||||
bool GetActive();
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxInitDialogEvent: public wxEvent {
|
||||
public:
|
||||
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxMenuEvent: public wxEvent {
|
||||
public:
|
||||
int GetMenuId();
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxShowEvent: public wxEvent {
|
||||
public:
|
||||
void SetShow(bool show);
|
||||
bool GetShow();
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxIconizeEvent: public wxEvent {
|
||||
public:
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxMaximizeEvent: public wxEvent {
|
||||
public:
|
||||
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxJoystickEvent: public wxEvent {
|
||||
public:
|
||||
wxPoint GetPosition();
|
||||
int GetZPosition();
|
||||
int GetButtonState();
|
||||
int GetButtonChange();
|
||||
int GetJoystick();
|
||||
void SetJoystick(int stick);
|
||||
void SetButtonState(int state);
|
||||
void SetButtonChange(int change);
|
||||
void SetPosition(const wxPoint& pos);
|
||||
void SetZPosition(int zPos);
|
||||
bool IsButton();
|
||||
bool IsMove();
|
||||
bool IsZMove();
|
||||
bool ButtonDown(int but = wxJOY_BUTTON_ANY);
|
||||
bool ButtonUp(int but = wxJOY_BUTTON_ANY);
|
||||
bool ButtonIsDown(int but = wxJOY_BUTTON_ANY);
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxDropFilesEvent: public wxEvent {
|
||||
public:
|
||||
wxPoint GetPosition();
|
||||
int GetNumberOfFiles();
|
||||
|
||||
%addmethods {
|
||||
PyObject* GetFiles() {
|
||||
int count = self->GetNumberOfFiles();
|
||||
wxString* files = self->GetFiles();
|
||||
PyObject* list = PyList_New(count);
|
||||
|
||||
if (!list) {
|
||||
PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (int i=0; i<count; i++) {
|
||||
PyList_SetItem(list, i, PyString_FromString((const char*)files[i]));
|
||||
}
|
||||
return list;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxIdleEvent: public wxEvent {
|
||||
public:
|
||||
void RequestMore(bool needMore = TRUE);
|
||||
bool MoreRequested();
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxUpdateUIEvent: public wxEvent {
|
||||
public:
|
||||
bool GetChecked();
|
||||
bool GetEnabled();
|
||||
wxString GetText();
|
||||
bool GetSetText();
|
||||
bool GetSetChecked();
|
||||
bool GetSetEnabled();
|
||||
|
||||
void Check(bool check);
|
||||
void Enable(bool enable);
|
||||
void SetText(const wxString& text);
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxSysColourChangedEvent: public wxEvent {
|
||||
public:
|
||||
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// $Log$
|
||||
// Revision 1.5 1998/12/15 20:41:17 RD
|
||||
// Changed the import semantics from "from wxPython import *" to "from
|
||||
// wxPython.wx import *" This is for people who are worried about
|
||||
// namespace pollution, they can use "from wxPython import wx" and then
|
||||
// prefix all the wxPython identifiers with "wx."
|
||||
//
|
||||
// Added wxTaskbarIcon for wxMSW.
|
||||
//
|
||||
// Made the events work for wxGrid.
|
||||
//
|
||||
// Added wxConfig.
|
||||
//
|
||||
// Added wxMiniFrame for wxGTK, (untested.)
|
||||
//
|
||||
// Changed many of the args and return values that were pointers to gdi
|
||||
// objects to references to reflect changes in the wxWindows API.
|
||||
//
|
||||
// Other assorted fixes and additions.
|
||||
//
|
||||
// Revision 1.4 1998/11/16 00:00:55 RD
|
||||
// Generic treectrl for wxPython/GTK compiles...
|
||||
//
|
||||
// Revision 1.3 1998/10/20 06:43:56 RD
|
||||
// New wxTreeCtrl wrappers (untested)
|
||||
// some changes in helpers
|
||||
// etc.
|
||||
//
|
||||
// Revision 1.2 1998/08/15 07:36:33 RD
|
||||
// - Moved the header in the .i files out of the code that gets put into
|
||||
// the .cpp files. It caused CVS conflicts because of the RCS ID being
|
||||
// different each time.
|
||||
//
|
||||
// - A few minor fixes.
|
||||
//
|
||||
// Revision 1.1 1998/08/09 08:25:50 RD
|
||||
// Initial version
|
||||
//
|
||||
//
|
||||
|
||||
122
utils/wxPython/src/frames.i
Normal file
122
utils/wxPython/src/frames.i
Normal file
@@ -0,0 +1,122 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: frames.i
|
||||
// Purpose: SWIG definitions of various window classes
|
||||
//
|
||||
// Author: Robin Dunn
|
||||
//
|
||||
// Created: 8/27/98
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 1998 by Total Control Software
|
||||
// Licence: wxWindows license
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
%module frames
|
||||
|
||||
%{
|
||||
#include "helpers.h"
|
||||
#include <wx/minifram.h>
|
||||
%}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
%include typemaps.i
|
||||
%include my_typemaps.i
|
||||
|
||||
// Import some definitions of other classes, etc.
|
||||
%import _defs.i
|
||||
%import misc.i
|
||||
%import gdi.i
|
||||
%import windows.i
|
||||
%import stattool.i
|
||||
|
||||
%pragma(python) code = "import wx"
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxFrame : public wxWindow {
|
||||
public:
|
||||
wxFrame(wxWindow* parent, const wxWindowID id, const wxString& title,
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
long style = wxDEFAULT_FRAME_STYLE,
|
||||
char* name = "frame");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdFrameCallbacks(self)"
|
||||
|
||||
void Centre(int direction = wxBOTH);
|
||||
#ifdef __WXMSW__
|
||||
void Command(int id);
|
||||
#endif
|
||||
wxStatusBar* CreateStatusBar(int number = 1,
|
||||
long style = wxST_SIZEGRIP,
|
||||
wxWindowID id = -1,
|
||||
char* name = "statusBar");
|
||||
wxToolBar* CreateToolBar(long style = wxNO_BORDER|wxTB_HORIZONTAL|wxTB_FLAT,
|
||||
wxWindowID id = -1,
|
||||
char* name = "toolBar");
|
||||
|
||||
wxMenuBar* GetMenuBar();
|
||||
wxStatusBar* GetStatusBar();
|
||||
wxString GetTitle();
|
||||
wxToolBar* GetToolBar();
|
||||
void Iconize(bool iconize);
|
||||
bool IsIconized();
|
||||
void Maximize(bool maximize);
|
||||
void SetAcceleratorTable(const wxAcceleratorTable& accel);
|
||||
void SetIcon(const wxIcon& icon);
|
||||
void SetMenuBar(wxMenuBar* menuBar);
|
||||
void SetStatusBar(wxStatusBar *statusBar);
|
||||
void SetStatusText(const wxString& text, int number = 0);
|
||||
void SetStatusWidths(int LCOUNT, int* LIST); // uses typemap
|
||||
void SetTitle(const wxString& title);
|
||||
void SetToolBar(wxToolBar* toolbar);
|
||||
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxMiniFrame : public wxFrame {
|
||||
public:
|
||||
wxMiniFrame(wxWindow* parent, const wxWindowID id, const wxString& title,
|
||||
const wxPoint& pos = wxPyDefaultPosition,
|
||||
const wxSize& size = wxPyDefaultSize,
|
||||
long style = wxDEFAULT_FRAME_STYLE,
|
||||
char* name = "frame");
|
||||
|
||||
%pragma(python) addtomethod = "__init__:wx._StdFrameCallbacks(self)"
|
||||
};
|
||||
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// $Log$
|
||||
// Revision 1.4 1998/12/16 22:10:53 RD
|
||||
// Tweaks needed to be able to build wxPython with wxGTK.
|
||||
//
|
||||
// Revision 1.3 1998/12/15 20:41:18 RD
|
||||
// Changed the import semantics from "from wxPython import *" to "from
|
||||
// wxPython.wx import *" This is for people who are worried about
|
||||
// namespace pollution, they can use "from wxPython import wx" and then
|
||||
// prefix all the wxPython identifiers with "wx."
|
||||
//
|
||||
// Added wxTaskbarIcon for wxMSW.
|
||||
//
|
||||
// Made the events work for wxGrid.
|
||||
//
|
||||
// Added wxConfig.
|
||||
//
|
||||
// Added wxMiniFrame for wxGTK, (untested.)
|
||||
//
|
||||
// Changed many of the args and return values that were pointers to gdi
|
||||
// objects to references to reflect changes in the wxWindows API.
|
||||
//
|
||||
// Other assorted fixes and additions.
|
||||
//
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
582
utils/wxPython/src/gdi.i
Normal file
582
utils/wxPython/src/gdi.i
Normal file
@@ -0,0 +1,582 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: gdi.i
|
||||
// Purpose: SWIG interface file for wxDC, wxBrush, wxPen, wxFont, etc.
|
||||
//
|
||||
// Author: Robin Dunn
|
||||
//
|
||||
// Created: 7/7/97
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 1998 by Total Control Software
|
||||
// Licence: wxWindows license
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
%module gdi
|
||||
|
||||
%{
|
||||
#include "helpers.h"
|
||||
#include <wx/metafile.h>
|
||||
#ifndef __WXMSW__
|
||||
#include <wx/dcps.h>
|
||||
#endif
|
||||
%}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
%include typemaps.i
|
||||
%include my_typemaps.i
|
||||
|
||||
// Import some definitions of other classes, etc.
|
||||
%import _defs.i
|
||||
%import misc.i
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxBitmap {
|
||||
public:
|
||||
wxBitmap(const wxString& name, long type);
|
||||
~wxBitmap();
|
||||
|
||||
#ifdef __WXMSW__
|
||||
void Create(int width, int height, int depth = -1);
|
||||
#endif
|
||||
int GetDepth();
|
||||
int GetHeight();
|
||||
wxPalette* GetPalette();
|
||||
wxMask* GetMask();
|
||||
int GetWidth();
|
||||
bool LoadFile(const wxString& name, long flags);
|
||||
bool Ok();
|
||||
bool SaveFile(const wxString& name, int type, wxPalette* palette = NULL);
|
||||
void SetDepth(int depth);
|
||||
void SetHeight(int height);
|
||||
void SetMask(wxMask* mask);
|
||||
#ifdef __WXMSW__
|
||||
void SetPalette(wxPalette& palette);
|
||||
#endif
|
||||
void SetWidth(int width);
|
||||
};
|
||||
|
||||
%new wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1);
|
||||
wxBitmap* wxNoRefBitmap(char* name, long flags);
|
||||
|
||||
%{ // Alternate 'constructor'
|
||||
wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1) {
|
||||
return new wxBitmap(width, height, depth);
|
||||
}
|
||||
|
||||
// This one won't own the reference, so Python won't call
|
||||
// the dtor, this is good for toolbars and such where
|
||||
// the parent will manage the bitmap.
|
||||
wxBitmap* wxNoRefBitmap(char* name, long flags) {
|
||||
return new wxBitmap(name, flags);
|
||||
}
|
||||
%}
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxMask {
|
||||
public:
|
||||
wxMask(const wxBitmap& bitmap);
|
||||
~wxMask();
|
||||
};
|
||||
|
||||
%new wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour);
|
||||
%{
|
||||
wxMask* wxMaskColour(const wxBitmap& bitmap, const wxColour& colour) {
|
||||
return new wxMask(bitmap, colour);
|
||||
}
|
||||
%}
|
||||
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
|
||||
class wxIcon : public wxBitmap {
|
||||
public:
|
||||
#ifdef __WXMSW__
|
||||
wxIcon(const wxString& name, long flags,
|
||||
int desiredWidth = -1, int desiredHeight = -1);
|
||||
#endif
|
||||
~wxIcon();
|
||||
|
||||
int GetDepth();
|
||||
int GetHeight();
|
||||
int GetWidth();
|
||||
bool LoadFile(const wxString& name, long flags);
|
||||
bool Ok();
|
||||
void SetDepth(int depth);
|
||||
void SetHeight(int height);
|
||||
void SetWidth(int width);
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxCursor : public wxBitmap {
|
||||
public:
|
||||
#ifdef __WXMSW__
|
||||
wxCursor(const wxString& cursorName, long flags, int hotSpotX=0, int hotSpotY=0);
|
||||
#endif
|
||||
~wxCursor();
|
||||
bool Ok();
|
||||
};
|
||||
|
||||
%name(wxStockCursor) %new wxCursor* wxPyStockCursor(int id);
|
||||
%{ // Alternate 'constructor'
|
||||
wxCursor* wxPyStockCursor(int id) {
|
||||
return new wxCursor(id);
|
||||
}
|
||||
%}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxFont {
|
||||
public:
|
||||
// I'll do it this way to use long-lived objects and not have to
|
||||
// worry about when python may delete the object.
|
||||
%addmethods {
|
||||
wxFont( int pointSize, int family, int style, int weight,
|
||||
int underline=FALSE, char* faceName = "") {
|
||||
|
||||
return wxTheFontList->FindOrCreateFont(pointSize, family, style, weight,
|
||||
underline, faceName);
|
||||
}
|
||||
// NO Destructor.
|
||||
}
|
||||
|
||||
|
||||
wxString GetFaceName();
|
||||
int GetFamily();
|
||||
#ifdef __WXMSW__
|
||||
int GetFontId();
|
||||
#endif
|
||||
int GetPointSize();
|
||||
int GetStyle();
|
||||
bool GetUnderlined();
|
||||
int GetWeight();
|
||||
void SetFaceName(const wxString& faceName);
|
||||
void SetFamily(int family);
|
||||
void SetPointSize(int pointSize);
|
||||
void SetStyle(int style);
|
||||
void SetUnderlined(bool underlined);
|
||||
void SetWeight(int weight);
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxColour {
|
||||
public:
|
||||
wxColour(unsigned char red=0, unsigned char green=0, unsigned char blue=0);
|
||||
~wxColour();
|
||||
unsigned char Red();
|
||||
unsigned char Green();
|
||||
unsigned char Blue();
|
||||
bool Ok();
|
||||
void Set(unsigned char red, unsigned char green, unsigned char blue);
|
||||
%addmethods {
|
||||
PyObject* Get() {
|
||||
PyObject* rv = PyTuple_New(3);
|
||||
PyTuple_SetItem(rv, 0, PyInt_FromLong(self->Red()));
|
||||
PyTuple_SetItem(rv, 1, PyInt_FromLong(self->Green()));
|
||||
PyTuple_SetItem(rv, 2, PyInt_FromLong(self->Blue()));
|
||||
return rv;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
%new wxColour* wxNamedColour(const wxString& colorName);
|
||||
%{ // Alternate 'constructor'
|
||||
wxColour* wxNamedColour(const wxString& colorName) {
|
||||
return new wxColour(colorName);
|
||||
}
|
||||
%}
|
||||
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
typedef unsigned long wxDash;
|
||||
|
||||
class wxPen {
|
||||
public:
|
||||
// I'll do it this way to use long-lived objects and not have to
|
||||
// worry about when python may delete the object.
|
||||
%addmethods {
|
||||
wxPen(wxColour* colour, int width=1, int style=wxSOLID) {
|
||||
return wxThePenList->FindOrCreatePen(*colour, width, style);
|
||||
}
|
||||
// NO Destructor.
|
||||
}
|
||||
|
||||
int GetCap();
|
||||
wxColour& GetColour();
|
||||
|
||||
int GetJoin();
|
||||
int GetStyle();
|
||||
int GetWidth();
|
||||
bool Ok();
|
||||
void SetCap(int cap_style);
|
||||
void SetColour(wxColour& colour);
|
||||
void SetJoin(int join_style);
|
||||
void SetStyle(int style);
|
||||
void SetWidth(int width);
|
||||
|
||||
#ifdef __WXMSW__
|
||||
// **** This one needs to return a list of ints (wxDash)
|
||||
int GetDashes(wxDash **dashes);
|
||||
wxBitmap* GetStipple();
|
||||
void SetDashes(int LCOUNT, wxDash* LIST);
|
||||
void SetStipple(wxBitmap& stipple);
|
||||
#endif
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxBrush {
|
||||
public:
|
||||
// I'll do it this way to use long-lived objects and not have to
|
||||
// worry about when python may delete the object.
|
||||
%addmethods {
|
||||
wxBrush(wxColour* colour, int style=wxSOLID) {
|
||||
return wxTheBrushList->FindOrCreateBrush(*colour, style);
|
||||
}
|
||||
// NO Destructor.
|
||||
}
|
||||
|
||||
wxColour& GetColour();
|
||||
wxBitmap * GetStipple();
|
||||
int GetStyle();
|
||||
bool Ok();
|
||||
void SetColour(wxColour &colour);
|
||||
void SetStipple(wxBitmap& bitmap);
|
||||
void SetStyle(int style);
|
||||
};
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
|
||||
|
||||
class wxDC {
|
||||
public:
|
||||
// wxDC(); **** abstract base class, can't instantiate.
|
||||
~wxDC();
|
||||
|
||||
void BeginDrawing();
|
||||
bool Blit(long xdest, long ydest, long width, long height,
|
||||
wxDC *source, long xsrc, long ysrc, long logical_func);
|
||||
void Clear();
|
||||
void CrossHair(long x, long y);
|
||||
void DestroyClippingRegion();
|
||||
long DeviceToLogicalX(long x);
|
||||
long DeviceToLogicalXRel(long x);
|
||||
long DeviceToLogicalY(long y);
|
||||
long DeviceToLogicalYRel(long y);
|
||||
void DrawArc(long x1, long y1, long x2, long y2, long xc, long yc);
|
||||
void DrawEllipse(long x, long y, long width, long height);
|
||||
void DrawEllipticArc(long x, long y, long width, long height, long start, long end);
|
||||
void DrawIcon(const wxIcon& icon, long x, long y);
|
||||
void DrawLine(long x1, long y1, long x2, long y2);
|
||||
void DrawLines(int LCOUNT, wxPoint* LIST, long xoffset=0, long yoffset=0);
|
||||
void DrawPolygon(int LCOUNT, wxPoint* LIST, long xoffset=0, long yoffset=0,
|
||||
int fill_style=wxODDEVEN_RULE);
|
||||
void DrawPoint(long x, long y);
|
||||
void DrawRectangle(long x, long y, long width, long height);
|
||||
void DrawRoundedRectangle(long x, long y, long width, long height, long radius=20);
|
||||
void DrawSpline(int LCOUNT, wxPoint* LIST);
|
||||
void DrawText(const wxString& text, long x, long y);
|
||||
void EndDoc();
|
||||
void EndDrawing();
|
||||
void EndPage();
|
||||
void FloodFill(long x, long y, const wxColour& colour, int style=wxFLOOD_SURFACE);
|
||||
wxBrush& GetBackground();
|
||||
wxBrush& GetBrush();
|
||||
long GetCharHeight();
|
||||
long GetCharWidth();
|
||||
void GetClippingBox(long *OUTPUT, long *OUTPUT,
|
||||
long *OUTPUT, long *OUTPUT);
|
||||
wxFont& GetFont();
|
||||
int GetLogicalFunction();
|
||||
int GetMapMode();
|
||||
bool GetOptimization();
|
||||
wxPen& GetPen();
|
||||
%addmethods {
|
||||
%new wxColour* GetPixel(long x, long y) {
|
||||
wxColour* wc = new wxColour();
|
||||
self->GetPixel(x, y, wc);
|
||||
return wc;
|
||||
}
|
||||
}
|
||||
void GetSize(int* OUTPUT, int* OUTPUT); //void GetSize(long* OUTPUT, long* OUTPUT);
|
||||
wxColour& GetTextBackground();
|
||||
void GetTextExtent(const wxString& string, long *OUTPUT, long *OUTPUT,
|
||||
long *OUTPUT, long *OUTPUT);
|
||||
wxColour& GetTextForeground();
|
||||
long LogicalToDeviceX(long x);
|
||||
long LogicalToDeviceXRel(long x);
|
||||
long LogicalToDeviceY(long y);
|
||||
long LogicalToDeviceYRel(long y);
|
||||
long MaxX();
|
||||
long MaxY();
|
||||
long MinX();
|
||||
long MinY();
|
||||
bool Ok();
|
||||
void SetDeviceOrigin(long x, long y);
|
||||
void SetBackground(const wxBrush& brush);
|
||||
void SetBackgroundMode(int mode);
|
||||
void SetClippingRegion(long x, long y, long width, long height);
|
||||
void SetPalette(const wxPalette& colourMap);
|
||||
void SetBrush(const wxBrush& brush);
|
||||
void SetFont(const wxFont& font);
|
||||
void SetLogicalFunction(int function);
|
||||
void SetMapMode(int mode);
|
||||
void SetOptimization(bool optimize);
|
||||
void SetPen(const wxPen& pen);
|
||||
void SetTextBackground(const wxColour& colour);
|
||||
void SetTextForeground(const wxColour& colour);
|
||||
void SetUserScale(double x_scale, double y_scale);
|
||||
bool StartDoc(const wxString& message);
|
||||
void StartPage();
|
||||
|
||||
|
||||
%addmethods {
|
||||
// This one is my own creation...
|
||||
void DrawBitmap(wxBitmap& bitmap, long x, long y, bool swapPalette=TRUE) {
|
||||
wxMemoryDC* memDC = new wxMemoryDC;
|
||||
memDC->SelectObject(bitmap);
|
||||
if (swapPalette)
|
||||
self->SetPalette(*bitmap.GetPalette());
|
||||
self->Blit(x, y, bitmap.GetWidth(), bitmap.GetHeight(), memDC,
|
||||
0, 0, self->GetLogicalFunction());
|
||||
memDC->SelectObject(wxNullBitmap);
|
||||
delete memDC;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class wxMemoryDC : public wxDC {
|
||||
public:
|
||||
wxMemoryDC();
|
||||
|
||||
void SelectObject(const wxBitmap& bitmap);
|
||||
}
|
||||
|
||||
%new wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC);
|
||||
%{ // Alternate 'constructor'
|
||||
wxMemoryDC* wxMemoryDCFromDC(wxDC* oldDC) {
|
||||
return new wxMemoryDC(oldDC);
|
||||
}
|
||||
%}
|
||||
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxScreenDC : public wxDC {
|
||||
public:
|
||||
wxScreenDC();
|
||||
|
||||
bool StartDrawingOnTop(wxWindow* window);
|
||||
%name(StartDrawingOnTopRect) bool StartDrawingOnTop(wxRect* rect = NULL);
|
||||
bool EndDrawingOnTop();
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxClientDC : public wxDC {
|
||||
public:
|
||||
wxClientDC(wxWindow* win);
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxPaintDC : public wxDC {
|
||||
public:
|
||||
wxPaintDC(wxWindow* win);
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxWindowDC : public wxDC {
|
||||
public:
|
||||
wxWindowDC(wxWindow* win);
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
#ifndef __WXMSW__
|
||||
class wxPostScriptDC : public wxDC {
|
||||
public:
|
||||
wxPostScriptDC(const wxString& output, bool interactive = TRUE, wxWindow* win = NULL);
|
||||
};
|
||||
#endif
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
#ifdef __WXMSW__
|
||||
class wxPrinterDC : public wxDC {
|
||||
public:
|
||||
wxPrinterDC(const wxString& driver, const wxString& device, const wxString& output,
|
||||
bool interactive = TRUE, int orientation = wxPORTRAIT);
|
||||
};
|
||||
#endif
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
#ifdef __WXMSW__
|
||||
class wxMetaFileDC : public wxDC {
|
||||
public:
|
||||
wxMetaFileDC(const wxString& filename = wxPyEmptyStr);
|
||||
wxMetaFile* Close();
|
||||
};
|
||||
#endif
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
|
||||
%readonly
|
||||
extern wxFont *wxNORMAL_FONT;
|
||||
extern wxFont *wxSMALL_FONT;
|
||||
extern wxFont *wxITALIC_FONT;
|
||||
extern wxFont *wxSWISS_FONT;
|
||||
extern wxPen *wxRED_PEN;
|
||||
|
||||
extern wxPen *wxCYAN_PEN;
|
||||
extern wxPen *wxGREEN_PEN;
|
||||
extern wxPen *wxBLACK_PEN;
|
||||
extern wxPen *wxWHITE_PEN;
|
||||
extern wxPen *wxTRANSPARENT_PEN;
|
||||
extern wxPen *wxBLACK_DASHED_PEN;
|
||||
extern wxPen *wxGREY_PEN;
|
||||
extern wxPen *wxMEDIUM_GREY_PEN;
|
||||
extern wxPen *wxLIGHT_GREY_PEN;
|
||||
|
||||
extern wxBrush *wxBLUE_BRUSH;
|
||||
extern wxBrush *wxGREEN_BRUSH;
|
||||
extern wxBrush *wxWHITE_BRUSH;
|
||||
extern wxBrush *wxBLACK_BRUSH;
|
||||
extern wxBrush *wxTRANSPARENT_BRUSH;
|
||||
extern wxBrush *wxCYAN_BRUSH;
|
||||
extern wxBrush *wxRED_BRUSH;
|
||||
extern wxBrush *wxGREY_BRUSH;
|
||||
extern wxBrush *wxMEDIUM_GREY_BRUSH;
|
||||
extern wxBrush *wxLIGHT_GREY_BRUSH;
|
||||
|
||||
extern wxColour *wxBLACK;
|
||||
extern wxColour *wxWHITE;
|
||||
extern wxColour *wxRED;
|
||||
extern wxColour *wxBLUE;
|
||||
extern wxColour *wxGREEN;
|
||||
extern wxColour *wxCYAN;
|
||||
extern wxColour *wxLIGHT_GREY;
|
||||
|
||||
extern wxCursor *wxSTANDARD_CURSOR;
|
||||
extern wxCursor *wxHOURGLASS_CURSOR;
|
||||
extern wxCursor *wxCROSS_CURSOR;
|
||||
|
||||
extern wxBitmap wxNullBitmap;
|
||||
extern wxIcon wxNullIcon;
|
||||
extern wxCursor wxNullCursor;
|
||||
extern wxPen wxNullPen;
|
||||
extern wxBrush wxNullBrush;
|
||||
extern wxPalette wxNullPalette;
|
||||
extern wxFont wxNullFont;
|
||||
extern wxColour wxNullColour;
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
class wxPalette {
|
||||
public:
|
||||
wxPalette(int LCOUNT, byte* LIST, byte* LIST, byte* LIST);
|
||||
~wxPalette();
|
||||
|
||||
int GetPixel(byte red, byte green, byte blue);
|
||||
bool GetRGB(int pixel, byte* OUTPUT, byte* OUTPUT, byte* OUTPUT);
|
||||
bool Ok();
|
||||
};
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// $Log$
|
||||
// Revision 1.12 1999/01/30 07:30:11 RD
|
||||
// Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
|
||||
//
|
||||
// Various cleanup, tweaks, minor additions, etc. to maintain
|
||||
// compatibility with the current wxWindows.
|
||||
//
|
||||
// Revision 1.11 1998/12/18 15:49:05 RR
|
||||
//
|
||||
// wxClipboard now serves the primary selection as well
|
||||
// wxPython fixes
|
||||
// warning mesages
|
||||
//
|
||||
// Revision 1.10 1998/12/17 18:05:50 RD
|
||||
//
|
||||
// wxPython 0.5.2
|
||||
// Minor fixes and SWIG code generation for RR's changes. MSW and GTK
|
||||
// versions are much closer now!
|
||||
//
|
||||
// Revision 1.9 1998/12/17 14:07:37 RR
|
||||
//
|
||||
// Removed minor differences between wxMSW and wxGTK
|
||||
//
|
||||
// Revision 1.8 1998/12/16 22:10:54 RD
|
||||
//
|
||||
// Tweaks needed to be able to build wxPython with wxGTK.
|
||||
//
|
||||
// Revision 1.7 1998/12/15 20:41:18 RD
|
||||
// Changed the import semantics from "from wxPython import *" to "from
|
||||
// wxPython.wx import *" This is for people who are worried about
|
||||
// namespace pollution, they can use "from wxPython import wx" and then
|
||||
// prefix all the wxPython identifiers with "wx."
|
||||
//
|
||||
// Added wxTaskbarIcon for wxMSW.
|
||||
//
|
||||
// Made the events work for wxGrid.
|
||||
//
|
||||
// Added wxConfig.
|
||||
//
|
||||
// Added wxMiniFrame for wxGTK, (untested.)
|
||||
//
|
||||
// Changed many of the args and return values that were pointers to gdi
|
||||
// objects to references to reflect changes in the wxWindows API.
|
||||
//
|
||||
// Other assorted fixes and additions.
|
||||
//
|
||||
// Revision 1.6 1998/11/25 08:45:24 RD
|
||||
//
|
||||
// Added wxPalette, wxRegion, wxRegionIterator, wxTaskbarIcon
|
||||
// Added events for wxGrid
|
||||
// Other various fixes and additions
|
||||
//
|
||||
// Revision 1.5 1998/10/20 06:43:57 RD
|
||||
// New wxTreeCtrl wrappers (untested)
|
||||
// some changes in helpers
|
||||
// etc.
|
||||
//
|
||||
// Revision 1.4 1998/10/02 06:40:38 RD
|
||||
//
|
||||
// Version 0.4 of wxPython for MSW.
|
||||
//
|
||||
// Revision 1.3 1998/08/18 19:48:16 RD
|
||||
// more wxGTK compatibility things.
|
||||
//
|
||||
// It builds now but there are serious runtime problems...
|
||||
//
|
||||
// Revision 1.2 1998/08/15 07:36:35 RD
|
||||
// - Moved the header in the .i files out of the code that gets put into
|
||||
// the .cpp files. It caused CVS conflicts because of the RCS ID being
|
||||
// different each time.
|
||||
//
|
||||
// - A few minor fixes.
|
||||
//
|
||||
// Revision 1.1 1998/08/09 08:25:50 RD
|
||||
// Initial version
|
||||
//
|
||||
//
|
||||
3830
utils/wxPython/src/gtk/cmndlgs.cpp
Normal file
3830
utils/wxPython/src/gtk/cmndlgs.cpp
Normal file
File diff suppressed because it is too large
Load Diff
592
utils/wxPython/src/gtk/cmndlgs.py
Normal file
592
utils/wxPython/src/gtk/cmndlgs.py
Normal file
@@ -0,0 +1,592 @@
|
||||
# This file was created automatically by SWIG.
|
||||
import cmndlgsc
|
||||
|
||||
from misc import *
|
||||
|
||||
from gdi import *
|
||||
|
||||
from windows import *
|
||||
import wx
|
||||
class wxColourDataPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
cmndlgsc.delete_wxColourData(self.this)
|
||||
def GetChooseFull(self):
|
||||
val = cmndlgsc.wxColourData_GetChooseFull(self.this)
|
||||
return val
|
||||
def GetColour(self):
|
||||
val = cmndlgsc.wxColourData_GetColour(self.this)
|
||||
val = wxColourPtr(val)
|
||||
return val
|
||||
def GetCustomColour(self,arg0):
|
||||
val = cmndlgsc.wxColourData_GetCustomColour(self.this,arg0)
|
||||
val = wxColourPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def SetChooseFull(self,arg0):
|
||||
val = cmndlgsc.wxColourData_SetChooseFull(self.this,arg0)
|
||||
return val
|
||||
def SetColour(self,arg0):
|
||||
val = cmndlgsc.wxColourData_SetColour(self.this,arg0.this)
|
||||
return val
|
||||
def SetCustomColour(self,arg0,arg1):
|
||||
val = cmndlgsc.wxColourData_SetCustomColour(self.this,arg0,arg1.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxColourData instance>"
|
||||
class wxColourData(wxColourDataPtr):
|
||||
def __init__(self) :
|
||||
self.this = cmndlgsc.new_wxColourData()
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxColourDialogPtr(wxDialogPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetColourData(self):
|
||||
val = cmndlgsc.wxColourDialog_GetColourData(self.this)
|
||||
val = wxColourDataPtr(val)
|
||||
return val
|
||||
def ShowModal(self):
|
||||
val = cmndlgsc.wxColourDialog_ShowModal(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxColourDialog instance>"
|
||||
class wxColourDialog(wxColourDialogPtr):
|
||||
def __init__(self,arg0,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(cmndlgsc.new_wxColourDialog,(arg0.this,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdDialogCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxDirDialogPtr(wxDialogPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetPath(self):
|
||||
val = cmndlgsc.wxDirDialog_GetPath(self.this)
|
||||
return val
|
||||
def GetMessage(self):
|
||||
val = cmndlgsc.wxDirDialog_GetMessage(self.this)
|
||||
return val
|
||||
def GetStyle(self):
|
||||
val = cmndlgsc.wxDirDialog_GetStyle(self.this)
|
||||
return val
|
||||
def SetMessage(self,arg0):
|
||||
val = cmndlgsc.wxDirDialog_SetMessage(self.this,arg0)
|
||||
return val
|
||||
def SetPath(self,arg0):
|
||||
val = cmndlgsc.wxDirDialog_SetPath(self.this,arg0)
|
||||
return val
|
||||
def ShowModal(self):
|
||||
val = cmndlgsc.wxDirDialog_ShowModal(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxDirDialog instance>"
|
||||
class wxDirDialog(wxDirDialogPtr):
|
||||
def __init__(self,arg0,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[3] = argl[3].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(cmndlgsc.new_wxDirDialog,(arg0.this,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdDialogCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxFileDialogPtr(wxDialogPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetDirectory(self):
|
||||
val = cmndlgsc.wxFileDialog_GetDirectory(self.this)
|
||||
return val
|
||||
def GetFilename(self):
|
||||
val = cmndlgsc.wxFileDialog_GetFilename(self.this)
|
||||
return val
|
||||
def GetFilterIndex(self):
|
||||
val = cmndlgsc.wxFileDialog_GetFilterIndex(self.this)
|
||||
return val
|
||||
def GetMessage(self):
|
||||
val = cmndlgsc.wxFileDialog_GetMessage(self.this)
|
||||
return val
|
||||
def GetPath(self):
|
||||
val = cmndlgsc.wxFileDialog_GetPath(self.this)
|
||||
return val
|
||||
def GetStyle(self):
|
||||
val = cmndlgsc.wxFileDialog_GetStyle(self.this)
|
||||
return val
|
||||
def GetWildcard(self):
|
||||
val = cmndlgsc.wxFileDialog_GetWildcard(self.this)
|
||||
return val
|
||||
def SetDirectory(self,arg0):
|
||||
val = cmndlgsc.wxFileDialog_SetDirectory(self.this,arg0)
|
||||
return val
|
||||
def SetFilename(self,arg0):
|
||||
val = cmndlgsc.wxFileDialog_SetFilename(self.this,arg0)
|
||||
return val
|
||||
def SetFilterIndex(self,arg0):
|
||||
val = cmndlgsc.wxFileDialog_SetFilterIndex(self.this,arg0)
|
||||
return val
|
||||
def SetMessage(self,arg0):
|
||||
val = cmndlgsc.wxFileDialog_SetMessage(self.this,arg0)
|
||||
return val
|
||||
def SetPath(self,arg0):
|
||||
val = cmndlgsc.wxFileDialog_SetPath(self.this,arg0)
|
||||
return val
|
||||
def SetStyle(self,arg0):
|
||||
val = cmndlgsc.wxFileDialog_SetStyle(self.this,arg0)
|
||||
return val
|
||||
def SetWildcard(self,arg0):
|
||||
val = cmndlgsc.wxFileDialog_SetWildcard(self.this,arg0)
|
||||
return val
|
||||
def ShowModal(self):
|
||||
val = cmndlgsc.wxFileDialog_ShowModal(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxFileDialog instance>"
|
||||
class wxFileDialog(wxFileDialogPtr):
|
||||
def __init__(self,arg0,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[5] = argl[5].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(cmndlgsc.new_wxFileDialog,(arg0.this,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdDialogCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxSingleChoiceDialogPtr(wxDialogPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetSelection(self):
|
||||
val = cmndlgsc.wxSingleChoiceDialog_GetSelection(self.this)
|
||||
return val
|
||||
def GetStringSelection(self):
|
||||
val = cmndlgsc.wxSingleChoiceDialog_GetStringSelection(self.this)
|
||||
return val
|
||||
def SetSelection(self,arg0):
|
||||
val = cmndlgsc.wxSingleChoiceDialog_SetSelection(self.this,arg0)
|
||||
return val
|
||||
def ShowModal(self):
|
||||
val = cmndlgsc.wxSingleChoiceDialog_ShowModal(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxSingleChoiceDialog instance>"
|
||||
class wxSingleChoiceDialog(wxSingleChoiceDialogPtr):
|
||||
def __init__(self,arg0,arg1,arg2,arg3,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(cmndlgsc.new_wxSingleChoiceDialog,(arg0.this,arg1,arg2,arg3,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdDialogCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxTextEntryDialogPtr(wxDialogPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetValue(self):
|
||||
val = cmndlgsc.wxTextEntryDialog_GetValue(self.this)
|
||||
return val
|
||||
def SetValue(self,arg0):
|
||||
val = cmndlgsc.wxTextEntryDialog_SetValue(self.this,arg0)
|
||||
return val
|
||||
def ShowModal(self):
|
||||
val = cmndlgsc.wxTextEntryDialog_ShowModal(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxTextEntryDialog instance>"
|
||||
class wxTextEntryDialog(wxTextEntryDialogPtr):
|
||||
def __init__(self,arg0,arg1,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[3] = argl[3].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(cmndlgsc.new_wxTextEntryDialog,(arg0.this,arg1,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdDialogCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxFontDataPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
cmndlgsc.delete_wxFontData(self.this)
|
||||
def EnableEffects(self,arg0):
|
||||
val = cmndlgsc.wxFontData_EnableEffects(self.this,arg0)
|
||||
return val
|
||||
def GetAllowSymbols(self):
|
||||
val = cmndlgsc.wxFontData_GetAllowSymbols(self.this)
|
||||
return val
|
||||
def GetColour(self):
|
||||
val = cmndlgsc.wxFontData_GetColour(self.this)
|
||||
val = wxColourPtr(val)
|
||||
return val
|
||||
def GetChosenFont(self):
|
||||
val = cmndlgsc.wxFontData_GetChosenFont(self.this)
|
||||
val = wxFontPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetEnableEffects(self):
|
||||
val = cmndlgsc.wxFontData_GetEnableEffects(self.this)
|
||||
return val
|
||||
def GetInitialFont(self):
|
||||
val = cmndlgsc.wxFontData_GetInitialFont(self.this)
|
||||
val = wxFontPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetShowHelp(self):
|
||||
val = cmndlgsc.wxFontData_GetShowHelp(self.this)
|
||||
return val
|
||||
def SetAllowSymbols(self,arg0):
|
||||
val = cmndlgsc.wxFontData_SetAllowSymbols(self.this,arg0)
|
||||
return val
|
||||
def SetChosenFont(self,arg0):
|
||||
val = cmndlgsc.wxFontData_SetChosenFont(self.this,arg0.this)
|
||||
return val
|
||||
def SetColour(self,arg0):
|
||||
val = cmndlgsc.wxFontData_SetColour(self.this,arg0.this)
|
||||
return val
|
||||
def SetInitialFont(self,arg0):
|
||||
val = cmndlgsc.wxFontData_SetInitialFont(self.this,arg0.this)
|
||||
return val
|
||||
def SetRange(self,arg0,arg1):
|
||||
val = cmndlgsc.wxFontData_SetRange(self.this,arg0,arg1)
|
||||
return val
|
||||
def SetShowHelp(self,arg0):
|
||||
val = cmndlgsc.wxFontData_SetShowHelp(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxFontData instance>"
|
||||
class wxFontData(wxFontDataPtr):
|
||||
def __init__(self) :
|
||||
self.this = cmndlgsc.new_wxFontData()
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxFontDialogPtr(wxDialogPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetFontData(self):
|
||||
val = cmndlgsc.wxFontDialog_GetFontData(self.this)
|
||||
val = wxFontDataPtr(val)
|
||||
return val
|
||||
def ShowModal(self):
|
||||
val = cmndlgsc.wxFontDialog_ShowModal(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxFontDialog instance>"
|
||||
class wxFontDialog(wxFontDialogPtr):
|
||||
def __init__(self,arg0,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(cmndlgsc.new_wxFontDialog,(arg0.this,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdDialogCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxPageSetupDataPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
cmndlgsc.delete_wxPageSetupData(self.this)
|
||||
def EnableHelp(self,arg0):
|
||||
val = cmndlgsc.wxPageSetupData_EnableHelp(self.this,arg0)
|
||||
return val
|
||||
def EnableMargins(self,arg0):
|
||||
val = cmndlgsc.wxPageSetupData_EnableMargins(self.this,arg0)
|
||||
return val
|
||||
def EnableOrientation(self,arg0):
|
||||
val = cmndlgsc.wxPageSetupData_EnableOrientation(self.this,arg0)
|
||||
return val
|
||||
def EnablePaper(self,arg0):
|
||||
val = cmndlgsc.wxPageSetupData_EnablePaper(self.this,arg0)
|
||||
return val
|
||||
def EnablePrinter(self,arg0):
|
||||
val = cmndlgsc.wxPageSetupData_EnablePrinter(self.this,arg0)
|
||||
return val
|
||||
def GetPaperSize(self):
|
||||
val = cmndlgsc.wxPageSetupData_GetPaperSize(self.this)
|
||||
val = wxPointPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetMarginTopLeft(self):
|
||||
val = cmndlgsc.wxPageSetupData_GetMarginTopLeft(self.this)
|
||||
val = wxPointPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetMarginBottomRight(self):
|
||||
val = cmndlgsc.wxPageSetupData_GetMarginBottomRight(self.this)
|
||||
val = wxPointPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetMinMarginTopLeft(self):
|
||||
val = cmndlgsc.wxPageSetupData_GetMinMarginTopLeft(self.this)
|
||||
val = wxPointPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetMinMarginBottomRight(self):
|
||||
val = cmndlgsc.wxPageSetupData_GetMinMarginBottomRight(self.this)
|
||||
val = wxPointPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetOrientation(self):
|
||||
val = cmndlgsc.wxPageSetupData_GetOrientation(self.this)
|
||||
return val
|
||||
def GetDefaultMinMargins(self):
|
||||
val = cmndlgsc.wxPageSetupData_GetDefaultMinMargins(self.this)
|
||||
return val
|
||||
def GetEnableMargins(self):
|
||||
val = cmndlgsc.wxPageSetupData_GetEnableMargins(self.this)
|
||||
return val
|
||||
def GetEnableOrientation(self):
|
||||
val = cmndlgsc.wxPageSetupData_GetEnableOrientation(self.this)
|
||||
return val
|
||||
def GetEnablePaper(self):
|
||||
val = cmndlgsc.wxPageSetupData_GetEnablePaper(self.this)
|
||||
return val
|
||||
def GetEnablePrinter(self):
|
||||
val = cmndlgsc.wxPageSetupData_GetEnablePrinter(self.this)
|
||||
return val
|
||||
def GetEnableHelp(self):
|
||||
val = cmndlgsc.wxPageSetupData_GetEnableHelp(self.this)
|
||||
return val
|
||||
def GetDefaultInfo(self):
|
||||
val = cmndlgsc.wxPageSetupData_GetDefaultInfo(self.this)
|
||||
return val
|
||||
def SetPaperSize(self,arg0):
|
||||
val = cmndlgsc.wxPageSetupData_SetPaperSize(self.this,arg0.this)
|
||||
return val
|
||||
def SetMarginTopLeft(self,arg0):
|
||||
val = cmndlgsc.wxPageSetupData_SetMarginTopLeft(self.this,arg0.this)
|
||||
return val
|
||||
def SetMarginBottomRight(self,arg0):
|
||||
val = cmndlgsc.wxPageSetupData_SetMarginBottomRight(self.this,arg0.this)
|
||||
return val
|
||||
def SetMinMarginTopLeft(self,arg0):
|
||||
val = cmndlgsc.wxPageSetupData_SetMinMarginTopLeft(self.this,arg0.this)
|
||||
return val
|
||||
def SetMinMarginBottomRight(self,arg0):
|
||||
val = cmndlgsc.wxPageSetupData_SetMinMarginBottomRight(self.this,arg0.this)
|
||||
return val
|
||||
def SetOrientation(self,arg0):
|
||||
val = cmndlgsc.wxPageSetupData_SetOrientation(self.this,arg0)
|
||||
return val
|
||||
def SetDefaultMinMargins(self,arg0):
|
||||
val = cmndlgsc.wxPageSetupData_SetDefaultMinMargins(self.this,arg0)
|
||||
return val
|
||||
def SetDefaultInfo(self,arg0):
|
||||
val = cmndlgsc.wxPageSetupData_SetDefaultInfo(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxPageSetupData instance>"
|
||||
class wxPageSetupData(wxPageSetupDataPtr):
|
||||
def __init__(self) :
|
||||
self.this = cmndlgsc.new_wxPageSetupData()
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxPageSetupDialogPtr(wxDialogPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetPageSetupData(self):
|
||||
val = cmndlgsc.wxPageSetupDialog_GetPageSetupData(self.this)
|
||||
val = wxPageSetupDataPtr(val)
|
||||
return val
|
||||
def ShowModal(self):
|
||||
val = cmndlgsc.wxPageSetupDialog_ShowModal(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxPageSetupDialog instance>"
|
||||
class wxPageSetupDialog(wxPageSetupDialogPtr):
|
||||
def __init__(self,arg0,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(cmndlgsc.new_wxPageSetupDialog,(arg0.this,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdDialogCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxPrintDataPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
cmndlgsc.delete_wxPrintData(self.this)
|
||||
def EnableHelp(self,arg0):
|
||||
val = cmndlgsc.wxPrintData_EnableHelp(self.this,arg0)
|
||||
return val
|
||||
def EnablePageNumbers(self,arg0):
|
||||
val = cmndlgsc.wxPrintData_EnablePageNumbers(self.this,arg0)
|
||||
return val
|
||||
def EnablePrintToFile(self,arg0):
|
||||
val = cmndlgsc.wxPrintData_EnablePrintToFile(self.this,arg0)
|
||||
return val
|
||||
def EnableSelection(self,arg0):
|
||||
val = cmndlgsc.wxPrintData_EnableSelection(self.this,arg0)
|
||||
return val
|
||||
def GetAllPages(self):
|
||||
val = cmndlgsc.wxPrintData_GetAllPages(self.this)
|
||||
return val
|
||||
def GetCollate(self):
|
||||
val = cmndlgsc.wxPrintData_GetCollate(self.this)
|
||||
return val
|
||||
def GetFromPage(self):
|
||||
val = cmndlgsc.wxPrintData_GetFromPage(self.this)
|
||||
return val
|
||||
def GetMaxPage(self):
|
||||
val = cmndlgsc.wxPrintData_GetMaxPage(self.this)
|
||||
return val
|
||||
def GetMinPage(self):
|
||||
val = cmndlgsc.wxPrintData_GetMinPage(self.this)
|
||||
return val
|
||||
def GetNoCopies(self):
|
||||
val = cmndlgsc.wxPrintData_GetNoCopies(self.this)
|
||||
return val
|
||||
def GetOrientation(self):
|
||||
val = cmndlgsc.wxPrintData_GetOrientation(self.this)
|
||||
return val
|
||||
def GetToPage(self):
|
||||
val = cmndlgsc.wxPrintData_GetToPage(self.this)
|
||||
return val
|
||||
def SetCollate(self,arg0):
|
||||
val = cmndlgsc.wxPrintData_SetCollate(self.this,arg0)
|
||||
return val
|
||||
def SetFromPage(self,arg0):
|
||||
val = cmndlgsc.wxPrintData_SetFromPage(self.this,arg0)
|
||||
return val
|
||||
def SetMaxPage(self,arg0):
|
||||
val = cmndlgsc.wxPrintData_SetMaxPage(self.this,arg0)
|
||||
return val
|
||||
def SetMinPage(self,arg0):
|
||||
val = cmndlgsc.wxPrintData_SetMinPage(self.this,arg0)
|
||||
return val
|
||||
def SetOrientation(self,arg0):
|
||||
val = cmndlgsc.wxPrintData_SetOrientation(self.this,arg0)
|
||||
return val
|
||||
def SetNoCopies(self,arg0):
|
||||
val = cmndlgsc.wxPrintData_SetNoCopies(self.this,arg0)
|
||||
return val
|
||||
def SetPrintToFile(self,arg0):
|
||||
val = cmndlgsc.wxPrintData_SetPrintToFile(self.this,arg0)
|
||||
return val
|
||||
def SetSetupDialog(self,arg0):
|
||||
val = cmndlgsc.wxPrintData_SetSetupDialog(self.this,arg0)
|
||||
return val
|
||||
def SetToPage(self,arg0):
|
||||
val = cmndlgsc.wxPrintData_SetToPage(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxPrintData instance>"
|
||||
class wxPrintData(wxPrintDataPtr):
|
||||
def __init__(self) :
|
||||
self.this = cmndlgsc.new_wxPrintData()
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxPrintDialogPtr(wxDialogPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetPrintData(self):
|
||||
val = cmndlgsc.wxPrintDialog_GetPrintData(self.this)
|
||||
val = wxPrintDataPtr(val)
|
||||
return val
|
||||
def GetPrintDC(self):
|
||||
val = cmndlgsc.wxPrintDialog_GetPrintDC(self.this)
|
||||
val = wxDCPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def ShowModal(self):
|
||||
val = cmndlgsc.wxPrintDialog_ShowModal(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxPrintDialog instance>"
|
||||
class wxPrintDialog(wxPrintDialogPtr):
|
||||
def __init__(self,arg0,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(cmndlgsc.new_wxPrintDialog,(arg0.this,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdDialogCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxMessageDialogPtr(wxDialogPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def ShowModal(self):
|
||||
val = cmndlgsc.wxMessageDialog_ShowModal(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxMessageDialog instance>"
|
||||
class wxMessageDialog(wxMessageDialogPtr):
|
||||
def __init__(self,arg0,arg1,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[2] = argl[2].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(cmndlgsc.new_wxMessageDialog,(arg0.this,arg1,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdDialogCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#-------------- FUNCTION WRAPPERS ------------------
|
||||
|
||||
|
||||
|
||||
#-------------- VARIABLE WRAPPERS ------------------
|
||||
|
||||
5843
utils/wxPython/src/gtk/controls.cpp
Normal file
5843
utils/wxPython/src/gtk/controls.cpp
Normal file
File diff suppressed because it is too large
Load Diff
836
utils/wxPython/src/gtk/controls.py
Normal file
836
utils/wxPython/src/gtk/controls.py
Normal file
@@ -0,0 +1,836 @@
|
||||
# This file was created automatically by SWIG.
|
||||
import controlsc
|
||||
|
||||
from misc import *
|
||||
|
||||
from windows import *
|
||||
|
||||
from gdi import *
|
||||
|
||||
from events import *
|
||||
import wx
|
||||
class wxControlPtr(wxWindowPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def Command(self,arg0):
|
||||
val = controlsc.wxControl_Command(self.this,arg0.this)
|
||||
return val
|
||||
def GetLabel(self):
|
||||
val = controlsc.wxControl_GetLabel(self.this)
|
||||
return val
|
||||
def SetLabel(self,arg0):
|
||||
val = controlsc.wxControl_SetLabel(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxControl instance>"
|
||||
class wxControl(wxControlPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxButtonPtr(wxControlPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def SetDefault(self):
|
||||
val = controlsc.wxButton_SetDefault(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxButton instance>"
|
||||
class wxButton(wxButtonPtr):
|
||||
def __init__(self,arg0,arg1,arg2,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controlsc.new_wxButton,(arg0.this,arg1,arg2,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdWindowCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxBitmapButtonPtr(wxButtonPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetBitmapLabel(self):
|
||||
val = controlsc.wxBitmapButton_GetBitmapLabel(self.this)
|
||||
val = wxBitmapPtr(val)
|
||||
return val
|
||||
def GetBitmapDisabled(self):
|
||||
val = controlsc.wxBitmapButton_GetBitmapDisabled(self.this)
|
||||
val = wxBitmapPtr(val)
|
||||
return val
|
||||
def GetBitmapFocus(self):
|
||||
val = controlsc.wxBitmapButton_GetBitmapFocus(self.this)
|
||||
val = wxBitmapPtr(val)
|
||||
return val
|
||||
def GetBitmapSelected(self):
|
||||
val = controlsc.wxBitmapButton_GetBitmapSelected(self.this)
|
||||
val = wxBitmapPtr(val)
|
||||
return val
|
||||
def SetBitmapDisabled(self,arg0):
|
||||
val = controlsc.wxBitmapButton_SetBitmapDisabled(self.this,arg0.this)
|
||||
return val
|
||||
def SetBitmapFocus(self,arg0):
|
||||
val = controlsc.wxBitmapButton_SetBitmapFocus(self.this,arg0.this)
|
||||
return val
|
||||
def SetBitmapSelected(self,arg0):
|
||||
val = controlsc.wxBitmapButton_SetBitmapSelected(self.this,arg0.this)
|
||||
return val
|
||||
def SetBitmapLabel(self,arg0):
|
||||
val = controlsc.wxBitmapButton_SetBitmapLabel(self.this,arg0.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxBitmapButton instance>"
|
||||
class wxBitmapButton(wxBitmapButtonPtr):
|
||||
def __init__(self,arg0,arg1,arg2,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controlsc.new_wxBitmapButton,(arg0.this,arg1,arg2.this,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdWindowCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxCheckBoxPtr(wxControlPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetValue(self):
|
||||
val = controlsc.wxCheckBox_GetValue(self.this)
|
||||
return val
|
||||
def SetValue(self,arg0):
|
||||
val = controlsc.wxCheckBox_SetValue(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxCheckBox instance>"
|
||||
class wxCheckBox(wxCheckBoxPtr):
|
||||
def __init__(self,arg0,arg1,arg2,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controlsc.new_wxCheckBox,(arg0.this,arg1,arg2,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdWindowCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxChoicePtr(wxControlPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def Append(self,arg0):
|
||||
val = controlsc.wxChoice_Append(self.this,arg0)
|
||||
return val
|
||||
def Clear(self):
|
||||
val = controlsc.wxChoice_Clear(self.this)
|
||||
return val
|
||||
def FindString(self,arg0):
|
||||
val = controlsc.wxChoice_FindString(self.this,arg0)
|
||||
return val
|
||||
def GetColumns(self):
|
||||
val = controlsc.wxChoice_GetColumns(self.this)
|
||||
return val
|
||||
def GetSelection(self):
|
||||
val = controlsc.wxChoice_GetSelection(self.this)
|
||||
return val
|
||||
def GetString(self,arg0):
|
||||
val = controlsc.wxChoice_GetString(self.this,arg0)
|
||||
return val
|
||||
def GetStringSelection(self):
|
||||
val = controlsc.wxChoice_GetStringSelection(self.this)
|
||||
return val
|
||||
def Number(self):
|
||||
val = controlsc.wxChoice_Number(self.this)
|
||||
return val
|
||||
def SetColumns(self,*args):
|
||||
val = apply(controlsc.wxChoice_SetColumns,(self.this,)+args)
|
||||
return val
|
||||
def SetSelection(self,arg0):
|
||||
val = controlsc.wxChoice_SetSelection(self.this,arg0)
|
||||
return val
|
||||
def SetStringSelection(self,arg0):
|
||||
val = controlsc.wxChoice_SetStringSelection(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxChoice instance>"
|
||||
class wxChoice(wxChoicePtr):
|
||||
def __init__(self,arg0,arg1,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controlsc.new_wxChoice,(arg0.this,arg1,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdWindowCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxComboBoxPtr(wxControlPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def Append(self,arg0):
|
||||
val = controlsc.wxComboBox_Append(self.this,arg0)
|
||||
return val
|
||||
def Clear(self):
|
||||
val = controlsc.wxComboBox_Clear(self.this)
|
||||
return val
|
||||
def Copy(self):
|
||||
val = controlsc.wxComboBox_Copy(self.this)
|
||||
return val
|
||||
def Cut(self):
|
||||
val = controlsc.wxComboBox_Cut(self.this)
|
||||
return val
|
||||
def Delete(self,arg0):
|
||||
val = controlsc.wxComboBox_Delete(self.this,arg0)
|
||||
return val
|
||||
def FindString(self,arg0):
|
||||
val = controlsc.wxComboBox_FindString(self.this,arg0)
|
||||
return val
|
||||
def GetInsertionPoint(self):
|
||||
val = controlsc.wxComboBox_GetInsertionPoint(self.this)
|
||||
return val
|
||||
def GetLastPosition(self):
|
||||
val = controlsc.wxComboBox_GetLastPosition(self.this)
|
||||
return val
|
||||
def GetSelection(self):
|
||||
val = controlsc.wxComboBox_GetSelection(self.this)
|
||||
return val
|
||||
def GetString(self,arg0):
|
||||
val = controlsc.wxComboBox_GetString(self.this,arg0)
|
||||
return val
|
||||
def GetStringSelection(self):
|
||||
val = controlsc.wxComboBox_GetStringSelection(self.this)
|
||||
return val
|
||||
def GetValue(self):
|
||||
val = controlsc.wxComboBox_GetValue(self.this)
|
||||
return val
|
||||
def Number(self):
|
||||
val = controlsc.wxComboBox_Number(self.this)
|
||||
return val
|
||||
def Paste(self):
|
||||
val = controlsc.wxComboBox_Paste(self.this)
|
||||
return val
|
||||
def Replace(self,arg0,arg1,arg2):
|
||||
val = controlsc.wxComboBox_Replace(self.this,arg0,arg1,arg2)
|
||||
return val
|
||||
def Remove(self,arg0,arg1):
|
||||
val = controlsc.wxComboBox_Remove(self.this,arg0,arg1)
|
||||
return val
|
||||
def SetInsertionPoint(self,arg0):
|
||||
val = controlsc.wxComboBox_SetInsertionPoint(self.this,arg0)
|
||||
return val
|
||||
def SetInsertionPointEnd(self):
|
||||
val = controlsc.wxComboBox_SetInsertionPointEnd(self.this)
|
||||
return val
|
||||
def SetSelection(self,arg0,*args):
|
||||
val = apply(controlsc.wxComboBox_SetSelection,(self.this,arg0,)+args)
|
||||
return val
|
||||
def SetMark(self,arg0,arg1):
|
||||
val = controlsc.wxComboBox_SetMark(self.this,arg0,arg1)
|
||||
return val
|
||||
def SetValue(self,arg0):
|
||||
val = controlsc.wxComboBox_SetValue(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxComboBox instance>"
|
||||
class wxComboBox(wxComboBoxPtr):
|
||||
def __init__(self,arg0,arg1,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
try: argl[2] = argl[2].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controlsc.new_wxComboBox,(arg0.this,arg1,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdWindowCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxGaugePtr(wxControlPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetBezelFace(self):
|
||||
val = controlsc.wxGauge_GetBezelFace(self.this)
|
||||
return val
|
||||
def GetRange(self):
|
||||
val = controlsc.wxGauge_GetRange(self.this)
|
||||
return val
|
||||
def GetShadowWidth(self):
|
||||
val = controlsc.wxGauge_GetShadowWidth(self.this)
|
||||
return val
|
||||
def GetValue(self):
|
||||
val = controlsc.wxGauge_GetValue(self.this)
|
||||
return val
|
||||
def SetBezelFace(self,arg0):
|
||||
val = controlsc.wxGauge_SetBezelFace(self.this,arg0)
|
||||
return val
|
||||
def SetRange(self,arg0):
|
||||
val = controlsc.wxGauge_SetRange(self.this,arg0)
|
||||
return val
|
||||
def SetShadowWidth(self,arg0):
|
||||
val = controlsc.wxGauge_SetShadowWidth(self.this,arg0)
|
||||
return val
|
||||
def SetValue(self,arg0):
|
||||
val = controlsc.wxGauge_SetValue(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxGauge instance>"
|
||||
class wxGauge(wxGaugePtr):
|
||||
def __init__(self,arg0,arg1,arg2,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controlsc.new_wxGauge,(arg0.this,arg1,arg2,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdWindowCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxStaticBoxPtr(wxControlPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __repr__(self):
|
||||
return "<C wxStaticBox instance>"
|
||||
class wxStaticBox(wxStaticBoxPtr):
|
||||
def __init__(self,arg0,arg1,arg2,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controlsc.new_wxStaticBox,(arg0.this,arg1,arg2,)+args)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxStaticTextPtr(wxControlPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetLabel(self):
|
||||
val = controlsc.wxStaticText_GetLabel(self.this)
|
||||
return val
|
||||
def SetLabel(self,arg0):
|
||||
val = controlsc.wxStaticText_SetLabel(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxStaticText instance>"
|
||||
class wxStaticText(wxStaticTextPtr):
|
||||
def __init__(self,arg0,arg1,arg2,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controlsc.new_wxStaticText,(arg0.this,arg1,arg2,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdWindowCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxListBoxPtr(wxControlPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def Append(self,arg0):
|
||||
val = controlsc.wxListBox_Append(self.this,arg0)
|
||||
return val
|
||||
def Clear(self):
|
||||
val = controlsc.wxListBox_Clear(self.this)
|
||||
return val
|
||||
def Delete(self,arg0):
|
||||
val = controlsc.wxListBox_Delete(self.this,arg0)
|
||||
return val
|
||||
def Deselect(self,arg0):
|
||||
val = controlsc.wxListBox_Deselect(self.this,arg0)
|
||||
return val
|
||||
def FindString(self,arg0):
|
||||
val = controlsc.wxListBox_FindString(self.this,arg0)
|
||||
return val
|
||||
def GetSelection(self):
|
||||
val = controlsc.wxListBox_GetSelection(self.this)
|
||||
return val
|
||||
def GetString(self,arg0):
|
||||
val = controlsc.wxListBox_GetString(self.this,arg0)
|
||||
return val
|
||||
def GetStringSelection(self):
|
||||
val = controlsc.wxListBox_GetStringSelection(self.this)
|
||||
return val
|
||||
def Number(self):
|
||||
val = controlsc.wxListBox_Number(self.this)
|
||||
return val
|
||||
def Selected(self,arg0):
|
||||
val = controlsc.wxListBox_Selected(self.this,arg0)
|
||||
return val
|
||||
def Set(self,arg0,*args):
|
||||
val = apply(controlsc.wxListBox_Set,(self.this,arg0,)+args)
|
||||
return val
|
||||
def SetFirstItem(self,arg0):
|
||||
val = controlsc.wxListBox_SetFirstItem(self.this,arg0)
|
||||
return val
|
||||
def SetFirstItemStr(self,arg0):
|
||||
val = controlsc.wxListBox_SetFirstItemStr(self.this,arg0)
|
||||
return val
|
||||
def SetSelection(self,arg0,*args):
|
||||
val = apply(controlsc.wxListBox_SetSelection,(self.this,arg0,)+args)
|
||||
return val
|
||||
def SetString(self,arg0,arg1):
|
||||
val = controlsc.wxListBox_SetString(self.this,arg0,arg1)
|
||||
return val
|
||||
def SetStringSelection(self,arg0,*args):
|
||||
val = apply(controlsc.wxListBox_SetStringSelection,(self.this,arg0,)+args)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxListBox instance>"
|
||||
class wxListBox(wxListBoxPtr):
|
||||
def __init__(self,arg0,arg1,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controlsc.new_wxListBox,(arg0.this,arg1,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdWindowCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxCheckListBoxPtr(wxListBoxPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def IsChecked(self,arg0):
|
||||
val = controlsc.wxCheckListBox_IsChecked(self.this,arg0)
|
||||
return val
|
||||
def Check(self,arg0,*args):
|
||||
val = apply(controlsc.wxCheckListBox_Check,(self.this,arg0,)+args)
|
||||
return val
|
||||
def GetItemHeight(self):
|
||||
val = controlsc.wxCheckListBox_GetItemHeight(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxCheckListBox instance>"
|
||||
class wxCheckListBox(wxCheckListBoxPtr):
|
||||
def __init__(self,arg0,arg1,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controlsc.new_wxCheckListBox,(arg0.this,arg1,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdWindowCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxTextCtrlPtr(wxControlPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def Clear(self):
|
||||
val = controlsc.wxTextCtrl_Clear(self.this)
|
||||
return val
|
||||
def Copy(self):
|
||||
val = controlsc.wxTextCtrl_Copy(self.this)
|
||||
return val
|
||||
def Cut(self):
|
||||
val = controlsc.wxTextCtrl_Cut(self.this)
|
||||
return val
|
||||
def DiscardEdits(self):
|
||||
val = controlsc.wxTextCtrl_DiscardEdits(self.this)
|
||||
return val
|
||||
def GetInsertionPoint(self):
|
||||
val = controlsc.wxTextCtrl_GetInsertionPoint(self.this)
|
||||
return val
|
||||
def GetLastPosition(self):
|
||||
val = controlsc.wxTextCtrl_GetLastPosition(self.this)
|
||||
return val
|
||||
def GetLineLength(self,arg0):
|
||||
val = controlsc.wxTextCtrl_GetLineLength(self.this,arg0)
|
||||
return val
|
||||
def GetLineText(self,arg0):
|
||||
val = controlsc.wxTextCtrl_GetLineText(self.this,arg0)
|
||||
return val
|
||||
def GetNumberOfLines(self):
|
||||
val = controlsc.wxTextCtrl_GetNumberOfLines(self.this)
|
||||
return val
|
||||
def GetValue(self):
|
||||
val = controlsc.wxTextCtrl_GetValue(self.this)
|
||||
return val
|
||||
def IsModified(self):
|
||||
val = controlsc.wxTextCtrl_IsModified(self.this)
|
||||
return val
|
||||
def LoadFile(self,arg0):
|
||||
val = controlsc.wxTextCtrl_LoadFile(self.this,arg0)
|
||||
return val
|
||||
def Paste(self):
|
||||
val = controlsc.wxTextCtrl_Paste(self.this)
|
||||
return val
|
||||
def PositionToXY(self,arg0):
|
||||
val = controlsc.wxTextCtrl_PositionToXY(self.this,arg0)
|
||||
return val
|
||||
def Remove(self,arg0,arg1):
|
||||
val = controlsc.wxTextCtrl_Remove(self.this,arg0,arg1)
|
||||
return val
|
||||
def Replace(self,arg0,arg1,arg2):
|
||||
val = controlsc.wxTextCtrl_Replace(self.this,arg0,arg1,arg2)
|
||||
return val
|
||||
def SaveFile(self,arg0):
|
||||
val = controlsc.wxTextCtrl_SaveFile(self.this,arg0)
|
||||
return val
|
||||
def SetEditable(self,arg0):
|
||||
val = controlsc.wxTextCtrl_SetEditable(self.this,arg0)
|
||||
return val
|
||||
def SetInsertionPoint(self,arg0):
|
||||
val = controlsc.wxTextCtrl_SetInsertionPoint(self.this,arg0)
|
||||
return val
|
||||
def SetInsertionPointEnd(self):
|
||||
val = controlsc.wxTextCtrl_SetInsertionPointEnd(self.this)
|
||||
return val
|
||||
def SetSelection(self,arg0,arg1):
|
||||
val = controlsc.wxTextCtrl_SetSelection(self.this,arg0,arg1)
|
||||
return val
|
||||
def SetValue(self,arg0):
|
||||
val = controlsc.wxTextCtrl_SetValue(self.this,arg0)
|
||||
return val
|
||||
def ShowPosition(self,arg0):
|
||||
val = controlsc.wxTextCtrl_ShowPosition(self.this,arg0)
|
||||
return val
|
||||
def WriteText(self,arg0):
|
||||
val = controlsc.wxTextCtrl_WriteText(self.this,arg0)
|
||||
return val
|
||||
def XYToPosition(self,arg0,arg1):
|
||||
val = controlsc.wxTextCtrl_XYToPosition(self.this,arg0,arg1)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxTextCtrl instance>"
|
||||
class wxTextCtrl(wxTextCtrlPtr):
|
||||
def __init__(self,arg0,arg1,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
try: argl[2] = argl[2].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controlsc.new_wxTextCtrl,(arg0.this,arg1,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdWindowCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxScrollBarPtr(wxControlPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetRange(self):
|
||||
val = controlsc.wxScrollBar_GetRange(self.this)
|
||||
return val
|
||||
def GetPageSize(self):
|
||||
val = controlsc.wxScrollBar_GetPageSize(self.this)
|
||||
return val
|
||||
def GetThumbPosition(self):
|
||||
val = controlsc.wxScrollBar_GetThumbPosition(self.this)
|
||||
return val
|
||||
def GetThumbSize(self):
|
||||
val = controlsc.wxScrollBar_GetThumbSize(self.this)
|
||||
return val
|
||||
def SetThumbPosition(self,arg0):
|
||||
val = controlsc.wxScrollBar_SetThumbPosition(self.this,arg0)
|
||||
return val
|
||||
def SetScrollbar(self,arg0,arg1,arg2,arg3,*args):
|
||||
val = apply(controlsc.wxScrollBar_SetScrollbar,(self.this,arg0,arg1,arg2,arg3,)+args)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxScrollBar instance>"
|
||||
class wxScrollBar(wxScrollBarPtr):
|
||||
def __init__(self,arg0,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
try: argl[2] = argl[2].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controlsc.new_wxScrollBar,(arg0.this,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdWindowCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxSpinButtonPtr(wxControlPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetMax(self):
|
||||
val = controlsc.wxSpinButton_GetMax(self.this)
|
||||
return val
|
||||
def GetMin(self):
|
||||
val = controlsc.wxSpinButton_GetMin(self.this)
|
||||
return val
|
||||
def GetValue(self):
|
||||
val = controlsc.wxSpinButton_GetValue(self.this)
|
||||
return val
|
||||
def SetRange(self,arg0,arg1):
|
||||
val = controlsc.wxSpinButton_SetRange(self.this,arg0,arg1)
|
||||
return val
|
||||
def SetValue(self,arg0):
|
||||
val = controlsc.wxSpinButton_SetValue(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxSpinButton instance>"
|
||||
class wxSpinButton(wxSpinButtonPtr):
|
||||
def __init__(self,arg0,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
try: argl[2] = argl[2].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controlsc.new_wxSpinButton,(arg0.this,)+args)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxStaticBitmapPtr(wxControlPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetBitmap(self):
|
||||
val = controlsc.wxStaticBitmap_GetBitmap(self.this)
|
||||
val = wxBitmapPtr(val)
|
||||
return val
|
||||
def SetBitmap(self,arg0):
|
||||
val = controlsc.wxStaticBitmap_SetBitmap(self.this,arg0.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxStaticBitmap instance>"
|
||||
class wxStaticBitmap(wxStaticBitmapPtr):
|
||||
def __init__(self,arg0,arg1,arg2,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controlsc.new_wxStaticBitmap,(arg0.this,arg1,arg2.this,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdWindowCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxRadioBoxPtr(wxControlPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def EnableBox(self,arg0):
|
||||
val = controlsc.wxRadioBox_EnableBox(self.this,arg0)
|
||||
return val
|
||||
def Enable(self,arg0,arg1):
|
||||
val = controlsc.wxRadioBox_Enable(self.this,arg0,arg1)
|
||||
return val
|
||||
def FindString(self,arg0):
|
||||
val = controlsc.wxRadioBox_FindString(self.this,arg0)
|
||||
return val
|
||||
def GetLabel(self,arg0):
|
||||
val = controlsc.wxRadioBox_GetLabel(self.this,arg0)
|
||||
return val
|
||||
def GetSelection(self):
|
||||
val = controlsc.wxRadioBox_GetSelection(self.this)
|
||||
return val
|
||||
def GetString(self,arg0):
|
||||
val = controlsc.wxRadioBox_GetString(self.this,arg0)
|
||||
return val
|
||||
def GetStringSelection(self):
|
||||
val = controlsc.wxRadioBox_GetStringSelection(self.this)
|
||||
return val
|
||||
def Number(self):
|
||||
val = controlsc.wxRadioBox_Number(self.this)
|
||||
return val
|
||||
def SetBoxLabel(self,arg0):
|
||||
val = controlsc.wxRadioBox_SetBoxLabel(self.this,arg0)
|
||||
return val
|
||||
def SetLabel(self,arg0,arg1):
|
||||
val = controlsc.wxRadioBox_SetLabel(self.this,arg0,arg1)
|
||||
return val
|
||||
def SetSelection(self,arg0):
|
||||
val = controlsc.wxRadioBox_SetSelection(self.this,arg0)
|
||||
return val
|
||||
def SetStringSelection(self,arg0):
|
||||
val = controlsc.wxRadioBox_SetStringSelection(self.this,arg0)
|
||||
return val
|
||||
def Show(self,arg0):
|
||||
val = controlsc.wxRadioBox_Show(self.this,arg0)
|
||||
return val
|
||||
def ShowItem(self,arg0,arg1):
|
||||
val = controlsc.wxRadioBox_ShowItem(self.this,arg0,arg1)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxRadioBox instance>"
|
||||
class wxRadioBox(wxRadioBoxPtr):
|
||||
def __init__(self,arg0,arg1,arg2,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controlsc.new_wxRadioBox,(arg0.this,arg1,arg2,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdWindowCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxRadioButtonPtr(wxControlPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetValue(self):
|
||||
val = controlsc.wxRadioButton_GetValue(self.this)
|
||||
return val
|
||||
def SetValue(self,arg0):
|
||||
val = controlsc.wxRadioButton_SetValue(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxRadioButton instance>"
|
||||
class wxRadioButton(wxRadioButtonPtr):
|
||||
def __init__(self,arg0,arg1,arg2,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controlsc.new_wxRadioButton,(arg0.this,arg1,arg2,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdWindowCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxSliderPtr(wxControlPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def ClearSel(self):
|
||||
val = controlsc.wxSlider_ClearSel(self.this)
|
||||
return val
|
||||
def ClearTicks(self):
|
||||
val = controlsc.wxSlider_ClearTicks(self.this)
|
||||
return val
|
||||
def GetLineSize(self):
|
||||
val = controlsc.wxSlider_GetLineSize(self.this)
|
||||
return val
|
||||
def GetMax(self):
|
||||
val = controlsc.wxSlider_GetMax(self.this)
|
||||
return val
|
||||
def GetMin(self):
|
||||
val = controlsc.wxSlider_GetMin(self.this)
|
||||
return val
|
||||
def GetPageSize(self):
|
||||
val = controlsc.wxSlider_GetPageSize(self.this)
|
||||
return val
|
||||
def GetSelEnd(self):
|
||||
val = controlsc.wxSlider_GetSelEnd(self.this)
|
||||
return val
|
||||
def GetSelStart(self):
|
||||
val = controlsc.wxSlider_GetSelStart(self.this)
|
||||
return val
|
||||
def GetThumbLength(self):
|
||||
val = controlsc.wxSlider_GetThumbLength(self.this)
|
||||
return val
|
||||
def GetTickFreq(self):
|
||||
val = controlsc.wxSlider_GetTickFreq(self.this)
|
||||
return val
|
||||
def GetValue(self):
|
||||
val = controlsc.wxSlider_GetValue(self.this)
|
||||
return val
|
||||
def SetRange(self,arg0,arg1):
|
||||
val = controlsc.wxSlider_SetRange(self.this,arg0,arg1)
|
||||
return val
|
||||
def SetTickFreq(self,arg0,arg1):
|
||||
val = controlsc.wxSlider_SetTickFreq(self.this,arg0,arg1)
|
||||
return val
|
||||
def SetLineSize(self,arg0):
|
||||
val = controlsc.wxSlider_SetLineSize(self.this,arg0)
|
||||
return val
|
||||
def SetPageSize(self,arg0):
|
||||
val = controlsc.wxSlider_SetPageSize(self.this,arg0)
|
||||
return val
|
||||
def SetSelection(self,arg0,arg1):
|
||||
val = controlsc.wxSlider_SetSelection(self.this,arg0,arg1)
|
||||
return val
|
||||
def SetThumbLength(self,arg0):
|
||||
val = controlsc.wxSlider_SetThumbLength(self.this,arg0)
|
||||
return val
|
||||
def SetTick(self,arg0):
|
||||
val = controlsc.wxSlider_SetTick(self.this,arg0)
|
||||
return val
|
||||
def SetValue(self,arg0):
|
||||
val = controlsc.wxSlider_SetValue(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxSlider instance>"
|
||||
class wxSlider(wxSliderPtr):
|
||||
def __init__(self,arg0,arg1,arg2,arg3,arg4,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controlsc.new_wxSlider,(arg0.this,arg1,arg2,arg3,arg4,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdWindowCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#-------------- FUNCTION WRAPPERS ------------------
|
||||
|
||||
|
||||
|
||||
#-------------- VARIABLE WRAPPERS ------------------
|
||||
|
||||
4160
utils/wxPython/src/gtk/controls2.cpp
Normal file
4160
utils/wxPython/src/gtk/controls2.cpp
Normal file
File diff suppressed because it is too large
Load Diff
606
utils/wxPython/src/gtk/controls2.py
Normal file
606
utils/wxPython/src/gtk/controls2.py
Normal file
@@ -0,0 +1,606 @@
|
||||
# This file was created automatically by SWIG.
|
||||
import controls2c
|
||||
|
||||
from misc import *
|
||||
|
||||
from windows import *
|
||||
|
||||
from gdi import *
|
||||
|
||||
from events import *
|
||||
|
||||
from controls import *
|
||||
import wx
|
||||
class wxListItemPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
controls2c.delete_wxListItem(self.this)
|
||||
def __setattr__(self,name,value):
|
||||
if name == "m_mask" :
|
||||
controls2c.wxListItem_m_mask_set(self.this,value)
|
||||
return
|
||||
if name == "m_itemId" :
|
||||
controls2c.wxListItem_m_itemId_set(self.this,value)
|
||||
return
|
||||
if name == "m_col" :
|
||||
controls2c.wxListItem_m_col_set(self.this,value)
|
||||
return
|
||||
if name == "m_state" :
|
||||
controls2c.wxListItem_m_state_set(self.this,value)
|
||||
return
|
||||
if name == "m_stateMask" :
|
||||
controls2c.wxListItem_m_stateMask_set(self.this,value)
|
||||
return
|
||||
if name == "m_text" :
|
||||
controls2c.wxListItem_m_text_set(self.this,value)
|
||||
return
|
||||
if name == "m_image" :
|
||||
controls2c.wxListItem_m_image_set(self.this,value)
|
||||
return
|
||||
if name == "m_data" :
|
||||
controls2c.wxListItem_m_data_set(self.this,value)
|
||||
return
|
||||
if name == "m_format" :
|
||||
controls2c.wxListItem_m_format_set(self.this,value)
|
||||
return
|
||||
if name == "m_width" :
|
||||
controls2c.wxListItem_m_width_set(self.this,value)
|
||||
return
|
||||
self.__dict__[name] = value
|
||||
def __getattr__(self,name):
|
||||
if name == "m_mask" :
|
||||
return controls2c.wxListItem_m_mask_get(self.this)
|
||||
if name == "m_itemId" :
|
||||
return controls2c.wxListItem_m_itemId_get(self.this)
|
||||
if name == "m_col" :
|
||||
return controls2c.wxListItem_m_col_get(self.this)
|
||||
if name == "m_state" :
|
||||
return controls2c.wxListItem_m_state_get(self.this)
|
||||
if name == "m_stateMask" :
|
||||
return controls2c.wxListItem_m_stateMask_get(self.this)
|
||||
if name == "m_text" :
|
||||
return controls2c.wxListItem_m_text_get(self.this)
|
||||
if name == "m_image" :
|
||||
return controls2c.wxListItem_m_image_get(self.this)
|
||||
if name == "m_data" :
|
||||
return controls2c.wxListItem_m_data_get(self.this)
|
||||
if name == "m_format" :
|
||||
return controls2c.wxListItem_m_format_get(self.this)
|
||||
if name == "m_width" :
|
||||
return controls2c.wxListItem_m_width_get(self.this)
|
||||
raise AttributeError,name
|
||||
def __repr__(self):
|
||||
return "<C wxListItem instance>"
|
||||
class wxListItem(wxListItemPtr):
|
||||
def __init__(self) :
|
||||
self.this = controls2c.new_wxListItem()
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxListEventPtr(wxCommandEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __setattr__(self,name,value):
|
||||
if name == "m_code" :
|
||||
controls2c.wxListEvent_m_code_set(self.this,value)
|
||||
return
|
||||
if name == "m_itemIndex" :
|
||||
controls2c.wxListEvent_m_itemIndex_set(self.this,value)
|
||||
return
|
||||
if name == "m_oldItemIndex" :
|
||||
controls2c.wxListEvent_m_oldItemIndex_set(self.this,value)
|
||||
return
|
||||
if name == "m_col" :
|
||||
controls2c.wxListEvent_m_col_set(self.this,value)
|
||||
return
|
||||
if name == "m_cancelled" :
|
||||
controls2c.wxListEvent_m_cancelled_set(self.this,value)
|
||||
return
|
||||
if name == "m_pointDrag" :
|
||||
controls2c.wxListEvent_m_pointDrag_set(self.this,value.this)
|
||||
return
|
||||
if name == "m_item" :
|
||||
controls2c.wxListEvent_m_item_set(self.this,value.this)
|
||||
return
|
||||
self.__dict__[name] = value
|
||||
def __getattr__(self,name):
|
||||
if name == "m_code" :
|
||||
return controls2c.wxListEvent_m_code_get(self.this)
|
||||
if name == "m_itemIndex" :
|
||||
return controls2c.wxListEvent_m_itemIndex_get(self.this)
|
||||
if name == "m_oldItemIndex" :
|
||||
return controls2c.wxListEvent_m_oldItemIndex_get(self.this)
|
||||
if name == "m_col" :
|
||||
return controls2c.wxListEvent_m_col_get(self.this)
|
||||
if name == "m_cancelled" :
|
||||
return controls2c.wxListEvent_m_cancelled_get(self.this)
|
||||
if name == "m_pointDrag" :
|
||||
return wxPointPtr(controls2c.wxListEvent_m_pointDrag_get(self.this))
|
||||
if name == "m_item" :
|
||||
return wxListItemPtr(controls2c.wxListEvent_m_item_get(self.this))
|
||||
raise AttributeError,name
|
||||
def __repr__(self):
|
||||
return "<C wxListEvent instance>"
|
||||
class wxListEvent(wxListEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxListCtrlPtr(wxControlPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def Arrange(self,*args):
|
||||
val = apply(controls2c.wxListCtrl_Arrange,(self.this,)+args)
|
||||
return val
|
||||
def DeleteItem(self,arg0):
|
||||
val = controls2c.wxListCtrl_DeleteItem(self.this,arg0)
|
||||
return val
|
||||
def DeleteAllItems(self):
|
||||
val = controls2c.wxListCtrl_DeleteAllItems(self.this)
|
||||
return val
|
||||
def DeleteColumn(self,arg0):
|
||||
val = controls2c.wxListCtrl_DeleteColumn(self.this,arg0)
|
||||
return val
|
||||
def DeleteAllColumns(self):
|
||||
val = controls2c.wxListCtrl_DeleteAllColumns(self.this)
|
||||
return val
|
||||
def ClearAll(self):
|
||||
val = controls2c.wxListCtrl_ClearAll(self.this)
|
||||
return val
|
||||
def EnsureVisible(self,arg0):
|
||||
val = controls2c.wxListCtrl_EnsureVisible(self.this,arg0)
|
||||
return val
|
||||
def FindItem(self,arg0,arg1,*args):
|
||||
val = apply(controls2c.wxListCtrl_FindItem,(self.this,arg0,arg1,)+args)
|
||||
return val
|
||||
def FindItemData(self,arg0,arg1):
|
||||
val = controls2c.wxListCtrl_FindItemData(self.this,arg0,arg1)
|
||||
return val
|
||||
def FindItemAtPos(self,arg0,arg1,arg2):
|
||||
val = controls2c.wxListCtrl_FindItemAtPos(self.this,arg0,arg1.this,arg2)
|
||||
return val
|
||||
def GetColumn(self,arg0,arg1):
|
||||
val = controls2c.wxListCtrl_GetColumn(self.this,arg0,arg1.this)
|
||||
return val
|
||||
def GetColumnWidth(self,arg0):
|
||||
val = controls2c.wxListCtrl_GetColumnWidth(self.this,arg0)
|
||||
return val
|
||||
def GetCountPerPage(self):
|
||||
val = controls2c.wxListCtrl_GetCountPerPage(self.this)
|
||||
return val
|
||||
def GetImageList(self,arg0):
|
||||
val = controls2c.wxListCtrl_GetImageList(self.this,arg0)
|
||||
return val
|
||||
def GetItemData(self,arg0):
|
||||
val = controls2c.wxListCtrl_GetItemData(self.this,arg0)
|
||||
return val
|
||||
def GetItem(self):
|
||||
val = controls2c.wxListCtrl_GetItem(self.this)
|
||||
val = wxListItemPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetItemPosition(self,arg0):
|
||||
val = controls2c.wxListCtrl_GetItemPosition(self.this,arg0)
|
||||
val = wxPointPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetItemRect(self,arg0,*args):
|
||||
val = apply(controls2c.wxListCtrl_GetItemRect,(self.this,arg0,)+args)
|
||||
val = wxRectPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetItemState(self,arg0,arg1):
|
||||
val = controls2c.wxListCtrl_GetItemState(self.this,arg0,arg1)
|
||||
return val
|
||||
def GetItemCount(self):
|
||||
val = controls2c.wxListCtrl_GetItemCount(self.this)
|
||||
return val
|
||||
def GetItemSpacing(self,arg0):
|
||||
val = controls2c.wxListCtrl_GetItemSpacing(self.this,arg0)
|
||||
return val
|
||||
def GetItemText(self,arg0):
|
||||
val = controls2c.wxListCtrl_GetItemText(self.this,arg0)
|
||||
return val
|
||||
def GetNextItem(self,arg0,*args):
|
||||
val = apply(controls2c.wxListCtrl_GetNextItem,(self.this,arg0,)+args)
|
||||
return val
|
||||
def GetSelectedItemCount(self):
|
||||
val = controls2c.wxListCtrl_GetSelectedItemCount(self.this)
|
||||
return val
|
||||
def GetTopItem(self):
|
||||
val = controls2c.wxListCtrl_GetTopItem(self.this)
|
||||
return val
|
||||
def HitTest(self,arg0):
|
||||
val = controls2c.wxListCtrl_HitTest(self.this,arg0.this)
|
||||
return val
|
||||
def InsertColumnWithInfo(self,arg0,arg1):
|
||||
val = controls2c.wxListCtrl_InsertColumnWithInfo(self.this,arg0,arg1.this)
|
||||
return val
|
||||
def InsertColumn(self,arg0,arg1,*args):
|
||||
val = apply(controls2c.wxListCtrl_InsertColumn,(self.this,arg0,arg1,)+args)
|
||||
return val
|
||||
def InsertItem(self,arg0):
|
||||
val = controls2c.wxListCtrl_InsertItem(self.this,arg0.this)
|
||||
return val
|
||||
def InsertStringItem(self,arg0,arg1):
|
||||
val = controls2c.wxListCtrl_InsertStringItem(self.this,arg0,arg1)
|
||||
return val
|
||||
def InsertImageItem(self,arg0,arg1):
|
||||
val = controls2c.wxListCtrl_InsertImageItem(self.this,arg0,arg1)
|
||||
return val
|
||||
def InsertImageStringItem(self,arg0,arg1,arg2):
|
||||
val = controls2c.wxListCtrl_InsertImageStringItem(self.this,arg0,arg1,arg2)
|
||||
return val
|
||||
def ScrollList(self,arg0,arg1):
|
||||
val = controls2c.wxListCtrl_ScrollList(self.this,arg0,arg1)
|
||||
return val
|
||||
def SetBackgroundColour(self,arg0):
|
||||
val = controls2c.wxListCtrl_SetBackgroundColour(self.this,arg0.this)
|
||||
return val
|
||||
def SetColumn(self,arg0,arg1):
|
||||
val = controls2c.wxListCtrl_SetColumn(self.this,arg0,arg1.this)
|
||||
return val
|
||||
def SetColumnWidth(self,arg0,arg1):
|
||||
val = controls2c.wxListCtrl_SetColumnWidth(self.this,arg0,arg1)
|
||||
return val
|
||||
def SetImageList(self,arg0,arg1):
|
||||
val = controls2c.wxListCtrl_SetImageList(self.this,arg0,arg1)
|
||||
return val
|
||||
def SetItem(self,arg0):
|
||||
val = controls2c.wxListCtrl_SetItem(self.this,arg0.this)
|
||||
return val
|
||||
def SetItemString(self,arg0,arg1,arg2,*args):
|
||||
val = apply(controls2c.wxListCtrl_SetItemString,(self.this,arg0,arg1,arg2,)+args)
|
||||
return val
|
||||
def SetItemData(self,arg0,arg1):
|
||||
val = controls2c.wxListCtrl_SetItemData(self.this,arg0,arg1)
|
||||
return val
|
||||
def SetItemImage(self,arg0,arg1,arg2):
|
||||
val = controls2c.wxListCtrl_SetItemImage(self.this,arg0,arg1,arg2)
|
||||
return val
|
||||
def SetItemPosition(self,arg0,arg1):
|
||||
val = controls2c.wxListCtrl_SetItemPosition(self.this,arg0,arg1.this)
|
||||
return val
|
||||
def SetItemState(self,arg0,arg1,arg2):
|
||||
val = controls2c.wxListCtrl_SetItemState(self.this,arg0,arg1,arg2)
|
||||
return val
|
||||
def SetItemText(self,arg0,arg1):
|
||||
val = controls2c.wxListCtrl_SetItemText(self.this,arg0,arg1)
|
||||
return val
|
||||
def SetSingleStyle(self,arg0,*args):
|
||||
val = apply(controls2c.wxListCtrl_SetSingleStyle,(self.this,arg0,)+args)
|
||||
return val
|
||||
def SetWindowStyleFlag(self,arg0):
|
||||
val = controls2c.wxListCtrl_SetWindowStyleFlag(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxListCtrl instance>"
|
||||
class wxListCtrl(wxListCtrlPtr):
|
||||
def __init__(self,arg0,arg1,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controls2c.new_wxListCtrl,(arg0.this,arg1,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdWindowCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxTreeItemIdPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
controls2c.delete_wxTreeItemId(self.this)
|
||||
def IsOk(self):
|
||||
val = controls2c.wxTreeItemId_IsOk(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxTreeItemId instance>"
|
||||
class wxTreeItemId(wxTreeItemIdPtr):
|
||||
def __init__(self) :
|
||||
self.this = controls2c.new_wxTreeItemId()
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxTreeItemDataPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
controls2c.delete_wxTreeItemData(self.this)
|
||||
def GetId(self):
|
||||
val = controls2c.wxTreeItemData_GetId(self.this)
|
||||
val = wxTreeItemIdPtr(val)
|
||||
return val
|
||||
def SetId(self,arg0):
|
||||
val = controls2c.wxTreeItemData_SetId(self.this,arg0.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxTreeItemData instance>"
|
||||
class wxTreeItemData(wxTreeItemDataPtr):
|
||||
def __init__(self) :
|
||||
self.this = controls2c.new_wxTreeItemData()
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxTreeEventPtr(wxCommandEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetItem(self):
|
||||
val = controls2c.wxTreeEvent_GetItem(self.this)
|
||||
val = wxTreeItemIdPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetOldItem(self):
|
||||
val = controls2c.wxTreeEvent_GetOldItem(self.this)
|
||||
val = wxTreeItemIdPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetPoint(self):
|
||||
val = controls2c.wxTreeEvent_GetPoint(self.this)
|
||||
val = wxPointPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetCode(self):
|
||||
val = controls2c.wxTreeEvent_GetCode(self.this)
|
||||
return val
|
||||
def Veto(self):
|
||||
val = controls2c.wxTreeEvent_Veto(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxTreeEvent instance>"
|
||||
class wxTreeEvent(wxTreeEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxTreeCtrlPtr(wxControlPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetCount(self):
|
||||
val = controls2c.wxTreeCtrl_GetCount(self.this)
|
||||
return val
|
||||
def GetIndent(self):
|
||||
val = controls2c.wxTreeCtrl_GetIndent(self.this)
|
||||
return val
|
||||
def SetIndent(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_SetIndent(self.this,arg0)
|
||||
return val
|
||||
def GetImageList(self):
|
||||
val = controls2c.wxTreeCtrl_GetImageList(self.this)
|
||||
return val
|
||||
def GetStateImageList(self):
|
||||
val = controls2c.wxTreeCtrl_GetStateImageList(self.this)
|
||||
return val
|
||||
def SetImageList(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_SetImageList(self.this,arg0)
|
||||
return val
|
||||
def SetStateImageList(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_SetStateImageList(self.this,arg0)
|
||||
return val
|
||||
def GetItemText(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_GetItemText(self.this,arg0.this)
|
||||
return val
|
||||
def GetItemImage(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_GetItemImage(self.this,arg0.this)
|
||||
return val
|
||||
def GetItemSelectedImage(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_GetItemSelectedImage(self.this,arg0.this)
|
||||
return val
|
||||
def GetItemData(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_GetItemData(self.this,arg0.this)
|
||||
val = wxTreeItemDataPtr(val)
|
||||
return val
|
||||
def SetItemText(self,arg0,arg1):
|
||||
val = controls2c.wxTreeCtrl_SetItemText(self.this,arg0.this,arg1)
|
||||
return val
|
||||
def SetItemImage(self,arg0,arg1):
|
||||
val = controls2c.wxTreeCtrl_SetItemImage(self.this,arg0.this,arg1)
|
||||
return val
|
||||
def SetItemSelectedImage(self,arg0,arg1):
|
||||
val = controls2c.wxTreeCtrl_SetItemSelectedImage(self.this,arg0.this,arg1)
|
||||
return val
|
||||
def SetItemData(self,arg0,arg1):
|
||||
val = controls2c.wxTreeCtrl_SetItemData(self.this,arg0.this,arg1.this)
|
||||
return val
|
||||
def SetItemHasChildren(self,arg0,*args):
|
||||
val = apply(controls2c.wxTreeCtrl_SetItemHasChildren,(self.this,arg0.this,)+args)
|
||||
return val
|
||||
def IsVisible(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_IsVisible(self.this,arg0.this)
|
||||
return val
|
||||
def ItemHasChildren(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_ItemHasChildren(self.this,arg0.this)
|
||||
return val
|
||||
def IsExpanded(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_IsExpanded(self.this,arg0.this)
|
||||
return val
|
||||
def IsSelected(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_IsSelected(self.this,arg0.this)
|
||||
return val
|
||||
def GetRootItem(self):
|
||||
val = controls2c.wxTreeCtrl_GetRootItem(self.this)
|
||||
val = wxTreeItemIdPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetSelection(self):
|
||||
val = controls2c.wxTreeCtrl_GetSelection(self.this)
|
||||
val = wxTreeItemIdPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetParent(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_GetParent(self.this,arg0.this)
|
||||
val = wxTreeItemIdPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetFirstChild(self,arg0,arg1):
|
||||
val = controls2c.wxTreeCtrl_GetFirstChild(self.this,arg0.this,arg1)
|
||||
return val
|
||||
def GetNextChild(self,arg0,arg1):
|
||||
val = controls2c.wxTreeCtrl_GetNextChild(self.this,arg0.this,arg1)
|
||||
return val
|
||||
def GetNextSibling(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_GetNextSibling(self.this,arg0.this)
|
||||
val = wxTreeItemIdPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetPrevSibling(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_GetPrevSibling(self.this,arg0.this)
|
||||
val = wxTreeItemIdPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetFirstVisibleItem(self):
|
||||
val = controls2c.wxTreeCtrl_GetFirstVisibleItem(self.this)
|
||||
val = wxTreeItemIdPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetNextVisible(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_GetNextVisible(self.this,arg0.this)
|
||||
val = wxTreeItemIdPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetPrevVisible(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_GetPrevVisible(self.this,arg0.this)
|
||||
val = wxTreeItemIdPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def AddRoot(self,arg0,*args):
|
||||
argl = map(None,args)
|
||||
try: argl[2] = argl[2].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
val = apply(controls2c.wxTreeCtrl_AddRoot,(self.this,arg0,)+args)
|
||||
val = wxTreeItemIdPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def PrependItem(self,arg0,arg1,*args):
|
||||
argl = map(None,args)
|
||||
try: argl[2] = argl[2].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
val = apply(controls2c.wxTreeCtrl_PrependItem,(self.this,arg0.this,arg1,)+args)
|
||||
val = wxTreeItemIdPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def InsertItem(self,arg0,arg1,arg2,*args):
|
||||
argl = map(None,args)
|
||||
try: argl[2] = argl[2].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
val = apply(controls2c.wxTreeCtrl_InsertItem,(self.this,arg0.this,arg1.this,arg2,)+args)
|
||||
val = wxTreeItemIdPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def AppendItem(self,arg0,arg1,*args):
|
||||
argl = map(None,args)
|
||||
try: argl[2] = argl[2].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
val = apply(controls2c.wxTreeCtrl_AppendItem,(self.this,arg0.this,arg1,)+args)
|
||||
val = wxTreeItemIdPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def Delete(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_Delete(self.this,arg0.this)
|
||||
return val
|
||||
def DeleteChildren(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_DeleteChildren(self.this,arg0.this)
|
||||
return val
|
||||
def DeleteAllItems(self):
|
||||
val = controls2c.wxTreeCtrl_DeleteAllItems(self.this)
|
||||
return val
|
||||
def Expand(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_Expand(self.this,arg0.this)
|
||||
return val
|
||||
def Collapse(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_Collapse(self.this,arg0.this)
|
||||
return val
|
||||
def CollapseAndReset(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_CollapseAndReset(self.this,arg0.this)
|
||||
return val
|
||||
def Toggle(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_Toggle(self.this,arg0.this)
|
||||
return val
|
||||
def Unselect(self):
|
||||
val = controls2c.wxTreeCtrl_Unselect(self.this)
|
||||
return val
|
||||
def SelectItem(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_SelectItem(self.this,arg0.this)
|
||||
return val
|
||||
def EnsureVisible(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_EnsureVisible(self.this,arg0.this)
|
||||
return val
|
||||
def ScrollTo(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_ScrollTo(self.this,arg0.this)
|
||||
return val
|
||||
def EditLabel(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_EditLabel(self.this,arg0.this)
|
||||
val = wxTextCtrlPtr(val)
|
||||
return val
|
||||
def GetEditControl(self):
|
||||
val = controls2c.wxTreeCtrl_GetEditControl(self.this)
|
||||
val = wxTextCtrlPtr(val)
|
||||
return val
|
||||
def EndEditLabel(self,arg0,*args):
|
||||
val = apply(controls2c.wxTreeCtrl_EndEditLabel,(self.this,arg0.this,)+args)
|
||||
return val
|
||||
def SetItemBold(self,arg0,*args):
|
||||
val = apply(controls2c.wxTreeCtrl_SetItemBold,(self.this,arg0.this,)+args)
|
||||
return val
|
||||
def IsBold(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_IsBold(self.this,arg0.this)
|
||||
return val
|
||||
def HitTest(self,arg0):
|
||||
val = controls2c.wxTreeCtrl_HitTest(self.this,arg0.this)
|
||||
val = wxTreeItemIdPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxTreeCtrl instance>"
|
||||
class wxTreeCtrl(wxTreeCtrlPtr):
|
||||
def __init__(self,arg0,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
try: argl[2] = argl[2].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(controls2c.new_wxTreeCtrl,(arg0.this,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdWindowCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#-------------- FUNCTION WRAPPERS ------------------
|
||||
|
||||
|
||||
|
||||
#-------------- VARIABLE WRAPPERS ------------------
|
||||
|
||||
0
utils/wxPython/src/gtk/dummy
Normal file
0
utils/wxPython/src/gtk/dummy
Normal file
2940
utils/wxPython/src/gtk/events.cpp
Normal file
2940
utils/wxPython/src/gtk/events.cpp
Normal file
File diff suppressed because it is too large
Load Diff
630
utils/wxPython/src/gtk/events.py
Normal file
630
utils/wxPython/src/gtk/events.py
Normal file
@@ -0,0 +1,630 @@
|
||||
# This file was created automatically by SWIG.
|
||||
import eventsc
|
||||
|
||||
from misc import *
|
||||
class wxEventPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetEventObject(self):
|
||||
val = eventsc.wxEvent_GetEventObject(self.this)
|
||||
return val
|
||||
def GetEventType(self):
|
||||
val = eventsc.wxEvent_GetEventType(self.this)
|
||||
return val
|
||||
def GetId(self):
|
||||
val = eventsc.wxEvent_GetId(self.this)
|
||||
return val
|
||||
def GetSkipped(self):
|
||||
val = eventsc.wxEvent_GetSkipped(self.this)
|
||||
return val
|
||||
def GetTimestamp(self):
|
||||
val = eventsc.wxEvent_GetTimestamp(self.this)
|
||||
return val
|
||||
def SetEventObject(self,arg0):
|
||||
val = eventsc.wxEvent_SetEventObject(self.this,arg0)
|
||||
return val
|
||||
def SetEventType(self,arg0):
|
||||
val = eventsc.wxEvent_SetEventType(self.this,arg0)
|
||||
return val
|
||||
def SetId(self,arg0):
|
||||
val = eventsc.wxEvent_SetId(self.this,arg0)
|
||||
return val
|
||||
def SetTimestamp(self,arg0):
|
||||
val = eventsc.wxEvent_SetTimestamp(self.this,arg0)
|
||||
return val
|
||||
def Skip(self,*args):
|
||||
val = apply(eventsc.wxEvent_Skip,(self.this,)+args)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxEvent instance>"
|
||||
class wxEvent(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxSizeEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetSize(self):
|
||||
val = eventsc.wxSizeEvent_GetSize(self.this)
|
||||
val = wxSizePtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxSizeEvent instance>"
|
||||
class wxSizeEvent(wxSizeEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxCloseEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def CanVeto(self):
|
||||
val = eventsc.wxCloseEvent_CanVeto(self.this)
|
||||
return val
|
||||
def GetLoggingOff(self):
|
||||
val = eventsc.wxCloseEvent_GetLoggingOff(self.this)
|
||||
return val
|
||||
def Veto(self,*args):
|
||||
val = apply(eventsc.wxCloseEvent_Veto,(self.this,)+args)
|
||||
return val
|
||||
def GetVeto(self):
|
||||
val = eventsc.wxCloseEvent_GetVeto(self.this)
|
||||
return val
|
||||
def SetForce(self,arg0):
|
||||
val = eventsc.wxCloseEvent_SetForce(self.this,arg0)
|
||||
return val
|
||||
def SetCanVeto(self,arg0):
|
||||
val = eventsc.wxCloseEvent_SetCanVeto(self.this,arg0)
|
||||
return val
|
||||
def SetLoggingOff(self,arg0):
|
||||
val = eventsc.wxCloseEvent_SetLoggingOff(self.this,arg0)
|
||||
return val
|
||||
def GetForce(self):
|
||||
val = eventsc.wxCloseEvent_GetForce(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxCloseEvent instance>"
|
||||
class wxCloseEvent(wxCloseEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxCommandEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def Checked(self):
|
||||
val = eventsc.wxCommandEvent_Checked(self.this)
|
||||
return val
|
||||
def GetExtraLong(self):
|
||||
val = eventsc.wxCommandEvent_GetExtraLong(self.this)
|
||||
return val
|
||||
def GetInt(self):
|
||||
val = eventsc.wxCommandEvent_GetInt(self.this)
|
||||
return val
|
||||
def GetSelection(self):
|
||||
val = eventsc.wxCommandEvent_GetSelection(self.this)
|
||||
return val
|
||||
def GetString(self):
|
||||
val = eventsc.wxCommandEvent_GetString(self.this)
|
||||
return val
|
||||
def IsSelection(self):
|
||||
val = eventsc.wxCommandEvent_IsSelection(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxCommandEvent instance>"
|
||||
class wxCommandEvent(wxCommandEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxScrollEventPtr(wxCommandEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetOrientation(self):
|
||||
val = eventsc.wxScrollEvent_GetOrientation(self.this)
|
||||
return val
|
||||
def GetPosition(self):
|
||||
val = eventsc.wxScrollEvent_GetPosition(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxScrollEvent instance>"
|
||||
class wxScrollEvent(wxScrollEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxSpinEventPtr(wxScrollEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __repr__(self):
|
||||
return "<C wxSpinEvent instance>"
|
||||
class wxSpinEvent(wxSpinEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxMouseEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def IsButton(self):
|
||||
val = eventsc.wxMouseEvent_IsButton(self.this)
|
||||
return val
|
||||
def ButtonDown(self,*args):
|
||||
val = apply(eventsc.wxMouseEvent_ButtonDown,(self.this,)+args)
|
||||
return val
|
||||
def ButtonDClick(self,*args):
|
||||
val = apply(eventsc.wxMouseEvent_ButtonDClick,(self.this,)+args)
|
||||
return val
|
||||
def ButtonUp(self,*args):
|
||||
val = apply(eventsc.wxMouseEvent_ButtonUp,(self.this,)+args)
|
||||
return val
|
||||
def Button(self,arg0):
|
||||
val = eventsc.wxMouseEvent_Button(self.this,arg0)
|
||||
return val
|
||||
def ButtonIsDown(self,arg0):
|
||||
val = eventsc.wxMouseEvent_ButtonIsDown(self.this,arg0)
|
||||
return val
|
||||
def ControlDown(self):
|
||||
val = eventsc.wxMouseEvent_ControlDown(self.this)
|
||||
return val
|
||||
def MetaDown(self):
|
||||
val = eventsc.wxMouseEvent_MetaDown(self.this)
|
||||
return val
|
||||
def AltDown(self):
|
||||
val = eventsc.wxMouseEvent_AltDown(self.this)
|
||||
return val
|
||||
def ShiftDown(self):
|
||||
val = eventsc.wxMouseEvent_ShiftDown(self.this)
|
||||
return val
|
||||
def LeftDown(self):
|
||||
val = eventsc.wxMouseEvent_LeftDown(self.this)
|
||||
return val
|
||||
def MiddleDown(self):
|
||||
val = eventsc.wxMouseEvent_MiddleDown(self.this)
|
||||
return val
|
||||
def RightDown(self):
|
||||
val = eventsc.wxMouseEvent_RightDown(self.this)
|
||||
return val
|
||||
def LeftUp(self):
|
||||
val = eventsc.wxMouseEvent_LeftUp(self.this)
|
||||
return val
|
||||
def MiddleUp(self):
|
||||
val = eventsc.wxMouseEvent_MiddleUp(self.this)
|
||||
return val
|
||||
def RightUp(self):
|
||||
val = eventsc.wxMouseEvent_RightUp(self.this)
|
||||
return val
|
||||
def LeftDClick(self):
|
||||
val = eventsc.wxMouseEvent_LeftDClick(self.this)
|
||||
return val
|
||||
def MiddleDClick(self):
|
||||
val = eventsc.wxMouseEvent_MiddleDClick(self.this)
|
||||
return val
|
||||
def RightDClick(self):
|
||||
val = eventsc.wxMouseEvent_RightDClick(self.this)
|
||||
return val
|
||||
def LeftIsDown(self):
|
||||
val = eventsc.wxMouseEvent_LeftIsDown(self.this)
|
||||
return val
|
||||
def MiddleIsDown(self):
|
||||
val = eventsc.wxMouseEvent_MiddleIsDown(self.this)
|
||||
return val
|
||||
def RightIsDown(self):
|
||||
val = eventsc.wxMouseEvent_RightIsDown(self.this)
|
||||
return val
|
||||
def Dragging(self):
|
||||
val = eventsc.wxMouseEvent_Dragging(self.this)
|
||||
return val
|
||||
def Moving(self):
|
||||
val = eventsc.wxMouseEvent_Moving(self.this)
|
||||
return val
|
||||
def Entering(self):
|
||||
val = eventsc.wxMouseEvent_Entering(self.this)
|
||||
return val
|
||||
def Leaving(self):
|
||||
val = eventsc.wxMouseEvent_Leaving(self.this)
|
||||
return val
|
||||
def Position(self):
|
||||
val = eventsc.wxMouseEvent_Position(self.this)
|
||||
return val
|
||||
def GetPosition(self):
|
||||
val = eventsc.wxMouseEvent_GetPosition(self.this)
|
||||
val = wxPointPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetLogicalPosition(self,arg0):
|
||||
val = eventsc.wxMouseEvent_GetLogicalPosition(self.this,arg0.this)
|
||||
val = wxPointPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetX(self):
|
||||
val = eventsc.wxMouseEvent_GetX(self.this)
|
||||
return val
|
||||
def GetY(self):
|
||||
val = eventsc.wxMouseEvent_GetY(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxMouseEvent instance>"
|
||||
class wxMouseEvent(wxMouseEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxKeyEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def ControlDown(self):
|
||||
val = eventsc.wxKeyEvent_ControlDown(self.this)
|
||||
return val
|
||||
def MetaDown(self):
|
||||
val = eventsc.wxKeyEvent_MetaDown(self.this)
|
||||
return val
|
||||
def AltDown(self):
|
||||
val = eventsc.wxKeyEvent_AltDown(self.this)
|
||||
return val
|
||||
def ShiftDown(self):
|
||||
val = eventsc.wxKeyEvent_ShiftDown(self.this)
|
||||
return val
|
||||
def KeyCode(self):
|
||||
val = eventsc.wxKeyEvent_KeyCode(self.this)
|
||||
return val
|
||||
def Position(self):
|
||||
val = eventsc.wxKeyEvent_Position(self.this)
|
||||
return val
|
||||
def GetX(self):
|
||||
val = eventsc.wxKeyEvent_GetX(self.this)
|
||||
return val
|
||||
def GetY(self):
|
||||
val = eventsc.wxKeyEvent_GetY(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxKeyEvent instance>"
|
||||
class wxKeyEvent(wxKeyEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxMoveEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetPosition(self):
|
||||
val = eventsc.wxMoveEvent_GetPosition(self.this)
|
||||
val = wxPointPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxMoveEvent instance>"
|
||||
class wxMoveEvent(wxMoveEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxPaintEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __repr__(self):
|
||||
return "<C wxPaintEvent instance>"
|
||||
class wxPaintEvent(wxPaintEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxEraseEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetDC(self):
|
||||
val = eventsc.wxEraseEvent_GetDC(self.this)
|
||||
val = wxDCPtr(val)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxEraseEvent instance>"
|
||||
class wxEraseEvent(wxEraseEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxFocusEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __repr__(self):
|
||||
return "<C wxFocusEvent instance>"
|
||||
class wxFocusEvent(wxFocusEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxActivateEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetActive(self):
|
||||
val = eventsc.wxActivateEvent_GetActive(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxActivateEvent instance>"
|
||||
class wxActivateEvent(wxActivateEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxInitDialogEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __repr__(self):
|
||||
return "<C wxInitDialogEvent instance>"
|
||||
class wxInitDialogEvent(wxInitDialogEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxMenuEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetMenuId(self):
|
||||
val = eventsc.wxMenuEvent_GetMenuId(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxMenuEvent instance>"
|
||||
class wxMenuEvent(wxMenuEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxShowEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def SetShow(self,arg0):
|
||||
val = eventsc.wxShowEvent_SetShow(self.this,arg0)
|
||||
return val
|
||||
def GetShow(self):
|
||||
val = eventsc.wxShowEvent_GetShow(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxShowEvent instance>"
|
||||
class wxShowEvent(wxShowEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxIconizeEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __repr__(self):
|
||||
return "<C wxIconizeEvent instance>"
|
||||
class wxIconizeEvent(wxIconizeEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxMaximizeEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __repr__(self):
|
||||
return "<C wxMaximizeEvent instance>"
|
||||
class wxMaximizeEvent(wxMaximizeEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxJoystickEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetPosition(self):
|
||||
val = eventsc.wxJoystickEvent_GetPosition(self.this)
|
||||
val = wxPointPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetZPosition(self):
|
||||
val = eventsc.wxJoystickEvent_GetZPosition(self.this)
|
||||
return val
|
||||
def GetButtonState(self):
|
||||
val = eventsc.wxJoystickEvent_GetButtonState(self.this)
|
||||
return val
|
||||
def GetButtonChange(self):
|
||||
val = eventsc.wxJoystickEvent_GetButtonChange(self.this)
|
||||
return val
|
||||
def GetJoystick(self):
|
||||
val = eventsc.wxJoystickEvent_GetJoystick(self.this)
|
||||
return val
|
||||
def SetJoystick(self,arg0):
|
||||
val = eventsc.wxJoystickEvent_SetJoystick(self.this,arg0)
|
||||
return val
|
||||
def SetButtonState(self,arg0):
|
||||
val = eventsc.wxJoystickEvent_SetButtonState(self.this,arg0)
|
||||
return val
|
||||
def SetButtonChange(self,arg0):
|
||||
val = eventsc.wxJoystickEvent_SetButtonChange(self.this,arg0)
|
||||
return val
|
||||
def SetPosition(self,arg0):
|
||||
val = eventsc.wxJoystickEvent_SetPosition(self.this,arg0.this)
|
||||
return val
|
||||
def SetZPosition(self,arg0):
|
||||
val = eventsc.wxJoystickEvent_SetZPosition(self.this,arg0)
|
||||
return val
|
||||
def IsButton(self):
|
||||
val = eventsc.wxJoystickEvent_IsButton(self.this)
|
||||
return val
|
||||
def IsMove(self):
|
||||
val = eventsc.wxJoystickEvent_IsMove(self.this)
|
||||
return val
|
||||
def IsZMove(self):
|
||||
val = eventsc.wxJoystickEvent_IsZMove(self.this)
|
||||
return val
|
||||
def ButtonDown(self,*args):
|
||||
val = apply(eventsc.wxJoystickEvent_ButtonDown,(self.this,)+args)
|
||||
return val
|
||||
def ButtonUp(self,*args):
|
||||
val = apply(eventsc.wxJoystickEvent_ButtonUp,(self.this,)+args)
|
||||
return val
|
||||
def ButtonIsDown(self,*args):
|
||||
val = apply(eventsc.wxJoystickEvent_ButtonIsDown,(self.this,)+args)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxJoystickEvent instance>"
|
||||
class wxJoystickEvent(wxJoystickEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxDropFilesEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetPosition(self):
|
||||
val = eventsc.wxDropFilesEvent_GetPosition(self.this)
|
||||
val = wxPointPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetNumberOfFiles(self):
|
||||
val = eventsc.wxDropFilesEvent_GetNumberOfFiles(self.this)
|
||||
return val
|
||||
def GetFiles(self):
|
||||
val = eventsc.wxDropFilesEvent_GetFiles(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxDropFilesEvent instance>"
|
||||
class wxDropFilesEvent(wxDropFilesEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxIdleEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def RequestMore(self,*args):
|
||||
val = apply(eventsc.wxIdleEvent_RequestMore,(self.this,)+args)
|
||||
return val
|
||||
def MoreRequested(self):
|
||||
val = eventsc.wxIdleEvent_MoreRequested(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxIdleEvent instance>"
|
||||
class wxIdleEvent(wxIdleEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxUpdateUIEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetChecked(self):
|
||||
val = eventsc.wxUpdateUIEvent_GetChecked(self.this)
|
||||
return val
|
||||
def GetEnabled(self):
|
||||
val = eventsc.wxUpdateUIEvent_GetEnabled(self.this)
|
||||
return val
|
||||
def GetText(self):
|
||||
val = eventsc.wxUpdateUIEvent_GetText(self.this)
|
||||
return val
|
||||
def GetSetText(self):
|
||||
val = eventsc.wxUpdateUIEvent_GetSetText(self.this)
|
||||
return val
|
||||
def GetSetChecked(self):
|
||||
val = eventsc.wxUpdateUIEvent_GetSetChecked(self.this)
|
||||
return val
|
||||
def GetSetEnabled(self):
|
||||
val = eventsc.wxUpdateUIEvent_GetSetEnabled(self.this)
|
||||
return val
|
||||
def Check(self,arg0):
|
||||
val = eventsc.wxUpdateUIEvent_Check(self.this,arg0)
|
||||
return val
|
||||
def Enable(self,arg0):
|
||||
val = eventsc.wxUpdateUIEvent_Enable(self.this,arg0)
|
||||
return val
|
||||
def SetText(self,arg0):
|
||||
val = eventsc.wxUpdateUIEvent_SetText(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxUpdateUIEvent instance>"
|
||||
class wxUpdateUIEvent(wxUpdateUIEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxSysColourChangedEventPtr(wxEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __repr__(self):
|
||||
return "<C wxSysColourChangedEvent instance>"
|
||||
class wxSysColourChangedEvent(wxSysColourChangedEventPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#-------------- FUNCTION WRAPPERS ------------------
|
||||
|
||||
|
||||
|
||||
#-------------- VARIABLE WRAPPERS ------------------
|
||||
|
||||
1020
utils/wxPython/src/gtk/frames.cpp
Normal file
1020
utils/wxPython/src/gtk/frames.cpp
Normal file
File diff suppressed because it is too large
Load Diff
124
utils/wxPython/src/gtk/frames.py
Normal file
124
utils/wxPython/src/gtk/frames.py
Normal file
@@ -0,0 +1,124 @@
|
||||
# This file was created automatically by SWIG.
|
||||
import framesc
|
||||
|
||||
from misc import *
|
||||
|
||||
from gdi import *
|
||||
|
||||
from windows import *
|
||||
|
||||
from stattool import *
|
||||
|
||||
from controls import *
|
||||
|
||||
from events import *
|
||||
import wx
|
||||
class wxFramePtr(wxWindowPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def Centre(self,*args):
|
||||
val = apply(framesc.wxFrame_Centre,(self.this,)+args)
|
||||
return val
|
||||
def CreateStatusBar(self,*args):
|
||||
val = apply(framesc.wxFrame_CreateStatusBar,(self.this,)+args)
|
||||
val = wxStatusBarPtr(val)
|
||||
return val
|
||||
def CreateToolBar(self,*args):
|
||||
val = apply(framesc.wxFrame_CreateToolBar,(self.this,)+args)
|
||||
val = wxToolBarPtr(val)
|
||||
return val
|
||||
def GetMenuBar(self):
|
||||
val = framesc.wxFrame_GetMenuBar(self.this)
|
||||
val = wxMenuBarPtr(val)
|
||||
return val
|
||||
def GetStatusBar(self):
|
||||
val = framesc.wxFrame_GetStatusBar(self.this)
|
||||
val = wxStatusBarPtr(val)
|
||||
return val
|
||||
def GetTitle(self):
|
||||
val = framesc.wxFrame_GetTitle(self.this)
|
||||
return val
|
||||
def GetToolBar(self):
|
||||
val = framesc.wxFrame_GetToolBar(self.this)
|
||||
val = wxToolBarPtr(val)
|
||||
return val
|
||||
def Iconize(self,arg0):
|
||||
val = framesc.wxFrame_Iconize(self.this,arg0)
|
||||
return val
|
||||
def IsIconized(self):
|
||||
val = framesc.wxFrame_IsIconized(self.this)
|
||||
return val
|
||||
def Maximize(self,arg0):
|
||||
val = framesc.wxFrame_Maximize(self.this,arg0)
|
||||
return val
|
||||
def SetAcceleratorTable(self,arg0):
|
||||
val = framesc.wxFrame_SetAcceleratorTable(self.this,arg0.this)
|
||||
return val
|
||||
def SetIcon(self,arg0):
|
||||
val = framesc.wxFrame_SetIcon(self.this,arg0.this)
|
||||
return val
|
||||
def SetMenuBar(self,arg0):
|
||||
val = framesc.wxFrame_SetMenuBar(self.this,arg0.this)
|
||||
return val
|
||||
def SetStatusBar(self,arg0):
|
||||
val = framesc.wxFrame_SetStatusBar(self.this,arg0.this)
|
||||
return val
|
||||
def SetStatusText(self,arg0,*args):
|
||||
val = apply(framesc.wxFrame_SetStatusText,(self.this,arg0,)+args)
|
||||
return val
|
||||
def SetStatusWidths(self,arg0,*args):
|
||||
val = apply(framesc.wxFrame_SetStatusWidths,(self.this,arg0,)+args)
|
||||
return val
|
||||
def SetTitle(self,arg0):
|
||||
val = framesc.wxFrame_SetTitle(self.this,arg0)
|
||||
return val
|
||||
def SetToolBar(self,arg0):
|
||||
val = framesc.wxFrame_SetToolBar(self.this,arg0.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxFrame instance>"
|
||||
class wxFrame(wxFramePtr):
|
||||
def __init__(self,arg0,arg1,arg2,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(framesc.new_wxFrame,(arg0.this,arg1,arg2,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdFrameCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxMiniFramePtr(wxFramePtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __repr__(self):
|
||||
return "<C wxMiniFrame instance>"
|
||||
class wxMiniFrame(wxMiniFramePtr):
|
||||
def __init__(self,arg0,arg1,arg2,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(framesc.new_wxMiniFrame,(arg0.this,arg1,arg2,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdFrameCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#-------------- FUNCTION WRAPPERS ------------------
|
||||
|
||||
|
||||
|
||||
#-------------- VARIABLE WRAPPERS ------------------
|
||||
|
||||
5155
utils/wxPython/src/gtk/gdi.cpp
Normal file
5155
utils/wxPython/src/gtk/gdi.cpp
Normal file
File diff suppressed because it is too large
Load Diff
758
utils/wxPython/src/gtk/gdi.py
Normal file
758
utils/wxPython/src/gtk/gdi.py
Normal file
@@ -0,0 +1,758 @@
|
||||
# This file was created automatically by SWIG.
|
||||
import gdic
|
||||
|
||||
from misc import *
|
||||
class wxBitmapPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
gdic.delete_wxBitmap(self.this)
|
||||
def GetDepth(self):
|
||||
val = gdic.wxBitmap_GetDepth(self.this)
|
||||
return val
|
||||
def GetHeight(self):
|
||||
val = gdic.wxBitmap_GetHeight(self.this)
|
||||
return val
|
||||
def GetPalette(self):
|
||||
val = gdic.wxBitmap_GetPalette(self.this)
|
||||
val = wxPalettePtr(val)
|
||||
return val
|
||||
def GetMask(self):
|
||||
val = gdic.wxBitmap_GetMask(self.this)
|
||||
val = wxMaskPtr(val)
|
||||
return val
|
||||
def GetWidth(self):
|
||||
val = gdic.wxBitmap_GetWidth(self.this)
|
||||
return val
|
||||
def LoadFile(self,arg0,arg1):
|
||||
val = gdic.wxBitmap_LoadFile(self.this,arg0,arg1)
|
||||
return val
|
||||
def Ok(self):
|
||||
val = gdic.wxBitmap_Ok(self.this)
|
||||
return val
|
||||
def SaveFile(self,arg0,arg1,*args):
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
val = apply(gdic.wxBitmap_SaveFile,(self.this,arg0,arg1,)+args)
|
||||
return val
|
||||
def SetDepth(self,arg0):
|
||||
val = gdic.wxBitmap_SetDepth(self.this,arg0)
|
||||
return val
|
||||
def SetHeight(self,arg0):
|
||||
val = gdic.wxBitmap_SetHeight(self.this,arg0)
|
||||
return val
|
||||
def SetMask(self,arg0):
|
||||
val = gdic.wxBitmap_SetMask(self.this,arg0.this)
|
||||
return val
|
||||
def SetWidth(self,arg0):
|
||||
val = gdic.wxBitmap_SetWidth(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxBitmap instance>"
|
||||
class wxBitmap(wxBitmapPtr):
|
||||
def __init__(self,arg0,arg1) :
|
||||
self.this = gdic.new_wxBitmap(arg0,arg1)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxMaskPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
gdic.delete_wxMask(self.this)
|
||||
def __repr__(self):
|
||||
return "<C wxMask instance>"
|
||||
class wxMask(wxMaskPtr):
|
||||
def __init__(self,arg0) :
|
||||
self.this = gdic.new_wxMask(arg0.this)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxIconPtr(wxBitmapPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
gdic.delete_wxIcon(self.this)
|
||||
def GetDepth(self):
|
||||
val = gdic.wxIcon_GetDepth(self.this)
|
||||
return val
|
||||
def GetHeight(self):
|
||||
val = gdic.wxIcon_GetHeight(self.this)
|
||||
return val
|
||||
def GetWidth(self):
|
||||
val = gdic.wxIcon_GetWidth(self.this)
|
||||
return val
|
||||
def LoadFile(self,arg0,arg1):
|
||||
val = gdic.wxIcon_LoadFile(self.this,arg0,arg1)
|
||||
return val
|
||||
def Ok(self):
|
||||
val = gdic.wxIcon_Ok(self.this)
|
||||
return val
|
||||
def SetDepth(self,arg0):
|
||||
val = gdic.wxIcon_SetDepth(self.this,arg0)
|
||||
return val
|
||||
def SetHeight(self,arg0):
|
||||
val = gdic.wxIcon_SetHeight(self.this,arg0)
|
||||
return val
|
||||
def SetWidth(self,arg0):
|
||||
val = gdic.wxIcon_SetWidth(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxIcon instance>"
|
||||
class wxIcon(wxIconPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxCursorPtr(wxBitmapPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
gdic.delete_wxCursor(self.this)
|
||||
def Ok(self):
|
||||
val = gdic.wxCursor_Ok(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxCursor instance>"
|
||||
class wxCursor(wxCursorPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxFontPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetFaceName(self):
|
||||
val = gdic.wxFont_GetFaceName(self.this)
|
||||
return val
|
||||
def GetFamily(self):
|
||||
val = gdic.wxFont_GetFamily(self.this)
|
||||
return val
|
||||
def GetPointSize(self):
|
||||
val = gdic.wxFont_GetPointSize(self.this)
|
||||
return val
|
||||
def GetStyle(self):
|
||||
val = gdic.wxFont_GetStyle(self.this)
|
||||
return val
|
||||
def GetUnderlined(self):
|
||||
val = gdic.wxFont_GetUnderlined(self.this)
|
||||
return val
|
||||
def GetWeight(self):
|
||||
val = gdic.wxFont_GetWeight(self.this)
|
||||
return val
|
||||
def SetFaceName(self,arg0):
|
||||
val = gdic.wxFont_SetFaceName(self.this,arg0)
|
||||
return val
|
||||
def SetFamily(self,arg0):
|
||||
val = gdic.wxFont_SetFamily(self.this,arg0)
|
||||
return val
|
||||
def SetPointSize(self,arg0):
|
||||
val = gdic.wxFont_SetPointSize(self.this,arg0)
|
||||
return val
|
||||
def SetStyle(self,arg0):
|
||||
val = gdic.wxFont_SetStyle(self.this,arg0)
|
||||
return val
|
||||
def SetUnderlined(self,arg0):
|
||||
val = gdic.wxFont_SetUnderlined(self.this,arg0)
|
||||
return val
|
||||
def SetWeight(self,arg0):
|
||||
val = gdic.wxFont_SetWeight(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxFont instance>"
|
||||
class wxFont(wxFontPtr):
|
||||
def __init__(self,arg0,arg1,arg2,arg3,*args) :
|
||||
self.this = apply(gdic.new_wxFont,(arg0,arg1,arg2,arg3,)+args)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxColourPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
gdic.delete_wxColour(self.this)
|
||||
def Red(self):
|
||||
val = gdic.wxColour_Red(self.this)
|
||||
return val
|
||||
def Green(self):
|
||||
val = gdic.wxColour_Green(self.this)
|
||||
return val
|
||||
def Blue(self):
|
||||
val = gdic.wxColour_Blue(self.this)
|
||||
return val
|
||||
def Ok(self):
|
||||
val = gdic.wxColour_Ok(self.this)
|
||||
return val
|
||||
def Set(self,arg0,arg1,arg2):
|
||||
val = gdic.wxColour_Set(self.this,arg0,arg1,arg2)
|
||||
return val
|
||||
def Get(self):
|
||||
val = gdic.wxColour_Get(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxColour instance>"
|
||||
class wxColour(wxColourPtr):
|
||||
def __init__(self,*args) :
|
||||
self.this = apply(gdic.new_wxColour,()+args)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxPenPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetCap(self):
|
||||
val = gdic.wxPen_GetCap(self.this)
|
||||
return val
|
||||
def GetColour(self):
|
||||
val = gdic.wxPen_GetColour(self.this)
|
||||
val = wxColourPtr(val)
|
||||
return val
|
||||
def GetJoin(self):
|
||||
val = gdic.wxPen_GetJoin(self.this)
|
||||
return val
|
||||
def GetStyle(self):
|
||||
val = gdic.wxPen_GetStyle(self.this)
|
||||
return val
|
||||
def GetWidth(self):
|
||||
val = gdic.wxPen_GetWidth(self.this)
|
||||
return val
|
||||
def Ok(self):
|
||||
val = gdic.wxPen_Ok(self.this)
|
||||
return val
|
||||
def SetCap(self,arg0):
|
||||
val = gdic.wxPen_SetCap(self.this,arg0)
|
||||
return val
|
||||
def SetColour(self,arg0):
|
||||
val = gdic.wxPen_SetColour(self.this,arg0.this)
|
||||
return val
|
||||
def SetJoin(self,arg0):
|
||||
val = gdic.wxPen_SetJoin(self.this,arg0)
|
||||
return val
|
||||
def SetStyle(self,arg0):
|
||||
val = gdic.wxPen_SetStyle(self.this,arg0)
|
||||
return val
|
||||
def SetWidth(self,arg0):
|
||||
val = gdic.wxPen_SetWidth(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxPen instance>"
|
||||
class wxPen(wxPenPtr):
|
||||
def __init__(self,arg0,*args) :
|
||||
self.this = apply(gdic.new_wxPen,(arg0.this,)+args)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxBrushPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def GetColour(self):
|
||||
val = gdic.wxBrush_GetColour(self.this)
|
||||
val = wxColourPtr(val)
|
||||
return val
|
||||
def GetStipple(self):
|
||||
val = gdic.wxBrush_GetStipple(self.this)
|
||||
val = wxBitmapPtr(val)
|
||||
return val
|
||||
def GetStyle(self):
|
||||
val = gdic.wxBrush_GetStyle(self.this)
|
||||
return val
|
||||
def Ok(self):
|
||||
val = gdic.wxBrush_Ok(self.this)
|
||||
return val
|
||||
def SetColour(self,arg0):
|
||||
val = gdic.wxBrush_SetColour(self.this,arg0.this)
|
||||
return val
|
||||
def SetStipple(self,arg0):
|
||||
val = gdic.wxBrush_SetStipple(self.this,arg0.this)
|
||||
return val
|
||||
def SetStyle(self,arg0):
|
||||
val = gdic.wxBrush_SetStyle(self.this,arg0)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxBrush instance>"
|
||||
class wxBrush(wxBrushPtr):
|
||||
def __init__(self,arg0,*args) :
|
||||
self.this = apply(gdic.new_wxBrush,(arg0.this,)+args)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxDCPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
gdic.delete_wxDC(self.this)
|
||||
def BeginDrawing(self):
|
||||
val = gdic.wxDC_BeginDrawing(self.this)
|
||||
return val
|
||||
def Blit(self,arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7):
|
||||
val = gdic.wxDC_Blit(self.this,arg0,arg1,arg2,arg3,arg4.this,arg5,arg6,arg7)
|
||||
return val
|
||||
def Clear(self):
|
||||
val = gdic.wxDC_Clear(self.this)
|
||||
return val
|
||||
def CrossHair(self,arg0,arg1):
|
||||
val = gdic.wxDC_CrossHair(self.this,arg0,arg1)
|
||||
return val
|
||||
def DestroyClippingRegion(self):
|
||||
val = gdic.wxDC_DestroyClippingRegion(self.this)
|
||||
return val
|
||||
def DeviceToLogicalX(self,arg0):
|
||||
val = gdic.wxDC_DeviceToLogicalX(self.this,arg0)
|
||||
return val
|
||||
def DeviceToLogicalXRel(self,arg0):
|
||||
val = gdic.wxDC_DeviceToLogicalXRel(self.this,arg0)
|
||||
return val
|
||||
def DeviceToLogicalY(self,arg0):
|
||||
val = gdic.wxDC_DeviceToLogicalY(self.this,arg0)
|
||||
return val
|
||||
def DeviceToLogicalYRel(self,arg0):
|
||||
val = gdic.wxDC_DeviceToLogicalYRel(self.this,arg0)
|
||||
return val
|
||||
def DrawArc(self,arg0,arg1,arg2,arg3,arg4,arg5):
|
||||
val = gdic.wxDC_DrawArc(self.this,arg0,arg1,arg2,arg3,arg4,arg5)
|
||||
return val
|
||||
def DrawEllipse(self,arg0,arg1,arg2,arg3):
|
||||
val = gdic.wxDC_DrawEllipse(self.this,arg0,arg1,arg2,arg3)
|
||||
return val
|
||||
def DrawEllipticArc(self,arg0,arg1,arg2,arg3,arg4,arg5):
|
||||
val = gdic.wxDC_DrawEllipticArc(self.this,arg0,arg1,arg2,arg3,arg4,arg5)
|
||||
return val
|
||||
def DrawIcon(self,arg0,arg1,arg2):
|
||||
val = gdic.wxDC_DrawIcon(self.this,arg0.this,arg1,arg2)
|
||||
return val
|
||||
def DrawLine(self,arg0,arg1,arg2,arg3):
|
||||
val = gdic.wxDC_DrawLine(self.this,arg0,arg1,arg2,arg3)
|
||||
return val
|
||||
def DrawLines(self,arg0,*args):
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
val = apply(gdic.wxDC_DrawLines,(self.this,arg0,)+args)
|
||||
return val
|
||||
def DrawPolygon(self,arg0,*args):
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
val = apply(gdic.wxDC_DrawPolygon,(self.this,arg0,)+args)
|
||||
return val
|
||||
def DrawPoint(self,arg0,arg1):
|
||||
val = gdic.wxDC_DrawPoint(self.this,arg0,arg1)
|
||||
return val
|
||||
def DrawRectangle(self,arg0,arg1,arg2,arg3):
|
||||
val = gdic.wxDC_DrawRectangle(self.this,arg0,arg1,arg2,arg3)
|
||||
return val
|
||||
def DrawRoundedRectangle(self,arg0,arg1,arg2,arg3,*args):
|
||||
val = apply(gdic.wxDC_DrawRoundedRectangle,(self.this,arg0,arg1,arg2,arg3,)+args)
|
||||
return val
|
||||
def DrawSpline(self,arg0,*args):
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
val = apply(gdic.wxDC_DrawSpline,(self.this,arg0,)+args)
|
||||
return val
|
||||
def DrawText(self,arg0,arg1,arg2):
|
||||
val = gdic.wxDC_DrawText(self.this,arg0,arg1,arg2)
|
||||
return val
|
||||
def EndDoc(self):
|
||||
val = gdic.wxDC_EndDoc(self.this)
|
||||
return val
|
||||
def EndDrawing(self):
|
||||
val = gdic.wxDC_EndDrawing(self.this)
|
||||
return val
|
||||
def EndPage(self):
|
||||
val = gdic.wxDC_EndPage(self.this)
|
||||
return val
|
||||
def FloodFill(self,arg0,arg1,arg2,*args):
|
||||
val = apply(gdic.wxDC_FloodFill,(self.this,arg0,arg1,arg2.this,)+args)
|
||||
return val
|
||||
def GetBackground(self):
|
||||
val = gdic.wxDC_GetBackground(self.this)
|
||||
val = wxBrushPtr(val)
|
||||
return val
|
||||
def GetBrush(self):
|
||||
val = gdic.wxDC_GetBrush(self.this)
|
||||
val = wxBrushPtr(val)
|
||||
return val
|
||||
def GetCharHeight(self):
|
||||
val = gdic.wxDC_GetCharHeight(self.this)
|
||||
return val
|
||||
def GetCharWidth(self):
|
||||
val = gdic.wxDC_GetCharWidth(self.this)
|
||||
return val
|
||||
def GetClippingBox(self):
|
||||
val = gdic.wxDC_GetClippingBox(self.this)
|
||||
return val
|
||||
def GetFont(self):
|
||||
val = gdic.wxDC_GetFont(self.this)
|
||||
val = wxFontPtr(val)
|
||||
return val
|
||||
def GetLogicalFunction(self):
|
||||
val = gdic.wxDC_GetLogicalFunction(self.this)
|
||||
return val
|
||||
def GetMapMode(self):
|
||||
val = gdic.wxDC_GetMapMode(self.this)
|
||||
return val
|
||||
def GetOptimization(self):
|
||||
val = gdic.wxDC_GetOptimization(self.this)
|
||||
return val
|
||||
def GetPen(self):
|
||||
val = gdic.wxDC_GetPen(self.this)
|
||||
val = wxPenPtr(val)
|
||||
return val
|
||||
def GetPixel(self,arg0,arg1):
|
||||
val = gdic.wxDC_GetPixel(self.this,arg0,arg1)
|
||||
val = wxColourPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetSize(self):
|
||||
val = gdic.wxDC_GetSize(self.this)
|
||||
return val
|
||||
def GetTextBackground(self):
|
||||
val = gdic.wxDC_GetTextBackground(self.this)
|
||||
val = wxColourPtr(val)
|
||||
return val
|
||||
def GetTextExtent(self,arg0):
|
||||
val = gdic.wxDC_GetTextExtent(self.this,arg0)
|
||||
return val
|
||||
def GetTextForeground(self):
|
||||
val = gdic.wxDC_GetTextForeground(self.this)
|
||||
val = wxColourPtr(val)
|
||||
return val
|
||||
def LogicalToDeviceX(self,arg0):
|
||||
val = gdic.wxDC_LogicalToDeviceX(self.this,arg0)
|
||||
return val
|
||||
def LogicalToDeviceXRel(self,arg0):
|
||||
val = gdic.wxDC_LogicalToDeviceXRel(self.this,arg0)
|
||||
return val
|
||||
def LogicalToDeviceY(self,arg0):
|
||||
val = gdic.wxDC_LogicalToDeviceY(self.this,arg0)
|
||||
return val
|
||||
def LogicalToDeviceYRel(self,arg0):
|
||||
val = gdic.wxDC_LogicalToDeviceYRel(self.this,arg0)
|
||||
return val
|
||||
def MaxX(self):
|
||||
val = gdic.wxDC_MaxX(self.this)
|
||||
return val
|
||||
def MaxY(self):
|
||||
val = gdic.wxDC_MaxY(self.this)
|
||||
return val
|
||||
def MinX(self):
|
||||
val = gdic.wxDC_MinX(self.this)
|
||||
return val
|
||||
def MinY(self):
|
||||
val = gdic.wxDC_MinY(self.this)
|
||||
return val
|
||||
def Ok(self):
|
||||
val = gdic.wxDC_Ok(self.this)
|
||||
return val
|
||||
def SetDeviceOrigin(self,arg0,arg1):
|
||||
val = gdic.wxDC_SetDeviceOrigin(self.this,arg0,arg1)
|
||||
return val
|
||||
def SetBackground(self,arg0):
|
||||
val = gdic.wxDC_SetBackground(self.this,arg0.this)
|
||||
return val
|
||||
def SetBackgroundMode(self,arg0):
|
||||
val = gdic.wxDC_SetBackgroundMode(self.this,arg0)
|
||||
return val
|
||||
def SetClippingRegion(self,arg0,arg1,arg2,arg3):
|
||||
val = gdic.wxDC_SetClippingRegion(self.this,arg0,arg1,arg2,arg3)
|
||||
return val
|
||||
def SetPalette(self,arg0):
|
||||
val = gdic.wxDC_SetPalette(self.this,arg0.this)
|
||||
return val
|
||||
def SetBrush(self,arg0):
|
||||
val = gdic.wxDC_SetBrush(self.this,arg0.this)
|
||||
return val
|
||||
def SetFont(self,arg0):
|
||||
val = gdic.wxDC_SetFont(self.this,arg0.this)
|
||||
return val
|
||||
def SetLogicalFunction(self,arg0):
|
||||
val = gdic.wxDC_SetLogicalFunction(self.this,arg0)
|
||||
return val
|
||||
def SetMapMode(self,arg0):
|
||||
val = gdic.wxDC_SetMapMode(self.this,arg0)
|
||||
return val
|
||||
def SetOptimization(self,arg0):
|
||||
val = gdic.wxDC_SetOptimization(self.this,arg0)
|
||||
return val
|
||||
def SetPen(self,arg0):
|
||||
val = gdic.wxDC_SetPen(self.this,arg0.this)
|
||||
return val
|
||||
def SetTextBackground(self,arg0):
|
||||
val = gdic.wxDC_SetTextBackground(self.this,arg0.this)
|
||||
return val
|
||||
def SetTextForeground(self,arg0):
|
||||
val = gdic.wxDC_SetTextForeground(self.this,arg0.this)
|
||||
return val
|
||||
def SetUserScale(self,arg0,arg1):
|
||||
val = gdic.wxDC_SetUserScale(self.this,arg0,arg1)
|
||||
return val
|
||||
def StartDoc(self,arg0):
|
||||
val = gdic.wxDC_StartDoc(self.this,arg0)
|
||||
return val
|
||||
def StartPage(self):
|
||||
val = gdic.wxDC_StartPage(self.this)
|
||||
return val
|
||||
def DrawBitmap(self,arg0,arg1,arg2,*args):
|
||||
val = apply(gdic.wxDC_DrawBitmap,(self.this,arg0.this,arg1,arg2,)+args)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxDC instance>"
|
||||
class wxDC(wxDCPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxMemoryDCPtr(wxDCPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def SelectObject(self,arg0):
|
||||
val = gdic.wxMemoryDC_SelectObject(self.this,arg0.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxMemoryDC instance>"
|
||||
class wxMemoryDC(wxMemoryDCPtr):
|
||||
def __init__(self) :
|
||||
self.this = gdic.new_wxMemoryDC()
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxScreenDCPtr(wxDCPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def StartDrawingOnTop(self,arg0):
|
||||
val = gdic.wxScreenDC_StartDrawingOnTop(self.this,arg0.this)
|
||||
return val
|
||||
def StartDrawingOnTopRect(self,*args):
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
val = apply(gdic.wxScreenDC_StartDrawingOnTopRect,(self.this,)+args)
|
||||
return val
|
||||
def EndDrawingOnTop(self):
|
||||
val = gdic.wxScreenDC_EndDrawingOnTop(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxScreenDC instance>"
|
||||
class wxScreenDC(wxScreenDCPtr):
|
||||
def __init__(self) :
|
||||
self.this = gdic.new_wxScreenDC()
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxClientDCPtr(wxDCPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __repr__(self):
|
||||
return "<C wxClientDC instance>"
|
||||
class wxClientDC(wxClientDCPtr):
|
||||
def __init__(self,arg0) :
|
||||
self.this = gdic.new_wxClientDC(arg0.this)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxPaintDCPtr(wxDCPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __repr__(self):
|
||||
return "<C wxPaintDC instance>"
|
||||
class wxPaintDC(wxPaintDCPtr):
|
||||
def __init__(self,arg0) :
|
||||
self.this = gdic.new_wxPaintDC(arg0.this)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxWindowDCPtr(wxDCPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __repr__(self):
|
||||
return "<C wxWindowDC instance>"
|
||||
class wxWindowDC(wxWindowDCPtr):
|
||||
def __init__(self,arg0) :
|
||||
self.this = gdic.new_wxWindowDC(arg0.this)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxPostScriptDCPtr(wxDCPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __repr__(self):
|
||||
return "<C wxPostScriptDC instance>"
|
||||
class wxPostScriptDC(wxPostScriptDCPtr):
|
||||
def __init__(self,arg0,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(gdic.new_wxPostScriptDC,(arg0,)+args)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxPalettePtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
gdic.delete_wxPalette(self.this)
|
||||
def GetPixel(self,arg0,arg1,arg2):
|
||||
val = gdic.wxPalette_GetPixel(self.this,arg0,arg1,arg2)
|
||||
return val
|
||||
def GetRGB(self,arg0,arg1,arg2,arg3):
|
||||
val = gdic.wxPalette_GetRGB(self.this,arg0,arg1,arg2,arg3)
|
||||
return val
|
||||
def Ok(self):
|
||||
val = gdic.wxPalette_Ok(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxPalette instance>"
|
||||
class wxPalette(wxPalettePtr):
|
||||
def __init__(self,arg0,arg1,arg2) :
|
||||
self.this = gdic.new_wxPalette(arg0,arg1,arg2)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#-------------- FUNCTION WRAPPERS ------------------
|
||||
|
||||
def wxEmptyBitmap(arg0,arg1,*args):
|
||||
val = apply(gdic.wxEmptyBitmap,(arg0,arg1,)+args)
|
||||
val = wxBitmapPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
|
||||
def wxNoRefBitmap(arg0,arg1):
|
||||
val = gdic.wxNoRefBitmap(arg0,arg1)
|
||||
val = wxBitmapPtr(val)
|
||||
return val
|
||||
|
||||
def wxMaskColour(arg0,arg1):
|
||||
val = gdic.wxMaskColour(arg0.this,arg1.this)
|
||||
val = wxMaskPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
|
||||
def wxStockCursor(arg0):
|
||||
val = gdic.wxStockCursor(arg0)
|
||||
val = wxCursorPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
|
||||
def wxNamedColour(arg0):
|
||||
val = gdic.wxNamedColour(arg0)
|
||||
val = wxColourPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
|
||||
def wxMemoryDCFromDC(arg0):
|
||||
val = gdic.wxMemoryDCFromDC(arg0.this)
|
||||
val = wxMemoryDCPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
|
||||
|
||||
|
||||
#-------------- VARIABLE WRAPPERS ------------------
|
||||
|
||||
cvar = gdic.cvar
|
||||
wxNORMAL_FONT = wxFontPtr(gdic.cvar.wxNORMAL_FONT)
|
||||
wxSMALL_FONT = wxFontPtr(gdic.cvar.wxSMALL_FONT)
|
||||
wxITALIC_FONT = wxFontPtr(gdic.cvar.wxITALIC_FONT)
|
||||
wxSWISS_FONT = wxFontPtr(gdic.cvar.wxSWISS_FONT)
|
||||
wxRED_PEN = wxPenPtr(gdic.cvar.wxRED_PEN)
|
||||
wxCYAN_PEN = wxPenPtr(gdic.cvar.wxCYAN_PEN)
|
||||
wxGREEN_PEN = wxPenPtr(gdic.cvar.wxGREEN_PEN)
|
||||
wxBLACK_PEN = wxPenPtr(gdic.cvar.wxBLACK_PEN)
|
||||
wxWHITE_PEN = wxPenPtr(gdic.cvar.wxWHITE_PEN)
|
||||
wxTRANSPARENT_PEN = wxPenPtr(gdic.cvar.wxTRANSPARENT_PEN)
|
||||
wxBLACK_DASHED_PEN = wxPenPtr(gdic.cvar.wxBLACK_DASHED_PEN)
|
||||
wxGREY_PEN = wxPenPtr(gdic.cvar.wxGREY_PEN)
|
||||
wxMEDIUM_GREY_PEN = wxPenPtr(gdic.cvar.wxMEDIUM_GREY_PEN)
|
||||
wxLIGHT_GREY_PEN = wxPenPtr(gdic.cvar.wxLIGHT_GREY_PEN)
|
||||
wxBLUE_BRUSH = wxBrushPtr(gdic.cvar.wxBLUE_BRUSH)
|
||||
wxGREEN_BRUSH = wxBrushPtr(gdic.cvar.wxGREEN_BRUSH)
|
||||
wxWHITE_BRUSH = wxBrushPtr(gdic.cvar.wxWHITE_BRUSH)
|
||||
wxBLACK_BRUSH = wxBrushPtr(gdic.cvar.wxBLACK_BRUSH)
|
||||
wxTRANSPARENT_BRUSH = wxBrushPtr(gdic.cvar.wxTRANSPARENT_BRUSH)
|
||||
wxCYAN_BRUSH = wxBrushPtr(gdic.cvar.wxCYAN_BRUSH)
|
||||
wxRED_BRUSH = wxBrushPtr(gdic.cvar.wxRED_BRUSH)
|
||||
wxGREY_BRUSH = wxBrushPtr(gdic.cvar.wxGREY_BRUSH)
|
||||
wxMEDIUM_GREY_BRUSH = wxBrushPtr(gdic.cvar.wxMEDIUM_GREY_BRUSH)
|
||||
wxLIGHT_GREY_BRUSH = wxBrushPtr(gdic.cvar.wxLIGHT_GREY_BRUSH)
|
||||
wxBLACK = wxColourPtr(gdic.cvar.wxBLACK)
|
||||
wxWHITE = wxColourPtr(gdic.cvar.wxWHITE)
|
||||
wxRED = wxColourPtr(gdic.cvar.wxRED)
|
||||
wxBLUE = wxColourPtr(gdic.cvar.wxBLUE)
|
||||
wxGREEN = wxColourPtr(gdic.cvar.wxGREEN)
|
||||
wxCYAN = wxColourPtr(gdic.cvar.wxCYAN)
|
||||
wxLIGHT_GREY = wxColourPtr(gdic.cvar.wxLIGHT_GREY)
|
||||
wxSTANDARD_CURSOR = wxCursorPtr(gdic.cvar.wxSTANDARD_CURSOR)
|
||||
wxHOURGLASS_CURSOR = wxCursorPtr(gdic.cvar.wxHOURGLASS_CURSOR)
|
||||
wxCROSS_CURSOR = wxCursorPtr(gdic.cvar.wxCROSS_CURSOR)
|
||||
wxNullBitmap = wxBitmapPtr(gdic.cvar.wxNullBitmap)
|
||||
wxNullIcon = wxIconPtr(gdic.cvar.wxNullIcon)
|
||||
wxNullCursor = wxCursorPtr(gdic.cvar.wxNullCursor)
|
||||
wxNullPen = wxPenPtr(gdic.cvar.wxNullPen)
|
||||
wxNullBrush = wxBrushPtr(gdic.cvar.wxNullBrush)
|
||||
wxNullFont = wxFontPtr(gdic.cvar.wxNullFont)
|
||||
wxNullColour = wxColourPtr(gdic.cvar.wxNullColour)
|
||||
964
utils/wxPython/src/gtk/mdi.cpp
Normal file
964
utils/wxPython/src/gtk/mdi.cpp
Normal file
@@ -0,0 +1,964 @@
|
||||
/*
|
||||
* FILE : gtk/mdi.cpp
|
||||
*
|
||||
* This file was automatically generated by :
|
||||
* Simplified Wrapper and Interface Generator (SWIG)
|
||||
* Version 1.1 (Patch 5)
|
||||
*
|
||||
* Portions Copyright (c) 1995-1998
|
||||
* The University of Utah and The Regents of the University of California.
|
||||
* Permission is granted to distribute this file in any manner provided
|
||||
* this notice remains intact.
|
||||
*
|
||||
* Do not make changes to this file--changes will be lost!
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#define SWIGCODE
|
||||
/* Implementation : PYTHON */
|
||||
|
||||
#define SWIGPYTHON
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
/* Definitions for Windows/Unix exporting */
|
||||
#if defined(__WIN32__)
|
||||
# if defined(_MSC_VER)
|
||||
# define SWIGEXPORT(a,b) __declspec(dllexport) a b
|
||||
# else
|
||||
# if defined(__BORLANDC__)
|
||||
# define SWIGEXPORT(a,b) a _export b
|
||||
# else
|
||||
# define SWIGEXPORT(a,b) a b
|
||||
# endif
|
||||
# endif
|
||||
#else
|
||||
# define SWIGEXPORT(a,b) a b
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
#include "Python.h"
|
||||
extern void SWIG_MakePtr(char *, void *, char *);
|
||||
extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
|
||||
extern char *SWIG_GetPtr(char *, void **, char *);
|
||||
extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
|
||||
extern PyObject *SWIG_newvarlink(void);
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#define SWIG_init initmdic
|
||||
|
||||
#define SWIG_name "mdic"
|
||||
|
||||
#include "helpers.h"
|
||||
|
||||
static PyObject* l_output_helper(PyObject* target, PyObject* o) {
|
||||
PyObject* o2;
|
||||
PyObject* o3;
|
||||
if (!target) {
|
||||
target = o;
|
||||
} else if (target == Py_None) {
|
||||
Py_DECREF(Py_None);
|
||||
target = o;
|
||||
} else {
|
||||
if (!PyList_Check(target)) {
|
||||
o2 = target;
|
||||
target = PyList_New(0);
|
||||
PyList_Append(target, o2);
|
||||
Py_XDECREF(o2);
|
||||
}
|
||||
PyList_Append(target,o);
|
||||
Py_XDECREF(o);
|
||||
}
|
||||
return target;
|
||||
}
|
||||
|
||||
static PyObject* t_output_helper(PyObject* target, PyObject* o) {
|
||||
PyObject* o2;
|
||||
PyObject* o3;
|
||||
|
||||
if (!target) {
|
||||
target = o;
|
||||
} else if (target == Py_None) {
|
||||
Py_DECREF(Py_None);
|
||||
target = o;
|
||||
} else {
|
||||
if (!PyTuple_Check(target)) {
|
||||
o2 = target;
|
||||
target = PyTuple_New(1);
|
||||
PyTuple_SetItem(target, 0, o2);
|
||||
}
|
||||
o3 = PyTuple_New(1);
|
||||
PyTuple_SetItem(o3, 0, o);
|
||||
|
||||
o2 = target;
|
||||
target = PySequence_Concat(o2, o3);
|
||||
Py_DECREF(o2);
|
||||
Py_DECREF(o3);
|
||||
}
|
||||
return target;
|
||||
}
|
||||
|
||||
|
||||
extern byte* byte_LIST_helper(PyObject* source);
|
||||
extern int* int_LIST_helper(PyObject* source);
|
||||
extern long* long_LIST_helper(PyObject* source);
|
||||
extern char** string_LIST_helper(PyObject* source);
|
||||
extern wxPoint* wxPoint_LIST_helper(PyObject* source);
|
||||
extern wxBitmap** wxBitmap_LIST_helper(PyObject* source);
|
||||
extern wxString* wxString_LIST_helper(PyObject* source);
|
||||
extern wxAcceleratorEntry* wxAcceleratorEntry_LIST_helper(PyObject* source);
|
||||
|
||||
|
||||
static char* wxStringErrorMsg = "string type is required for parameter";
|
||||
static void *SwigwxMDIParentFrameTowxFrame(void *ptr) {
|
||||
wxMDIParentFrame *src;
|
||||
wxFrame *dest;
|
||||
src = (wxMDIParentFrame *) ptr;
|
||||
dest = (wxFrame *) src;
|
||||
return (void *) dest;
|
||||
}
|
||||
|
||||
static void *SwigwxMDIParentFrameTowxWindow(void *ptr) {
|
||||
wxMDIParentFrame *src;
|
||||
wxWindow *dest;
|
||||
src = (wxMDIParentFrame *) ptr;
|
||||
dest = (wxWindow *) src;
|
||||
return (void *) dest;
|
||||
}
|
||||
|
||||
static void *SwigwxMDIParentFrameTowxEvtHandler(void *ptr) {
|
||||
wxMDIParentFrame *src;
|
||||
wxEvtHandler *dest;
|
||||
src = (wxMDIParentFrame *) ptr;
|
||||
dest = (wxEvtHandler *) src;
|
||||
return (void *) dest;
|
||||
}
|
||||
|
||||
#define new_wxMDIParentFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6) (new wxMDIParentFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6))
|
||||
static PyObject *_wrap_new_wxMDIParentFrame(PyObject *self, PyObject *args) {
|
||||
PyObject * _resultobj;
|
||||
wxMDIParentFrame * _result;
|
||||
wxWindow * _arg0;
|
||||
wxWindowID _arg1;
|
||||
wxString * _arg2;
|
||||
wxPoint * _arg3 = &wxPyDefaultPosition;
|
||||
wxSize * _arg4 = &wxPyDefaultSize;
|
||||
long _arg5 = (wxDEFAULT_FRAME_STYLE)|(wxVSCROLL)|(wxHSCROLL);
|
||||
char * _arg6 = "frame";
|
||||
char * _argc0 = 0;
|
||||
PyObject * _obj2 = 0;
|
||||
char * _argc3 = 0;
|
||||
char * _argc4 = 0;
|
||||
char _ptemp[128];
|
||||
|
||||
self = self;
|
||||
if(!PyArg_ParseTuple(args,"siO|ssls:new_wxMDIParentFrame",&_argc0,&_arg1,&_obj2,&_argc3,&_argc4,&_arg5,&_arg6))
|
||||
return NULL;
|
||||
if (_argc0) {
|
||||
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxWindow_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMDIParentFrame. Expected _wxWindow_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
{
|
||||
if (!PyString_Check(_obj2)) {
|
||||
PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
|
||||
return NULL;
|
||||
}
|
||||
_arg2 = new wxString(PyString_AsString(_obj2));
|
||||
}
|
||||
if (_argc3) {
|
||||
if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxMDIParentFrame. Expected _wxPoint_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
if (_argc4) {
|
||||
if (SWIG_GetPtr(_argc4,(void **) &_arg4,"_wxSize_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxMDIParentFrame. Expected _wxSize_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
_result = (wxMDIParentFrame *)new_wxMDIParentFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
|
||||
SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIParentFrame_p");
|
||||
_resultobj = Py_BuildValue("s",_ptemp);
|
||||
{
|
||||
if (_obj2)
|
||||
delete _arg2;
|
||||
}
|
||||
return _resultobj;
|
||||
}
|
||||
|
||||
#define wxMDIParentFrame_ActivateNext(_swigobj) (_swigobj->ActivateNext())
|
||||
static PyObject *_wrap_wxMDIParentFrame_ActivateNext(PyObject *self, PyObject *args) {
|
||||
PyObject * _resultobj;
|
||||
wxMDIParentFrame * _arg0;
|
||||
char * _argc0 = 0;
|
||||
|
||||
self = self;
|
||||
if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_ActivateNext",&_argc0))
|
||||
return NULL;
|
||||
if (_argc0) {
|
||||
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_ActivateNext. Expected _wxMDIParentFrame_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
wxMDIParentFrame_ActivateNext(_arg0);
|
||||
Py_INCREF(Py_None);
|
||||
_resultobj = Py_None;
|
||||
return _resultobj;
|
||||
}
|
||||
|
||||
#define wxMDIParentFrame_ActivatePrevious(_swigobj) (_swigobj->ActivatePrevious())
|
||||
static PyObject *_wrap_wxMDIParentFrame_ActivatePrevious(PyObject *self, PyObject *args) {
|
||||
PyObject * _resultobj;
|
||||
wxMDIParentFrame * _arg0;
|
||||
char * _argc0 = 0;
|
||||
|
||||
self = self;
|
||||
if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_ActivatePrevious",&_argc0))
|
||||
return NULL;
|
||||
if (_argc0) {
|
||||
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_ActivatePrevious. Expected _wxMDIParentFrame_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
wxMDIParentFrame_ActivatePrevious(_arg0);
|
||||
Py_INCREF(Py_None);
|
||||
_resultobj = Py_None;
|
||||
return _resultobj;
|
||||
}
|
||||
|
||||
#define wxMDIParentFrame_ArrangeIcons(_swigobj) (_swigobj->ArrangeIcons())
|
||||
static PyObject *_wrap_wxMDIParentFrame_ArrangeIcons(PyObject *self, PyObject *args) {
|
||||
PyObject * _resultobj;
|
||||
wxMDIParentFrame * _arg0;
|
||||
char * _argc0 = 0;
|
||||
|
||||
self = self;
|
||||
if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_ArrangeIcons",&_argc0))
|
||||
return NULL;
|
||||
if (_argc0) {
|
||||
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_ArrangeIcons. Expected _wxMDIParentFrame_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
wxMDIParentFrame_ArrangeIcons(_arg0);
|
||||
Py_INCREF(Py_None);
|
||||
_resultobj = Py_None;
|
||||
return _resultobj;
|
||||
}
|
||||
|
||||
#define wxMDIParentFrame_Cascade(_swigobj) (_swigobj->Cascade())
|
||||
static PyObject *_wrap_wxMDIParentFrame_Cascade(PyObject *self, PyObject *args) {
|
||||
PyObject * _resultobj;
|
||||
wxMDIParentFrame * _arg0;
|
||||
char * _argc0 = 0;
|
||||
|
||||
self = self;
|
||||
if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_Cascade",&_argc0))
|
||||
return NULL;
|
||||
if (_argc0) {
|
||||
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_Cascade. Expected _wxMDIParentFrame_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
wxMDIParentFrame_Cascade(_arg0);
|
||||
Py_INCREF(Py_None);
|
||||
_resultobj = Py_None;
|
||||
return _resultobj;
|
||||
}
|
||||
|
||||
#define wxMDIParentFrame_GetClientSize(_swigobj,_swigarg0,_swigarg1) (_swigobj->GetClientSize(_swigarg0,_swigarg1))
|
||||
static PyObject *_wrap_wxMDIParentFrame_GetClientSize(PyObject *self, PyObject *args) {
|
||||
PyObject * _resultobj;
|
||||
wxMDIParentFrame * _arg0;
|
||||
int * _arg1;
|
||||
int temp;
|
||||
int * _arg2;
|
||||
int temp0;
|
||||
char * _argc0 = 0;
|
||||
|
||||
self = self;
|
||||
{
|
||||
_arg1 = &temp;
|
||||
}
|
||||
{
|
||||
_arg2 = &temp0;
|
||||
}
|
||||
if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetClientSize",&_argc0))
|
||||
return NULL;
|
||||
if (_argc0) {
|
||||
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetClientSize. Expected _wxMDIParentFrame_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
wxMDIParentFrame_GetClientSize(_arg0,_arg1,_arg2);
|
||||
Py_INCREF(Py_None);
|
||||
_resultobj = Py_None;
|
||||
{
|
||||
PyObject *o;
|
||||
o = PyInt_FromLong((long) (*_arg1));
|
||||
_resultobj = t_output_helper(_resultobj, o);
|
||||
}
|
||||
{
|
||||
PyObject *o;
|
||||
o = PyInt_FromLong((long) (*_arg2));
|
||||
_resultobj = t_output_helper(_resultobj, o);
|
||||
}
|
||||
return _resultobj;
|
||||
}
|
||||
|
||||
#define wxMDIParentFrame_GetActiveChild(_swigobj) (_swigobj->GetActiveChild())
|
||||
static PyObject *_wrap_wxMDIParentFrame_GetActiveChild(PyObject *self, PyObject *args) {
|
||||
PyObject * _resultobj;
|
||||
wxMDIChildFrame * _result;
|
||||
wxMDIParentFrame * _arg0;
|
||||
char * _argc0 = 0;
|
||||
char _ptemp[128];
|
||||
|
||||
self = self;
|
||||
if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetActiveChild",&_argc0))
|
||||
return NULL;
|
||||
if (_argc0) {
|
||||
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetActiveChild. Expected _wxMDIParentFrame_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
_result = (wxMDIChildFrame *)wxMDIParentFrame_GetActiveChild(_arg0);
|
||||
SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIChildFrame_p");
|
||||
_resultobj = Py_BuildValue("s",_ptemp);
|
||||
return _resultobj;
|
||||
}
|
||||
|
||||
#define wxMDIParentFrame_GetClientWindow(_swigobj) (_swigobj->GetClientWindow())
|
||||
static PyObject *_wrap_wxMDIParentFrame_GetClientWindow(PyObject *self, PyObject *args) {
|
||||
PyObject * _resultobj;
|
||||
wxMDIClientWindow * _result;
|
||||
wxMDIParentFrame * _arg0;
|
||||
char * _argc0 = 0;
|
||||
char _ptemp[128];
|
||||
|
||||
self = self;
|
||||
if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetClientWindow",&_argc0))
|
||||
return NULL;
|
||||
if (_argc0) {
|
||||
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetClientWindow. Expected _wxMDIParentFrame_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
_result = (wxMDIClientWindow *)wxMDIParentFrame_GetClientWindow(_arg0);
|
||||
SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIClientWindow_p");
|
||||
_resultobj = Py_BuildValue("s",_ptemp);
|
||||
return _resultobj;
|
||||
}
|
||||
|
||||
#define wxMDIParentFrame_GetToolBar(_swigobj) (_swigobj->GetToolBar())
|
||||
static PyObject *_wrap_wxMDIParentFrame_GetToolBar(PyObject *self, PyObject *args) {
|
||||
PyObject * _resultobj;
|
||||
wxWindow * _result;
|
||||
wxMDIParentFrame * _arg0;
|
||||
char * _argc0 = 0;
|
||||
char _ptemp[128];
|
||||
|
||||
self = self;
|
||||
if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_GetToolBar",&_argc0))
|
||||
return NULL;
|
||||
if (_argc0) {
|
||||
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_GetToolBar. Expected _wxMDIParentFrame_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
_result = (wxWindow *)wxMDIParentFrame_GetToolBar(_arg0);
|
||||
SWIG_MakePtr(_ptemp, (char *) _result,"_wxWindow_p");
|
||||
_resultobj = Py_BuildValue("s",_ptemp);
|
||||
return _resultobj;
|
||||
}
|
||||
|
||||
#define wxMDIParentFrame_Tile(_swigobj) (_swigobj->Tile())
|
||||
static PyObject *_wrap_wxMDIParentFrame_Tile(PyObject *self, PyObject *args) {
|
||||
PyObject * _resultobj;
|
||||
wxMDIParentFrame * _arg0;
|
||||
char * _argc0 = 0;
|
||||
|
||||
self = self;
|
||||
if(!PyArg_ParseTuple(args,"s:wxMDIParentFrame_Tile",&_argc0))
|
||||
return NULL;
|
||||
if (_argc0) {
|
||||
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIParentFrame_Tile. Expected _wxMDIParentFrame_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
wxMDIParentFrame_Tile(_arg0);
|
||||
Py_INCREF(Py_None);
|
||||
_resultobj = Py_None;
|
||||
return _resultobj;
|
||||
}
|
||||
|
||||
static void *SwigwxMDIChildFrameTowxFrame(void *ptr) {
|
||||
wxMDIChildFrame *src;
|
||||
wxFrame *dest;
|
||||
src = (wxMDIChildFrame *) ptr;
|
||||
dest = (wxFrame *) src;
|
||||
return (void *) dest;
|
||||
}
|
||||
|
||||
static void *SwigwxMDIChildFrameTowxWindow(void *ptr) {
|
||||
wxMDIChildFrame *src;
|
||||
wxWindow *dest;
|
||||
src = (wxMDIChildFrame *) ptr;
|
||||
dest = (wxWindow *) src;
|
||||
return (void *) dest;
|
||||
}
|
||||
|
||||
static void *SwigwxMDIChildFrameTowxEvtHandler(void *ptr) {
|
||||
wxMDIChildFrame *src;
|
||||
wxEvtHandler *dest;
|
||||
src = (wxMDIChildFrame *) ptr;
|
||||
dest = (wxEvtHandler *) src;
|
||||
return (void *) dest;
|
||||
}
|
||||
|
||||
#define new_wxMDIChildFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6) (new wxMDIChildFrame(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6))
|
||||
static PyObject *_wrap_new_wxMDIChildFrame(PyObject *self, PyObject *args) {
|
||||
PyObject * _resultobj;
|
||||
wxMDIChildFrame * _result;
|
||||
wxMDIParentFrame * _arg0;
|
||||
wxWindowID _arg1;
|
||||
wxString * _arg2;
|
||||
wxPoint * _arg3 = &wxPyDefaultPosition;
|
||||
wxSize * _arg4 = &wxPyDefaultSize;
|
||||
long _arg5 = (wxDEFAULT_FRAME_STYLE);
|
||||
char * _arg6 = "frame";
|
||||
char * _argc0 = 0;
|
||||
PyObject * _obj2 = 0;
|
||||
char * _argc3 = 0;
|
||||
char * _argc4 = 0;
|
||||
char _ptemp[128];
|
||||
|
||||
self = self;
|
||||
if(!PyArg_ParseTuple(args,"siO|ssls:new_wxMDIChildFrame",&_argc0,&_arg1,&_obj2,&_argc3,&_argc4,&_arg5,&_arg6))
|
||||
return NULL;
|
||||
if (_argc0) {
|
||||
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMDIChildFrame. Expected _wxMDIParentFrame_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
{
|
||||
if (!PyString_Check(_obj2)) {
|
||||
PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
|
||||
return NULL;
|
||||
}
|
||||
_arg2 = new wxString(PyString_AsString(_obj2));
|
||||
}
|
||||
if (_argc3) {
|
||||
if (SWIG_GetPtr(_argc3,(void **) &_arg3,"_wxPoint_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of new_wxMDIChildFrame. Expected _wxPoint_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
if (_argc4) {
|
||||
if (SWIG_GetPtr(_argc4,(void **) &_arg4,"_wxSize_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of new_wxMDIChildFrame. Expected _wxSize_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
_result = (wxMDIChildFrame *)new_wxMDIChildFrame(_arg0,_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6);
|
||||
SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIChildFrame_p");
|
||||
_resultobj = Py_BuildValue("s",_ptemp);
|
||||
{
|
||||
if (_obj2)
|
||||
delete _arg2;
|
||||
}
|
||||
return _resultobj;
|
||||
}
|
||||
|
||||
#define wxMDIChildFrame_Activate(_swigobj) (_swigobj->Activate())
|
||||
static PyObject *_wrap_wxMDIChildFrame_Activate(PyObject *self, PyObject *args) {
|
||||
PyObject * _resultobj;
|
||||
wxMDIChildFrame * _arg0;
|
||||
char * _argc0 = 0;
|
||||
|
||||
self = self;
|
||||
if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_Activate",&_argc0))
|
||||
return NULL;
|
||||
if (_argc0) {
|
||||
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_Activate. Expected _wxMDIChildFrame_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
wxMDIChildFrame_Activate(_arg0);
|
||||
Py_INCREF(Py_None);
|
||||
_resultobj = Py_None;
|
||||
return _resultobj;
|
||||
}
|
||||
|
||||
#define wxMDIChildFrame_Maximize(_swigobj) (_swigobj->Maximize())
|
||||
static PyObject *_wrap_wxMDIChildFrame_Maximize(PyObject *self, PyObject *args) {
|
||||
PyObject * _resultobj;
|
||||
wxMDIChildFrame * _arg0;
|
||||
char * _argc0 = 0;
|
||||
|
||||
self = self;
|
||||
if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_Maximize",&_argc0))
|
||||
return NULL;
|
||||
if (_argc0) {
|
||||
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_Maximize. Expected _wxMDIChildFrame_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
wxMDIChildFrame_Maximize(_arg0);
|
||||
Py_INCREF(Py_None);
|
||||
_resultobj = Py_None;
|
||||
return _resultobj;
|
||||
}
|
||||
|
||||
#define wxMDIChildFrame_Restore(_swigobj) (_swigobj->Restore())
|
||||
static PyObject *_wrap_wxMDIChildFrame_Restore(PyObject *self, PyObject *args) {
|
||||
PyObject * _resultobj;
|
||||
wxMDIChildFrame * _arg0;
|
||||
char * _argc0 = 0;
|
||||
|
||||
self = self;
|
||||
if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_Restore",&_argc0))
|
||||
return NULL;
|
||||
if (_argc0) {
|
||||
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_Restore. Expected _wxMDIChildFrame_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
wxMDIChildFrame_Restore(_arg0);
|
||||
Py_INCREF(Py_None);
|
||||
_resultobj = Py_None;
|
||||
return _resultobj;
|
||||
}
|
||||
|
||||
#define wxMDIChildFrame_SetMenuBar(_swigobj,_swigarg0) (_swigobj->SetMenuBar(_swigarg0))
|
||||
static PyObject *_wrap_wxMDIChildFrame_SetMenuBar(PyObject *self, PyObject *args) {
|
||||
PyObject * _resultobj;
|
||||
wxMDIChildFrame * _arg0;
|
||||
wxMenuBar * _arg1;
|
||||
char * _argc0 = 0;
|
||||
char * _argc1 = 0;
|
||||
|
||||
self = self;
|
||||
if(!PyArg_ParseTuple(args,"ss:wxMDIChildFrame_SetMenuBar",&_argc0,&_argc1))
|
||||
return NULL;
|
||||
if (_argc0) {
|
||||
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_SetMenuBar. Expected _wxMDIChildFrame_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
if (_argc1) {
|
||||
if (SWIG_GetPtr(_argc1,(void **) &_arg1,"_wxMenuBar_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxMDIChildFrame_SetMenuBar. Expected _wxMenuBar_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
wxMDIChildFrame_SetMenuBar(_arg0,_arg1);
|
||||
Py_INCREF(Py_None);
|
||||
_resultobj = Py_None;
|
||||
return _resultobj;
|
||||
}
|
||||
|
||||
#define wxMDIChildFrame_SetClientSize(_swigobj,_swigarg0,_swigarg1) (_swigobj->SetClientSize(_swigarg0,_swigarg1))
|
||||
static PyObject *_wrap_wxMDIChildFrame_SetClientSize(PyObject *self, PyObject *args) {
|
||||
PyObject * _resultobj;
|
||||
wxMDIChildFrame * _arg0;
|
||||
int _arg1;
|
||||
int _arg2;
|
||||
char * _argc0 = 0;
|
||||
|
||||
self = self;
|
||||
if(!PyArg_ParseTuple(args,"sii:wxMDIChildFrame_SetClientSize",&_argc0,&_arg1,&_arg2))
|
||||
return NULL;
|
||||
if (_argc0) {
|
||||
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_SetClientSize. Expected _wxMDIChildFrame_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
wxMDIChildFrame_SetClientSize(_arg0,_arg1,_arg2);
|
||||
Py_INCREF(Py_None);
|
||||
_resultobj = Py_None;
|
||||
return _resultobj;
|
||||
}
|
||||
|
||||
#define wxMDIChildFrame_GetPosition(_swigobj,_swigarg0,_swigarg1) (_swigobj->GetPosition(_swigarg0,_swigarg1))
|
||||
static PyObject *_wrap_wxMDIChildFrame_GetPosition(PyObject *self, PyObject *args) {
|
||||
PyObject * _resultobj;
|
||||
wxMDIChildFrame * _arg0;
|
||||
int * _arg1;
|
||||
int temp;
|
||||
int * _arg2;
|
||||
int temp0;
|
||||
char * _argc0 = 0;
|
||||
|
||||
self = self;
|
||||
{
|
||||
_arg1 = &temp;
|
||||
}
|
||||
{
|
||||
_arg2 = &temp0;
|
||||
}
|
||||
if(!PyArg_ParseTuple(args,"s:wxMDIChildFrame_GetPosition",&_argc0))
|
||||
return NULL;
|
||||
if (_argc0) {
|
||||
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIChildFrame_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxMDIChildFrame_GetPosition. Expected _wxMDIChildFrame_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
wxMDIChildFrame_GetPosition(_arg0,_arg1,_arg2);
|
||||
Py_INCREF(Py_None);
|
||||
_resultobj = Py_None;
|
||||
{
|
||||
PyObject *o;
|
||||
o = PyInt_FromLong((long) (*_arg1));
|
||||
_resultobj = t_output_helper(_resultobj, o);
|
||||
}
|
||||
{
|
||||
PyObject *o;
|
||||
o = PyInt_FromLong((long) (*_arg2));
|
||||
_resultobj = t_output_helper(_resultobj, o);
|
||||
}
|
||||
return _resultobj;
|
||||
}
|
||||
|
||||
static void *SwigwxMDIClientWindowTowxWindow(void *ptr) {
|
||||
wxMDIClientWindow *src;
|
||||
wxWindow *dest;
|
||||
src = (wxMDIClientWindow *) ptr;
|
||||
dest = (wxWindow *) src;
|
||||
return (void *) dest;
|
||||
}
|
||||
|
||||
static void *SwigwxMDIClientWindowTowxEvtHandler(void *ptr) {
|
||||
wxMDIClientWindow *src;
|
||||
wxEvtHandler *dest;
|
||||
src = (wxMDIClientWindow *) ptr;
|
||||
dest = (wxEvtHandler *) src;
|
||||
return (void *) dest;
|
||||
}
|
||||
|
||||
#define new_wxMDIClientWindow(_swigarg0,_swigarg1) (new wxMDIClientWindow(_swigarg0,_swigarg1))
|
||||
static PyObject *_wrap_new_wxMDIClientWindow(PyObject *self, PyObject *args) {
|
||||
PyObject * _resultobj;
|
||||
wxMDIClientWindow * _result;
|
||||
wxMDIParentFrame * _arg0;
|
||||
long _arg1 = 0;
|
||||
char * _argc0 = 0;
|
||||
char _ptemp[128];
|
||||
|
||||
self = self;
|
||||
if(!PyArg_ParseTuple(args,"s|l:new_wxMDIClientWindow",&_argc0,&_arg1))
|
||||
return NULL;
|
||||
if (_argc0) {
|
||||
if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_wxMDIParentFrame_p")) {
|
||||
PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxMDIClientWindow. Expected _wxMDIParentFrame_p.");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
_result = (wxMDIClientWindow *)new_wxMDIClientWindow(_arg0,_arg1);
|
||||
SWIG_MakePtr(_ptemp, (char *) _result,"_wxMDIClientWindow_p");
|
||||
_resultobj = Py_BuildValue("s",_ptemp);
|
||||
return _resultobj;
|
||||
}
|
||||
|
||||
static PyMethodDef mdicMethods[] = {
|
||||
{ "new_wxMDIClientWindow", _wrap_new_wxMDIClientWindow, 1 },
|
||||
{ "wxMDIChildFrame_GetPosition", _wrap_wxMDIChildFrame_GetPosition, 1 },
|
||||
{ "wxMDIChildFrame_SetClientSize", _wrap_wxMDIChildFrame_SetClientSize, 1 },
|
||||
{ "wxMDIChildFrame_SetMenuBar", _wrap_wxMDIChildFrame_SetMenuBar, 1 },
|
||||
{ "wxMDIChildFrame_Restore", _wrap_wxMDIChildFrame_Restore, 1 },
|
||||
{ "wxMDIChildFrame_Maximize", _wrap_wxMDIChildFrame_Maximize, 1 },
|
||||
{ "wxMDIChildFrame_Activate", _wrap_wxMDIChildFrame_Activate, 1 },
|
||||
{ "new_wxMDIChildFrame", _wrap_new_wxMDIChildFrame, 1 },
|
||||
{ "wxMDIParentFrame_Tile", _wrap_wxMDIParentFrame_Tile, 1 },
|
||||
{ "wxMDIParentFrame_GetToolBar", _wrap_wxMDIParentFrame_GetToolBar, 1 },
|
||||
{ "wxMDIParentFrame_GetClientWindow", _wrap_wxMDIParentFrame_GetClientWindow, 1 },
|
||||
{ "wxMDIParentFrame_GetActiveChild", _wrap_wxMDIParentFrame_GetActiveChild, 1 },
|
||||
{ "wxMDIParentFrame_GetClientSize", _wrap_wxMDIParentFrame_GetClientSize, 1 },
|
||||
{ "wxMDIParentFrame_Cascade", _wrap_wxMDIParentFrame_Cascade, 1 },
|
||||
{ "wxMDIParentFrame_ArrangeIcons", _wrap_wxMDIParentFrame_ArrangeIcons, 1 },
|
||||
{ "wxMDIParentFrame_ActivatePrevious", _wrap_wxMDIParentFrame_ActivatePrevious, 1 },
|
||||
{ "wxMDIParentFrame_ActivateNext", _wrap_wxMDIParentFrame_ActivateNext, 1 },
|
||||
{ "new_wxMDIParentFrame", _wrap_new_wxMDIParentFrame, 1 },
|
||||
{ NULL, NULL }
|
||||
};
|
||||
static PyObject *SWIG_globals;
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
#endif
|
||||
SWIGEXPORT(void,initmdic)() {
|
||||
PyObject *m, *d;
|
||||
SWIG_globals = SWIG_newvarlink();
|
||||
m = Py_InitModule("mdic", mdicMethods);
|
||||
d = PyModule_GetDict(m);
|
||||
/*
|
||||
* These are the pointer type-equivalency mappings.
|
||||
* (Used by the SWIG pointer type-checker).
|
||||
*/
|
||||
SWIG_RegisterMapping("_wxAcceleratorTable","_class_wxAcceleratorTable",0);
|
||||
SWIG_RegisterMapping("_wxEvent","_class_wxEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxActivateEvent","_wxActivateEvent",0);
|
||||
SWIG_RegisterMapping("_signed_long","_long",0);
|
||||
SWIG_RegisterMapping("_wxMenuEvent","_class_wxMenuEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxRegionIterator","_wxRegionIterator",0);
|
||||
SWIG_RegisterMapping("_class_wxMenuBar","_wxMenuBar",0);
|
||||
SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
|
||||
SWIG_RegisterMapping("_class_wxEvtHandler","_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
|
||||
SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
|
||||
SWIG_RegisterMapping("_class_wxEvtHandler","_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
|
||||
SWIG_RegisterMapping("_class_wxEvtHandler","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
|
||||
SWIG_RegisterMapping("_class_wxEvtHandler","_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
|
||||
SWIG_RegisterMapping("_class_wxEvtHandler","_wxEvtHandler",0);
|
||||
SWIG_RegisterMapping("_wxPaintEvent","_class_wxPaintEvent",0);
|
||||
SWIG_RegisterMapping("_wxIndividualLayoutConstraint","_class_wxIndividualLayoutConstraint",0);
|
||||
SWIG_RegisterMapping("_wxCursor","_class_wxCursor",0);
|
||||
SWIG_RegisterMapping("_wxMask","_class_wxMask",0);
|
||||
SWIG_RegisterMapping("_wxPyMenu","_class_wxPyMenu",0);
|
||||
SWIG_RegisterMapping("_wxPen","_class_wxPen",0);
|
||||
SWIG_RegisterMapping("_wxUpdateUIEvent","_class_wxUpdateUIEvent",0);
|
||||
SWIG_RegisterMapping("_byte","_unsigned_char",0);
|
||||
SWIG_RegisterMapping("_wxStaticBox","_class_wxStaticBox",0);
|
||||
SWIG_RegisterMapping("_wxChoice","_class_wxChoice",0);
|
||||
SWIG_RegisterMapping("_wxSlider","_class_wxSlider",0);
|
||||
SWIG_RegisterMapping("_long","_wxDash",0);
|
||||
SWIG_RegisterMapping("_long","_unsigned_long",0);
|
||||
SWIG_RegisterMapping("_long","_signed_long",0);
|
||||
SWIG_RegisterMapping("_wxDropFilesEvent","_class_wxDropFilesEvent",0);
|
||||
SWIG_RegisterMapping("_wxBitmapButton","_class_wxBitmapButton",0);
|
||||
SWIG_RegisterMapping("_class_wxAcceleratorTable","_wxAcceleratorTable",0);
|
||||
SWIG_RegisterMapping("_class_wxGauge","_wxGauge",0);
|
||||
SWIG_RegisterMapping("_wxDC","_class_wxDC",0);
|
||||
SWIG_RegisterMapping("_wxSpinEvent","_class_wxSpinEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxRealPoint","_wxRealPoint",0);
|
||||
SWIG_RegisterMapping("_class_wxMenuItem","_wxMenuItem",0);
|
||||
SWIG_RegisterMapping("_class_wxPaintEvent","_wxPaintEvent",0);
|
||||
SWIG_RegisterMapping("_wxSysColourChangedEvent","_class_wxSysColourChangedEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxStatusBar","_wxStatusBar",0);
|
||||
SWIG_RegisterMapping("_class_wxPostScriptDC","_wxPostScriptDC",0);
|
||||
SWIG_RegisterMapping("_wxPanel","_class_wxPanel",0);
|
||||
SWIG_RegisterMapping("_wxInitDialogEvent","_class_wxInitDialogEvent",0);
|
||||
SWIG_RegisterMapping("_wxCheckBox","_class_wxCheckBox",0);
|
||||
SWIG_RegisterMapping("_wxTextCtrl","_class_wxTextCtrl",0);
|
||||
SWIG_RegisterMapping("_class_wxMask","_wxMask",0);
|
||||
SWIG_RegisterMapping("_class_wxKeyEvent","_wxKeyEvent",0);
|
||||
SWIG_RegisterMapping("_wxColour","_class_wxColour",0);
|
||||
SWIG_RegisterMapping("_class_wxDialog","_wxDialog",0);
|
||||
SWIG_RegisterMapping("_wxIdleEvent","_class_wxIdleEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxUpdateUIEvent","_wxUpdateUIEvent",0);
|
||||
SWIG_RegisterMapping("_wxToolBar","_class_wxToolBar",0);
|
||||
SWIG_RegisterMapping("_wxBrush","_class_wxBrush",0);
|
||||
SWIG_RegisterMapping("_wxMiniFrame","_class_wxMiniFrame",0);
|
||||
SWIG_RegisterMapping("_wxShowEvent","_class_wxShowEvent",0);
|
||||
SWIG_RegisterMapping("_uint","_unsigned_int",0);
|
||||
SWIG_RegisterMapping("_uint","_int",0);
|
||||
SWIG_RegisterMapping("_uint","_wxWindowID",0);
|
||||
SWIG_RegisterMapping("_class_wxEvent","_wxEvent",0);
|
||||
SWIG_RegisterMapping("_wxCheckListBox","_class_wxCheckListBox",0);
|
||||
SWIG_RegisterMapping("_wxRect","_class_wxRect",0);
|
||||
SWIG_RegisterMapping("_wxCommandEvent","_class_wxCommandEvent",0);
|
||||
SWIG_RegisterMapping("_wxSizeEvent","_class_wxSizeEvent",0);
|
||||
SWIG_RegisterMapping("_wxPoint","_class_wxPoint",0);
|
||||
SWIG_RegisterMapping("_class_wxButton","_wxButton",0);
|
||||
SWIG_RegisterMapping("_wxRadioBox","_class_wxRadioBox",0);
|
||||
SWIG_RegisterMapping("_wxBitmap","_class_wxBitmap",0);
|
||||
SWIG_RegisterMapping("_wxPyTimer","_class_wxPyTimer",0);
|
||||
SWIG_RegisterMapping("_wxWindowDC","_class_wxWindowDC",0);
|
||||
SWIG_RegisterMapping("_wxScrollBar","_class_wxScrollBar",0);
|
||||
SWIG_RegisterMapping("_wxSpinButton","_class_wxSpinButton",0);
|
||||
SWIG_RegisterMapping("_wxToolBarTool","_class_wxToolBarTool",0);
|
||||
SWIG_RegisterMapping("_class_wxIndividualLayoutConstraint","_wxIndividualLayoutConstraint",0);
|
||||
SWIG_RegisterMapping("_class_wxIconizeEvent","_wxIconizeEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxStaticBitmap","_wxStaticBitmap",0);
|
||||
SWIG_RegisterMapping("_wxMDIChildFrame","_class_wxMDIChildFrame",0);
|
||||
SWIG_RegisterMapping("_class_wxToolBar","_wxToolBar",0);
|
||||
SWIG_RegisterMapping("_wxScrollEvent","_class_wxScrollEvent",0);
|
||||
SWIG_RegisterMapping("_EBool","_signed_int",0);
|
||||
SWIG_RegisterMapping("_EBool","_int",0);
|
||||
SWIG_RegisterMapping("_EBool","_wxWindowID",0);
|
||||
SWIG_RegisterMapping("_class_wxRegion","_wxRegion",0);
|
||||
SWIG_RegisterMapping("_class_wxDropFilesEvent","_wxDropFilesEvent",0);
|
||||
SWIG_RegisterMapping("_wxStaticText","_class_wxStaticText",0);
|
||||
SWIG_RegisterMapping("_wxFont","_class_wxFont",0);
|
||||
SWIG_RegisterMapping("_wxCloseEvent","_class_wxCloseEvent",0);
|
||||
SWIG_RegisterMapping("_unsigned_long","_wxDash",0);
|
||||
SWIG_RegisterMapping("_unsigned_long","_long",0);
|
||||
SWIG_RegisterMapping("_class_wxRect","_wxRect",0);
|
||||
SWIG_RegisterMapping("_class_wxDC","_wxDC",0);
|
||||
SWIG_RegisterMapping("_wxMDIParentFrame","_class_wxMDIParentFrame",0);
|
||||
SWIG_RegisterMapping("_class_wxPyTimer","_wxPyTimer",0);
|
||||
SWIG_RegisterMapping("_wxFocusEvent","_class_wxFocusEvent",0);
|
||||
SWIG_RegisterMapping("_wxMaximizeEvent","_class_wxMaximizeEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxSpinButton","_wxSpinButton",0);
|
||||
SWIG_RegisterMapping("_wxAcceleratorEntry","_class_wxAcceleratorEntry",0);
|
||||
SWIG_RegisterMapping("_class_wxPanel","_wxPanel",0);
|
||||
SWIG_RegisterMapping("_class_wxCheckBox","_wxCheckBox",0);
|
||||
SWIG_RegisterMapping("_wxComboBox","_class_wxComboBox",0);
|
||||
SWIG_RegisterMapping("_wxRadioButton","_class_wxRadioButton",0);
|
||||
SWIG_RegisterMapping("_signed_int","_EBool",0);
|
||||
SWIG_RegisterMapping("_signed_int","_wxWindowID",0);
|
||||
SWIG_RegisterMapping("_signed_int","_int",0);
|
||||
SWIG_RegisterMapping("_class_wxTextCtrl","_wxTextCtrl",0);
|
||||
SWIG_RegisterMapping("_wxLayoutConstraints","_class_wxLayoutConstraints",0);
|
||||
SWIG_RegisterMapping("_wxMenu","_class_wxMenu",0);
|
||||
SWIG_RegisterMapping("_class_wxMoveEvent","_wxMoveEvent",0);
|
||||
SWIG_RegisterMapping("_wxListBox","_class_wxListBox",0);
|
||||
SWIG_RegisterMapping("_wxScreenDC","_class_wxScreenDC",0);
|
||||
SWIG_RegisterMapping("_class_wxMDIChildFrame","_wxMDIChildFrame",0);
|
||||
SWIG_RegisterMapping("_WXTYPE","_short",0);
|
||||
SWIG_RegisterMapping("_WXTYPE","_signed_short",0);
|
||||
SWIG_RegisterMapping("_WXTYPE","_unsigned_short",0);
|
||||
SWIG_RegisterMapping("_class_wxMDIClientWindow","_wxMDIClientWindow",0);
|
||||
SWIG_RegisterMapping("_class_wxBrush","_wxBrush",0);
|
||||
SWIG_RegisterMapping("_unsigned_short","_WXTYPE",0);
|
||||
SWIG_RegisterMapping("_unsigned_short","_short",0);
|
||||
SWIG_RegisterMapping("_class_wxWindow","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
|
||||
SWIG_RegisterMapping("_class_wxWindow","_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
|
||||
SWIG_RegisterMapping("_class_wxWindow","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
|
||||
SWIG_RegisterMapping("_class_wxWindow","_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
|
||||
SWIG_RegisterMapping("_class_wxWindow","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
|
||||
SWIG_RegisterMapping("_class_wxWindow","_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
|
||||
SWIG_RegisterMapping("_class_wxWindow","_wxWindow",0);
|
||||
SWIG_RegisterMapping("_class_wxStaticText","_wxStaticText",0);
|
||||
SWIG_RegisterMapping("_class_wxFont","_wxFont",0);
|
||||
SWIG_RegisterMapping("_class_wxCloseEvent","_wxCloseEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxMenuEvent","_wxMenuEvent",0);
|
||||
SWIG_RegisterMapping("_wxClientDC","_class_wxClientDC",0);
|
||||
SWIG_RegisterMapping("_wxMouseEvent","_class_wxMouseEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxPoint","_wxPoint",0);
|
||||
SWIG_RegisterMapping("_wxRealPoint","_class_wxRealPoint",0);
|
||||
SWIG_RegisterMapping("_class_wxRadioBox","_wxRadioBox",0);
|
||||
SWIG_RegisterMapping("_signed_short","_WXTYPE",0);
|
||||
SWIG_RegisterMapping("_signed_short","_short",0);
|
||||
SWIG_RegisterMapping("_wxMemoryDC","_class_wxMemoryDC",0);
|
||||
SWIG_RegisterMapping("_wxPaintDC","_class_wxPaintDC",0);
|
||||
SWIG_RegisterMapping("_class_wxWindowDC","_wxWindowDC",0);
|
||||
SWIG_RegisterMapping("_class_wxFocusEvent","_wxFocusEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxMaximizeEvent","_wxMaximizeEvent",0);
|
||||
SWIG_RegisterMapping("_wxStatusBar","_class_wxStatusBar",0);
|
||||
SWIG_RegisterMapping("_class_wxToolBarTool","_wxToolBarTool",0);
|
||||
SWIG_RegisterMapping("_class_wxAcceleratorEntry","_wxAcceleratorEntry",0);
|
||||
SWIG_RegisterMapping("_class_wxCursor","_wxCursor",0);
|
||||
SWIG_RegisterMapping("_wxPostScriptDC","_class_wxPostScriptDC",0);
|
||||
SWIG_RegisterMapping("_wxScrolledWindow","_class_wxScrolledWindow",0);
|
||||
SWIG_RegisterMapping("_unsigned_char","_byte",0);
|
||||
SWIG_RegisterMapping("_class_wxMenu","_wxMenu",0);
|
||||
SWIG_RegisterMapping("_wxControl","_class_wxControl",0);
|
||||
SWIG_RegisterMapping("_class_wxListBox","_wxListBox",0);
|
||||
SWIG_RegisterMapping("_unsigned_int","_uint",0);
|
||||
SWIG_RegisterMapping("_unsigned_int","_wxWindowID",0);
|
||||
SWIG_RegisterMapping("_unsigned_int","_int",0);
|
||||
SWIG_RegisterMapping("_wxIcon","_class_wxIcon",0);
|
||||
SWIG_RegisterMapping("_wxDialog","_class_wxDialog",0);
|
||||
SWIG_RegisterMapping("_class_wxPyMenu","_wxPyMenu",0);
|
||||
SWIG_RegisterMapping("_class_wxPen","_wxPen",0);
|
||||
SWIG_RegisterMapping("_short","_WXTYPE",0);
|
||||
SWIG_RegisterMapping("_short","_unsigned_short",0);
|
||||
SWIG_RegisterMapping("_short","_signed_short",0);
|
||||
SWIG_RegisterMapping("_class_wxStaticBox","_wxStaticBox",0);
|
||||
SWIG_RegisterMapping("_class_wxScrollEvent","_wxScrollEvent",0);
|
||||
SWIG_RegisterMapping("_wxJoystickEvent","_class_wxJoystickEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxChoice","_wxChoice",0);
|
||||
SWIG_RegisterMapping("_class_wxSlider","_wxSlider",0);
|
||||
SWIG_RegisterMapping("_class_wxBitmapButton","_wxBitmapButton",0);
|
||||
SWIG_RegisterMapping("_wxFrame","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
|
||||
SWIG_RegisterMapping("_wxFrame","_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
|
||||
SWIG_RegisterMapping("_wxFrame","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
|
||||
SWIG_RegisterMapping("_wxFrame","_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
|
||||
SWIG_RegisterMapping("_wxFrame","_class_wxFrame",0);
|
||||
SWIG_RegisterMapping("_wxWindowID","_EBool",0);
|
||||
SWIG_RegisterMapping("_wxWindowID","_uint",0);
|
||||
SWIG_RegisterMapping("_wxWindowID","_int",0);
|
||||
SWIG_RegisterMapping("_wxWindowID","_signed_int",0);
|
||||
SWIG_RegisterMapping("_wxWindowID","_unsigned_int",0);
|
||||
SWIG_RegisterMapping("_int","_EBool",0);
|
||||
SWIG_RegisterMapping("_int","_uint",0);
|
||||
SWIG_RegisterMapping("_int","_wxWindowID",0);
|
||||
SWIG_RegisterMapping("_int","_unsigned_int",0);
|
||||
SWIG_RegisterMapping("_int","_signed_int",0);
|
||||
SWIG_RegisterMapping("_class_wxMouseEvent","_wxMouseEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxSpinEvent","_wxSpinEvent",0);
|
||||
SWIG_RegisterMapping("_wxButton","_class_wxButton",0);
|
||||
SWIG_RegisterMapping("_wxSize","_class_wxSize",0);
|
||||
SWIG_RegisterMapping("_wxRegionIterator","_class_wxRegionIterator",0);
|
||||
SWIG_RegisterMapping("_class_wxMDIParentFrame","_wxMDIParentFrame",0);
|
||||
SWIG_RegisterMapping("_class_wxPaintDC","_wxPaintDC",0);
|
||||
SWIG_RegisterMapping("_class_wxSysColourChangedEvent","_wxSysColourChangedEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxInitDialogEvent","_wxInitDialogEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxComboBox","_wxComboBox",0);
|
||||
SWIG_RegisterMapping("_class_wxRadioButton","_wxRadioButton",0);
|
||||
SWIG_RegisterMapping("_class_wxLayoutConstraints","_wxLayoutConstraints",0);
|
||||
SWIG_RegisterMapping("_wxIconizeEvent","_class_wxIconizeEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxControl","_wxControl",0);
|
||||
SWIG_RegisterMapping("_wxStaticBitmap","_class_wxStaticBitmap",0);
|
||||
SWIG_RegisterMapping("_class_wxIcon","_wxIcon",0);
|
||||
SWIG_RegisterMapping("_class_wxColour","_wxColour",0);
|
||||
SWIG_RegisterMapping("_class_wxScreenDC","_wxScreenDC",0);
|
||||
SWIG_RegisterMapping("_wxPalette","_class_wxPalette",0);
|
||||
SWIG_RegisterMapping("_class_wxIdleEvent","_wxIdleEvent",0);
|
||||
SWIG_RegisterMapping("_wxEraseEvent","_class_wxEraseEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxJoystickEvent","_wxJoystickEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxMiniFrame","_wxMiniFrame",0);
|
||||
SWIG_RegisterMapping("_wxRegion","_class_wxRegion",0);
|
||||
SWIG_RegisterMapping("_class_wxShowEvent","_wxShowEvent",0);
|
||||
SWIG_RegisterMapping("_wxActivateEvent","_class_wxActivateEvent",0);
|
||||
SWIG_RegisterMapping("_wxGauge","_class_wxGauge",0);
|
||||
SWIG_RegisterMapping("_class_wxCheckListBox","_wxCheckListBox",0);
|
||||
SWIG_RegisterMapping("_class_wxCommandEvent","_wxCommandEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxClientDC","_wxClientDC",0);
|
||||
SWIG_RegisterMapping("_class_wxSizeEvent","_wxSizeEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxSize","_wxSize",0);
|
||||
SWIG_RegisterMapping("_class_wxBitmap","_wxBitmap",0);
|
||||
SWIG_RegisterMapping("_class_wxMemoryDC","_wxMemoryDC",0);
|
||||
SWIG_RegisterMapping("_wxMenuBar","_class_wxMenuBar",0);
|
||||
SWIG_RegisterMapping("_wxEvtHandler","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
|
||||
SWIG_RegisterMapping("_wxEvtHandler","_wxMDIClientWindow",SwigwxMDIClientWindowTowxEvtHandler);
|
||||
SWIG_RegisterMapping("_wxEvtHandler","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
|
||||
SWIG_RegisterMapping("_wxEvtHandler","_wxMDIChildFrame",SwigwxMDIChildFrameTowxEvtHandler);
|
||||
SWIG_RegisterMapping("_wxEvtHandler","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
|
||||
SWIG_RegisterMapping("_wxEvtHandler","_wxMDIParentFrame",SwigwxMDIParentFrameTowxEvtHandler);
|
||||
SWIG_RegisterMapping("_wxEvtHandler","_class_wxEvtHandler",0);
|
||||
SWIG_RegisterMapping("_wxMenuItem","_class_wxMenuItem",0);
|
||||
SWIG_RegisterMapping("_class_wxScrollBar","_wxScrollBar",0);
|
||||
SWIG_RegisterMapping("_wxDash","_unsigned_long",0);
|
||||
SWIG_RegisterMapping("_wxDash","_long",0);
|
||||
SWIG_RegisterMapping("_class_wxScrolledWindow","_wxScrolledWindow",0);
|
||||
SWIG_RegisterMapping("_wxKeyEvent","_class_wxKeyEvent",0);
|
||||
SWIG_RegisterMapping("_wxMoveEvent","_class_wxMoveEvent",0);
|
||||
SWIG_RegisterMapping("_class_wxPalette","_wxPalette",0);
|
||||
SWIG_RegisterMapping("_class_wxEraseEvent","_wxEraseEvent",0);
|
||||
SWIG_RegisterMapping("_wxMDIClientWindow","_class_wxMDIClientWindow",0);
|
||||
SWIG_RegisterMapping("_wxWindow","_class_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
|
||||
SWIG_RegisterMapping("_wxWindow","_wxMDIClientWindow",SwigwxMDIClientWindowTowxWindow);
|
||||
SWIG_RegisterMapping("_wxWindow","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
|
||||
SWIG_RegisterMapping("_wxWindow","_wxMDIChildFrame",SwigwxMDIChildFrameTowxWindow);
|
||||
SWIG_RegisterMapping("_wxWindow","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
|
||||
SWIG_RegisterMapping("_wxWindow","_wxMDIParentFrame",SwigwxMDIParentFrameTowxWindow);
|
||||
SWIG_RegisterMapping("_wxWindow","_class_wxWindow",0);
|
||||
SWIG_RegisterMapping("_class_wxFrame","_class_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
|
||||
SWIG_RegisterMapping("_class_wxFrame","_wxMDIChildFrame",SwigwxMDIChildFrameTowxFrame);
|
||||
SWIG_RegisterMapping("_class_wxFrame","_class_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
|
||||
SWIG_RegisterMapping("_class_wxFrame","_wxMDIParentFrame",SwigwxMDIParentFrameTowxFrame);
|
||||
SWIG_RegisterMapping("_class_wxFrame","_wxFrame",0);
|
||||
}
|
||||
131
utils/wxPython/src/gtk/mdi.py
Normal file
131
utils/wxPython/src/gtk/mdi.py
Normal file
@@ -0,0 +1,131 @@
|
||||
# This file was created automatically by SWIG.
|
||||
import mdic
|
||||
|
||||
from misc import *
|
||||
|
||||
from windows import *
|
||||
|
||||
from gdi import *
|
||||
|
||||
from frames import *
|
||||
|
||||
from stattool import *
|
||||
|
||||
from controls import *
|
||||
|
||||
from events import *
|
||||
import wx
|
||||
class wxMDIParentFramePtr(wxFramePtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def ActivateNext(self):
|
||||
val = mdic.wxMDIParentFrame_ActivateNext(self.this)
|
||||
return val
|
||||
def ActivatePrevious(self):
|
||||
val = mdic.wxMDIParentFrame_ActivatePrevious(self.this)
|
||||
return val
|
||||
def ArrangeIcons(self):
|
||||
val = mdic.wxMDIParentFrame_ArrangeIcons(self.this)
|
||||
return val
|
||||
def Cascade(self):
|
||||
val = mdic.wxMDIParentFrame_Cascade(self.this)
|
||||
return val
|
||||
def GetClientSize(self):
|
||||
val = mdic.wxMDIParentFrame_GetClientSize(self.this)
|
||||
return val
|
||||
def GetActiveChild(self):
|
||||
val = mdic.wxMDIParentFrame_GetActiveChild(self.this)
|
||||
val = wxMDIChildFramePtr(val)
|
||||
return val
|
||||
def GetClientWindow(self):
|
||||
val = mdic.wxMDIParentFrame_GetClientWindow(self.this)
|
||||
val = wxMDIClientWindowPtr(val)
|
||||
return val
|
||||
def GetToolBar(self):
|
||||
val = mdic.wxMDIParentFrame_GetToolBar(self.this)
|
||||
val = wxWindowPtr(val)
|
||||
return val
|
||||
def Tile(self):
|
||||
val = mdic.wxMDIParentFrame_Tile(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxMDIParentFrame instance>"
|
||||
class wxMDIParentFrame(wxMDIParentFramePtr):
|
||||
def __init__(self,arg0,arg1,arg2,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(mdic.new_wxMDIParentFrame,(arg0.this,arg1,arg2,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdFrameCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxMDIChildFramePtr(wxFramePtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def Activate(self):
|
||||
val = mdic.wxMDIChildFrame_Activate(self.this)
|
||||
return val
|
||||
def Maximize(self):
|
||||
val = mdic.wxMDIChildFrame_Maximize(self.this)
|
||||
return val
|
||||
def Restore(self):
|
||||
val = mdic.wxMDIChildFrame_Restore(self.this)
|
||||
return val
|
||||
def SetMenuBar(self,arg0):
|
||||
val = mdic.wxMDIChildFrame_SetMenuBar(self.this,arg0.this)
|
||||
return val
|
||||
def SetClientSize(self,arg0,arg1):
|
||||
val = mdic.wxMDIChildFrame_SetClientSize(self.this,arg0,arg1)
|
||||
return val
|
||||
def GetPosition(self):
|
||||
val = mdic.wxMDIChildFrame_GetPosition(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxMDIChildFrame instance>"
|
||||
class wxMDIChildFrame(wxMDIChildFramePtr):
|
||||
def __init__(self,arg0,arg1,arg2,*args) :
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
try: argl[1] = argl[1].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
self.this = apply(mdic.new_wxMDIChildFrame,(arg0.this,arg1,arg2,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdFrameCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
class wxMDIClientWindowPtr(wxWindowPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __repr__(self):
|
||||
return "<C wxMDIClientWindow instance>"
|
||||
class wxMDIClientWindow(wxMDIClientWindowPtr):
|
||||
def __init__(self,arg0,*args) :
|
||||
self.this = apply(mdic.new_wxMDIClientWindow,(arg0.this,)+args)
|
||||
self.thisown = 1
|
||||
wx._StdWindowCallbacks(self)
|
||||
wx._StdOnScrollCallbacks(self)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#-------------- FUNCTION WRAPPERS ------------------
|
||||
|
||||
|
||||
|
||||
#-------------- VARIABLE WRAPPERS ------------------
|
||||
|
||||
3417
utils/wxPython/src/gtk/misc.cpp
Normal file
3417
utils/wxPython/src/gtk/misc.cpp
Normal file
File diff suppressed because it is too large
Load Diff
617
utils/wxPython/src/gtk/misc.py
Normal file
617
utils/wxPython/src/gtk/misc.py
Normal file
@@ -0,0 +1,617 @@
|
||||
# This file was created automatically by SWIG.
|
||||
import miscc
|
||||
class wxSizePtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
miscc.delete_wxSize(self.this)
|
||||
def Set(self,arg0,arg1):
|
||||
val = miscc.wxSize_Set(self.this,arg0,arg1)
|
||||
return val
|
||||
def GetWidth(self):
|
||||
val = miscc.wxSize_GetWidth(self.this)
|
||||
return val
|
||||
def GetHeight(self):
|
||||
val = miscc.wxSize_GetHeight(self.this)
|
||||
return val
|
||||
def __str__(self):
|
||||
val = miscc.wxSize___str__(self.this)
|
||||
return val
|
||||
def __setattr__(self,name,value):
|
||||
if name == "width" :
|
||||
miscc.wxSize_width_set(self.this,value)
|
||||
return
|
||||
if name == "height" :
|
||||
miscc.wxSize_height_set(self.this,value)
|
||||
return
|
||||
self.__dict__[name] = value
|
||||
def __getattr__(self,name):
|
||||
if name == "width" :
|
||||
return miscc.wxSize_width_get(self.this)
|
||||
if name == "height" :
|
||||
return miscc.wxSize_height_get(self.this)
|
||||
raise AttributeError,name
|
||||
def __repr__(self):
|
||||
return "<C wxSize instance>"
|
||||
class wxSize(wxSizePtr):
|
||||
def __init__(self,*args) :
|
||||
self.this = apply(miscc.new_wxSize,()+args)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxRealPointPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
miscc.delete_wxRealPoint(self.this)
|
||||
def __setattr__(self,name,value):
|
||||
if name == "x" :
|
||||
miscc.wxRealPoint_x_set(self.this,value)
|
||||
return
|
||||
if name == "y" :
|
||||
miscc.wxRealPoint_y_set(self.this,value)
|
||||
return
|
||||
self.__dict__[name] = value
|
||||
def __getattr__(self,name):
|
||||
if name == "x" :
|
||||
return miscc.wxRealPoint_x_get(self.this)
|
||||
if name == "y" :
|
||||
return miscc.wxRealPoint_y_get(self.this)
|
||||
raise AttributeError,name
|
||||
def __repr__(self):
|
||||
return "<C wxRealPoint instance>"
|
||||
class wxRealPoint(wxRealPointPtr):
|
||||
def __init__(self,*args) :
|
||||
self.this = apply(miscc.new_wxRealPoint,()+args)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxPointPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
miscc.delete_wxPoint(self.this)
|
||||
def Set(self,arg0,arg1):
|
||||
val = miscc.wxPoint_Set(self.this,arg0,arg1)
|
||||
return val
|
||||
def __str__(self):
|
||||
val = miscc.wxPoint___str__(self.this)
|
||||
return val
|
||||
def __setattr__(self,name,value):
|
||||
if name == "x" :
|
||||
miscc.wxPoint_x_set(self.this,value)
|
||||
return
|
||||
if name == "y" :
|
||||
miscc.wxPoint_y_set(self.this,value)
|
||||
return
|
||||
self.__dict__[name] = value
|
||||
def __getattr__(self,name):
|
||||
if name == "x" :
|
||||
return miscc.wxPoint_x_get(self.this)
|
||||
if name == "y" :
|
||||
return miscc.wxPoint_y_get(self.this)
|
||||
raise AttributeError,name
|
||||
def __repr__(self):
|
||||
return "<C wxPoint instance>"
|
||||
class wxPoint(wxPointPtr):
|
||||
def __init__(self,*args) :
|
||||
self.this = apply(miscc.new_wxPoint,()+args)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxRectPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
miscc.delete_wxRect(self.this)
|
||||
def GetX(self):
|
||||
val = miscc.wxRect_GetX(self.this)
|
||||
return val
|
||||
def SetX(self,arg0):
|
||||
val = miscc.wxRect_SetX(self.this,arg0)
|
||||
return val
|
||||
def GetY(self):
|
||||
val = miscc.wxRect_GetY(self.this)
|
||||
return val
|
||||
def SetY(self,arg0):
|
||||
val = miscc.wxRect_SetY(self.this,arg0)
|
||||
return val
|
||||
def GetWidth(self):
|
||||
val = miscc.wxRect_GetWidth(self.this)
|
||||
return val
|
||||
def SetWidth(self,arg0):
|
||||
val = miscc.wxRect_SetWidth(self.this,arg0)
|
||||
return val
|
||||
def GetHeight(self):
|
||||
val = miscc.wxRect_GetHeight(self.this)
|
||||
return val
|
||||
def SetHeight(self,arg0):
|
||||
val = miscc.wxRect_SetHeight(self.this,arg0)
|
||||
return val
|
||||
def GetPosition(self):
|
||||
val = miscc.wxRect_GetPosition(self.this)
|
||||
val = wxPointPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetSize(self):
|
||||
val = miscc.wxRect_GetSize(self.this)
|
||||
val = wxSizePtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def GetLeft(self):
|
||||
val = miscc.wxRect_GetLeft(self.this)
|
||||
return val
|
||||
def GetTop(self):
|
||||
val = miscc.wxRect_GetTop(self.this)
|
||||
return val
|
||||
def GetBottom(self):
|
||||
val = miscc.wxRect_GetBottom(self.this)
|
||||
return val
|
||||
def GetRight(self):
|
||||
val = miscc.wxRect_GetRight(self.this)
|
||||
return val
|
||||
def __setattr__(self,name,value):
|
||||
if name == "x" :
|
||||
miscc.wxRect_x_set(self.this,value)
|
||||
return
|
||||
if name == "y" :
|
||||
miscc.wxRect_y_set(self.this,value)
|
||||
return
|
||||
if name == "width" :
|
||||
miscc.wxRect_width_set(self.this,value)
|
||||
return
|
||||
if name == "height" :
|
||||
miscc.wxRect_height_set(self.this,value)
|
||||
return
|
||||
self.__dict__[name] = value
|
||||
def __getattr__(self,name):
|
||||
if name == "x" :
|
||||
return miscc.wxRect_x_get(self.this)
|
||||
if name == "y" :
|
||||
return miscc.wxRect_y_get(self.this)
|
||||
if name == "width" :
|
||||
return miscc.wxRect_width_get(self.this)
|
||||
if name == "height" :
|
||||
return miscc.wxRect_height_get(self.this)
|
||||
raise AttributeError,name
|
||||
def __repr__(self):
|
||||
return "<C wxRect instance>"
|
||||
class wxRect(wxRectPtr):
|
||||
def __init__(self,*args) :
|
||||
self.this = apply(miscc.new_wxRect,()+args)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxPyTimerPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
miscc.delete_wxPyTimer(self.this)
|
||||
def Interval(self):
|
||||
val = miscc.wxPyTimer_Interval(self.this)
|
||||
return val
|
||||
def Start(self,*args):
|
||||
val = apply(miscc.wxPyTimer_Start,(self.this,)+args)
|
||||
return val
|
||||
def Stop(self):
|
||||
val = miscc.wxPyTimer_Stop(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxPyTimer instance>"
|
||||
class wxPyTimer(wxPyTimerPtr):
|
||||
def __init__(self,arg0) :
|
||||
self.this = miscc.new_wxPyTimer(arg0)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxIndividualLayoutConstraintPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def Above(self,arg0,*args):
|
||||
val = apply(miscc.wxIndividualLayoutConstraint_Above,(self.this,arg0.this,)+args)
|
||||
return val
|
||||
def Absolute(self,arg0):
|
||||
val = miscc.wxIndividualLayoutConstraint_Absolute(self.this,arg0)
|
||||
return val
|
||||
def AsIs(self):
|
||||
val = miscc.wxIndividualLayoutConstraint_AsIs(self.this)
|
||||
return val
|
||||
def Below(self,arg0,*args):
|
||||
val = apply(miscc.wxIndividualLayoutConstraint_Below,(self.this,arg0.this,)+args)
|
||||
return val
|
||||
def Unconstrained(self):
|
||||
val = miscc.wxIndividualLayoutConstraint_Unconstrained(self.this)
|
||||
return val
|
||||
def LeftOf(self,arg0,*args):
|
||||
val = apply(miscc.wxIndividualLayoutConstraint_LeftOf,(self.this,arg0.this,)+args)
|
||||
return val
|
||||
def PercentOf(self,arg0,arg1,arg2):
|
||||
val = miscc.wxIndividualLayoutConstraint_PercentOf(self.this,arg0.this,arg1,arg2)
|
||||
return val
|
||||
def RightOf(self,arg0,*args):
|
||||
val = apply(miscc.wxIndividualLayoutConstraint_RightOf,(self.this,arg0.this,)+args)
|
||||
return val
|
||||
def SameAs(self,arg0,arg1,*args):
|
||||
val = apply(miscc.wxIndividualLayoutConstraint_SameAs,(self.this,arg0.this,arg1,)+args)
|
||||
return val
|
||||
def Set(self,arg0,arg1,arg2,*args):
|
||||
val = apply(miscc.wxIndividualLayoutConstraint_Set,(self.this,arg0,arg1.this,arg2,)+args)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxIndividualLayoutConstraint instance>"
|
||||
class wxIndividualLayoutConstraint(wxIndividualLayoutConstraintPtr):
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
|
||||
|
||||
|
||||
|
||||
class wxLayoutConstraintsPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __setattr__(self,name,value):
|
||||
if name == "bottom" :
|
||||
miscc.wxLayoutConstraints_bottom_set(self.this,value.this)
|
||||
return
|
||||
if name == "centreX" :
|
||||
miscc.wxLayoutConstraints_centreX_set(self.this,value.this)
|
||||
return
|
||||
if name == "centreY" :
|
||||
miscc.wxLayoutConstraints_centreY_set(self.this,value.this)
|
||||
return
|
||||
if name == "height" :
|
||||
miscc.wxLayoutConstraints_height_set(self.this,value.this)
|
||||
return
|
||||
if name == "left" :
|
||||
miscc.wxLayoutConstraints_left_set(self.this,value.this)
|
||||
return
|
||||
if name == "right" :
|
||||
miscc.wxLayoutConstraints_right_set(self.this,value.this)
|
||||
return
|
||||
if name == "top" :
|
||||
miscc.wxLayoutConstraints_top_set(self.this,value.this)
|
||||
return
|
||||
if name == "width" :
|
||||
miscc.wxLayoutConstraints_width_set(self.this,value.this)
|
||||
return
|
||||
self.__dict__[name] = value
|
||||
def __getattr__(self,name):
|
||||
if name == "bottom" :
|
||||
return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_bottom_get(self.this))
|
||||
if name == "centreX" :
|
||||
return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_centreX_get(self.this))
|
||||
if name == "centreY" :
|
||||
return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_centreY_get(self.this))
|
||||
if name == "height" :
|
||||
return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_height_get(self.this))
|
||||
if name == "left" :
|
||||
return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_left_get(self.this))
|
||||
if name == "right" :
|
||||
return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_right_get(self.this))
|
||||
if name == "top" :
|
||||
return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_top_get(self.this))
|
||||
if name == "width" :
|
||||
return wxIndividualLayoutConstraintPtr(miscc.wxLayoutConstraints_width_get(self.this))
|
||||
raise AttributeError,name
|
||||
def __repr__(self):
|
||||
return "<C wxLayoutConstraints instance>"
|
||||
class wxLayoutConstraints(wxLayoutConstraintsPtr):
|
||||
def __init__(self) :
|
||||
self.this = miscc.new_wxLayoutConstraints()
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxRegionPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
miscc.delete_wxRegion(self.this)
|
||||
def Clear(self):
|
||||
val = miscc.wxRegion_Clear(self.this)
|
||||
return val
|
||||
def Contains(self,arg0,arg1):
|
||||
val = miscc.wxRegion_Contains(self.this,arg0,arg1)
|
||||
return val
|
||||
def ContainsPoint(self,arg0):
|
||||
val = miscc.wxRegion_ContainsPoint(self.this,arg0.this)
|
||||
return val
|
||||
def ContainsRect(self,arg0):
|
||||
val = miscc.wxRegion_ContainsRect(self.this,arg0.this)
|
||||
return val
|
||||
def GetBox(self):
|
||||
val = miscc.wxRegion_GetBox(self.this)
|
||||
val = wxRectPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def Intersect(self,arg0):
|
||||
val = miscc.wxRegion_Intersect(self.this,arg0.this)
|
||||
return val
|
||||
def Subtract(self,arg0):
|
||||
val = miscc.wxRegion_Subtract(self.this,arg0.this)
|
||||
return val
|
||||
def Union(self,arg0):
|
||||
val = miscc.wxRegion_Union(self.this,arg0.this)
|
||||
return val
|
||||
def Xor(self,arg0):
|
||||
val = miscc.wxRegion_Xor(self.this,arg0.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxRegion instance>"
|
||||
class wxRegion(wxRegionPtr):
|
||||
def __init__(self) :
|
||||
self.this = miscc.new_wxRegion()
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxRegionIteratorPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __del__(self):
|
||||
if self.thisown == 1 :
|
||||
miscc.delete_wxRegionIterator(self.this)
|
||||
def GetX(self):
|
||||
val = miscc.wxRegionIterator_GetX(self.this)
|
||||
return val
|
||||
def GetY(self):
|
||||
val = miscc.wxRegionIterator_GetY(self.this)
|
||||
return val
|
||||
def GetW(self):
|
||||
val = miscc.wxRegionIterator_GetW(self.this)
|
||||
return val
|
||||
def GetWidth(self):
|
||||
val = miscc.wxRegionIterator_GetWidth(self.this)
|
||||
return val
|
||||
def GetH(self):
|
||||
val = miscc.wxRegionIterator_GetH(self.this)
|
||||
return val
|
||||
def GetHeight(self):
|
||||
val = miscc.wxRegionIterator_GetHeight(self.this)
|
||||
return val
|
||||
def GetRect(self):
|
||||
val = miscc.wxRegionIterator_GetRect(self.this)
|
||||
val = wxRectPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
def HaveRects(self):
|
||||
val = miscc.wxRegionIterator_HaveRects(self.this)
|
||||
return val
|
||||
def Reset(self):
|
||||
val = miscc.wxRegionIterator_Reset(self.this)
|
||||
return val
|
||||
def Next(self):
|
||||
val = miscc.wxRegionIterator_Next(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxRegionIterator instance>"
|
||||
class wxRegionIterator(wxRegionIteratorPtr):
|
||||
def __init__(self,arg0) :
|
||||
self.this = miscc.new_wxRegionIterator(arg0.this)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxAcceleratorEntryPtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def Set(self,arg0,arg1,arg2):
|
||||
val = miscc.wxAcceleratorEntry_Set(self.this,arg0,arg1,arg2)
|
||||
return val
|
||||
def GetFlags(self):
|
||||
val = miscc.wxAcceleratorEntry_GetFlags(self.this)
|
||||
return val
|
||||
def GetKeyCode(self):
|
||||
val = miscc.wxAcceleratorEntry_GetKeyCode(self.this)
|
||||
return val
|
||||
def GetCommand(self):
|
||||
val = miscc.wxAcceleratorEntry_GetCommand(self.this)
|
||||
return val
|
||||
def __repr__(self):
|
||||
return "<C wxAcceleratorEntry instance>"
|
||||
class wxAcceleratorEntry(wxAcceleratorEntryPtr):
|
||||
def __init__(self,*args) :
|
||||
self.this = apply(miscc.new_wxAcceleratorEntry,()+args)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
class wxAcceleratorTablePtr :
|
||||
def __init__(self,this):
|
||||
self.this = this
|
||||
self.thisown = 0
|
||||
def __repr__(self):
|
||||
return "<C wxAcceleratorTable instance>"
|
||||
class wxAcceleratorTable(wxAcceleratorTablePtr):
|
||||
def __init__(self,arg0) :
|
||||
self.this = miscc.new_wxAcceleratorTable(arg0.this)
|
||||
self.thisown = 1
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#-------------- FUNCTION WRAPPERS ------------------
|
||||
|
||||
def wxFileSelector(arg0,*args):
|
||||
argl = map(None,args)
|
||||
try: argl[5] = argl[5].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
val = apply(miscc.wxFileSelector,(arg0,)+args)
|
||||
return val
|
||||
|
||||
def wxGetTextFromUser(arg0,*args):
|
||||
argl = map(None,args)
|
||||
try: argl[2] = argl[2].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
val = apply(miscc.wxGetTextFromUser,(arg0,)+args)
|
||||
return val
|
||||
|
||||
def wxGetSingleChoice(arg0,arg1,arg2,*args):
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
val = apply(miscc.wxGetSingleChoice,(arg0,arg1,arg2,)+args)
|
||||
return val
|
||||
|
||||
def wxGetSingleChoiceIndex(arg0,arg1,arg2,*args):
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
val = apply(miscc.wxGetSingleChoiceIndex,(arg0,arg1,arg2,)+args)
|
||||
return val
|
||||
|
||||
def wxMessageBox(arg0,*args):
|
||||
argl = map(None,args)
|
||||
try: argl[2] = argl[2].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
val = apply(miscc.wxMessageBox,(arg0,)+args)
|
||||
return val
|
||||
|
||||
wxColourDisplay = miscc.wxColourDisplay
|
||||
|
||||
wxDisplayDepth = miscc.wxDisplayDepth
|
||||
|
||||
def wxSetCursor(arg0):
|
||||
val = miscc.wxSetCursor(arg0.this)
|
||||
return val
|
||||
|
||||
NewId = miscc.NewId
|
||||
|
||||
RegisterId = miscc.RegisterId
|
||||
|
||||
def wxBeginBusyCursor(*args):
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
val = apply(miscc.wxBeginBusyCursor,()+args)
|
||||
return val
|
||||
|
||||
wxBell = miscc.wxBell
|
||||
|
||||
wxDisplaySize = miscc.wxDisplaySize
|
||||
|
||||
wxEndBusyCursor = miscc.wxEndBusyCursor
|
||||
|
||||
wxExecute = miscc.wxExecute
|
||||
|
||||
def wxFindWindowByLabel(arg0,*args):
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
val = apply(miscc.wxFindWindowByLabel,(arg0,)+args)
|
||||
val = wxWindowPtr(val)
|
||||
return val
|
||||
|
||||
def wxFindWindowByName(arg0,*args):
|
||||
argl = map(None,args)
|
||||
try: argl[0] = argl[0].this
|
||||
except: pass
|
||||
args = tuple(argl)
|
||||
val = apply(miscc.wxFindWindowByName,(arg0,)+args)
|
||||
val = wxWindowPtr(val)
|
||||
return val
|
||||
|
||||
wxGetMousePosition = miscc.wxGetMousePosition
|
||||
|
||||
wxIsBusy = miscc.wxIsBusy
|
||||
|
||||
wxNow = miscc.wxNow
|
||||
|
||||
wxYield = miscc.wxYield
|
||||
|
||||
wxGetResource = miscc.wxGetResource
|
||||
|
||||
wxResourceAddIdentifier = miscc.wxResourceAddIdentifier
|
||||
|
||||
wxResourceClear = miscc.wxResourceClear
|
||||
|
||||
def wxResourceCreateBitmap(arg0):
|
||||
val = miscc.wxResourceCreateBitmap(arg0)
|
||||
val = wxBitmapPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
|
||||
def wxResourceCreateIcon(arg0):
|
||||
val = miscc.wxResourceCreateIcon(arg0)
|
||||
val = wxIconPtr(val)
|
||||
val.thisown = 1
|
||||
return val
|
||||
|
||||
def wxResourceCreateMenuBar(arg0):
|
||||
val = miscc.wxResourceCreateMenuBar(arg0)
|
||||
val = wxMenuBarPtr(val)
|
||||
return val
|
||||
|
||||
wxResourceGetIdentifier = miscc.wxResourceGetIdentifier
|
||||
|
||||
wxResourceParseData = miscc.wxResourceParseData
|
||||
|
||||
wxResourceParseFile = miscc.wxResourceParseFile
|
||||
|
||||
wxResourceParseString = miscc.wxResourceParseString
|
||||
|
||||
|
||||
|
||||
#-------------- VARIABLE WRAPPERS ------------------
|
||||
|
||||
wxLeft = miscc.wxLeft
|
||||
wxTop = miscc.wxTop
|
||||
wxRight = miscc.wxRight
|
||||
wxBottom = miscc.wxBottom
|
||||
wxWidth = miscc.wxWidth
|
||||
wxHeight = miscc.wxHeight
|
||||
wxCentre = miscc.wxCentre
|
||||
wxCenter = miscc.wxCenter
|
||||
wxCentreX = miscc.wxCentreX
|
||||
wxCentreY = miscc.wxCentreY
|
||||
wxUnconstrained = miscc.wxUnconstrained
|
||||
wxAsIs = miscc.wxAsIs
|
||||
wxPercentOf = miscc.wxPercentOf
|
||||
wxAbove = miscc.wxAbove
|
||||
wxBelow = miscc.wxBelow
|
||||
wxLeftOf = miscc.wxLeftOf
|
||||
wxRightOf = miscc.wxRightOf
|
||||
wxSameAs = miscc.wxSameAs
|
||||
wxAbsolute = miscc.wxAbsolute
|
||||
wxOutRegion = miscc.wxOutRegion
|
||||
wxPartRegion = miscc.wxPartRegion
|
||||
wxInRegion = miscc.wxInRegion
|
||||
1586
utils/wxPython/src/gtk/stattool.cpp
Normal file
1586
utils/wxPython/src/gtk/stattool.cpp
Normal file
File diff suppressed because it is too large
Load Diff
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user