This commit was manufactured by cvs2svn to create tag

'LAST_WITH_IFDEF_QT'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/LAST_WITH_IFDEF_QT@11451 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/accel.h

@@ -0,0 +1,123 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/app.h

@@ -0,0 +1,512 @@
+/////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/bitmap.h

@@ -0,0 +1,175 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/bmpbuttn.h

@@ -0,0 +1,98 @@
+/////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/brush.h

@@ -0,0 +1,23 @@
+#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_

include/wx/button.h

@@ -0,0 +1,82 @@
+/////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/checkbox.h

@@ -0,0 +1,56 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/checklst.h

@@ -0,0 +1,52 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/choice.h

@@ -0,0 +1,85 @@
+/////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/clipbrd.h

@@ -0,0 +1,142 @@
+/////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/colour.h

@@ -0,0 +1,25 @@
+#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_

include/wx/combobox.h

@@ -0,0 +1,75 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/control.h

@@ -0,0 +1,98 @@
+/////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/cursor.h

@@ -0,0 +1,60 @@
+#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_

include/wx/dataobj.h

@@ -0,0 +1,467 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/dc.h

@@ -0,0 +1,812 @@
+/////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/dcclient.h

@@ -0,0 +1,23 @@
+#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_

include/wx/dcmemory.h

@@ -0,0 +1,23 @@
+#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_

include/wx/dcscreen.h

@@ -0,0 +1,23 @@
+#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_

include/wx/dde.h

@@ -0,0 +1,21 @@
+#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_

include/wx/dialog.h

@@ -0,0 +1,69 @@
+/////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/dirdlg.h

@@ -0,0 +1,41 @@
+#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_

include/wx/dnd.h

@@ -0,0 +1,232 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/dragimag.h

@@ -0,0 +1,50 @@
+#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_

include/wx/filedlg.h

@@ -0,0 +1,40 @@
+#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_

include/wx/font.h

@@ -0,0 +1,183 @@
+/////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/gauge.h

@@ -0,0 +1,102 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/gdiobj.h

@@ -0,0 +1,23 @@
+#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_

include/wx/glcanvas.h

@@ -0,0 +1,21 @@
+#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_

include/wx/icon.h

@@ -0,0 +1,29 @@
+#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_

include/wx/listbox.h

@@ -0,0 +1,149 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/mdi.h

@@ -0,0 +1,21 @@
+#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_

include/wx/menu.h

@@ -0,0 +1,468 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/menuitem.h

@@ -0,0 +1,157 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/msgdlg.h

@@ -0,0 +1,37 @@
+#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_

include/wx/notebook.h

@@ -0,0 +1,289 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/palette.h

@@ -0,0 +1,23 @@
+#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_

include/wx/pen.h

@@ -0,0 +1,23 @@
+#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_

include/wx/printdlg.h

@@ -0,0 +1,32 @@
+#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_

include/wx/radiobox.h

@@ -0,0 +1,118 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/radiobut.h

@@ -0,0 +1,57 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/region.h

@@ -0,0 +1,23 @@
+#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_

include/wx/scrolbar.h

@@ -0,0 +1,62 @@
+#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_

include/wx/settings.h

@@ -0,0 +1,129 @@
+/////////////////////////////////////////////////////////////////////////////
+// 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_
+

include/wx/setup.h

@@ -0,0 +1,84 @@
+/*
+ * 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_ */

include/wx/slider.h

@@ -0,0 +1,114 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/spinbutt.h

@@ -0,0 +1,128 @@
+/////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/statbmp.h

@@ -0,0 +1,70 @@
+/////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/statbox.h

@@ -0,0 +1,42 @@
+#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_

include/wx/stattext.h

@@ -0,0 +1,38 @@
+#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_

include/wx/taskbar.h

@@ -0,0 +1,19 @@
+#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_

include/wx/textctrl.h

@@ -0,0 +1,345 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/tglbtn.h

@@ -0,0 +1,50 @@
+/////////////////////////////////////////////////////////////////////////////
+// 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_
+

include/wx/timer.h

@@ -0,0 +1,244 @@
+/////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/toolbar.h

@@ -0,0 +1,59 @@
+/////////////////////////////////////////////////////////////////////////////
+// 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_

include/wx/tooltip.h

@@ -0,0 +1,21 @@
+#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_

include/wx/treectrl.h

@@ -0,0 +1,40 @@
+#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_
+

include/wx/wave.h

@@ -0,0 +1,19 @@
+#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_

wxPython/.cvsignore

@@ -1,9 +0,0 @@
-.emacs.desktop
-MANIFEST
-build
-build.local
-dist
-licence
-s.bat
-temp
-update.log

wxPython/BUILD.unix.txt

@@ -1,273 +0,0 @@
-Building wxPython on Unix or Unix-like Systems
-----------------------------------------------
-
-The basic steps for building wxPython for Unix or Unix-like systems
-are:
-
-     1. Compile and/or install glib and gtk+
-     2. Compile and/or install wxGTK
-     3. Compile and install wxPython
-
-We'll go into more detail of each of these steps below, but first a
-few bits of background information on tools.
-
-I use a tool called SWIG (http://www.swig.org) to help generate the
-C++ sources used in the wxPython extension module.  However you don't
-need to have SWIG unless you want to modify the *.i files.  If you do
-you'll want to have version 1.1-883 of SWIG and you'll need to apply
-the patches and updates in wxPython/SWIG and rebuild it.  Then you'll
-need to change a flag in the setup.py script as described below so the
-wxPython build process will use SWIG if needed.
-
-I use the new Python Distutils tool to build wxPython.  It is included
-with Python 2.0, but if you want to use Python 1.5.2 or 1.6 then
-you'll need to download and install Distutils 1.0 from
-http://www.python.org/sigs/distutils-sig/
-
-I usually use RedHat Linux when working on the wxGTK version of
-wxPython, but I occasionally build and test on Solaris and I hope to
-be able to add some other platforms soon.  The compiler I use is
-whatever comes with the current version of RedHat I am using.  I find
-that there are less portability problems with the RPMs if I don't try
-using the latest and greatest compilers all the time.  On the other
-platforms I usually stick with as recent a version of GCC that I can
-find pre-built for that platform.
-
-Okay, now on the the fun stuff...
-
-
-1. Compile and/or install glib and gtk+
----------------------------------------
-
-A. First of all, check and see if you've already got glib/gtk+ on your
-   system, all the Linux distributions I know of come with it, at
-   least as an option.  Look for libglib.* and libgtk.* in your system's
-   standard library directories.  You'll also need the headers and
-   config scripts in order to build things that use glib/gtk.  Try
-   running gtk-config:
-
-	   gtk-config --version
-
-   If you have version 1.2.5 or better then you're all set.  You can
-   skip to step #2.
-
-B. If your system has a binary package mechanism, (RPMs, debs,
-   whatever...) check and see if binaries for glib abd gtk+ are
-   available.  Be sure to get the runtime library package as well as
-   the development package, if they are separate.  Install them with
-   your package tool, and skip to step #2.
-
-C. If all else fails, you can get the source code for glib and gtk+ at
-   http://www.gtk.org/.  Fetch the latest of each in the 1.2.x
-   series.  Compile and install each of them like this:
-
-	    gzip -d [package].tar.gz | tar xvf -
-	    cd [package]
-	    ./configure
-	    make
-	    make install
-
-   The last step will probably have to be done as root.  Also, if your
-   system needs anything done to update the dynamic loader for shared
-   libraries, (such as running ldconfig on Linux) then do it after
-   each library is installed.
-
-
-
-2. Compile and/or install wxGTK
--------------------------------
-
-A. You can find the sources and RPMs for wxGTK at
-   ftp://wesley.informatik.uni-freiburg.de/pub/linux/wxxt/source/, or
-   just follow the download links from http://wxwindows.org/.  You can
-   also check out a current snapshot of the sources from the CVS
-   server.  (Some information about annonymous CVS access is at
-   http://wxwindows.org/cvs.htm.)  The advantage of using CVS is that
-   you can easily update as soon as the developers check in new
-   sources or fixes.  The advantage of using a released version is
-   that it usually has had more testing done.  You can decide which
-   method is best for you.
-
-B. You'll usually want to use a version of wxGTK that has the same
-   version number as the wxPython sources you are using.  (Another
-   advantage of using CVS is that you'll get both at the same time.)
-
-C. If using the RPMs be sure to get both the wxGTK and wxGTK-devel
-   RPMs (at a minimum) and then install them as root.
-
-	rpm -Uhv wxGTK-2.2.2-0.i386.rpm wxGTK-devel-2.2.2-0.i386.rpm
-
-D. If using the sources (either from the tarball or from CVS) then
-   configure it like this:
-
-	cd wxWindows   # or whatever your top-level directory is called
-	mkdir build
-	cd build
-	../configure --with-gtk
-
-   There are gobs and gobs of options for the configure script, run
-   ../configure --help to see them all.  I'll describe some that I find
-   useful here.
-
-   If you have OpenGL or compatible libraries installed, then add the
-   --with-opengl flag.
-
-   If you are on Solaris and are using a recent version of GCC, then
-   you'll probably want to add the --enable-permissive flag so the
-   compiler won't barf on your broken X11 header files.
-
-   To make a debugging version of wxGTK, add the --enable-debug flag.
-   This sets the -g flag for the compiler and also activates some
-   special debugging code in wxWindows by defining the __WXDEBUG__
-   macro.  You'll get some extra asserts, failure logging, etc.
-
-   To make a static library and not make a shared library, use the
-   --disable-shared and --enable-static flags.
-
-E. Now just compile and install.  You need to use GNU make, so if your
-   system has something else get GNU make and build and install it and
-   use it instead of your system's default make command.
-
-       make
-       make install
-
-   The last step will probably have to be done as root.  Also, if your
-   system needs anything done to update the dynamic loader for shared
-   libraries, (such as running ldconfig on Linux) then do it now.
-
-F. You can test your build by changing to one of the directories under
-   build/samples or build/demos, running make and then running the
-   executable that is built.
-
-
-
-3. Compile and install wxPython
--------------------------------
-
-A. You have the same options (and same advantages/disadvantages) for
-   getting the wxPython source, either a released snapshot or from
-   CVS.  The released version file is named wxPython-[version].tar.gz
-   and is available at http://wxpython.org/download.php.  If you want
-   to use CVS you'll find wxPython in the wxWindows CVS tree (see
-   above) in the wxWindows/wxPython directory.
-
-B. As mentioned previouslly, wxPython is built with the standard
-   Python Distutils tool.  If you are using Python 2.0 or later you
-   are all set, otherwise you need to download and install Distutils
-   1.0 from http://www.python.org/sigs/distutils-sig/.
-
-   On Unix systems Distutils figures out what commands and flags to
-   use for the compiler and linker by looking in the Makefile that was
-   used to build Python itself.  Most of the time this works okay.  If
-   it doesn't, there doesn't seem to be a way to override the values
-   that Distutils uses without hacking either Distutils itself, or
-   Python's Makefile.  (Complain to the distutils-sig about this
-   please.)  For example, on my Solaris system I had to edit
-   /usr/local/lib/python1.5/config/Makefile and replace
-
-         LDSHARED=ld -G
-
-   with
-
-         LDSHARED=gcc -G
-
-   This particular problem has been fixed in Python 1.6 and beyond,
-   but there may be similar issues on other platforms.
-
-   While we're on the subject of how Python was built... Since
-   wxPython is a C++ extension some platforms and/or compilers will
-   require that the Python executable was linked with the C++ linker
-   in order for everything to work correctly.  If you build and
-   install Python yourself then this is easy to take care of,
-   otherwise you may have to mess with binary packages or bribe your
-   system administrator...
-
-   In my case on Solaris wxPython applications would core dump on
-   exit.  The core file indicated that the fault happened after
-   _exit() was called and the run-time was trying to execute cleanup
-   code.  After relinking the Python executable the problem went away.
-   To build Python to link with the C++ linker do this:
-
-         cd Python-2.0      # wherever the root of the source tree is
-	 rm python          # in case it's still there from an old build
-         make LINKCC=g++    # or whatever your C++ command is
-	 make install
-
-
-C. Change to the root wxPython directory and look at the setup.py
-   file.  This is the script that configures and defines all the
-   information that Distutils needs to build wxPython.  There are some
-   options near the begining of the script that you may want or need
-   to change based on your system and what options you have selected
-   up to this point, (sources from tar.gz or from CVS, etc.)  You can
-   either change these flags directly in setup.py or supply them on
-   the command-line.
-
-	BUILD_GLCANVAS Set to zero if you don't want to build the
-		       Open GL canvas extension module.  If you don't
-		       have OpenGL or compatible libraries then you'll
-		       need to set this to zero.
-
-	     BUILD_OGL Set to zero if you don't want to build the
-		       Object Graphics Library extension module.
-
-  	     BUILD_STC Set to zero if you don't want to build the
-		       wxStyledTextCtrl (the Scintilla wrapper)
-		       extension module.
-
-  	      USE_SWIG If you have edited any of the *.i files you
-		       will need to set this flag to non-zero so SWIG
-		       will be executed to regenerate the wrapper C++
-		       and shadow python files.
-
-	   IN_CVS_TREE If you are using the CVS version of the
-		       wxWindows and wxPython sources then you will
-		       need to set this flag to non-zero.  This is
-		       needed because some source files from the
-		       wxWindows tree are copied to be under the
-		       wxPython tree in order to keep Distutils happy.
-		       With this flag set then setup.py will
-		       automatically keep these copied sources up to
-		       date if the original version is ever updated.
-		       If you are using the tar.gz version of the
-		       Python sources then these copied sources are
-		       already present in your source tree.
-
-
-D. To build and install wxPython you simply need to execute the
-   setup.py script.  If you have more than one version of Python
-   installed, be sure to execute setup.py with the version you want to
-   build wxPython for.  Depending on the permissions on your
-   site-packages directory you may need to be root to run the install
-   command.
-
-	 python setup.py build
-   	 python setup.py install
-
-E. At this point you should be able to change into the wxPython/demo
-   directory and run the demo:
-
-	 python demo.py
-
-F. If you would like to make a test build that doesn't overwrite the
-   installed version of wxPython you can do so with this command
-   instead of the install command above:
-
-	 python setup.py build_ext --inplace
-
-   This will build the wxPython package in the local wxPython
-   directory instead of installing it under your Python installation.
-   To run using this test version just add the base wxPython source
-   directory to the PYTHONPATH:
-
-         export PYTHONPATH=~/projects/wxWindows/wxPython
-	 # or whatever is required for your shell
-	 cd ~/projects/wxWindows/wxPython/demo
-	 python demo.py
-
-
-That's all folks!
-
-
------------------
-robin@alldunn.com

wxPython/BUILD.win32.txt

@@ -1,284 +0,0 @@
-Building wxPython on Win32
---------------------------
-
-
-Building wxPython for use on win32 systems is a fairly simple process
-consisting of just a few steps.  However depending on where you get
-your sources from and what your desired end result is, there are
-several permutations of those steps.  At a high level the basic steps
-are:
-
-     1. Get the wxWindows sources
-     2. Build the wxWindows DLL
-     3. Get the wxPython sources
-     4. Build and Install wxPython
-
-We'll go into more detail of each of these steps below, but first a
-few bits of background information on tools.
-
-I use a tool called SWIG (http://www.swig.org) to help generate the
-C++ sources used in the wxPython extension module.  However you don't
-need to have SWIG unless you want to modify the *.i files.  If you do
-you'll want to have version 1.1-883 of SWIG and you'll need to apply
-the patches and updates in wxPython/SWIG and rebuild it.  Then you'll
-need to change a flag in the setup.py script as described below so the
-wxPython build process will use SWIG if needed.
-
-I use the new Python Distutils tool to build wxPython.  It is included
-with Python 2.0, but if you want to use Python 1.5.2 or 1.6 then
-you'll need to download and install Distutils 1.0 from
-http://www.python.org/sigs/distutils-sig/
-
-I use Microsoft Visual C++ 6.0 (5.0 with the service packs should work
-also) to compile the wxPython C++ sources.  Since I am using Distutils
-it should be easier now to build with other win32 compilers such as
-the free mingw32 or Borland compilers, but I havn't tried them yet.
-If anybody wants to try it I'll take any required patches for the
-setup script and for these instructions.
-
-And now on to the fun stuff...
-
-
-
-1. Get the wxWindows sources
-----------------------------
-
-A. There are a few possible ways to get sources for wxWindows.  You
-   can download a released version from http://wxwindows.org/ or you
-   can get current development sources from the CVS server.  (Some
-   information about annonymous CVS access is at
-   http://wxwindows.org/cvs.htm.)  The advantage of using CVS is that
-   you can easily update as soon as the developers check in new
-   sources or fixes.  The advantage of using a released version is
-   that it usually has had more testing done.  You can decide which
-   method is best for you.
-
-B. You'll usually want to use wxWindows sources that have the same
-   version number as the wxPython sources you are using.  (Another
-   advantage of using CVS is that you'll get both at the same time.)
-
-C. Once you get the sources be sure to put them in a path without a
-   space in it (i.e., NOT c:\Program Files\wx) and set an environment
-   variable named WXWIN to this directory.  For example:
-
-	 mkdir \wx2
-	 cd \wx2
-	 unzip wxMSW-2.2.2.zip
-	 set WXWIN=c:\wx2
-
-   You'll probably want to add that last line to your autoexec.bat or
-   System Properties depending on the type of system you are on.
-
-D. Change to the wx2\include\wx\msw directory and copy setup0.h to
-   setup.h and then edit setup.h.  This is how you control which parts
-   of wxWindows are compiled into or left out of the build, simply by
-   turning options on or off.  At a minimum you should set the
-   following:
-
-	 wxUSE_NEW_GRID			    1
-	 wxUSE_GLOBAL_MEMORY_OPERATORS	    0
-	 wxUSE_LIBTIFF			    1
-	 wxDIALOG_UNIT_COMPATIBILITY	    0
-
-    I also turn off the following as they are not currently used in
-    wxPython.  There are probably others that can be turned off to
-    help save space, but I havn't investigated all the potential
-    configurations yet.  Please note that wxPython doesn't (yet) check
-    these flags for its own build, so if you turn off something that
-    wxPython expects then you'll get link errors later on.
-
-	 wxUSE_DIALUP_MANAGER		    0
-	 wxUSE_DYNLIB_CLASS		    0
-	 wxUSE_DOC_VIEW_ARCHITECTURE	    0
-	 wxUSE_PLOT			    0
-	 wxUSE_POSTSCRIPT_ARCHITECTURE_IN_MSW 0
-
-
-    ** NEW **
-    Be sure that wxUSE_GLCANVAS is defined to be 0 as wxPython now
-    keeps its own copy of the glcanvas sources and expects that it is
-    not in the main library.  This is done to reduce the number of
-    dependant DLLs on the core library and therefore help reduce
-    startup time.
-
-
-
-2. Build the wxWindows DLL
----------------------------
-
-A. Although MSVC project files are provided I always use the makefiles
-   to build wxWindows because by default the flags are compatible with
-   Python, (and I make sure they stay that way.)  You would have to
-   edit the project files a bit to make it work otherwise.
-
-B. There are three different types of wxWindows DLLs that can be
-   produced by the VC makefile simply by providing a flag on the nmake
-   command-line, I call the three types DEBUG, FINAL, and HYBRID.
-   (The last one is brand new, you'll need my version of the 2.2.2
-   sources to get the HYBRID capability.)  Here are some more details:
-
-      DEBUG Specified with "FINAL=0" and produces a DLL named
-	    wx[version]d.dll.  This DLL is compiled with full
-	    debugging information and with the __WXDEBUG__ set which
-	    enables some debugging-only code in wxWindows such as
-	    assertions and failure log messages.  The /MDd flag is
-	    used which means that it is linked with the debugging
-	    version of the C runtime library and also that you must
-	    use the debugging version of Python, (python_d.exe and
-	    pythonXX_d.dll) which also means that all extensions
-	    loaded by Python should also have the _d in the name.
-	    With this option you can use the MSVC debugger to trace
-	    though the Python interpreter, as well as the code for the
-	    wxPython extension and the wxWindows DLL.
-
-      FINAL Specified with "FINAL=1" and produces a DLL named
-            wx[version].dll.  This DLL is compiled with optimizations
-            turned on and without debugging information and without
-            __WXDEBUG__.  The /MD flag is used which means that you
-            can use this version with the standard python.exe.  This
-            is the version that I use when making the binary installer
-            for win32.
-
-     HYBRID Specified with "FINAL=hybrid" and produces a DLL named
-            wx[version]h.dll.  This DLL is almost the same as the
-            DEBUG version except the /MD flag is used which means that
-            you can use the standard python.exe but you still get the
-            debugging info and the __WXDEBUG__ code enabled.  With the
-            debugger you can trace through the the code for the
-            wxPython extension and the wxWindows DLL, but not the
-            Python interpreter.  You might use this version when you
-            want to deploy a wxPython app with the __WXDEBUG__ code
-            enabled.  I use this mode most of the time during
-            development simply because it's easier than having to
-            remember to type python_d all the time.
-
-   Since different DLL names and object file directories are used you
-   can build all three types if you like.
-
-C. Change to the wx2\src\msw directory and type the following command,
-   using the value for FINAL that you want:
-
-	 nmake -f makefile.vc dll pch FINAL=hybrid
-
-   Your machine will then crunch away for possibly a long time,
-   depending on your hardware, and when it's done you should have a
-   DLL and some library files in \wx2\lib.
-
-D. You'll either need to add \wx2\lib to the PATH or copy the DLL file
-   to a directory already on the PATH so the DLL can be found at runtime.
-
-E. You can test your build by changing to one of the directories under
-   \wx2\samples or \wx2\demos and typing (using the right FINAL flag):
-
-	nmake -f makefile.vc FINAL=hybrid WXUSINGDLL=1
-
-   and then executing the resulting .exe file.
-
-
-
-3. Get the wxPython sources
----------------------------
-
-A. You have the same options (and same advantages/disadvantages) for
-   getting the wxPython source, either a released snapshot or from
-   CVS.  The released version file is named wxPython-[version].tar.gz
-   and is available at http://wxpython.org/download.php.  You can use
-   WinZip to unpack it if you don't have tar and gzip.  If you want to
-   use CVS you'll find wxPython in the wxWindows CVS tree (see above)
-   in the wxWindows/wxPython directory.
-
-
-
-4. Build and Install wxPython
------------------------------
-
-A. As mentioned previouslly, wxPython is built with the standard
-   Python Distutils tool.  If you are using Python 2.0c1 or later you
-   are all set, otherwise you need to download and install Distutils
-   1.0 from http://www.python.org/sigs/distutils-sig/.
-
-B. Change to the root wxPython directory and look at the setup.py
-   file.  This is the script that configures and defines all the
-   information that Distutils needs to build wxPython.  There are some
-   options near the begining of the script that you may want or need
-   to change based on what options you have selected up to this point,
-   (type of DLL built, sources from tar.gz or from CVS, etc.)  You can
-   either change these flags directly in setup.py or supply them on
-   the command-line.
-
-	BUILD_GLCANVAS Set to zero if you don't want to build the
-		       Open GL canvas extension module.
-
-	     BUILD_OGL Set to zero if you don't want to build the
-		       Object Graphics Library extension module.
-
-  	     BUILD_STC Set to zero if you don't want to build the
-		       wxStyledTextCtrl (the Scintilla wrapper)
-		       extension module.
-
-  	      USE_SWIG If you have edited any of the *.i files you
-		       will need to set this flag to non-zero so SWIG
-		       will be executed to regenerate the wrapper C++
-		       and shadow python files.
-
-	   IN_CVS_TREE If you are using the CVS version of the
-		       wxWindows and wxPython sources then you will
-		       need to set this flag to non-zero.  This is
-		       needed because some source files from the
-		       wxWindows tree are copied to be under the
-		       wxPython tree in order to keep Distutils happy.
-		       With this flag set then setup.py will
-		       automatically keep these copied sources up to
-		       date if the original version is ever updated.
-		       If you are using the tar.gz version of the
-		       Python sources then these copied sources are
-		       already present in your source tree.
-
-
-C. To build and install wxPython you simply need to execute the
-   setup.py script.  If you have more than one version of Python
-   installed, be sure to execute setup.py with the version you want to
-   build wxPython for.
-
-   Depending on what kind of wxWindows DLL you built there are
-   different command-line parameters you'll want to pass to setup (in
-   addition to possibly one or more of the above):
-
-	 FINAL:	    python setup.py install
-
-	 DEBUG:	    python setup.py build --debug install
-
-	 HYBRID:    python setup.py HYBRID=1 install
-
-
-D. At this point you should be able to change into the wxPython\demo
-   directory and run the demo:
-
-	 python demo.py
-
-E. If you would like to make a test build that doesn't overwrite the
-   installed version of wxPython you can do so with one of these
-   commands instead of the install command above:
-
-	 FINAL:	    python setup.py build_ext --inplace
-
-	 DEBUG:	    python setup.py build_ext --debug --inplace
-
-	 HYBRID:    python setup.py HYBRID=1 build_ext --inplace
-
-   This will build the wxPython package in the local wxPython
-   directory instead of installing it under your Python installation.
-   To run using this test version just add the base wxPython source
-   directory to the PYTHONPATH:
-
-         set PYTHONPATH=c:\wx2\wxPython
-	 cd c:\wx2\wxPython\demo
-	 python demo.py
-
-
-That's all folks!
-
-
------------------
-robin@alldunn.com
-

wxPython/CHANGES.txt

@@ -1,983 +0,0 @@
-CHANGES.txt for wxPython
-
-----------------------------------------------------------------------
-
-?????
------
-Added EVT_HELP, EVT_HELP_RANGE, EVT_DETAILED_HELP,
-EVT_DETAILED_HELP_RANGE, EVT_CONTEXT_MENU, wxHelpEvent,
-wxContextMenuEvent, wxContextHelp, wxContextHelpButton, wxTipWindow,
-and a demo to show them in action.
-
-Deprecated PyShell and PyShellWindow, added a snapshot of PyCrust (see
-http://sourceforge.net/projects/pycrust/. )
-
-Added the new virtual list capabilities to wxListCtrl.
-
-Added a wxSTC style editor from Riaan Booysen to the sample apps.
-
-Added XRCed to the wxPython Tools directory, contributed by Roman
-Rolinsky.
-
-Added a new "constructor" to most of the window classes that calls the
-default C++ contructor, (the one with no parameters) and also added the
-coresponding Create(...) method.  This allows you to do a 2-step
-creation of windows which is sometimes required for doing things such
-as setting extended style flags before the window is created, or for
-passing the object to the XRC resource system to be created from the
-resource.  The name of the new "constructor" is the original name of
-the class with a "Pre" in it.  For example, wxPreWindow, wxPreFrame,
-etc.
-
-Updated to version 1.39 of Scintilla and updated wxStyledTextCtrl
-accordingly.
-
-Updated wxColumnSorterMixin to also be able to place sort icons on the
-column headers, and updated the wxListCtrl demo to show it off by
-using wxColumnSorterMixin.
-
-Added wxGenBitmapTextButton, TablePrint, etc. contribs from Lorne White.
-
-Added wxNativeFontInfo and wxFontMapper.
-
-Added pySketch to the samples.
-
-Significantly changed how the Python interpreter lock and thread state
-are managed, which should fix the problem of running on a
-multi-processor machine.
-
-
-
-2.3.1
------
-Added EVT_GRID_EDITOR_CREATED and wxGridEditorCreatedEvent so the user
-code can get access to the edit control when it is created, (to push
-on a custom event handler for example.)
-
-Added wxTextAttr class and SetStyle, SetDefaultStyle and
-GetDefaultStyle methods to wxTextCtrl.
-
-Added ability to use xml resource files.  Still need to add ability to
-subclass wxXmlResourceHandler, etc...
-
-Added wxGridAutoEditMixin to the mixins library package.
-
-Made ColourSelect be derived from wxButton.
-
-Fixed img2py to work correctly with Python 2.1.
-
-Added enhanced wxVTKRenderWindow by Prabhu Ramachandran
-
-
-
-2.3.0
------
-Removed initial startup dependency on the OpenGL DLLs so only the
-glcanvasc.pyd depends on them, (on wxMSW.)
-
-Changed wxFont, wxPen, wxBrush to not implicitly use the
-wxThe[Font|Pen|Brush]List objects behind the scenes, but to use normal
-ctor and dtors.
-
-Exposed the wxThe[Font|Pen|Brush]List to wxPython.
-
-Also added wxTheColourDatabase and added a library module (in the
-wxPython.lib.colourdb module) to load LOTS more colour names into the
-colour database.
-
-Added wxWakeUpMainThread, wxMutexGuiEnter, wxMutexGuiLeave,
-wxMutexGuiLocker and wxThread_IsMain to assist with dealing with GUI
-access from non-GUI threads.
-
-wxPyOnDemandOutputWindow is now (more) thread safe if non-GUI threads
-use print, sys.stdout.write, etc.
-
-Added CreateTextSizer and CreateButtonSizer to wxDialog
-
-Added wxPython/lib/infoframe.py from Chris Fama.  It contains a class
-that can be used in place of wxPyOnDemandOutputWindow.
-
-Added colourselect.py, imagebrowser.py and an updated calendar.py to
-wxPython/lib from Lorne White.
-
-Added patch to wxPoint_LIST_helper from Tim Hochberg that should make
-it gobs faster in certain situations.
-
-Added tools that will take an image file in a wx supported format and
-convert it to data embedded in a Python source file.  The image is
-converted to XPM format which is essentially a list of strings
-containing info about each pixel.  The image's transparency mask is
-included, if there is one, or a mask can be added if a mask colour is
-specified on the command line.  It is then pickled and optionally
-compressed and written to a Python source file along with functions to
-convert it to either a wxBitmap or a wxImage.  See
-wxPython/demo/images.py for examples, and wxPython/Tools/img2py.py for
-the implementation.
-
-Fixed wxStyledTextCtrl to be much faster on wxGTK.  There was some
-experimental code that got left in place that ended up causing way too
-many refreshes.
-
-A couple more hacks in my_distutils.py so wxPython can be built with
-the distutils that comes with Python 2.1.
-
-Added a ton of missing methods for wxPrintData.
-
-Switched to InnoSetup for MSW distributions.
-
-Added wxToggleButton.
-
-Fixed bug that prevented wxTreeCtrl.OnCompareItems from being called.
-
-Added some methods to wxGrid:
-      GetCellHighlightPenWidth
-      GetCellHighlightROPenWidth
-      SetCellHighlightPenWidth
-      SetCellHighlightROPenWidth
-      GetGridWindow
-      GetGridRowLabelWindow
-      GetGridColLabelWindow
-      GetGridCornerLabelWindow
-
-Added wxGetClientDisplayRect which on wxMSW returns a wxRect
-representing the area on screen not occupied by the taskbar and such.
-On other platforms it is equivallent to wxGetDisplaySize.
-
-
-***---***---***---***---***---***---***---***---***---***---***---
-   Implemented the first phase of OOR (Original Object Return).  See
-   the text in the demo for more details of what this means, but in a
-   nutshell methods such as wxWindow.GetParent or FindWindowById will
-   now return a shadow object of the proper type if it can.  By
-   "proper type" I mean that if the wxWindow pointer returned from
-   FindWindowById really points to a wxButton then the Python object
-   constructed will be of a wxButtonPtr class instead of wxWindowPtr
-   as before.  This should reduce or eliminiate the need for
-   wxPyTypeCast.  (Woo Hoo!)  The objects returned are still not the
-   original Python object, but that is the next step.  (Although it
-   will probably only work on Python 2.1 and beyond because it will
-   use weak references.)
-
-   This first phase of the OOR plan is fairly significant and has
-   required a lot of changes all over wxPython, most of which should
-   be transparent to you, however I'm not 100% sure that it didn't
-   introduce any new bugs that are hiding somewhere and didn't get
-   stomped on during my testing.  So please be sure to test everything
-   thoroughly when you install this version and be sure to report any
-   object-type related oddities to me.
-***---***---***---***---***---***---***---***---***---***---***---
-
-There is now a wxObject class that most other classes derive from like
-in C++, but the methods provided don't really match but are wxPython
-specific.  It could have been added long ago but OOR required it so it
-finally got done.
-
-Finally added wxPyLineShape.GetLineControlPoints, which has been on my
-list for a while.  The above OOR modification made this easier.
-
-Fixed the __cmp__ methods for wxPoint and others.
-
-Added wxWave.
-
-Added the wxPython.lib.mixins package to the library, it is where
-useful mix-in classes can be placed.  Currently there is one to help
-make the columns in a wxListCtrl sortable, and the MagicIMageList from
-Mike Fletcher.  If you have any custom code that can be factored out
-of existing classes into a mix-in that would be useful to others
-please send it to me for inclusion in this package.
-
-Added a few little sample applications to help newbies to get started
-by having smaller functional apps to play with.  They can be found in
-wxPython/samples.
-
-
-
-
-2.2.6
------
-
-No changes happened in the Python wrappers for this release, only
-changes and fixes in the wxWindows library.
-
-
-
-2.2.5
------
-
-New typemaps for wxString when compiling for Python 2.0 and beyond
-that allow Unicode objects to be passed as well as String objects.  If
-a Unicode object is passed PyString_AsStringAndSize is used to convert
-it to a wxString using the default encoding.
-
-Fixed the generic buttons so tool tips work for them.
-
-Fixed a bug in the demo's tree control.
-
-Added a listbox to the listbox demo that shows how to find items with
-a matching prefix as keys are typed.
-
-Added code to the wxListCtrl demo to show how to get text from a
-column in report mode.
-
-Added code to the toolbar demo to clear the long help from the status
-bar after 2 seconds.
-
-Added wxJoystick.
-
-Fixed wxTimer so it can be used as described in the docs, either with
-a Notify method in a subclass, or sending an event to a wxEvtHandler
-object, (usually a window.)
-
-Added wxNotifyEvent.Allow()
-
-Fixed GOBS of reference leaks.
-
-Massive code changes and cleanup to allow wxPython to be split into
-multiple extension modules again.  A Python CObject is used to allow
-the "export" of SWIG functions and other common helper functions from
-the wxc module to other modules, even if they are in separate shared
-libraries.  Should also be usable from 3rd party code, just include
-wxPython/src/export.h
-
-Changed the default setup so the following are built as separate
-extension modules:  calendar, glcanvas, grid, html, ogl, stc, and
-utils.  Will probably add more later.
-
-Changed the wxPrinterDC to use the new constructor taking a
-wxPrintData object.  The old ctor is still there using the
-wxPrinterDC2 name.
-
-Added wxPython.lib.anchors.py from Riaan Booysen.  It contains a class
-that implements Delphi's Anchors with wxLayoutConstraints.
-
-Added wxPython.lib.fancytext from Timothy Hochberg.
-
-Changed the GenericButtons to send their event in idle time, so the
-mouse won't be captured when the event handler is called.
-
-Added wxPython.lib.rpcMixin from Greg Landrum, although it's not
-integrated with the demo yet.  It allows a wxPython GUI to be an
-XML-RPC server.
-
-
-
-New in 2.2.2
-------------
-
-Significantly changed how the wxStyledtextCtrl code that wraps
-Scintilla is implemented.  Most of it is now automatically generated
-from an interface definition file provided by Scintilla.  This means
-that it will be much easier to stay in sync with new Scintilla
-releases, but also means that some of the method and identifier names
-have changed.  See wxPython/demo/data/stc.h for a copy of the C++
-interface from which the Python interface is generated.  There is now
-some inline documentation in that file that should really help explain
-how things work.
-
-I am now using the Python Distutils to build wxPython and to make some
-of the distribution files.  (See http://www.python.org/sigs/distutils-sig/)
-This means no more messing with my kludgy build.py/Makefile hack,
-builds will be more consistent with other Python extensions that also
-use Distutils, and will hopefully make wxPython easier to build for
-platforms where there have been troubles before.  If you are building
-wxPython for Python 1.5.2 or for 1.6, then you will need to get and
-install version 1.0 of Distutils from the website above.  If you are
-using Python 2.0 then you already have it.
-
-Added wxInputStream and the wxFileSystem family of classes,
-contributed by Joerg Baumann.
-
-Added wxProcess and support for it to wxExecute.  wxProcess lets you
-get notified when an asyncronous child process terminates, and also to
-get input/output streams for the child process's stdout, stderr and
-stdin.
-
-Removed the old python sizers.
-
-Added __add__, __sub__ and __cmp__ (equality check only) for wxPoint
-and wxRealPoint.
-
-Changed the build to make one big extension module instead of one for
-the core and each contrib.  This allowed me to do away with the
-libwxPyHelpers.so on unix systems.
-
-Lots of little fixes here and there.
-
-Some hacks on wxGTK to try and make the AutoComplete listbox in the
-wxStyledTextCtrl to behave better.  It's still not as nice as on
-wxMSW, but at least it's a bit more usable now.
-
-
-
-
-New in 2.2.1
-------------
-
-Various tweaks, fixes, missing methods, etc.
-
-Added example use of wxTaskBarIcon to the demo.
-
-
-
-New in 2.2.0
-------------
-
-Added wxLog and friends.
-
-Added wxFrame.ShowFullScreen for MSW.
-
-Added PyShellWindow to the wxPython.lib package.
-
-
-
-New in 2.1.16
--------------
-
-Added an attribute named labelDelta to the generic buttons that
-specifies how far to offset the label when the button is in the
-depressed state.
-
-Added wxTipProvider and friends.  See the demo for an example.
-
-wxGrid can now change the cell highlight colour.
-
-Added wxDragImage.
-
-Fixed printing on wxGTK.
-
-Added wxDateTime, wxTimeSpan, and wxDateSpan to wxPython.utils.
-
-Added wxCalendarCtrl.
-
-WARNING: A while back I asked what should be done about the Magic
-Method Names.  (Methods that are automatically turned into event
-handlers by virtue of their name.)  The consensus was that it is more
-confusing to have them than to try and expand them to have greater
-coverage.  I am finally getting around to removing the code that
-generates the event binding.  This means that if you are using any of
-the following method names without a EVT_* call that you need to
-modify your code to add the EVT_* to hook the event to the method.
-
-    OnChar
-    OnSize
-    OnEraseBackground
-    OnSysColourChanged
-    OnInitDialog
-    OnPaint
-    OnIdle
-    OnActivate
-    OnMenuHighlight
-    OnCloseWindow
-    OnScroll
-
-Added wxSpinCtrl.
-
-
-
-
-New in 2.1.15
--------------
-
-Fixed wxTreeCtrl.HitTest to return both the tree item as well as the
-flags that clairify where the click was in relation to the item.
-
-Fixed thread state problem in wxTreeCtrl.GetBoundingBox and
-GetSelections.
-
-Fixed some problems in OGL.  Also wxShape.SetClientData and
-.GetClientData can now deal with Python objects.
-
-Added wxListCtrl.SortItems and changed the demo to show how to use it.
-
-Plugged a memory leak.
-
-Wrapped the new wxGrid and friends.  The old wxGrid class is no longer
-available.  There are some incompatibilities, and unfortunately the
-new classes are not documented yet, (however the methods are more
-consistent with each other now so you may be able to guess pretty
-good...)
-
-Updated filebrowsebutton.py and calendar.py with changes from their
-authors.  There is now a FileBrowseButtonWithHistory class (what a
-mouthful!) and wxCalendar has printing support.
-
-Added ActiveXWrapper to the library, and some good demos of it too.
-It works great for embedding a COM (a.k.a OCX, a.k.a ActiveX) control
-in a window and calling its methods.  It actually creates a new class
-on the fly that derives from wxWindow, the COM CoClass and others
-needed to make it all work.  The resulting class can be instantiated
-just like wxWindow, used in sizers, etc.  It also responds to all COM
-method calls, properties, etc., and if the class or a mix-in has
-matching method names, then the COM events will be propogated back to
-them.
-
-Created a typemap that allows a string to be used for parameters
-expecting a wxColour type.  The string is either a colour name as
-defined in the wxColourDatabase, or a colour spec of the form
-"#RRGGBB".  See the wxStyledTextCtrl demo for an example.
-
-I almost forgot to mention the wxStyledTextCtrl!  Yes, the
-wxStyledTextCtrl is finally in wxPython!!  (And the crowd goes
-wild...)   There's no documentaTion yet (the crowd boos and hisses...)
-but I've included a very readable source file in the
-wxPython/demo/data directory, a couple fairly good examples, and you
-can also refer to the Scintilla documentaion at
-http://www.scintilla.org/ScintillaDoc.html to help fill in the gaps
-until the docs are done.  (The croud murmers contentedly as the tool
-provider smiles convincingly and removes his flame-proof suit.)
-
-
-
-
-What's new in 2.1.13
---------------------
-Skipped a version number to match what has been released for wxGTK.
-
-Updated wxMVCTree and added a demo for it, also fixed layout on GTK
-and some flicker problems.
-
-Added a wrapper class for the Visualization ToolKit (or VTK) in the
-wxPython.lib.vtk module.  (http://www.kitware.com/)
-
-Fixed wxTreeCtrl.SetItemImage and GetItemImage to recognise the new
-"which" parameter.
-
-Added wxPython.lib.spashscreen from Mike Fletcher.
-
-Added wxPython.lib.filebrowsebutton also from Mike Fletcher.
-
-Renamed wxTreeCtrl.GetParent to GetItemParent to avoid a name clash
-with wxWindow.GetParent.
-
-Added wxIntersectRect to compute the intersection of two wxRect's.
-It is used like this:
-
-   intersect = wxIntersectRect(rect1, rect2)
-
-If r1 and r2 don't intersect then None is returned, otherwise the
-rectangle representing the intersection is returned.
-
-Some bug fixes for Clipboard and Drag-n-Drop.
-
-Rotated text!!!  WooHoo!  (See wxDC.DrawRotatedText())
-
-Added a set of Generic Buttons to the library.  These are simple
-window classes that look and act like native buttons, but you can have
-a bit more control over them.  The bezel width can be set in addition
-to colours, fonts, etc.  There is a ToggleButton as well as Bitmap
-versions too.  They should also serve as a good example of how to
-create your own classes derived from wxControl.
-
-The C++ wxToolBar classes have been redone, and so have the wxPython
-wrappers.  There have been slight modifications to some of the methods
-but shouldn't impact anybody too much.  I took the opportunity to add
-support for setting user data on each toolbar tool.  The new AddTool
-methods look like this:
-
-        def AddTool(ID,
-                    bitmap,
-                    pushedBitmap = wxNullBitmap,
-                    toggle = FALSE,
-                    clientData = NULL,
-                    shortHelpString = "",
-                    longHelpString = "")
-
-        def AddSimpleTool(ID,
-                          bitmap,
-                          shortHelpString = "",
-                          longHelpString = "",
-                          toggle=FALSE)
-
-
-There are also coresponding InsertTool and InsertSimpleTool methods
-that additionally take an integer position as the first parameter.
-
-Added a wrapper for the new PCX and TIFF ImageHandlers.
-
-wxRect now simulates attributes named left, right, top and bottom.
-
-Removed all non wx stuff from the glcanvas module since DA's PyOpenGL
-is better and compatible with the wxGLCanvas.  You can get it at
-http://starship.python.net:9673/crew/da/Code/PyOpenGL.
-
-Added some missing EVT_ functions.
-
-Added Dirk Holtwic's editor classes to the wxPython.lib.editor
-package.
-
-Changed all the "LIST" parameter names to "choices" to match the docs.
-
-More fixes for the wxFloatBar, and it now works on wxGTK even better
-than wxMSW!  (The feat is accomplished by using the wxTB_DOCKABLE
-style flag instead of trying to float it ourselves.)
-
-
-
-
-What's new in 2.1.11
---------------------
-Skipped a few version numbers so wxMSW, wxGTK and wxPython are all
-syncronized.
-
-wxImage.SetData now makes a copy of the image data before giving it to
-wxImage.  I mistakenly thought that wxImage would copy the data
-itself.
-
-Fixed wxMSW's notebook so the pages get their size set as they are
-being added.  This should remove the need for our
-wxNotebook.ResizeChildren hack.
-
-wxPanels now support AutoLayout, and wxNotebooks and wxSplitterWindows
-no longer tell their children to Layout() themselves.  This will
-probably only effect you if you have a wxWindow with AutoLayout inside
-a notebook or splitter.  If so, either change it to a wxPanel or add
-an EVT_SIZE handler that calls Layout().
-
-Fixed deadlock problem that happened when using threads.
-
-Added new HTML printing classes.
-
-Added wxWindow.GetHandle
-
-Apparently wxMouseEvent.Position has been depreciated in wxWindows as
-it is no longer available by default.  You can use GetPositionTuple
-(returning a tuple with x,y) instead, or GetPosition (returning a
-wxPoint.)
-
-Added wxPostEvent function that allows events to be posted and then
-processed later.  This is a thread-safe way to interact with the GUI
-thread from other threads.
-
-Added Clipboard and Drag-and-Drop classes.
-
-Added wxFontEnumerator.
-
-Many updates to wxMenu, wxMenuBar.
-
-wxPyEvent and wxPyCommandEvent derived classes now give you the actual
-Python object in the event handler instead of a new shadow.
-
-Added a Calendar widget from Lorne White to the library.
-
-Made some fixes to the wxFloatbar.  It still has some troubles on
-wxGTK...
-
-Added an MVC tree control from Bryn Keller to the library.
-
-
-
-
-What's new in 2.1.5
--------------------
-This is a quick bug-fix release to take care of a few nasties that
-crept in at the last minute before 2.1.4 was called done.  No new
-major features.
-
-
-
-What's new in 2.1.4
---------------------
-
-This release is NOT syncronized with a snapshot release of wxGTK or
-wxMSW.  For MSW this isn't much of a problem since you can get the
-binaries from the web site.  For other platforms you'll have to build
-wxGTK from CVS.  (See http://web.ukonline.co.uk/julian.smart/wxwin/cvs.htm)
-To get the same set of sources from CVS that I used, checkout using
-the wxPy-2-1-4 tag.
-
-Now back to what's new...
-
-Much more support for event-less callbacks and add-on modules.
-
-Created add-on module with wxOGL classes.
-
-Added wxWindow.GetChildren().  Be careful of this.  It returns a *copy*
-of the list of the window's children.  While you are using the list if
-anything changes in the real list (a child is deleted, etc.) then the
-list you are holding will suddenly have window references to garbage
-memory and your app will likely crash.  But if you are careful it works
-great!
-
-Added a bunch of new and missing methods to wxTreeCrtl.  The
-SortChildren method is now supported, but currently only for the
-default sort order.
-
-Added typemaps for wxSize, wxPoint, wxRealPoint, and wxRect that allow
-either the actual objects or Python sequence values to be used.  For
-example, the following are equivallent:
-
-    win = wxWindow(parent, size = wxSize(100, 100))
-    win = wxWindow(parent, size = (100, 100))
-
-Super-charged the wxHtml module.  You can now create your own tag
-handlers and also have access to the parser and cell classes.  There
-is a tag handler in the library at wxPython.lib.wxpTag that
-understands the WXP tag and is able to place wxPython windows on HTML
-pages.  See the demo for an example.
-
-A bunch of the methods of wxMenuBar were previously ifdef'd out for
-wxGTK.  Added them back in since the methods exist now.
-
-Wrapped the wxHtmlHelpController and related classes.
-
-Wrapped the C++ versions of wxSizer and friends.  The Python-only
-versions are still in the library, but depreciated.  (You will get a
-warning message if you try to use them, but the warning can be
-disabled.) The usage of the C++ versions is slightly different, and
-the functionality of wxBorderSizer is now part of wxBoxSizer.  I have
-added a few methods to wxSizer to try and make the transition as
-smooth as possible, I combined all Add methods into a single method
-that handles all cases, added an AddMany method, etc.  One step I did
-not take was to make the default value of flag in the Add method be
-wxGROW.  This would have made it more backward compatible, but less
-portable to and from wxWin C++ code.  Please see the docs and demo for
-further details.
-
-Added wxPyEvent and wxPyCommandEvent classes, derived from wxEvent and
-wxCommandEvent.  Each of them has SetPyData and GetPyData methods that
-accept or return a single Python object.  You can use these classes
-directly or derive from them to create your own types of event objects
-that can pass through the wxWindows event system without loosing their
-Python parts (as long as they are stored with SetPyData.)  Stay tuned
-for more info and examples in future releases.
-
-Added wxPython.lib.grids as an example of how to derive a new sizer
-from the C++ sizers.  In this module you will find wxGridSizer and
-wxFlexGridSizer.  wxGridSizer arrainges its items in a grid in which
-all the widths and heights are the same.  wxFlexgridSizer allows
-different widths and heights, and you can also specify rows and/or
-columns that are growable.  See the demo for a couple examples for how
-to use them.
-
-Added the wxValidator class, and created a class named wxPyValidator
-that should be used for the base class of any Python validators.  See
-the demo for an example.  Please note that you MUST implement a Clone
-method in your validator classes because of the way some things work
-in the underlying C++ library.  I did not add wxTextValidator because
-of some issues of how it transfers data to and from a wxString, which
-in wxPython is automatically translated to and from Python strings, so
-there would never be a concrete wxString that would hang around long
-enough for the validator to do its job.  On the other hand, it should
-be real easy to duplicate the functionality of wxTextValidator in a
-pure Python class derived from wxPyValidator.
-
-I've finally added a feature that has been on my list for close to two
-years!  Ever wondered what that zero is for when you create your app
-object?  Well now you can leave it out or explicitly set it to a true
-value.  This value now controls what is to be done with sys.stdout and
-sys.stderr.  A false value leaves them alone, and a true value sets
-them to an instance of wxPyOnDemandOutputWindow.  (On windows the
-default is true, on unix platforms the default is false.)  This class
-creates a frame containing a wxTextCtrl as soon as anything is written
-to sys.stdout or sys.stderr.  If you close the window it will come
-back again the next time something is written.  (You can call
-app.RestoreStdio to turn this off.)  If you would rather that the stdio be
-redirected to a file, you can provide a second parameter to your app
-object's constructor that is a filename.  If you want to use your own
-class instead of wxPyOnDemandOutputWindow you can either implement
-RedirectStdio() in you app class or change the value of
-wxApp.outputWindowClass like this:
-
-    class MyApp(wxApp):
-        outputWindowClass = MyClass
-
-        def OnInit(self):
-            frame = MyFrame()
-            self.SetTopWindow(frame)
-            return true
-
-Please see the implementation of wxPyOnDemandOutputWindow and wxApp in
-wx.py for more details.  A few words of caution:  if you are running
-your app in a debugger, changing sys.stdout and sys.stderr is likely
-to really screw things up.
-
-Added wxCaret.  Unfortunately it's author has still not documented it
-in the wxWindows docs...
-
-Some new 3rd party contributions in wxPython.lib.  PyShell, in
-shell.py is an interesting implementaion of an interactive Python
-shell in wxWindows.  floatbar.py has a class derived from wxToolBar
-that can sense mouse drags and then reparent itself into another
-frame. Moving the new frame close to where it came from puts the tool
-bar back into the original parent.  (Unfortunately there is currently
-a bug in wxGTK's wxFrame.SetToolBar so the FloatBar has some
-problems...)
-
-
-
-
-What's new in 2.1b3
---------------------
-
-This release is syncronized with release 2.1 snapshot 9 of wxWindows.
-
-Switched to using SWIG from CVS (see http://swig.cs.uchicago.edu/cvs.html)
-for some of the new features and such.  Also they have encorporated my
-patches so there is really no reason to stick with the current (very
-old) release...  This version of SWIG gives the following new
-features:
-
-    1. Keyword arguments.  You no longer have to specify all the
-       parameters with defaults to a method just to specify a
-       non-default value on the end.  You can now do this instead:
-
-          win = wxWindow(parent, -1, style = mystyle)
-
-    2. There is now an an equivalence between Python's None and C++'s
-       NULL.  This means that any methods that might return NULL will
-       now return None and you can use none where wxWindows might be
-       expecting NULL.  This makes things much more snake-ish.
-
-
-There is a new build system based on a new Python program instead of
-raw makefiles.  Now wxPython builds are virtually the same on MSW or
-Unix systems.  See the end of this file for new build instructions and
-see distrib/build.py for more details.
-
-wxDC.Bilt now includes the useMask parameter, and has been split into
-two different versions.  wxDC.BlitXY is like what was there before and
-takes raw coordinants and sizes, and the new wxDC.Blit is for the new
-interface using wxPoints and a wxSize.
-
-
-
-
-
-What's new in 2.1b2
---------------------
-
-Added the missing wxWindow.GetUpdateRegion() method.
-
-Made a new change in SWIG (update your patches everybody) that
-provides a fix for global shadow objects that get an exception in
-their __del__ when their extension module has already been deleted.
-It was only a 1 line change in .../SWIG/Modules/pycpp.cxx at about
-line 496 if you want to do it by hand.
-
-It is now possible to run through MainLoop more than once in any one
-process.  The cleanup that used to happen as MainLoop completed (and
-prevented it from running again) has been delayed until the wxc module
-is being unloaded by Python.
-
-I fixed a bunch of stuff in the C++ version of wxGrid so it wouldn't
-make wxPython look bad.
-
-wxWindow.PopupMenu() now takes a wxPoint instead of  x,y.  Added
-wxWindow.PopupMenuXY to be consistent with some other methods.
-
-Added wxGrid.SetEditInPlace and wxGrid.GetEditInPlace.
-
-You can now provide your own app.MainLoop method.  See
-wxPython/demo/demoMainLoop.py for an example and some explaination.
-
-Got the in-place-edit for the wxTreeCtrl fixed and added some demo
-code to show how to use it.
-
-Put the wxIcon constructor back in for GTK as it now has one that
-matches MSW's.
-
-Added wxGrid.GetCells
-
-Added wxSystemSettings static methods as functions with names like
-wxSystemSettings_GetSystemColour.
-
-Removed wxPyMenu since using menu callbacks have been depreciated in
-wxWindows.  Use wxMenu and events instead.
-
-Added alternate wxBitmap constructor (for MSW only) as
-      wxBitmapFromData(data, type, width, height, depth = 1)
-
-Added a helper function named wxPyTypeCast that can convert shadow
-objects of one type into shadow objects of another type.  (Like doing
-a down-cast.)  See the implementation in wx.py for some docs.
-
-Fixed wxImage GetData and SetData to properly use String objects for
-data transfer.
-
-Added access methods to wxGridEvent.
-
-New Makefile/Setup files supporting multiple dynamic extension modules
-for unix systems.
-
-Fixes for the wxGLCanvas demo to work around a strange bug in gtk.
-
-SWIG support routines now compiled separately instead of being bundled
-in wx.cpp.
-
-
-
-
-
-What's new in 2.1b1
---------------------
-Fixed wxComboBox.SetSelection so that it actually sets the selected
-item.  (Actually just removed it from wxPython and let it default to
-wxChoice.SetSelection which was already doing the right thing.)
-
-Added the Printing Framework.
-
-Switched back to using the wxWindows DLL for the pre-built Win32
-version.  The problem was needing to reinitialize static class info
-data after loading each extension module.
-
-Lots of little tweaks and additions to reflect changes to various
-wxWindows classes.
-
-Fixed a bug with attaching objects to tree items.  Actually was a
-symptom of a larger problem with not obtaining the interpreter lock
-when doing any Py_DECREFs.
-
-wxSizer and friends.  Sizers are layout tools that manage a colection
-of windows and sizers.  Different types of sizers apply different
-types of layout algorithms.  You saw it here first!  These classes are
-not even in the wxWindows C++ library yet!
-
-
-
-What's new in 2.0b9
--------------------
-Bug fix for ListCtrl in test4.py (Was a missing file...  DSM!)
-
-Bug fix for occassional GPF on Win32 systems upon termination of a
-wxPython application.
-
-Added wxListBox.GetSelections returning selections as a Tuple.
-
-Added a wxTreeItemData that is able to hold any Python object and be
-associated with items in a wxTreeCtrl.  Added test pytree.py to show
-this feature off.
-
-Added wxSafeYield function.
-
-OpenGL Canvas can be optionally compiled in to wxPython.
-
-Awesome new Demo Framework for showing off wxPython and for learning
-how it all works.
-
-The pre-built Win32 version is no longer distributing the wxWindows
-DLL.  It is statically linked with the wxWindows library instead.
-
-Added a couple missing items from the docs.
-
-Added wxImage, wxImageHandler, wxPNGHandler, wxJPEGHandler,
-wxGIFHandler and wxBMPHandler.
-
-Added new methods to wxTextCtrl.
-
-Fixed some problems with how SWIG was wrapping some wxTreeCtrl
-methods.
-
-
-
-What's new in 2.0b8
--------------------
-Support for using Python threads in wxPython apps.
-
-Several missing methods from various classes.
-
-Various bug fixes.
-
-
-
-What's new in 2.0b7
--------------------
-Added DLG_PNT and DLG_SZE convienience methods to wxWindow class.
-
-Added missing constructor and other methods for wxMenuItem.
-
-
-
-What's new in 2.0b6
--------------------
-Just a quickie update to fix the self-installer to be compatible with
-Python 1.5.2b2's Registry settings.
-
-
-What's new in 2.0b5
--------------------
-Well obviously the numbering scheme has changed.  I did this to
-reflect the fact that this truly is the second major revision of
-wxPython, (well the third actually if you count the one I did for
-wxWindows 1.68 and then threw away...) and also that it is associated
-with the 2.0 version of wxWindows.
-
-I have finally started documenting wxPython.  There are several pages
-in the wxWindows documentation tree specifically about wxPython, and I
-have added notes within the class references about where and how wxPython
-diverges from wxWindows.
-
-Added wxWindow_FromHWND(hWnd) for wxMSW to construct a wxWindow from a
-window handle.  If you can get the window handle into the python code,
-it should just work...  More news on this later.
-
-Added wxImageList, wxToolTip.
-
-Re-enabled wxConfig.DeleteAll() since it is reportedly fixed for the
-wxRegConfig class.
-
-As usual, some bug fixes, tweaks, etc.
-
-
-
-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.
-
-----------------------------------------------------------------------

wxPython/MANIFEST.in

@@ -1,144 +0,0 @@
-include *.txt
-include my_distutils.py
-## include my_install_data.py
-include licence/*.txt
-include b
-include b.bat
-include MANIFEST.in
-
-include SWIG/*
-exclude SWIG/CVS/*
-
-include demo/*.py
-include demo/bitmaps/*.bmp
-include demo/bitmaps/*.ico
-include demo/bitmaps/*.gif
-include demo/bitmaps/*.png
-include demo/bitmaps/*.jpg
-include demo/bmp_source/*.bmp
-include demo/bmp_source/*.ico
-include demo/bmp_source/*.gif
-include demo/bmp_source/*.png
-include demo/bmp_source/*.jpg
-include demo/*.txt
-include demo/*.xml
-include demo/data/*.png
-include demo/data/*.htm
-include demo/data/*.html
-include demo/data/*.bmp
-include demo/data/*.txt
-include demo/data/*.i
-include demo/data/*.h
-include demo/data/*.py
-include demo/data/*.wav
-include demo/data/*.wdr
-include demo/data/*.xrc
-
-include samples/doodle/*.txt
-include samples/doodle/*.py
-include samples/doodle/sample.ddl
-include samples/stxview/*.txt
-include samples/stxview/*.py
-include samples/stxview/*.stx
-include samples/stxview/StructuredText/*.py
-include samples/stxview/StructuredText/*.txt
-include samples/wxProject/*.txt
-include samples/wxProject/*.py
-include samples/StyleEditor/*.py
-include samples/StyleEditor/*.txt
-include samples/StyleEditor/*.cfg
-include samples/pySketch/*.py
-include samples/pySketch/images/*.bmp
-
-
-include wxPython/lib/*.py
-include wxPython/lib/*.txt
-include wxPython/lib/editor/*.py
-include wxPython/lib/editor/*.txt
-include wxPython/lib/mixins/*.py
-include wxPython/lib/PyCrust/*.py
-include wxPython/lib/PyCrust/*.txt
-include wxPython/lib/PyCrust/*.ico
-
-exclude wxPython/*
-exclude tests
-
-include src/*.i
-include src/*.py
-include src/*.cpp
-include src/*.c
-include src/*.h
-include src/*.ico
-include src/*.rc
-
-include src/msw/*.cpp
-include src/msw/*.h
-include src/msw/*.py
-
-include src/gtk/*.cpp
-include src/gtk/*.h
-include src/gtk/*.py
-
-include tools/*.py
-tools/XRCed/CHANGES
-tools/XRCed/TODO
-tools/XRCed/README
-tools/XRCed/*.py
-tools/XRCed/*.xrc
-
-
-include contrib/glcanvas/*.i
-include contrib/glcanvas/*.py
-include contrib/glcanvas/*.cpp
-include contrib/glcanvas/*.c
-include contrib/glcanvas/*.h
-include contrib/glcanvas/msw/*.cpp
-include contrib/glcanvas/msw/*.h
-include contrib/glcanvas/msw/*.py
-include contrib/glcanvas/gtk/*.cpp
-include contrib/glcanvas/gtk/*.h
-include contrib/glcanvas/gtk/*.py
-
-include contrib/ogl/*.txt
-include contrib/ogl/*.i
-include contrib/ogl/*.py
-include contrib/ogl/*.cpp
-include contrib/ogl/*.c
-include contrib/ogl/*.h
-include contrib/ogl/contrib/include/wx/ogl/*.h
-include contrib/ogl/contrib/src/ogl/*.cpp
-
-include contrib/stc/*.txt
-include contrib/stc/*.i
-include contrib/stc/*.py
-include contrib/stc/*.cpp
-include contrib/stc/*.c
-include contrib/stc/*.h
-include contrib/stc/*.cpp
-include contrib/stc/*.py
-include contrib/stc/contrib/include/wx/stc/*.h
-include contrib/stc/contrib/src/stc/*.h
-include contrib/stc/contrib/src/stc/*.cpp
-include contrib/stc/contrib/src/stc/*.txt
-include contrib/stc/contrib/src/stc/*.py
-include contrib/stc/contrib/src/stc/*.in
-include contrib/stc/contrib/src/stc/scintilla/include/*.h
-include contrib/stc/contrib/src/stc/scintilla/include/*.iface
-include contrib/stc/contrib/src/stc/scintilla/src/*.h
-include contrib/stc/contrib/src/stc/scintilla/src/*.cxx
-
-include contrib/xrc/*.txt
-include contrib/xrc/*.i
-include contrib/xrc/*.py
-include contrib/xrc/*.cpp
-include contrib/xrc/*.c
-include contrib/xrc/*.h
-include contrib/xrc/contrib/include/wx/xrc/*.h
-include contrib/xrc/contrib/src/xrc/*.cpp
-include contrib/xrc/contrib/src/xrc/*.txt
-include contrib/xrc/contrib/src/xrc/README.EXPAT
-include contrib/xrc/contrib/src/xrc/expat/*.txt
-include contrib/xrc/contrib/src/xrc/expat/xmlparse/*.c
-include contrib/xrc/contrib/src/xrc/expat/xmlparse/*.h
-include contrib/xrc/contrib/src/xrc/expat/xmltok/*.c
-include contrib/xrc/contrib/src/xrc/expat/xmltok/*.h

wxPython/README.txt

@@ -1,88 +0,0 @@
-wxPython README
----------------
-
-Welcome to the wonderful world of wxPython!
-
-Once you have installed the wxPython extension module, you can try it
-out by going to the [install dir]\wxPython\demo directory and typing:
-
-    python demo.py
-
-There are also some other sample files there for you to play with and
-learn from.
-
-If you selected to install the documentation then point your browser
-to [install dir]\wxPython\docs\index.htm and you will then be looking
-at the docs for wxWindows.  For the most part you can use the C++ docs
-as most classes and methods are used identically.  Where there are
-differences they are documented with a "wxPython Note."
-
-On Win32 systems the binary self-installer creates a program group on
-the Start Menu that contains a link to running the demo and a link to
-the help file.  To help you save disk space I'm now using Microsoft's
-HTML Help format.  If your system doesn't know what to do with the help
-file, you can install the HTML Help Viewer as part of IE 4+, NT
-Service Pack 4+, or the HTML Workshop at
-
-http://msdn.microsoft.com/workshop/author/htmlhelp/download.asp.
-
-For some features, the latest common controls library from microsoft
-is required.  You can get this by installing IE 5.0 or Office 2000.
-You can also get it independently from here:
-
-http://download.microsoft.com/download/platformsdk/Comctl32/5.80.2614.3600/W9XNT4/EN-US/50comupd.exe
-
-Windows 95 users may also need the WinSock 2.0 and OpenGL libraries.
-These can be found at these sites:
-
-
-http://www.microsoft.com/windows95/downloads/contents/wuadmintools/s_wunetworkingtools/w95sockets2/default.asp
-
-http://www.opengl.org/Downloads/Downloads.html
-
-
-
-Getting Help
-------------
-
-Since wxPython is a blending of multiple technologies, help comes from
-multiple sources.  See the http://wxPython.org/ for details on various
-sources of help, but probably the best source is the wxPython-users
-mail list.  You can view the archive or subscribe by going to
-
-       http://lists.wxwindows.org/mailman/listinfo/wxpython-users
-
-Or you can send mail directly to the list using this address:
-
-       wxpython-users@lists.wxwindows.org
-
-
-Other Info
-----------
-
-Please also see the following files in this directory:
-
-       CHANGES.txt     Information about new features, fixes, etc. in
-                       each release.
-
-       BUILD.unix.txt  Instructions for building wxPython on various
-		       Unix-like platforms.
-
-       BUILD.win32.txt Instructions for building wxPython on Windows.
-
-       licence/*       Text of the wxWindows license.
-
-
-
------------------
-Robin Dunn
-robin@alldunn.com
-
-
-
-
-
-
-
-
-

wxPython/SWIG/README.txt

@@ -1,11 +0,0 @@
-
-Some minor tweaks were made to pyexp.swg and typemaps.i to allow
-wxPython to build with Python 1.6.  Just put these in your
-swig_lib/python dir and you'll be all set.  These are from SWIG
-1.1-883.
-
-
-Additionally, there is a patch in python.cxx.patch that should be
-applied to SWIG's .../Modules/python.cxx file.  This patch prevents
-the out typemap from being used on constructors.
-

wxPython/SWIG/cplus.cxx.patch

@@ -1,37 +0,0 @@
-*** SWIG\cplus.cxx.orig	Fri May 18 13:03:34 2001
---- SWIG\cplus.cxx	Fri May 18 13:07:42 2001
-***************
-*** 839,845 ****
-  
-    if (name) {
-      if (strlen(name)) {
-!       if (strlen(ctype) > 0) {
-  	sprintf(temp,"%s %s", ctype, name);
-  	typeeq_derived(temp,name);       // Map "struct foo" to "foo"
-  	typeeq_derived(name,temp);       // Map "foo" to "struct foo"
---- 839,845 ----
-  
-    if (name) {
-      if (strlen(name)) {
-!       if (strlen(ctype) > 0 && strcmp(ctype, "class") != 0) {
-  	sprintf(temp,"%s %s", ctype, name);
-  	typeeq_derived(temp,name);       // Map "struct foo" to "foo"
-  	typeeq_derived(name,temp);       // Map "foo" to "struct foo"
-***************
-*** 1092,1098 ****
-  
-        // Make a type-equivalence allowing derived classes to be used in functions of the
-  
-!       if (strlen(current_class->classtype) > 0) {
-  	temp1 = "";
-  	temp1 << current_class->classtype << " " << current_class->classname;
-  	temp2 = "";
---- 1092,1099 ----
-  
-        // Make a type-equivalence allowing derived classes to be used in functions of the
-  
-!       if (strlen(current_class->classtype) > 0 &&
-!           strcmp(current_class->classtype, "class") != 0) {
-  	temp1 = "";
-  	temp1 << current_class->classtype << " " << current_class->classname;
-  	temp2 = "";

wxPython/SWIG/pyexp.swg

@@ -1,32 +0,0 @@
-#include <string.h>
-#include <stdlib.h>
-/* Definitions for Windows/Unix exporting */
-#if defined(__WIN32__)
-#   if defined(_MSC_VER)
-#	define SWIGEXPORT(a) __declspec(dllexport) a
-#   else
-#	if defined(__BORLANDC__)
-#	    define SWIGEXPORT(a) a _export
-#	else
-#	    define SWIGEXPORT(a) a
-#	endif
-#   endif
-#else
-#   define SWIGEXPORT(a) a
-#endif
-
-#include "Python.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern void SWIG_MakePtr(char *, void *, char *);
-extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
-extern char *SWIG_GetPtr(char *, void **, char *);
-extern char *SWIG_GetPtrObj(PyObject *, void **, char *);
-extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
-extern PyObject *SWIG_newvarlink(void);
-#ifdef __cplusplus
-}
-#endif

wxPython/SWIG/python.cxx.patch

@@ -1,20 +0,0 @@
-*** Modules\python.cxx.orig	Fri May 11 16:04:01 2001
---- Modules\python.cxx	Fri May 11 16:14:08 2001
-***************
-*** 879,885 ****
-    // If there was a result, it was saved in _result.
-    // If the function is a void type, don't do anything.
-  
-!   if ((tm = typemap_lookup("out","python",d,iname,"_result","_resultobj"))) {
-      // Yep.  Use it instead of the default
-      f.code << tm << "\n";
-    } else {
---- 879,886 ----
-    // If there was a result, it was saved in _result.
-    // If the function is a void type, don't do anything.
-  
-!   if ((strncmp(name, "new_", 4) != 0) &&  // don't use the out typemap for constructors
-!       (tm = typemap_lookup("out","python",d,iname,"_result","_resultobj"))) {
-      // Yep.  Use it instead of the default
-      f.code << tm << "\n";
-    } else {

wxPython/SWIG/typemaps.i

@@ -1,564 +0,0 @@
-//
-// SWIG Typemap library
-// Dave Beazley
-// May 5, 1997
-//
-// Python implementation
-//
-// This library provides standard typemaps for modifying SWIG's behavior.
-// With enough entries in this file, I hope that very few people actually
-// ever need to write a typemap.
-//
-// Disclaimer : Unless you really understand how typemaps work, this file
-// probably isn't going to make much sense.
-//
-#ifdef AUTODOC
-%section "Typemap Library (Python)",info,after,pre,nosort,skip=1,chop_left=3,chop_right=0,chop_top=0,chop_bottom=0
-%text %{
-%include typemaps.i
-
-The SWIG typemap library provides a language independent mechanism for
-supporting output arguments, input values, and other C function
-calling mechanisms.  The primary use of the library is to provide a
-better interface to certain C function--especially those involving
-pointers.
-%}
-
-#endif
-
-// ------------------------------------------------------------------------
-// Pointer handling
-//
-// These mappings provide support for input/output arguments and common
-// uses for C/C++ pointers.
-// ------------------------------------------------------------------------
-
-// INPUT typemaps.
-// These remap a C pointer to be an "INPUT" value which is passed by value
-// instead of reference.
-
-
-#ifdef AUTODOC
-%subsection "Input Methods"
-
-%text %{
-The following methods can be applied to turn a pointer into a simple
-"input" value.  That is, instead of passing a pointer to an object,
-you would use a real value instead.
-
-         int            *INPUT
-         short          *INPUT
-         long           *INPUT
-         unsigned int   *INPUT
-         unsigned short *INPUT
-         unsigned long  *INPUT
-         unsigned char  *INPUT
-         float          *INPUT
-         double         *INPUT
-
-To use these, suppose you had a C function like this :
-
-        double fadd(double *a, double *b) {
-               return *a+*b;
-        }
-
-You could wrap it with SWIG as follows :
-
-        %include typemaps.i
-        double fadd(double *INPUT, double *INPUT);
-
-or you can use the %apply directive :
-
-        %include typemaps.i
-        %apply double *INPUT { double *a, double *b };
-        double fadd(double *a, double *b);
-
-%}
-#endif
-
-%typemap(python,in) double *INPUT(double temp)
-{
-  temp = PyFloat_AsDouble($source);
-  $target = &temp;
-}
-
-%typemap(python,in) float  *INPUT(float temp)
-{
-  temp = (float) PyFloat_AsDouble($source);
-  $target = &temp;
-}
-
-%typemap(python,in) int            *INPUT(int temp)
-{
-  temp = (int) PyInt_AsLong($source);
-  $target = &temp;
-}
-
-%typemap(python,in) short          *INPUT(short temp)
-{
-  temp = (short) PyInt_AsLong($source);
-  $target = &temp;
-}
-
-%typemap(python,in) long           *INPUT(long temp)
-{
-  temp = (long) PyInt_AsLong($source);
-  $target = &temp;
-}
-%typemap(python,in) unsigned int   *INPUT(unsigned int temp)
-{
-  temp = (unsigned int) PyInt_AsLong($source);
-  $target = &temp;
-}
-%typemap(python,in) unsigned short *INPUT(unsigned short temp)
-{
-  temp = (unsigned short) PyInt_AsLong($source);
-  $target = &temp;
-}
-%typemap(python,in) unsigned long  *INPUT(unsigned long temp)
-{
-  temp = (unsigned long) PyInt_AsLong($source);
-  $target = &temp;
-}
-%typemap(python,in) unsigned char  *INPUT(unsigned char temp)
-{
-  temp = (unsigned char) PyInt_AsLong($source);
-  $target = &temp;
-}
-
-%typemap(python,in) signed char  *INPUT(signed char temp)
-{
-  temp = (unsigned char) PyInt_AsLong($source);
-  $target = &temp;
-}
-
-// OUTPUT typemaps.   These typemaps are used for parameters that
-// are output only.   The output value is appended to the result as
-// a list element.
-
-#ifdef AUTODOC
-%subsection "Output Methods"
-
-%text %{
-The following methods can be applied to turn a pointer into an "output"
-value.  When calling a function, no input value would be given for
-a parameter, but an output value would be returned.  In the case of
-multiple output values, they are returned in the form of a Python tuple.
-
-         int            *OUTPUT
-         short          *OUTPUT
-         long           *OUTPUT
-         unsigned int   *OUTPUT
-         unsigned short *OUTPUT
-         unsigned long  *OUTPUT
-         unsigned char  *OUTPUT
-         float          *OUTPUT
-         double         *OUTPUT
-
-A Python List can also be returned by using L_OUTPUT instead of OUTPUT.
-
-For example, suppose you were trying to wrap the modf() function in the
-C math library which splits x into integral and fractional parts (and
-returns the integer part in one of its parameters).K:
-
-        double modf(double x, double *ip);
-
-You could wrap it with SWIG as follows :
-
-        %include typemaps.i
-        double modf(double x, double *OUTPUT);
-
-or you can use the %apply directive :
-
-        %include typemaps.i
-        %apply double *OUTPUT { double *ip };
-        double modf(double x, double *ip);
-
-The Python output of the function would be a tuple containing both
-output values.
-%}
-#endif
-
-
-// I don't use this anywhere, get rid of it...
-
-// Helper function for List output
-//  static PyObject* l_output_helper(PyObject* target, PyObject* o) {
-//      PyObject*   o2;
-//      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;
-//  }
-
-%{
-%}
-
-// Force the argument to be ignored.
-
-%typemap(python,ignore) int            *L_OUTPUT(int temp),
-                        short          *L_OUTPUT(short temp),
-                        long           *L_OUTPUT(long temp),
-                        unsigned int   *L_OUTPUT(unsigned int temp),
-                        unsigned short *L_OUTPUT(unsigned short temp),
-                        unsigned long  *L_OUTPUT(unsigned long temp),
-                        unsigned char  *L_OUTPUT(unsigned char temp),
-                        signed char    *L_OUTPUT(signed char temp),
-                        float          *L_OUTPUT(float temp),
-                        double         *L_OUTPUT(double temp)
-{
-  $target = &temp;
-}
-
-%typemap(python,argout) int            *L_OUTPUT,
-                        short          *L_OUTPUT,
-                        long           *L_OUTPUT,
-                        unsigned int   *L_OUTPUT,
-                        unsigned short *L_OUTPUT,
-                        unsigned long  *L_OUTPUT,
-                        unsigned char  *L_OUTPUT,
-                        signed char    *L_OUTPUT
-{
-    PyObject *o;
-    o = PyInt_FromLong((long) (*$source));
-    l_output_helper($target,o);
-}
-
-%typemap(python,argout) float    *L_OUTPUT,
-                        double   *L_OUTPUT
-{
-    PyObject *o;
-    o = PyFloat_FromDouble((double) (*$source));
-    $target = l_output_helper($target,o);
-}
-
-// These typemaps contributed by Robin Dunn
-//----------------------------------------------------------------------
-//
-// T_OUTPUT typemap (and helper function) to return multiple argouts as
-// a tuple instead of a list.
-//
-// Author: Robin Dunn
-//----------------------------------------------------------------------
-
-%{
-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;
-}
-%}
-
-// Force the argument to be ignored.
-%typemap(python,ignore) int            *T_OUTPUT(int temp),
-                        short          *T_OUTPUT(short temp),
-                        long           *T_OUTPUT(long temp),
-                        unsigned int   *T_OUTPUT(unsigned int temp),
-                        unsigned short *T_OUTPUT(unsigned short temp),
-                        unsigned long  *T_OUTPUT(unsigned long temp),
-                        unsigned char  *T_OUTPUT(unsigned char temp),
-                        float          *T_OUTPUT(float temp),
-                        double         *T_OUTPUT(double temp)
-{
-  $target = &temp;
-}
-
-%typemap(python,argout) int            *T_OUTPUT,
-                        short          *T_OUTPUT,
-                        long           *T_OUTPUT,
-                        unsigned int   *T_OUTPUT,
-                        unsigned short *T_OUTPUT,
-                        unsigned long  *T_OUTPUT,
-                        unsigned char  *T_OUTPUT
-{
-    PyObject *o;
-    o = PyInt_FromLong((long) (*$source));
-    $target = t_output_helper($target, o);
-}
-
-%typemap(python,argout) float    *T_OUTPUT,
-                        double   *T_OUTPUT
-{
-    PyObject *o;
-    o = PyFloat_FromDouble((double) (*$source));
-    $target = t_output_helper($target, o);
-}
-
-// Set the default output typemap
-
-#ifdef OUTPUT_LIST
-%typemap(python,ignore) int                *OUTPUT = int   *L_OUTPUT;
-%typemap(python,ignore) short              *OUTPUT = short *L_OUTPUT;
-%typemap(python,ignore) long               *OUTPUT = long  *L_OUTPUT;
-%typemap(python,ignore) unsigned           *OUTPUT = unsigned *L_OUTPUT;
-%typemap(python,ignore) unsigned short     *OUTPUT = unsigned short *L_OUTPUT;
-%typemap(python,ignore) unsigned long      *OUTPUT = unsigned long  *L_OUTPUT;
-%typemap(python,ignore) unsigned char      *OUTPUT = unsigned char  *L_OUTPUT;
-%typemap(python,ignore) signed char        *OUTPUT = signed char    *L_OUTPUT;
-%typemap(python,ignore) double             *OUTPUT = double         *L_OUTPUT;
-%typemap(python,ignore) float              *OUTPUT = float          *L_OUTPUT;
-
-%typemap(python,argout) int                *OUTPUT = int   *L_OUTPUT;
-%typemap(python,argout) short              *OUTPUT = short *L_OUTPUT;
-%typemap(python,argout) long               *OUTPUT = long  *L_OUTPUT;
-%typemap(python,argout) unsigned           *OUTPUT = unsigned *L_OUTPUT;
-%typemap(python,argout) unsigned short     *OUTPUT = unsigned short *L_OUTPUT;
-%typemap(python,argout) unsigned long      *OUTPUT = unsigned long  *L_OUTPUT;
-%typemap(python,argout) unsigned char      *OUTPUT = unsigned char  *L_OUTPUT;
-%typemap(python,argout) signed char        *OUTPUT = signed char    *L_OUTPUT;
-%typemap(python,argout) double             *OUTPUT = double         *L_OUTPUT;
-%typemap(python,argout) float              *OUTPUT = float          *L_OUTPUT;
-#else
-%typemap(python,ignore) int                *OUTPUT = int   *T_OUTPUT;
-%typemap(python,ignore) short              *OUTPUT = short *T_OUTPUT;
-%typemap(python,ignore) long               *OUTPUT = long  *T_OUTPUT;
-%typemap(python,ignore) unsigned           *OUTPUT = unsigned *T_OUTPUT;
-%typemap(python,ignore) unsigned short     *OUTPUT = unsigned short *T_OUTPUT;
-%typemap(python,ignore) unsigned long      *OUTPUT = unsigned long  *T_OUTPUT;
-%typemap(python,ignore) unsigned char      *OUTPUT = unsigned char  *T_OUTPUT;
-%typemap(python,ignore) signed char        *OUTPUT = signed char    *T_OUTPUT;
-%typemap(python,ignore) double             *OUTPUT = double         *T_OUTPUT;
-%typemap(python,ignore) float              *OUTPUT = float          *T_OUTPUT;
-
-%typemap(python,argout) int                *OUTPUT = int   *T_OUTPUT;
-%typemap(python,argout) short              *OUTPUT = short *T_OUTPUT;
-%typemap(python,argout) long               *OUTPUT = long  *T_OUTPUT;
-%typemap(python,argout) unsigned           *OUTPUT = unsigned *T_OUTPUT;
-%typemap(python,argout) unsigned short     *OUTPUT = unsigned short *T_OUTPUT;
-%typemap(python,argout) unsigned long      *OUTPUT = unsigned long  *T_OUTPUT;
-%typemap(python,argout) unsigned char      *OUTPUT = unsigned char  *T_OUTPUT;
-%typemap(python,argout) signed char        *OUTPUT = signed char    *T_OUTPUT;
-%typemap(python,argout) double             *OUTPUT = double         *T_OUTPUT;
-%typemap(python,argout) float              *OUTPUT = float          *T_OUTPUT;
-#endif
-
-// INOUT
-// Mappings for an argument that is both an input and output
-// parameter
-
-
-#ifdef AUTODOC
-%subsection "Input/Output Methods"
-
-%text %{
-The following methods can be applied to make a function parameter both
-an input and output value.  This combines the behavior of both the
-"INPUT" and "OUTPUT" methods described earlier.  Output values are
-returned in the form of a Python tuple.  To return a Python list,
-using L_INOUT instead.
-
-         int            *INOUT
-         short          *INOUT
-         long           *INOUT
-         unsigned int   *INOUT
-         unsigned short *INOUT
-         unsigned long  *INOUT
-         unsigned char  *INOUT
-         float          *INOUT
-         double         *INOUT
-
-For example, suppose you were trying to wrap the following function :
-
-        void neg(double *x) {
-             *x = -(*x);
-        }
-
-You could wrap it with SWIG as follows :
-
-        %include typemaps.i
-        void neg(double *INOUT);
-
-or you can use the %apply directive :
-
-        %include typemaps.i
-        %apply double *INOUT { double *x };
-        void neg(double *x);
-
-Unlike C, this mapping does not directly modify the input value (since
-this makes no sense in Python).  Rather, the modified input value shows
-up as the return value of the function.  Thus, to apply this function
-to a Python variable you might do this :
-
-       x = neg(x)
-
-Note : previous versions of SWIG used the symbol 'BOTH' to mark
-input/output arguments.   This is still supported, but will be slowly
-phased out in future releases.
-%}
-
-#endif
-
-%typemap(python,in) int *INOUT = int *INPUT;
-%typemap(python,in) short *INOUT = short *INPUT;
-%typemap(python,in) long *INOUT = long *INPUT;
-%typemap(python,in) unsigned *INOUT = unsigned *INPUT;
-%typemap(python,in) unsigned short *INOUT = unsigned short *INPUT;
-%typemap(python,in) unsigned long *INOUT = unsigned long *INPUT;
-%typemap(python,in) unsigned char *INOUT = unsigned char *INPUT;
-%typemap(python,in) float *INOUT = float *INPUT;
-%typemap(python,in) double *INOUT = double *INPUT;
-
-%typemap(python,argout) int *INOUT = int *OUTPUT;
-%typemap(python,argout) short *INOUT = short *OUTPUT;
-%typemap(python,argout) long *INOUT = long *OUTPUT;
-%typemap(python,argout) unsigned *INOUT = unsigned *OUTPUT;
-%typemap(python,argout) unsigned short *INOUT = unsigned short *OUTPUT;
-%typemap(python,argout) unsigned long *INOUT = unsigned long *OUTPUT;
-%typemap(python,argout) unsigned char *INOUT = unsigned char *OUTPUT;
-%typemap(python,argout) float *INOUT = float *OUTPUT;
-%typemap(python,argout) double *INOUT = double *OUTPUT;
-
-%typemap(python,in) int *T_INOUT = int *INPUT;
-%typemap(python,in) short *T_INOUT = short *INPUT;
-%typemap(python,in) long *T_INOUT = long *INPUT;
-%typemap(python,in) unsigned *T_INOUT = unsigned *INPUT;
-%typemap(python,in) unsigned short *T_INOUT = unsigned short *INPUT;
-%typemap(python,in) unsigned long *T_INOUT = unsigned long *INPUT;
-%typemap(python,in) unsigned char *T_INOUT = unsigned char *INPUT;
-%typemap(python,in) float *T_INOUT = float *INPUT;
-%typemap(python,in) double *T_INOUT = double *INPUT;
-
-%typemap(python,argout) int *T_INOUT = int *T_OUTPUT;
-%typemap(python,argout) short *T_INOUT = short *T_OUTPUT;
-%typemap(python,argout) long *T_INOUT = long *T_OUTPUT;
-%typemap(python,argout) unsigned *T_INOUT = unsigned *T_OUTPUT;
-%typemap(python,argout) unsigned short *T_INOUT = unsigned short *T_OUTPUT;
-%typemap(python,argout) unsigned long *T_INOUT = unsigned long *T_OUTPUT;
-%typemap(python,argout) unsigned char *T_INOUT = unsigned char *T_OUTPUT;
-%typemap(python,argout) float *T_INOUT = float *T_OUTPUT;
-%typemap(python,argout) double *T_INOUT = double *T_OUTPUT;
-
-%typemap(python,in) int *L_INOUT = int *INPUT;
-%typemap(python,in) short *L_INOUT = short *INPUT;
-%typemap(python,in) long *L_INOUT = long *INPUT;
-%typemap(python,in) unsigned *L_INOUT = unsigned *INPUT;
-%typemap(python,in) unsigned short *L_INOUT = unsigned short *INPUT;
-%typemap(python,in) unsigned long *L_INOUT = unsigned long *INPUT;
-%typemap(python,in) unsigned char *L_INOUT = unsigned char *INPUT;
-%typemap(python,in) float *L_INOUT = float *INPUT;
-%typemap(python,in) double *L_INOUT = double *INPUT;
-
-%typemap(python,argout) int *L_INOUT = int *L_OUTPUT;
-%typemap(python,argout) short *L_INOUT = short *L_OUTPUT;
-%typemap(python,argout) long *L_INOUT = long *L_OUTPUT;
-%typemap(python,argout) unsigned *L_INOUT = unsigned *L_OUTPUT;
-%typemap(python,argout) unsigned short *L_INOUT = unsigned short *L_OUTPUT;
-%typemap(python,argout) unsigned long *L_INOUT = unsigned long *L_OUTPUT;
-%typemap(python,argout) unsigned char *L_INOUT = unsigned char *L_OUTPUT;
-%typemap(python,argout) float *L_INOUT = float *L_OUTPUT;
-%typemap(python,argout) double *L_INOUT = double *L_OUTPUT;
-
-// Backwards compatibility
-
-%typemap(python,in) int *BOTH = int *INOUT;
-%typemap(python,in) short *BOTH = short *INOUT;
-%typemap(python,in) long *BOTH = long *INOUT;
-%typemap(python,in) unsigned *BOTH = unsigned *INOUT;
-%typemap(python,in) unsigned short *BOTH = unsigned short *INOUT;
-%typemap(python,in) unsigned long *BOTH = unsigned long *INOUT;
-%typemap(python,in) unsigned char *BOTH = unsigned char *INOUT;
-%typemap(python,in) float *BOTH = float *INOUT;
-%typemap(python,in) double *BOTH = double *INOUT;
-
-%typemap(python,argout) int *BOTH = int *INOUT;
-%typemap(python,argout) short *BOTH = short *INOUT;
-%typemap(python,argout) long *BOTH = long *INOUT;
-%typemap(python,argout) unsigned *BOTH = unsigned *INOUT;
-%typemap(python,argout) unsigned short *BOTH = unsigned short *INOUT;
-%typemap(python,argout) unsigned long *BOTH = unsigned long *INOUT;
-%typemap(python,argout) unsigned char *BOTH = unsigned char *INOUT;
-%typemap(python,argout) float *BOTH = float *INOUT;
-%typemap(python,argout) double *BOTH = double *INOUT;
-
-%typemap(python,in) int *T_BOTH = int *T_INOUT;
-%typemap(python,in) short *T_BOTH = short *T_INOUT;
-%typemap(python,in) long *T_BOTH = long *T_INOUT;
-%typemap(python,in) unsigned *T_BOTH = unsigned *T_INOUT;
-%typemap(python,in) unsigned short *T_BOTH = unsigned short *T_INOUT;
-%typemap(python,in) unsigned long *T_BOTH = unsigned long *T_INOUT;
-%typemap(python,in) unsigned char *T_BOTH = unsigned char *T_INOUT;
-%typemap(python,in) float *T_BOTH = float *T_INOUT;
-%typemap(python,in) double *T_BOTH = double *T_INOUT;
-
-%typemap(python,argout) int *T_BOTH = int *T_INOUT;
-%typemap(python,argout) short *T_BOTH = short *T_INOUT;
-%typemap(python,argout) long *T_BOTH = long *T_INOUT;
-%typemap(python,argout) unsigned *T_BOTH = unsigned *T_INOUT;
-%typemap(python,argout) unsigned short *T_BOTH = unsigned short *T_INOUT;
-%typemap(python,argout) unsigned long *T_BOTH = unsigned long *T_INOUT;
-%typemap(python,argout) unsigned char *T_BOTH = unsigned char *T_INOUT;
-%typemap(python,argout) float *T_BOTH = float *T_INOUT;
-%typemap(python,argout) double *T_BOTH = double *T_INOUT;
-
-// --------------------------------------------------------------------
-// Special types
-//
-// --------------------------------------------------------------------
-
-#ifdef AUTODOC
-%subsection "Special Methods"
-
-%text %{
-The typemaps.i library also provides the following mappings :
-
-PyObject *
-
-      When a PyObject * appears as either an input value or return
-      value of a function, SWIG passes it through unmodified.  Thus,
-      if you want to write a C function that operates on PyObjects,
-      it is easy to write.  For example :
-
-           %include typemaps.i
-           PyObject *spam(PyObject *obj1, int n);
-
-      Unlike normal Python wrapper functions, These functions can
-      use any combination of parameters that you wish.
-
-%}
-
-#endif
-
-
-// If a PyObject * appears as either an argument or a function return
-// value, simply pass it straight through.
-
-%typemap(python,in) PyObject * {
-  $target = $source;
-}
-
-%typemap(python,out) PyObject * {
-  $target = $source;
-}
-

wxPython/b

@@ -1,115 +0,0 @@
-#!/bin/sh
-
-function getpyver {
-    if [ "$1" = "15" ]; then
-	PYVER=1.5
-    elif [ "$1" = "20" ]; then
-	PYVER=2.0
-    elif [ "$1" = "21" ]; then
-	PYVER=2.1
-    else
-	echo You must specify Python version as first parameter.
-        exit
-    fi
-}
-
-getpyver $1
-shift
-
-python$PYVER -c "import sys;print '\n', sys.version, '\n'"
-
-WXPYVER=`python -c "import setup;print setup.VERSION"`
-SETUP="python$PYVER -u setup.py"
-FLAGS="USE_SWIG=1 IN_CVS_TREE=1"
-OTHERFLAGS=""
-
-
-
-# "c" --> clean
-if [ "$1" =  "c" ]; then
-    shift
-    CMD="$SETUP $FLAGS $OTHERFLAGS clean"
-    OTHERCMD="rm -f wxPython/*.so"
-
-# "d" --> clean extension modules only
-elif [ "$1" = "d" ]; then
-    shift
-    CMD="rm -f wxPython/*.so"
-
-# "t" --> touch *.i files
-elif [ "$1" = "t" ]; then
-    shift
-    CMD="set CMD=touch src\*.i; touch contrib\glcanvas\*.i; touch contrib\ogl\*.i; touch contrib\stc\*.i"
-
-# "i" --> install
-elif [ "$1" = "i" ]; then
-    shift
-    CMD="$SETUP build $OTHERFLAGS install"
-
-# "s" --> source dist
-elif [ "$1" = "s" ]; then
-    shift
-    CMD="$SETUP $OTHERFLAGS sdist"
-
-# "r" --> rpm dist
-elif [ "$1" = "r" ]; then
-
-    for VER in 15 20 21; do
-	getpyver $VER
-
-	echo "*****************************************************************"
-	echo "*******      Building wxPython for Python $PYVER"
-	echo "*****************************************************************"
-
-	# NOTE:  This assumes that /usr/local/bin is BEFORE /usr/bin on the PATH
-	#        AND that you have write access to it.
-	rm -f /usr/local/bin/python
-	ln -s /usr/bin/python$PYVER /usr/local/bin/python
-	SETUP="/usr/local/bin/python -u setup.py"
-
-	# save the original
-	cp setup.py setup.py.save
-
-	# fix up setup.py the way we want...
-	sed "s/BUILD_GLCANVAS = /BUILD_GLCANVAS = 0 #/" < setup.py.save > setup.py.temp
-	sed "s/GL_ONLY = /GL_ONLY = 1 #/" < setup.py.temp > setup.py
-
-	# build wxPython-gl RPM
-	$SETUP $OTHERFLAGS bdist_rpm --binary-only --doc-files README.txt
-	rm dist/wxPython-gl*.tar.gz
-
-	# Build wxPython RPM
-	cp setup.py setup.py.temp
-	sed "s/GL_ONLY = /GL_ONLY = 0 #/" < setup.py.temp > setup.py
-	$SETUP $OTHERFLAGS bdist_rpm --binary-only
-
-	# put the oringal setup.py back
-	cp setup.py.save setup.py
-	rm setup.py.*
-
-	# rename the binary RPM's
-	mv dist/wxPython-$WXPYVER-1.i386.rpm dist/wxPython-$WXPYVER-1-Py$VER.i386.rpm
-	mv dist/wxPython-gl-$WXPYVER-1.i386.rpm dist/wxPython-gl-$WXPYVER-1-Py$VER.i386.rpm
-
-    done
-    # rebuild the source dists without the munched up setup.py
-    $SETUP $OTHERFLAGS sdist
-    $SETUP $OTHERFLAGS bdist_rpm --source-only
-    exit 0
-
-
-# (no command arg) --> normal build for development
-else
-    CMD="$SETUP $FLAGS $OTHERFLAGS build_ext --inplace $*"
-fi
-
-
-echo $CMD
-$CMD
-
-
-if [ "$OTHERCMD" != "" ]; then
-    echo $OTHERCMD
-    $OTHERCMD
-fi
-

wxPython/b.bat

@@ -1,103 +0,0 @@
-@echo off
-setlocal
-
-set FLAGS=USE_SWIG=1 IN_CVS_TREE=1
-
-
-rem  Use non-default python?
-iff "%1" == "15" .or. "%1" == "20" .or. "%1" == "21" then
-	set PYTHON=c:\tools\python%1%\python.exe
-	shift
-else
-	beep
-	echo You must specify Python version as first parameter.
-	quit
-endiff
-set SETUP=%PYTHON% -u setup.py
-
-
-%PYTHON% -c "import sys;print '\n', sys.version, '\n'"
-
-
-rem "c" --> clean
-iff "%1" == "c" then
-	shift
-	set CMD=%SETUP% %FLAGS% clean
-	set OTHERCMD=del wxPython\*.pyd
-
-rem just remove the *.pyd's
-elseiff "%1" == "d" then
-	shift
-	set CMD=del wxPython\*.pyd
-
-rem touch all the *.i files so swig will regenerate
-elseiff "%1" == "t" then
-	shift
-	set CMD=touch src\*.i & touch contrib\glcanvas\*.i & touch contrib\ogl\*.i & touch contrib\stc\*.i
-
-rem "i" --> install
-elseiff "%1" == "i" then
-	shift
-	set CMD=%SETUP% build install
-
-rem "r" --> make installer
-elseiff "%1" == "r" then
-	shift
-	set CMD=%PYTHON% distrib\make_installer.py
-
-rem "s" --> source dist
-elseiff "%1" == "s" then
-	shift
-	set CMD=%SETUP sdist
-
-rem "f" --> FINAL
-elseiff "%1" == "f" then
-	shift
-	set CMD=%SETUP% %FLAGS% FINAL=1 build_ext --inplace %1 %2 %3 %4 %5 %6 %7 %8 %9
-
-rem "h" --> HYBRID
-elseiff "%1" == "h" then
-	shift
-	set CMD=%SETUP% %FLAGS% HYBRID=1 build_ext --inplace %1 %2 %3 %4 %5 %6 %7 %8 %9
-
-rem "a" --> make all installers
-elseiff "%1" == "a" then
-	shift
-	set CMD=echo Finished!
-	call b.bat 15 c
-	call b.bat 15 f
-	call b.bat 15 r
-	call b.bat 15 c
-	call b.bat 15 h
-	call b.bat 15 r
-
-	call b.bat 20 c
-	call b.bat 20 f
-	call b.bat 20 r
-	call b.bat 20 c
-	call b.bat 20 h
-	call b.bat 20 r
-
-	call b.bat 21 c
-	call b.bat 21 f
-	call b.bat 21 r
-	call b.bat 21 c
-	call b.bat 21 h
-	call b.bat 21 r
-
-
-rem (no command arg) --> normal build for development
-else
-	set CMD=%SETUP% %FLAGS% HYBRID=0 build_ext --inplace --debug %1 %2 %3 %4 %5 %6 %7 %8 %9
-endiff
-
-
-
-echo %CMD%
-%CMD%
-
-iff "%OTHERCMD%" != "" then
-	echo %OTHERCMD%
-	%OTHERCMD%
-endiff
-

wxPython/contrib/.cvsignore

@@ -1 +0,0 @@
-update.log

wxPython/contrib/README

@@ -1,3 +0,0 @@
-These sub directories contain add-on modules that are not part of the
-core wxPython, either because of licensing issues, optional code in
-wxWindows, contrib code in wxWindows, or whatever.

wxPython/contrib/glcanvas/.cvsignore

@@ -1,14 +0,0 @@
-
-*.exp
-*.lib
-*.obj
-*.pch
-Makefile
-Makefile.pre
-Setup
-build.local
-config.c
-glcanvas.h
-glcanvasc.ilk
-glcanvasc.pyd
-sedscript

wxPython/contrib/glcanvas/glcanvas.i

@@ -1,125 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        glcanvas.i
-// Purpose:     SWIG definitions for the OpenGL wxWindows classes
-//
-// Author:      Robin Dunn
-//
-// Created:     15-Mar-1999
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-
-%module glcanvas
-
-%{
-#include "export.h"
-#ifdef __WXMSW__
-#include "myglcanvas.h"
-#else
-#include <wx/glcanvas.h>
-#endif
-
-%}
-
-//---------------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-%extern wx.i
-%extern windows.i
-%extern windows2.i
-%extern windows3.i
-%extern frames.i
-%extern _defs.i
-%extern misc.i
-%extern gdi.i
-%extern controls.i
-%extern events.i
-
-
-%pragma(python) code = "import wx"
-
-//---------------------------------------------------------------------------
-
-class wxPalette;
-class wxWindow;
-class wxSize;
-class wxPoint;
-class wxGLCanvas;
-
-//---------------------------------------------------------------------------
-
-class wxGLContext : public wxObject {
-public:
-    wxGLContext(bool isRGB, wxGLCanvas *win, const wxPalette& palette = wxNullPalette);
-    ~wxGLContext();
-
-    void SetCurrent();
-    void SetColour(const char *colour);
-    void SwapBuffers();
-
-#ifdef __WXGTK__
-    void SetupPixelFormat();
-    void SetupPalette(const wxPalette& palette);
-    wxPalette CreateDefaultPalette();
-    wxPalette* GetPalette();
-#endif
-
-    wxWindow* GetWindow();
-};
-
-//---------------------------------------------------------------------------
-
-%typemap(python, in) int *attribList (int *temp) {
-    int i;
-    if (PySequence_Check($source)) {
-        int size = PyObject_Length($source);
-        temp = new int[size+1]; // (int*)malloc((size + 1) * sizeof(int));
-        for (i = 0; i < size; i++) {
-            temp[i] = PyInt_AsLong(PySequence_GetItem($source, i));
-        }
-        temp[size] = 0;
-        $target = temp;
-    }
-}
-
-%typemap(python, freearg) int *attribList
-{
-    delete [] $source;
-}
-
-
-
-class wxGLCanvas : public wxScrolledWindow {
-public:
-    wxGLCanvas(wxWindow *parent, wxWindowID id = -1,
-               const wxPoint& pos = wxDefaultPosition,
-               const wxSize& size = wxDefaultSize, long style = 0,
-               const char* name = "GLCanvas",
-               int *attribList = NULL,
-               const wxPalette& palette = wxNullPalette);
-
-    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
-
-    void SetCurrent();
-    void SetColour(const char *colour);
-    void SwapBuffers();
-
-    wxGLContext* GetContext();
-};
-
-
-//---------------------------------------------------------------------------
-
-%init %{
-
-    wxClassInfo::CleanUpClasses();
-    wxClassInfo::InitializeClasses();
-
-%}
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------

wxPython/contrib/glcanvas/gtk/.cvsignore

@@ -1,2 +0,0 @@
-*~
-_glcanvas.cpp

wxPython/contrib/glcanvas/gtk/glcanvas.py

@@ -1,122 +0,0 @@
-# This file was created automatically by SWIG.
-import glcanvasc
-
-from misc import *
-
-from misc2 import *
-
-from windows import *
-
-from gdi import *
-
-from clip_dnd import *
-
-from events import *
-
-from streams import *
-
-from mdi import *
-
-from frames import *
-
-from stattool import *
-
-from controls import *
-
-from controls2 import *
-
-from windows2 import *
-
-from cmndlgs import *
-
-from windows3 import *
-
-from image import *
-
-from printfw import *
-
-from sizers import *
-
-from filesys import *
-
-from utils import *
-import wx
-class wxGLContextPtr(wxObjectPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self,glcanvasc=glcanvasc):
-        if self.thisown == 1 :
-            glcanvasc.delete_wxGLContext(self)
-    def SetCurrent(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SetCurrent,(self,) + _args, _kwargs)
-        return val
-    def SetColour(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SetColour,(self,) + _args, _kwargs)
-        return val
-    def SwapBuffers(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SwapBuffers,(self,) + _args, _kwargs)
-        return val
-    def SetupPixelFormat(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SetupPixelFormat,(self,) + _args, _kwargs)
-        return val
-    def SetupPalette(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SetupPalette,(self,) + _args, _kwargs)
-        return val
-    def CreateDefaultPalette(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_CreateDefaultPalette,(self,) + _args, _kwargs)
-        if val: val = wxPalettePtr(val) ; val.thisown = 1
-        return val
-    def GetPalette(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_GetPalette,(self,) + _args, _kwargs)
-        if val: val = wxPalettePtr(val) 
-        return val
-    def GetWindow(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_GetWindow,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxGLContext instance at %s>" % (self.this,)
-class wxGLContext(wxGLContextPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(glcanvasc.new_wxGLContext,_args,_kwargs)
-        self.thisown = 1
-
-
-
-
-class wxGLCanvasPtr(wxScrolledWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SetCurrent(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_SetCurrent,(self,) + _args, _kwargs)
-        return val
-    def SetColour(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_SetColour,(self,) + _args, _kwargs)
-        return val
-    def SwapBuffers(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_SwapBuffers,(self,) + _args, _kwargs)
-        return val
-    def GetContext(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_GetContext,(self,) + _args, _kwargs)
-        if val: val = wxGLContextPtr(val) 
-        return val
-    def __repr__(self):
-        return "<C wxGLCanvas instance at %s>" % (self.this,)
-class wxGLCanvas(wxGLCanvasPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(glcanvasc.new_wxGLCanvas,_args,_kwargs)
-        self.thisown = 1
-        #wx._StdWindowCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

wxPython/contrib/glcanvas/msw/.cvsignore

@@ -1 +0,0 @@
-*~

wxPython/contrib/glcanvas/msw/glcanvas.cpp

@@ -1,676 +0,0 @@
-/*
- * FILE : contrib/glcanvas/msw/glcanvas.cpp
- * 
- * This file was automatically generated by :
- * Simplified Wrapper and Interface Generator (SWIG)
- * Version 1.1 (Build 883)
- * 
- * 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) __declspec(dllexport) a
-#   else
-#	if defined(__BORLANDC__)
-#	    define SWIGEXPORT(a) a _export
-#	else
-#	    define SWIGEXPORT(a) a
-#	endif
-#   endif
-#else
-#   define SWIGEXPORT(a) a
-#endif
-
-#include "Python.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern void SWIG_MakePtr(char *, void *, char *);
-extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
-extern char *SWIG_GetPtr(char *, void **, char *);
-extern char *SWIG_GetPtrObj(PyObject *, void **, char *);
-extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
-extern PyObject *SWIG_newvarlink(void);
-#ifdef __cplusplus
-}
-#endif
-#define SWIG_init    initglcanvasc
-
-#define SWIG_name    "glcanvasc"
-
-#include "export.h"
-#ifdef __WXMSW__
-#include "myglcanvas.h"
-#else
-#include <wx/glcanvas.h>
-#endif
-
-
-
-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;
-}
-
-#if PYTHON_API_VERSION >= 1009
-    static char* wxStringErrorMsg = "String or Unicode type required";
-#else
-    static char* wxStringErrorMsg = "string type is required for parameter";
-#endif
-#ifdef __cplusplus
-extern "C" {
-#endif
-static void *SwigwxGLContextTowxObject(void *ptr) {
-    wxGLContext *src;
-    wxObject *dest;
-    src = (wxGLContext *) ptr;
-    dest = (wxObject *) src;
-    return (void *) dest;
-}
-
-#define new_wxGLContext(_swigarg0,_swigarg1,_swigarg2) (new wxGLContext(_swigarg0,_swigarg1,_swigarg2))
-static PyObject *_wrap_new_wxGLContext(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLContext * _result;
-    bool  _arg0;
-    wxGLCanvas * _arg1;
-    wxPalette * _arg2 = (wxPalette *) &wxNullPalette;
-    int tempbool0;
-    PyObject * _argo1 = 0;
-    PyObject * _argo2 = 0;
-    char *_kwnames[] = { "isRGB","win","palette", NULL };
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"iO|O:new_wxGLContext",_kwnames,&tempbool0,&_argo1,&_argo2)) 
-        return NULL;
-    _arg0 = (bool ) tempbool0;
-    if (_argo1) {
-        if (_argo1 == Py_None) { _arg1 = NULL; }
-        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGLCanvas_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of new_wxGLContext. Expected _wxGLCanvas_p.");
-        return NULL;
-        }
-    }
-    if (_argo2) {
-        if (_argo2 == Py_None) { _arg2 = NULL; }
-        else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxPalette_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxGLContext. Expected _wxPalette_p.");
-        return NULL;
-        }
-    }
-{
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGLContext *)new_wxGLContext(_arg0,_arg1,*_arg2);
-
-    wxPy_END_ALLOW_THREADS;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGLContext_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
-    return _resultobj;
-}
-
-#define delete_wxGLContext(_swigobj) (delete _swigobj)
-static PyObject *_wrap_delete_wxGLContext(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLContext * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxGLContext",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLContext_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxGLContext. Expected _wxGLContext_p.");
-        return NULL;
-        }
-    }
-{
-    wxPy_BEGIN_ALLOW_THREADS;
-        delete_wxGLContext(_arg0);
-
-    wxPy_END_ALLOW_THREADS;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxGLContext_SetCurrent(_swigobj)  (_swigobj->SetCurrent())
-static PyObject *_wrap_wxGLContext_SetCurrent(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLContext * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGLContext_SetCurrent",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLContext_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_SetCurrent. Expected _wxGLContext_p.");
-        return NULL;
-        }
-    }
-{
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGLContext_SetCurrent(_arg0);
-
-    wxPy_END_ALLOW_THREADS;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxGLContext_SetColour(_swigobj,_swigarg0)  (_swigobj->SetColour(_swigarg0))
-static PyObject *_wrap_wxGLContext_SetColour(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLContext * _arg0;
-    char * _arg1;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self","colour", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Os:wxGLContext_SetColour",_kwnames,&_argo0,&_arg1)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLContext_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_SetColour. Expected _wxGLContext_p.");
-        return NULL;
-        }
-    }
-{
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGLContext_SetColour(_arg0,_arg1);
-
-    wxPy_END_ALLOW_THREADS;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxGLContext_SwapBuffers(_swigobj)  (_swigobj->SwapBuffers())
-static PyObject *_wrap_wxGLContext_SwapBuffers(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLContext * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGLContext_SwapBuffers",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLContext_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_SwapBuffers. Expected _wxGLContext_p.");
-        return NULL;
-        }
-    }
-{
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGLContext_SwapBuffers(_arg0);
-
-    wxPy_END_ALLOW_THREADS;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxGLContext_GetWindow(_swigobj)  (_swigobj->GetWindow())
-static PyObject *_wrap_wxGLContext_GetWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxWindow * _result;
-    wxGLContext * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGLContext_GetWindow",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLContext_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLContext_GetWindow. Expected _wxGLContext_p.");
-        return NULL;
-        }
-    }
-{
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxWindow *)wxGLContext_GetWindow(_arg0);
-
-    wxPy_END_ALLOW_THREADS;
-}{ _resultobj = wxPyMake_wxObject(_result); }
-    return _resultobj;
-}
-
-static void *SwigwxGLCanvasTowxScrolledWindow(void *ptr) {
-    wxGLCanvas *src;
-    wxScrolledWindow *dest;
-    src = (wxGLCanvas *) ptr;
-    dest = (wxScrolledWindow *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxGLCanvasTowxPanel(void *ptr) {
-    wxGLCanvas *src;
-    wxPanel *dest;
-    src = (wxGLCanvas *) ptr;
-    dest = (wxPanel *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxGLCanvasTowxWindow(void *ptr) {
-    wxGLCanvas *src;
-    wxWindow *dest;
-    src = (wxGLCanvas *) ptr;
-    dest = (wxWindow *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxGLCanvasTowxEvtHandler(void *ptr) {
-    wxGLCanvas *src;
-    wxEvtHandler *dest;
-    src = (wxGLCanvas *) ptr;
-    dest = (wxEvtHandler *) src;
-    return (void *) dest;
-}
-
-static void *SwigwxGLCanvasTowxObject(void *ptr) {
-    wxGLCanvas *src;
-    wxObject *dest;
-    src = (wxGLCanvas *) ptr;
-    dest = (wxObject *) src;
-    return (void *) dest;
-}
-
-#define new_wxGLCanvas(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6,_swigarg7) (new wxGLCanvas(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6,_swigarg7))
-static PyObject *_wrap_new_wxGLCanvas(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLCanvas * _result;
-    wxWindow * _arg0;
-    wxWindowID  _arg1 = (wxWindowID ) -1;
-    wxPoint * _arg2 = (wxPoint *) &wxDefaultPosition;
-    wxSize * _arg3 = (wxSize *) &wxDefaultSize;
-    long  _arg4 = (long ) 0;
-    char * _arg5 = (char *) "GLCanvas";
-    int * _arg6 = (int *) NULL;
-    wxPalette * _arg7 = (wxPalette *) &wxNullPalette;
-    PyObject * _argo0 = 0;
-    wxPoint  temp;
-    PyObject * _obj2 = 0;
-    wxSize  temp0;
-    PyObject * _obj3 = 0;
-    int * temp1;
-    PyObject * _obj6 = 0;
-    PyObject * _argo7 = 0;
-    char *_kwnames[] = { "parent","id","pos","size","style","name","attribList","palette", NULL };
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iOOlsOO:new_wxGLCanvas",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_arg5,&_obj6,&_argo7)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWindow_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxGLCanvas. Expected _wxWindow_p.");
-        return NULL;
-        }
-    }
-    if (_obj2)
-{
-    _arg2 = &temp;
-    if (! wxPoint_helper(_obj2, &_arg2))
-        return NULL;
-}
-    if (_obj3)
-{
-    _arg3 = &temp0;
-    if (! wxSize_helper(_obj3, &_arg3))
-        return NULL;
-}
-    if (_obj6)
-{
-    int i;
-    if (PySequence_Check(_obj6)) {
-        int size = PyObject_Length(_obj6);
-        temp1 = new int[size+1]; // (int*)malloc((size + 1) * sizeof(int));
-        for (i = 0; i < size; i++) {
-            temp1[i] = PyInt_AsLong(PySequence_GetItem(_obj6, i));
-        }
-        temp1[size] = 0;
-        _arg6 = temp1;
-    }
-}
-    if (_argo7) {
-        if (_argo7 == Py_None) { _arg7 = NULL; }
-        else if (SWIG_GetPtrObj(_argo7,(void **) &_arg7,"_wxPalette_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 8 of new_wxGLCanvas. Expected _wxPalette_p.");
-        return NULL;
-        }
-    }
-{
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGLCanvas *)new_wxGLCanvas(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5,_arg6,*_arg7);
-
-    wxPy_END_ALLOW_THREADS;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGLCanvas_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
-{
-    delete [] _arg6;
-}
-    return _resultobj;
-}
-
-#define wxGLCanvas_SetCurrent(_swigobj)  (_swigobj->SetCurrent())
-static PyObject *_wrap_wxGLCanvas_SetCurrent(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLCanvas * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGLCanvas_SetCurrent",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLCanvas_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLCanvas_SetCurrent. Expected _wxGLCanvas_p.");
-        return NULL;
-        }
-    }
-{
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGLCanvas_SetCurrent(_arg0);
-
-    wxPy_END_ALLOW_THREADS;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxGLCanvas_SetColour(_swigobj,_swigarg0)  (_swigobj->SetColour(_swigarg0))
-static PyObject *_wrap_wxGLCanvas_SetColour(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLCanvas * _arg0;
-    char * _arg1;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self","colour", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Os:wxGLCanvas_SetColour",_kwnames,&_argo0,&_arg1)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLCanvas_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLCanvas_SetColour. Expected _wxGLCanvas_p.");
-        return NULL;
-        }
-    }
-{
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGLCanvas_SetColour(_arg0,_arg1);
-
-    wxPy_END_ALLOW_THREADS;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxGLCanvas_SwapBuffers(_swigobj)  (_swigobj->SwapBuffers())
-static PyObject *_wrap_wxGLCanvas_SwapBuffers(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLCanvas * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGLCanvas_SwapBuffers",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLCanvas_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLCanvas_SwapBuffers. Expected _wxGLCanvas_p.");
-        return NULL;
-        }
-    }
-{
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxGLCanvas_SwapBuffers(_arg0);
-
-    wxPy_END_ALLOW_THREADS;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-#define wxGLCanvas_GetContext(_swigobj)  (_swigobj->GetContext())
-static PyObject *_wrap_wxGLCanvas_GetContext(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    wxGLContext * _result;
-    wxGLCanvas * _arg0;
-    PyObject * _argo0 = 0;
-    char *_kwnames[] = { "self", NULL };
-    char _ptemp[128];
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGLCanvas_GetContext",_kwnames,&_argo0)) 
-        return NULL;
-    if (_argo0) {
-        if (_argo0 == Py_None) { _arg0 = NULL; }
-        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGLCanvas_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGLCanvas_GetContext. Expected _wxGLCanvas_p.");
-        return NULL;
-        }
-    }
-{
-    wxPy_BEGIN_ALLOW_THREADS;
-        _result = (wxGLContext *)wxGLCanvas_GetContext(_arg0);
-
-    wxPy_END_ALLOW_THREADS;
-}    if (_result) {
-        SWIG_MakePtr(_ptemp, (char *) _result,"_wxGLContext_p");
-        _resultobj = Py_BuildValue("s",_ptemp);
-    } else {
-        Py_INCREF(Py_None);
-        _resultobj = Py_None;
-    }
-    return _resultobj;
-}
-
-static PyMethodDef glcanvascMethods[] = {
-	 { "wxGLCanvas_GetContext", (PyCFunction) _wrap_wxGLCanvas_GetContext, METH_VARARGS | METH_KEYWORDS },
-	 { "wxGLCanvas_SwapBuffers", (PyCFunction) _wrap_wxGLCanvas_SwapBuffers, METH_VARARGS | METH_KEYWORDS },
-	 { "wxGLCanvas_SetColour", (PyCFunction) _wrap_wxGLCanvas_SetColour, METH_VARARGS | METH_KEYWORDS },
-	 { "wxGLCanvas_SetCurrent", (PyCFunction) _wrap_wxGLCanvas_SetCurrent, METH_VARARGS | METH_KEYWORDS },
-	 { "new_wxGLCanvas", (PyCFunction) _wrap_new_wxGLCanvas, METH_VARARGS | METH_KEYWORDS },
-	 { "wxGLContext_GetWindow", (PyCFunction) _wrap_wxGLContext_GetWindow, METH_VARARGS | METH_KEYWORDS },
-	 { "wxGLContext_SwapBuffers", (PyCFunction) _wrap_wxGLContext_SwapBuffers, METH_VARARGS | METH_KEYWORDS },
-	 { "wxGLContext_SetColour", (PyCFunction) _wrap_wxGLContext_SetColour, METH_VARARGS | METH_KEYWORDS },
-	 { "wxGLContext_SetCurrent", (PyCFunction) _wrap_wxGLContext_SetCurrent, METH_VARARGS | METH_KEYWORDS },
-	 { "delete_wxGLContext", (PyCFunction) _wrap_delete_wxGLContext, METH_VARARGS | METH_KEYWORDS },
-	 { "new_wxGLContext", (PyCFunction) _wrap_new_wxGLContext, METH_VARARGS | METH_KEYWORDS },
-	 { NULL, NULL }
-};
-#ifdef __cplusplus
-}
-#endif
-/*
- * This table is used by the pointer type-checker
- */
-static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
-    { "_signed_long","_long",0},
-    { "_wxPrintQuality","_wxCoord",0},
-    { "_wxPrintQuality","_int",0},
-    { "_wxPrintQuality","_signed_int",0},
-    { "_wxPrintQuality","_unsigned_int",0},
-    { "_wxPrintQuality","_wxWindowID",0},
-    { "_wxPrintQuality","_uint",0},
-    { "_wxPrintQuality","_EBool",0},
-    { "_wxPrintQuality","_size_t",0},
-    { "_wxPrintQuality","_time_t",0},
-    { "_byte","_unsigned_char",0},
-    { "_long","_unsigned_long",0},
-    { "_long","_signed_long",0},
-    { "_size_t","_wxCoord",0},
-    { "_size_t","_wxPrintQuality",0},
-    { "_size_t","_time_t",0},
-    { "_size_t","_unsigned_int",0},
-    { "_size_t","_int",0},
-    { "_size_t","_wxWindowID",0},
-    { "_size_t","_uint",0},
-    { "_wxPanel","_wxGLCanvas",SwigwxGLCanvasTowxPanel},
-    { "_uint","_wxCoord",0},
-    { "_uint","_wxPrintQuality",0},
-    { "_uint","_time_t",0},
-    { "_uint","_size_t",0},
-    { "_uint","_unsigned_int",0},
-    { "_uint","_int",0},
-    { "_uint","_wxWindowID",0},
-    { "_wxChar","_char",0},
-    { "_char","_wxChar",0},
-    { "_EBool","_wxCoord",0},
-    { "_EBool","_wxPrintQuality",0},
-    { "_EBool","_signed_int",0},
-    { "_EBool","_int",0},
-    { "_EBool","_wxWindowID",0},
-    { "_unsigned_long","_long",0},
-    { "_signed_int","_wxCoord",0},
-    { "_signed_int","_wxPrintQuality",0},
-    { "_signed_int","_EBool",0},
-    { "_signed_int","_wxWindowID",0},
-    { "_signed_int","_int",0},
-    { "_WXTYPE","_wxDateTime_t",0},
-    { "_WXTYPE","_short",0},
-    { "_WXTYPE","_signed_short",0},
-    { "_WXTYPE","_unsigned_short",0},
-    { "_unsigned_short","_wxDateTime_t",0},
-    { "_unsigned_short","_WXTYPE",0},
-    { "_unsigned_short","_short",0},
-    { "_wxObject","_wxGLCanvas",SwigwxGLCanvasTowxObject},
-    { "_wxObject","_wxGLContext",SwigwxGLContextTowxObject},
-    { "_signed_short","_WXTYPE",0},
-    { "_signed_short","_short",0},
-    { "_wxScrolledWindow","_wxGLCanvas",SwigwxGLCanvasTowxScrolledWindow},
-    { "_unsigned_char","_byte",0},
-    { "_unsigned_int","_wxCoord",0},
-    { "_unsigned_int","_wxPrintQuality",0},
-    { "_unsigned_int","_time_t",0},
-    { "_unsigned_int","_size_t",0},
-    { "_unsigned_int","_uint",0},
-    { "_unsigned_int","_wxWindowID",0},
-    { "_unsigned_int","_int",0},
-    { "_short","_wxDateTime_t",0},
-    { "_short","_WXTYPE",0},
-    { "_short","_unsigned_short",0},
-    { "_short","_signed_short",0},
-    { "_wxWindowID","_wxCoord",0},
-    { "_wxWindowID","_wxPrintQuality",0},
-    { "_wxWindowID","_time_t",0},
-    { "_wxWindowID","_size_t",0},
-    { "_wxWindowID","_EBool",0},
-    { "_wxWindowID","_uint",0},
-    { "_wxWindowID","_int",0},
-    { "_wxWindowID","_signed_int",0},
-    { "_wxWindowID","_unsigned_int",0},
-    { "_int","_wxCoord",0},
-    { "_int","_wxPrintQuality",0},
-    { "_int","_time_t",0},
-    { "_int","_size_t",0},
-    { "_int","_EBool",0},
-    { "_int","_uint",0},
-    { "_int","_wxWindowID",0},
-    { "_int","_unsigned_int",0},
-    { "_int","_signed_int",0},
-    { "_wxDateTime_t","_unsigned_short",0},
-    { "_wxDateTime_t","_short",0},
-    { "_wxDateTime_t","_WXTYPE",0},
-    { "_time_t","_wxCoord",0},
-    { "_time_t","_wxPrintQuality",0},
-    { "_time_t","_unsigned_int",0},
-    { "_time_t","_int",0},
-    { "_time_t","_wxWindowID",0},
-    { "_time_t","_uint",0},
-    { "_time_t","_size_t",0},
-    { "_wxCoord","_int",0},
-    { "_wxCoord","_signed_int",0},
-    { "_wxCoord","_unsigned_int",0},
-    { "_wxCoord","_wxWindowID",0},
-    { "_wxCoord","_uint",0},
-    { "_wxCoord","_EBool",0},
-    { "_wxCoord","_size_t",0},
-    { "_wxCoord","_time_t",0},
-    { "_wxCoord","_wxPrintQuality",0},
-    { "_wxEvtHandler","_wxGLCanvas",SwigwxGLCanvasTowxEvtHandler},
-    { "_wxWindow","_wxGLCanvas",SwigwxGLCanvasTowxWindow},
-{0,0,0}};
-
-static PyObject *SWIG_globals;
-#ifdef __cplusplus
-extern "C" 
-#endif
-SWIGEXPORT(void) initglcanvasc() {
-	 PyObject *m, *d;
-	 SWIG_globals = SWIG_newvarlink();
-	 m = Py_InitModule("glcanvasc", glcanvascMethods);
-	 d = PyModule_GetDict(m);
-
-
-    wxClassInfo::CleanUpClasses();
-    wxClassInfo::InitializeClasses();
-
-{
-   int i;
-   for (i = 0; _swig_mapping[i].n1; i++)
-        SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
-}
-}

wxPython/contrib/glcanvas/msw/glcanvas.py

@@ -1,108 +0,0 @@
-# This file was created automatically by SWIG.
-import glcanvasc
-
-from misc import *
-
-from misc2 import *
-
-from windows import *
-
-from gdi import *
-
-from clip_dnd import *
-
-from events import *
-
-from streams import *
-
-from mdi import *
-
-from frames import *
-
-from stattool import *
-
-from controls import *
-
-from controls2 import *
-
-from windows2 import *
-
-from cmndlgs import *
-
-from windows3 import *
-
-from image import *
-
-from printfw import *
-
-from sizers import *
-
-from filesys import *
-
-from utils import *
-import wx
-class wxGLContextPtr(wxObjectPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self,glcanvasc=glcanvasc):
-        if self.thisown == 1 :
-            glcanvasc.delete_wxGLContext(self)
-    def SetCurrent(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SetCurrent,(self,) + _args, _kwargs)
-        return val
-    def SetColour(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SetColour,(self,) + _args, _kwargs)
-        return val
-    def SwapBuffers(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_SwapBuffers,(self,) + _args, _kwargs)
-        return val
-    def GetWindow(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLContext_GetWindow,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxGLContext instance at %s>" % (self.this,)
-class wxGLContext(wxGLContextPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(glcanvasc.new_wxGLContext,_args,_kwargs)
-        self.thisown = 1
-
-
-
-
-class wxGLCanvasPtr(wxScrolledWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SetCurrent(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_SetCurrent,(self,) + _args, _kwargs)
-        return val
-    def SetColour(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_SetColour,(self,) + _args, _kwargs)
-        return val
-    def SwapBuffers(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_SwapBuffers,(self,) + _args, _kwargs)
-        return val
-    def GetContext(self, *_args, **_kwargs):
-        val = apply(glcanvasc.wxGLCanvas_GetContext,(self,) + _args, _kwargs)
-        if val: val = wxGLContextPtr(val) 
-        return val
-    def __repr__(self):
-        return "<C wxGLCanvas instance at %s>" % (self.this,)
-class wxGLCanvas(wxGLCanvasPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(glcanvasc.new_wxGLCanvas,_args,_kwargs)
-        self.thisown = 1
-        #wx._StdWindowCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

wxPython/contrib/glcanvas/msw/myglcanvas.cpp

@@ -1,720 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        glcanvas.cpp
-// Purpose:     wxGLCanvas, for using OpenGL with wxWindows under MS Windows
-// Author:      Julian Smart
-// Modified by:
-// Created:     04/01/98
-// RCS-ID:      $Id$
-// Copyright:   (c) Julian Smart
-// Licence:   	wxWindows licence
-/////////////////////////////////////////////////////////////////////////////
-
-#ifdef __GNUG__
-#pragma implementation "glcanvas.h"
-#endif
-
-#include "wx/wxprec.h"
-
-#if defined(__BORLANDC__)
-#pragma hdrstop
-#endif
-
-#include <wx/setup.h>
-
-
-#undef wxUSE_GLCANVAS
-#define wxUSE_GLCANVAS 1
-#if wxUSE_GLCANVAS
-
-#ifndef WX_PRECOMP
-#include <wx/frame.h>
-#endif
-
-#include <wx/msw/private.h>
-#include <wx/settings.h>
-#include <wx/log.h>
-
-#include "myglcanvas.h"
-
-wxChar wxGLCanvasClassName[]        = wxT("wxGLCanvasClass");
-
-LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message,
-                                   WPARAM wParam, LPARAM lParam);
-
-/*
- * GLContext implementation
- */
-
-wxGLContext::wxGLContext(bool isRGB, wxGLCanvas *win, const wxPalette& palette)
-{
-  m_window = win;
-
-  m_hDC = win->GetHDC();
-
-  m_glContext = wglCreateContext((HDC) m_hDC);
-  wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGl context") );
-
-  wglMakeCurrent((HDC) m_hDC, m_glContext);
-}
-
-wxGLContext::wxGLContext(
-               bool isRGB, wxGLCanvas *win,
-               const wxPalette& palette,
-               const wxGLContext *other  /* for sharing display lists */
-             )
-{
-  m_window = win;
-
-  m_hDC = win->GetHDC();
-
-  m_glContext = wglCreateContext((HDC) m_hDC);
-  wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGl context") );
-
-  if( other != 0 )
-    wglShareLists( other->m_glContext, m_glContext );
-
-  wglMakeCurrent((HDC) m_hDC, m_glContext);
-}
-
-wxGLContext::~wxGLContext()
-{
-  if (m_glContext)
-  {
-    wglMakeCurrent(NULL, NULL);
-    wglDeleteContext(m_glContext);
-  }
-}
-
-void wxGLContext::SwapBuffers()
-{
-  if (m_glContext)
-  {
-    wglMakeCurrent((HDC) m_hDC, m_glContext);
-    ::SwapBuffers((HDC) m_hDC);    //blits the backbuffer into DC
-  }
-}
-
-void wxGLContext::SetCurrent()
-{
-  if (m_glContext)
-  {
-    wglMakeCurrent((HDC) m_hDC, m_glContext);
-  }
-
-  /*
-  setupPixelFormat(hDC);
-  setupPalette(hDC);
-  */
-}
-
-void wxGLContext::SetColour(const char *colour)
-{
-  float r = 0.0;
-  float g = 0.0;
-  float b = 0.0;
-  wxColour *col = wxTheColourDatabase->FindColour(colour);
-  if (col)
-  {
-    r = (float)(col->Red()/256.0);
-    g = (float)(col->Green()/256.0);
-    b = (float)(col->Blue()/256.0);
-    glColor3f( r, g, b);
-  }
-}
-
-
-/*
- * wxGLCanvas implementation
- */
-
-IMPLEMENT_CLASS(wxGLCanvas, wxScrolledWindow)
-
-BEGIN_EVENT_TABLE(wxGLCanvas, wxScrolledWindow)
-    EVT_SIZE(wxGLCanvas::OnSize)
-    EVT_PALETTE_CHANGED(wxGLCanvas::OnPaletteChanged)
-    EVT_QUERY_NEW_PALETTE(wxGLCanvas::OnQueryNewPalette)
-END_EVENT_TABLE()
-
-wxGLCanvas::wxGLCanvas(wxWindow *parent, wxWindowID id,
-    const wxPoint& pos, const wxSize& size, long style, const wxString& name,
-    int *attribList, const wxPalette& palette) : wxScrolledWindow()
-{
-  m_glContext = (wxGLContext*) NULL;
-
-  bool ret = Create(parent, id, pos, size, style, name);
-
-  if ( ret )
-  {
-    SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
-    SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
-  }
-
-  m_hDC = (WXHDC) ::GetDC((HWND) GetHWND());
-
-  SetupPixelFormat(attribList);
-  SetupPalette(palette);
-
-  m_glContext = new wxGLContext(TRUE, this, palette);
-}
-
-wxGLCanvas::wxGLCanvas( wxWindow *parent,
-              const wxGLContext *shared, wxWindowID id,
-              const wxPoint& pos, const wxSize& size, long style, const wxString& name,
-              int *attribList, const wxPalette& palette )
-  : wxScrolledWindow()
-{
-  m_glContext = (wxGLContext*) NULL;
-
-  bool ret = Create(parent, id, pos, size, style, name);
-
-  if ( ret )
-  {
-    SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
-    SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
-  }
-
-  m_hDC = (WXHDC) ::GetDC((HWND) GetHWND());
-
-  SetupPixelFormat(attribList);
-  SetupPalette(palette);
-
-  m_glContext = new wxGLContext(TRUE, this, palette, shared );
-}
-
-// Not very useful for wxMSW, but this is to be wxGTK compliant
-
-wxGLCanvas::wxGLCanvas( wxWindow *parent, const wxGLCanvas *shared, wxWindowID id,
-                        const wxPoint& pos, const wxSize& size, long style, const wxString& name,
-                        int *attribList, const wxPalette& palette ):
-  wxScrolledWindow()
-{
-  m_glContext = (wxGLContext*) NULL;
-
-  bool ret = Create(parent, id, pos, size, style, name);
-
-  if ( ret )
-  {
-    SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
-    SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
-  }
-
-  m_hDC = (WXHDC) ::GetDC((HWND) GetHWND());
-
-  SetupPixelFormat(attribList);
-  SetupPalette(palette);
-
-  wxGLContext *sharedContext=0;
-  if (shared) sharedContext=shared->GetContext();
-  m_glContext = new wxGLContext(TRUE, this, palette, sharedContext );
-}
-
-wxGLCanvas::~wxGLCanvas()
-{
-  if (m_glContext)
-    delete m_glContext;
-
-  ::ReleaseDC((HWND) GetHWND(), (HDC) m_hDC);
-}
-
-// Replaces wxWindow::Create functionality, since we need to use a different window class
-bool wxGLCanvas::Create(wxWindow *parent, wxWindowID id,
-              const wxPoint& pos, const wxSize& size, long style, const wxString& name)
-{
-  /*
-  Suggestion from Kelly Brock <kbrock@8cs.com> (not yet implemented):
-
-  OpenGL corruption fix is simple assuming it doesn't screw anything else
-  up.  Add the following line to the top of the create function:
-
-       wxSize parentSize = GetClientSize();
-
-  All locations within the function that use 'size' are changed to
-  'parentSize'.
-  The above corrects the initial display corruption with the GeForce and
-  TNT2, not sure about other NVidia cards yet.
-  */
-
-  static bool registeredGLCanvasClass = FALSE;
-
-  // We have to register a special window class because we need
-  // the CS_OWNDC style for GLCanvas.
-
-  /*
-  From Angel Popov <jumpo@bitex.com>
-
-  Here are two snips from a dicussion in the OpenGL Gamedev list that explains
-  how this problem can be fixed:
-
-  "There are 5 common DCs available in Win95. These are aquired when you call
-  GetDC or GetDCEx from a window that does _not_ have the OWNDC flag.
-  OWNDC flagged windows do not get their DC from the common DC pool, the issue
-  is they require 800 bytes each from the limited 64Kb local heap for GDI."
-
-  "The deal is, if you hold onto one of the 5 shared DC's too long (as GL apps
-  do), Win95 will actually "steal" it from you.  MakeCurrent fails,
-  apparently, because Windows re-assigns the HDC to a different window.  The
-  only way to prevent this, the only reliable means, is to set CS_OWNDC."
-  */
-
-  if (!registeredGLCanvasClass)
-  {
-    WNDCLASS wndclass;
-
-    static const long styleNormal = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | CS_OWNDC;
-
-    // the fields which are common to all classes
-    wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
-    wndclass.cbClsExtra    = 0;
-    wndclass.cbWndExtra    = sizeof( DWORD ); // VZ: what is this DWORD used for?
-    wndclass.hInstance     = wxhInstance;
-    wndclass.hIcon         = (HICON) NULL;
-    wndclass.hCursor       = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
-    wndclass.lpszMenuName  = NULL;
-
-    // Register the GLCanvas class name
-    wndclass.hbrBackground = (HBRUSH)NULL;
-    wndclass.lpszClassName = wxGLCanvasClassName;
-    wndclass.style         = styleNormal;
-
-    if ( !RegisterClass(&wndclass) )
-    {
-      wxLogLastError(wxT("RegisterClass(wxGLCanvasClass)"));
-      return FALSE;
-    }
-
-    registeredGLCanvasClass = TRUE;
-  }
-
-  wxCHECK_MSG( parent, FALSE, wxT("can't create wxWindow without parent") );
-
-  if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
-    return FALSE;
-
-  parent->AddChild(this);
-
-  DWORD msflags = 0;
-  if ( style & wxBORDER )
-    msflags |= WS_BORDER;
-  if ( style & wxTHICK_FRAME )
-    msflags |= WS_THICKFRAME;
-
-  /*
-  A general rule with OpenGL and Win32 is that any window that will have a
-  HGLRC built for it must have two flags:  WS_CLIPCHILDREN & WS_CLIPSIBLINGS.
-  You can find references about this within the knowledge base and most OpenGL
-  books that contain the wgl function descriptions.
-  */
-
-  msflags |= WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS;
-  //  if ( style & wxCLIP_CHILDREN )
-  //    msflags |= WS_CLIPCHILDREN;
-  msflags |= WS_CLIPCHILDREN;
-
-  bool want3D;
-  WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D);
-
-  // Even with extended styles, need to combine with WS_BORDER
-  // for them to look right.
-  if ( want3D || (m_windowStyle & wxSIMPLE_BORDER) || (m_windowStyle & wxRAISED_BORDER ) ||
-       (m_windowStyle & wxSUNKEN_BORDER) || (m_windowStyle & wxDOUBLE_BORDER))
-  {
-    msflags |= WS_BORDER;
-  }
-
-  // calculate the value to return from WM_GETDLGCODE handler
-  if ( GetWindowStyleFlag() & wxWANTS_CHARS )
-  {
-    // want everything: i.e. all keys and WM_CHAR message
-    m_lDlgCode = DLGC_WANTARROWS | DLGC_WANTCHARS |
-                 DLGC_WANTTAB | DLGC_WANTMESSAGE;
-  }
-
-  MSWCreate(m_windowId, parent, wxGLCanvasClassName, this, NULL,
-            pos.x, pos.y,
-            WidthDefault(size.x), HeightDefault(size.y),
-            msflags, NULL, exStyle);
-
-  return TRUE;
-}
-
-void wxGLCanvas::SetupPixelFormat(int *attribList) // (HDC hDC)
-{
-  int pixelFormat;
-  PIXELFORMATDESCRIPTOR pfd = {
-		sizeof(PIXELFORMATDESCRIPTOR),	/* size */
-		1,				/* version */
-		PFD_SUPPORT_OPENGL |
-		PFD_DRAW_TO_WINDOW |
-		PFD_DOUBLEBUFFER,		/* support double-buffering */
-		PFD_TYPE_RGBA,			/* color type */
-		16,				/* prefered color depth */
-		0, 0, 0, 0, 0, 0,		/* color bits (ignored) */
-		0,				/* no alpha buffer */
-		0,				/* alpha bits (ignored) */
-		0,				/* no accumulation buffer */
-		0, 0, 0, 0,			/* accum bits (ignored) */
-		16,				/* depth buffer */
-		0,				/* no stencil buffer */
-		0,				/* no auxiliary buffers */
-		PFD_MAIN_PLANE,			/* main layer */
-		0,				/* reserved */
-		0, 0, 0,			/* no layer, visible, damage masks */
-	};
-
-  if (attribList) {
-    pfd.dwFlags &= ~PFD_DOUBLEBUFFER;
-    pfd.iPixelType = PFD_TYPE_COLORINDEX;
-    pfd.cColorBits = 0;
-    int arg=0;
-
-    while( (attribList[arg]!=0) )
-    {
-      switch( attribList[arg++] )
-      {
-        case WX_GL_RGBA:
-          pfd.iPixelType = PFD_TYPE_RGBA;
-          break;
-        case WX_GL_BUFFER_SIZE:
-          pfd.cColorBits = attribList[arg++];
-          break;
-        case WX_GL_LEVEL:
-          // this member looks like it may be obsolete
-          if (attribList[arg] > 0) {
-            pfd.iLayerType = PFD_OVERLAY_PLANE;
-          } else if (attribList[arg] < 0) {
-            pfd.iLayerType = PFD_UNDERLAY_PLANE;
-          } else {
-            pfd.iLayerType = PFD_MAIN_PLANE;
-          }
-          arg++;
-          break;
-        case WX_GL_DOUBLEBUFFER:
-          pfd.dwFlags |= PFD_DOUBLEBUFFER;
-          break;
-        case WX_GL_STEREO:
-          pfd.dwFlags |= PFD_STEREO;
-          break;
-        case WX_GL_AUX_BUFFERS:
-          pfd.cAuxBuffers = attribList[arg++];
-          break;
-        case WX_GL_MIN_RED:
-          pfd.cColorBits += (pfd.cRedBits = attribList[arg++]);
-          break;
-        case WX_GL_MIN_GREEN:
-          pfd.cColorBits += (pfd.cGreenBits = attribList[arg++]);
-          break;
-        case WX_GL_MIN_BLUE:
-          pfd.cColorBits += (pfd.cBlueBits = attribList[arg++]);
-          break;
-        case WX_GL_MIN_ALPHA:
-          // doesn't count in cColorBits
-          pfd.cAlphaBits = attribList[arg++];
-          break;
-        case WX_GL_DEPTH_SIZE:
-          pfd.cDepthBits = attribList[arg++];
-          break;
-        case WX_GL_STENCIL_SIZE:
-          pfd.cStencilBits = attribList[arg++];
-          break;
-        case WX_GL_MIN_ACCUM_RED:
-          pfd.cAccumBits += (pfd.cAccumRedBits = attribList[arg++]);
-          break;
-        case WX_GL_MIN_ACCUM_GREEN:
-          pfd.cAccumBits += (pfd.cAccumGreenBits = attribList[arg++]);
-          break;
-        case WX_GL_MIN_ACCUM_BLUE:
-          pfd.cAccumBits += (pfd.cAccumBlueBits = attribList[arg++]);
-          break;
-        case WX_GL_MIN_ACCUM_ALPHA:
-          pfd.cAccumBits += (pfd.cAccumAlphaBits = attribList[arg++]);
-          break;
-        default:
-          break;
-      }
-    }
-  }
-  pixelFormat = ChoosePixelFormat((HDC) m_hDC, &pfd);
-  if (pixelFormat == 0) {
-    MessageBox(WindowFromDC((HDC) m_hDC), wxT("ChoosePixelFormat failed."), wxT("Error"),
-               MB_ICONERROR | MB_OK);
-    exit(1);
-  }
-
-  if (SetPixelFormat((HDC) m_hDC, pixelFormat, &pfd) != TRUE) {
-    MessageBox(WindowFromDC((HDC) m_hDC), wxT("SetPixelFormat failed."), wxT("Error"),
-               MB_ICONERROR | MB_OK);
-    exit(1);
-  }
-}
-
-void wxGLCanvas::SetupPalette(const wxPalette& palette)
-{
-    int pixelFormat = GetPixelFormat((HDC) m_hDC);
-    PIXELFORMATDESCRIPTOR pfd;
-
-    DescribePixelFormat((HDC) m_hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
-
-    if (pfd.dwFlags & PFD_NEED_PALETTE)
-    {
-    }
-    else
-    {
-	  return;
-    }
-
-    m_palette = palette;
-
-    if ( !m_palette.Ok() )
-    {
-        m_palette = CreateDefaultPalette();
-    }
-
-    if (m_palette.Ok())
-    {
-        SelectPalette((HDC) m_hDC, (HPALETTE) m_palette.GetHPALETTE(), FALSE);
-        RealizePalette((HDC) m_hDC);
-    }
-}
-
-wxPalette wxGLCanvas::CreateDefaultPalette()
-{
-    PIXELFORMATDESCRIPTOR pfd;
-    int paletteSize;
-    int pixelFormat = GetPixelFormat((HDC) m_hDC);
-
-    DescribePixelFormat((HDC) m_hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
-
-    paletteSize = 1 << pfd.cColorBits;
-
-    LOGPALETTE* pPal =
-     (LOGPALETTE*) malloc(sizeof(LOGPALETTE) + paletteSize * sizeof(PALETTEENTRY));
-    pPal->palVersion = 0x300;
-    pPal->palNumEntries = paletteSize;
-
-    /* build a simple RGB color palette */
-    {
-	int redMask = (1 << pfd.cRedBits) - 1;
-	int greenMask = (1 << pfd.cGreenBits) - 1;
-	int blueMask = (1 << pfd.cBlueBits) - 1;
-	int i;
-
-	for (i=0; i<paletteSize; ++i) {
-	    pPal->palPalEntry[i].peRed =
-		    (((i >> pfd.cRedShift) & redMask) * 255) / redMask;
-	    pPal->palPalEntry[i].peGreen =
-		    (((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;
-	    pPal->palPalEntry[i].peBlue =
-		    (((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask;
-	    pPal->palPalEntry[i].peFlags = 0;
-	}
-    }
-
-    HPALETTE hPalette = CreatePalette(pPal);
-    free(pPal);
-
-    wxPalette palette;
-    palette.SetHPALETTE((WXHPALETTE) hPalette);
-
-    return palette;
-}
-
-void wxGLCanvas::SwapBuffers()
-{
-  if (m_glContext)
-    m_glContext->SwapBuffers();
-}
-
-void wxGLCanvas::OnSize(wxSizeEvent& event)
-{
-  int width, height;
-  GetClientSize(& width, & height);
-
-  if (m_glContext)
-  {
-    m_glContext->SetCurrent();
-
-    glViewport(0, 0, (GLint)width, (GLint)height);
-    glMatrixMode(GL_PROJECTION);
-    glLoadIdentity();
-    glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 15.0 );
-    glMatrixMode(GL_MODELVIEW);
-  }
-}
-
-void wxGLCanvas::SetCurrent()
-{
-  if (m_glContext)
-  {
-    m_glContext->SetCurrent();
-  }
-}
-
-void wxGLCanvas::SetColour(const char *colour)
-{
-  if (m_glContext)
-    m_glContext->SetColour(colour);
-}
-
-// TODO: Have to have this called by parent frame (?)
-// So we need wxFrame to call OnQueryNewPalette for all children...
-void wxGLCanvas::OnQueryNewPalette(wxQueryNewPaletteEvent& event)
-{
-  /* realize palette if this is the current window */
-  if ( GetPalette()->Ok() ) {
-    ::UnrealizeObject((HPALETTE) GetPalette()->GetHPALETTE());
-    ::SelectPalette((HDC) GetHDC(), (HPALETTE) GetPalette()->GetHPALETTE(), FALSE);
-    ::RealizePalette((HDC) GetHDC());
-    Refresh();
-    event.SetPaletteRealized(TRUE);
-  }
-  else
-    event.SetPaletteRealized(FALSE);
-}
-
-// I think this doesn't have to be propagated to child windows.
-void wxGLCanvas::OnPaletteChanged(wxPaletteChangedEvent& event)
-{
-  /* realize palette if this is *not* the current window */
-  if ( GetPalette() &&
-       GetPalette()->Ok() && (this != event.GetChangedWindow()) )
-  {
-    ::UnrealizeObject((HPALETTE) GetPalette()->GetHPALETTE());
-    ::SelectPalette((HDC) GetHDC(), (HPALETTE) GetPalette()->GetHPALETTE(), FALSE);
-    ::RealizePalette((HDC) GetHDC());
-    Refresh();
-  }
-}
-
-/* Give extensions proper function names. */
-
-/* EXT_vertex_array */
-void glArrayElementEXT(GLint i)
-{
-}
-
-void glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
-{
-}
-
-void glDrawArraysEXT(GLenum mode, GLint first, GLsizei count)
-{
-#ifdef GL_EXT_vertex_array
-    static PFNGLDRAWARRAYSEXTPROC proc = 0;
-
-    if ( !proc )
-    {
-        proc = (PFNGLDRAWARRAYSEXTPROC) wglGetProcAddress("glDrawArraysEXT");
-    }
-
-    if ( proc )
-        (* proc) (mode, first, count);
-#endif
-}
-
-void glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *pointer)
-{
-}
-
-void glGetPointervEXT(GLenum pname, GLvoid* *params)
-{
-}
-
-void glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
-{
-}
-
-void glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
-{
-#ifdef GL_EXT_vertex_array
-  static PFNGLNORMALPOINTEREXTPROC proc = 0;
-
-  if ( !proc )
-  {
-    proc = (PFNGLNORMALPOINTEREXTPROC) wglGetProcAddress("glNormalPointerEXT");
-  }
-
-  if ( proc )
-    (* proc) (type, stride, count, pointer);
-#endif
-}
-
-void glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
-{
-}
-
-void glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
-{
-#ifdef GL_EXT_vertex_array
-  static PFNGLVERTEXPOINTEREXTPROC proc = 0;
-
-  if ( !proc )
-  {
-    proc = (PFNGLVERTEXPOINTEREXTPROC) wglGetProcAddress("glVertexPointerEXT");
-  }
-  if ( proc )
-    (* proc) (size, type, stride, count, pointer);
-#endif
-}
-
-/* EXT_color_subtable */
-void glColorSubtableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *table)
-{
-}
-
-/* EXT_color_table */
-void glColorTableEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
-{
-}
-
-void glCopyColorTableEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-}
-
-void glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid *table)
-{
-}
-
-void glGetColorTableParamaterfvEXT(GLenum target, GLenum pname, GLfloat *params)
-{
-}
-
-void glGetColorTavleParameterivEXT(GLenum target, GLenum pname, GLint *params)
-{
-}
-
-/* SGI_compiled_vertex_array */
-void glLockArraysSGI(GLint first, GLsizei count)
-{
-}
-
-void glUnlockArraysSGI()
-{
-}
-
-
-/* SGI_cull_vertex */
-void glCullParameterdvSGI(GLenum pname, GLdouble* params)
-{
-}
-
-void glCullParameterfvSGI(GLenum pname, GLfloat* params)
-{
-}
-
-/* SGI_index_func */
-void glIndexFuncSGI(GLenum func, GLclampf ref)
-{
-}
-
-/* SGI_index_material */
-void glIndexMaterialSGI(GLenum face, GLenum mode)
-{
-}
-
-/* WIN_swap_hint */
-void glAddSwapHintRectWin(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-}
-
-#endif
-    // wxUSE_GLCANVAS

wxPython/contrib/glcanvas/msw/myglcanvas.h

@@ -1,141 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        glcanvas.h
-// Purpose:     wxGLCanvas, for using OpenGL with wxWindows under Windows
-// Author:      Julian Smart
-// Modified by:
-// Created:     04/01/98
-// RCS-ID:      $Id$
-// Copyright:   (c) Julian Smart
-// Licence:   	wxWindows licence
-/////////////////////////////////////////////////////////////////////////////
-
-#ifdef __GNUG__
-#pragma interface "glcanvas.h"
-#endif
-
-#ifndef _WX_GLCANVAS_H_
-#define _WX_GLCANVAS_H_
-
-#include <wx/setup.h>
-
-
-#undef wxUSE_GLCANVAS
-#define wxUSE_GLCANVAS 1
-#if wxUSE_GLCANVAS
-
-#include <wx/palette.h>
-#include <wx/scrolwin.h>
-
-#include <windows.h>
-
-#include "gl/gl.h"
-
-//---------------------------------------------------------------------------
-// Constants for attriblist
-//---------------------------------------------------------------------------
-
-// The generic GL implementation doesn't support most of these options,
-// such as stereo, auxiliary buffers, alpha channel, and accum buffer.
-// Other implementations may actually support them.
-
-enum
-{
-  WX_GL_RGBA=1,          /* use true color palette */
-  WX_GL_BUFFER_SIZE,     /* bits for buffer if not WX_GL_RGBA */
-  WX_GL_LEVEL,           /* 0 for main buffer, >0 for overlay, <0 for underlay */
-  WX_GL_DOUBLEBUFFER,    /* use doublebuffer */
-  WX_GL_STEREO,          /* use stereoscopic display */
-  WX_GL_AUX_BUFFERS,     /* number of auxiliary buffers */
-  WX_GL_MIN_RED,         /* use red buffer with most bits (> MIN_RED bits) */
-  WX_GL_MIN_GREEN,       /* use green buffer with most bits (> MIN_GREEN bits) */
-  WX_GL_MIN_BLUE,        /* use blue buffer with most bits (> MIN_BLUE bits) */
-  WX_GL_MIN_ALPHA,       /* use blue buffer with most bits (> MIN_ALPHA bits) */
-  WX_GL_DEPTH_SIZE,      /* bits for Z-buffer (0,16,32) */
-  WX_GL_STENCIL_SIZE,    /* bits for stencil buffer */
-  WX_GL_MIN_ACCUM_RED,   /* use red accum buffer with most bits (> MIN_ACCUM_RED bits) */
-  WX_GL_MIN_ACCUM_GREEN, /* use green buffer with most bits (> MIN_ACCUM_GREEN bits) */
-  WX_GL_MIN_ACCUM_BLUE,  /* use blue buffer with most bits (> MIN_ACCUM_BLUE bits) */
-  WX_GL_MIN_ACCUM_ALPHA  /* use blue buffer with most bits (> MIN_ACCUM_ALPHA bits) */
-};
-
-class wxGLCanvas;     /* forward reference */
-
-class wxGLContext: public wxObject
-{
-public:
-   wxGLContext(bool isRGB, wxGLCanvas *win, const wxPalette& palette = wxNullPalette);
-   wxGLContext(
-               bool isRGB, wxGLCanvas *win,
-               const wxPalette& WXUNUSED(palette),
-               const wxGLContext *other        /* for sharing display lists */
-    );
-   ~wxGLContext();
-
-   void SetCurrent();
-   void SetColour(const char *colour);
-   void SwapBuffers();
-
-
-   inline wxWindow* GetWindow() const { return m_window; }
-   inline WXHDC GetHDC() const { return m_hDC; }
-   inline HGLRC GetGLRC() const { return m_glContext; }
-
-public:
-   HGLRC            m_glContext;
-   WXHDC            m_hDC;
-   wxWindow*        m_window;
-};
-
-class wxGLCanvas: public wxScrolledWindow
-{
-   DECLARE_CLASS(wxGLCanvas)
- public:
-   wxGLCanvas(wxWindow *parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition,
-        const wxSize& size = wxDefaultSize, long style = 0,
-        const wxString& name = "GLCanvas", int *attribList = 0, const wxPalette& palette = wxNullPalette);
-   wxGLCanvas( wxWindow *parent, const wxGLContext *shared = (wxGLContext *)NULL,
-        wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition,
-        const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "GLCanvas",
-        int *attribList = (int*) NULL, const wxPalette& palette = wxNullPalette );
-
-   wxGLCanvas( wxWindow *parent, const wxGLCanvas *shared = (wxGLCanvas *)NULL, wxWindowID id = -1,
-        const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0,
-        const wxString& name = "GLCanvas", int *attribList = 0, const wxPalette& palette = wxNullPalette );
-
-   ~wxGLCanvas();
-
-   // Replaces wxWindow::Create functionality, since we need to use a different window class
-   bool Create(wxWindow *parent, wxWindowID id,
-          const wxPoint& pos, const wxSize& size, long style, const wxString& name);
-
-   void SetCurrent();
-   void SetColour(const char *colour);
-   void SwapBuffers();
-
-   void OnSize(wxSizeEvent& event);
-
-   void OnQueryNewPalette(wxQueryNewPaletteEvent& event);
-   void OnPaletteChanged(wxPaletteChangedEvent& event);
-
-   inline wxGLContext* GetContext() const { return m_glContext; }
-
-   inline WXHDC GetHDC() const { return m_hDC; }
-   void SetupPixelFormat(int *attribList = (int*) NULL);
-   void SetupPalette(const wxPalette& palette);
-   wxPalette CreateDefaultPalette();
-
-   inline wxPalette* GetPalette() const { return (wxPalette*) & m_palette; }
-
-protected:
-    wxGLContext*   m_glContext;  // this is typedef-ed ptr, in fact
-    wxPalette      m_palette;
-    WXHDC          m_hDC;
-
-DECLARE_EVENT_TABLE()
-};
-
-#endif
-    // wxUSE_GLCANVAS
-#endif
-    // _WX_GLCANVAS_H_
-

wxPython/contrib/glcanvas/myglcanvas.h

@@ -1,17 +0,0 @@
-
-//----------------------------------------------------------------------
-//
-// For MSW I keep my own copy of the glcanvas code.  This lets me build
-// the main wxWindows library without OpenGL support and the DLL
-// depenencies that go along with it.  The DLL dependencies will then
-// be localized to this extension module, will not need to be loaded
-// when the core is started up, and won't make the core unrunnable on
-// systems that don't have OpenGL.
-//
-//----------------------------------------------------------------------
-
-#if defined(__WXMSW__)
-#include "msw/myglcanvas.h"
-#else
-#include <wx/glcanvas.h>
-#endif

wxPython/contrib/ogl/.cvsignore

@@ -1,6 +0,0 @@
-Makefile
-contrib
-oglc.exp
-oglc.ilk
-oglc.pch
-oglc.pyd

wxPython/contrib/ogl/README.txt

@@ -1,7 +0,0 @@
-Since OGL is not always bundled with distributions of wxWindows, in
-order for it to be a standard part of wxPython I need to bundle it
-here.  The contents of the contrib directory are copies of the
-relevant parts of the main contrib directory in wxWindows.  The
-build.py script in this directory will also build the needed files
-from there, so you no longer have to worry about aquiring and building
-additional libraries beyond wxWindows itself.

wxPython/contrib/ogl/_ogldefs.i

@@ -1,137 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        _ogldefs.i
-// Purpose:     SWIG definitions for the wxWindows Object Graphics Library
-//
-// Author:      Robin Dunn
-//
-// Created:     27-Aug-1999
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-
-//---------------------------------------------------------------------------
-
-
-class wxOGLConstraint;
-class wxBitmapShape;
-class wxDiagram;
-class wxDrawnShape;
-class wxCircleShape;
-class wxCompositeShape;
-class wxDividedShape;
-class wxDivisionShape;
-class wxEllipseShape;
-class wxLineShape;
-class wxPolygonShape;
-class wxRectangleShape;
-class wxPseudoMetaFile;
-class wxShape;
-class wxShapeCanvas;
-class wxShapeEvtHandler;
-class wxTextShape;
-class wxControlPoint;
-
-class wxPyOGLConstraint;
-class wxPyBitmapShape;
-class wxPyDiagram;
-class wxPyDrawnShape;
-class wxPyCircleShape;
-class wxPyCompositeShape;
-class wxPyDividedShape;
-class wxPyDivisionShape;
-class wxPyEllipseShape;
-class wxPyLineShape;
-class wxPyPolygonShape;
-class wxPyRectangleShape;
-class wxPyPseudoMetaFile;
-class wxPyShape;
-class wxPyShapeCanvas;
-class wxPyShapeEvtHandler;
-class wxPyTextShape;
-class wxPyControlPoint;
-
-
-//---------------------------------------------------------------------------
-// Typemaps just for OGL
-
-
-// OOR Support
-%typemap(python, out) wxPyShape*                { $target = wxPyMake_wxObject($source); }
-%typemap(python, out) wxPyShapeEvtHandler*      { $target = wxPyMake_wxObject($source); }
-%typemap(python, out) wxPyShapeCanvas*          { $target = wxPyMake_wxObject($source); }
-%typemap(python, out) wxDiagram*                { $target = wxPyMake_wxObject($source); }
-%typemap(python, out) wxOGLConstraint*          { $target = wxPyMake_wxObject($source); }
-%typemap(python, out) wxPyDivisionShape*        { $target = wxPyMake_wxObject($source); }
-%typemap(python, out) wxPseudoMetaFile*         { $target = wxPyMake_wxObject($source); }
-%typemap(python, out) wxArrowHead*              { $target = wxPyMake_wxObject($source); }
-
-
-
-
-// wxOGL doesn't use a ref-counted copy of pens and brushes, so we'll
-// use the pen and brush lists to simulate that...
-
-%typemap(python, in) wxPen* {
-    wxPen* temp;
-    if ($source) {
-        if ($source == Py_None) { temp = NULL; }
-        else if (SWIG_GetPtrObj($source, (void **) &temp,"_wxPen_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error, expected _wxPen_p.");
-        return NULL;
-        }
-    }
-    if (temp)
-        $target = wxThePenList->FindOrCreatePen(temp->GetColour(),
-                                                temp->GetWidth(),
-                                                temp->GetStyle());
-    else
-        $target = NULL;
-}
-
-%typemap(python, in) wxBrush* {
-    wxBrush* temp;
-    if ($source) {
-        if ($source == Py_None) { temp = NULL; }
-        else if (SWIG_GetPtrObj($source, (void **) &temp,"_wxBrush_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error, expected _wxBrush_p.");
-        return NULL;
-        }
-    }
-    if (temp)
-        $target = wxTheBrushList->FindOrCreateBrush(temp->GetColour(), temp->GetStyle());
-    else
-        $target = NULL;
-}
-
-
-%typemap(python, in) wxFont* {
-    wxFont* temp;
-    if ($source) {
-        if ($source == Py_None) { temp = NULL; }
-        else if (SWIG_GetPtrObj($source, (void **) &temp,"_wxFont_p")) {
-            PyErr_SetString(PyExc_TypeError,"Type error, expected _wxFont_p.");
-        return NULL;
-        }
-    }
-    if (temp)
-        $target = wxTheFontList->FindOrCreateFont(temp->GetPointSize(),
-                                                  temp->GetFamily(),
-                                                  temp->GetStyle(),
-                                                  temp->GetWeight(),
-                                                  temp->GetUnderlined(),
-                                                  temp->GetFaceName(),
-                                                  temp->GetEncoding());
-    else
-        $target = NULL;
-}
-
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-
-
-
-
-

wxPython/contrib/ogl/_oglextras.py

@@ -1,41 +0,0 @@
-
-# aliases
-wxShapeCanvas =       wxPyShapeCanvas
-wxShapeEvtHandler =   wxPyShapeEvtHandler
-wxShape =             wxPyShape
-wxRectangleShape =    wxPyRectangleShape
-wxBitmapShape =       wxPyBitmapShape
-wxDrawnShape =        wxPyDrawnShape
-wxCompositeShape =    wxPyCompositeShape
-wxDividedShape =      wxPyDividedShape
-wxDivisionShape =     wxPyDivisionShape
-wxEllipseShape =      wxPyEllipseShape
-wxCircleShape =       wxPyCircleShape
-wxLineShape =         wxPyLineShape
-wxPolygonShape =      wxPyPolygonShape
-wxTextShape =         wxPyTextShape
-wxControlPoint =      wxPyControlPoint
-
-# Stuff these names into the wx namespace so wxPyConstructObject can find them
-import wx
-wx.wxArrowHeadPtr         = wxArrowHeadPtr
-wx.wxControlPointPtr      = wxPyControlPointPtr
-wx.wxDiagramPtr           = wxDiagramPtr
-wx.wxOGLConstraintPtr     = wxOGLConstraintPtr
-wx.wxPseudoMetaFilePtr    = wxPseudoMetaFile
-wx.wxPyBitmapShapePtr     = wxPyBitmapShapePtr
-wx.wxPyCircleShapePtr     = wxPyCircleShapePtr
-wx.wxPyCompositeShapePtr  = wxPyCompositeShapePtr
-wx.wxPyControlPointPtr    = wxPyControlPointPtr
-wx.wxPyDividedShapePtr    = wxPyDividedShapePtr
-wx.wxPyDivisionShapePtr   = wxPyDivisionShapePtr
-wx.wxPyDrawnShapePtr      = wxPyDrawnShapePtr
-wx.wxPyEllipseShapePtr    = wxPyEllipseShapePtr
-wx.wxPyLineShapePtr       = wxPyLineShapePtr
-wx.wxPyPolygonShapePtr    = wxPyPolygonShapePtr
-wx.wxPyRectangleShapePtr  = wxPyRectangleShapePtr
-wx.wxPyShapeCanvasPtr     = wxPyShapeCanvasPtr
-wx.wxPyShapeEvtHandlerPtr = wxPyShapeEvtHandlerPtr
-wx.wxPyShapePtr           = wxPyShapePtr
-wx.wxPyTextShapePtr       = wxPyTextShapePtr
-wx.wxShapeRegionPtr       = wxShapeRegionPtr

wxPython/contrib/ogl/ogl.cpp

@@ -1,449 +0,0 @@
-/*
- * FILE : contrib/ogl/ogl.cpp
- * 
- * This file was automatically generated by :
- * Simplified Wrapper and Interface Generator (SWIG)
- * Version 1.1 (Build 883)
- * 
- * 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) __declspec(dllexport) a
-#   else
-#	if defined(__BORLANDC__)
-#	    define SWIGEXPORT(a) a _export
-#	else
-#	    define SWIGEXPORT(a) a
-#	endif
-#   endif
-#else
-#   define SWIGEXPORT(a) a
-#endif
-
-#include "Python.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern void SWIG_MakePtr(char *, void *, char *);
-extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
-extern char *SWIG_GetPtr(char *, void **, char *);
-extern char *SWIG_GetPtrObj(PyObject *, void **, char *);
-extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
-extern PyObject *SWIG_newvarlink(void);
-#ifdef __cplusplus
-}
-#endif
-#define SWIG_init    initoglc
-
-#define SWIG_name    "oglc"
-
-#include "export.h"
-#include "oglhelpers.h"
-
-
-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;
-}
-
-#if PYTHON_API_VERSION >= 1009
-    static char* wxStringErrorMsg = "String or Unicode type required";
-#else
-    static char* wxStringErrorMsg = "string type is required for parameter";
-#endif
-
-//---------------------------------------------------------------------------
-// This one will work for any class for the VERY generic cases, but beyond that
-// the helper needs to know more about the type.
-
-wxList* wxPy_wxListHelper(PyObject* pyList, char* className) {
-    wxPyTState* state = wxPyBeginBlockThreads();
-    if (!PyList_Check(pyList)) {
-        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
-        wxPyEndBlockThreads(state);
-        return NULL;
-    }
-    int count = PyList_Size(pyList);
-    wxList* list = new wxList;
-    if (! list) {
-        PyErr_SetString(PyExc_MemoryError, "Unable to allocate wxList object");
-        wxPyEndBlockThreads(state);
-        return NULL;
-    }
-    for (int x=0; x<count; x++) {
-        PyObject* pyo = PyList_GetItem(pyList, x);
-        wxObject* wxo = NULL;
-
-        if (SWIG_GetPtrObj(pyo, (void **)&wxo, className)) {
-            char errmsg[1024];
-            sprintf(errmsg, "Type error, expected list of %s objects", className);
-            PyErr_SetString(PyExc_TypeError, errmsg);
-             wxPyEndBlockThreads(state);
-            return NULL;
-        }
-        list->Append(wxo);
-    }
-    wxPyEndBlockThreads(state);
-    return list;
-}
-
-//---------------------------------------------------------------------------
-
-wxList* wxPy_wxRealPoint_ListHelper(PyObject* pyList) {
-    wxPyTState* state = wxPyBeginBlockThreads();
-    if (!PyList_Check(pyList)) {
-        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
-        wxPyEndBlockThreads(state);
-        return NULL;
-    }
-    int count = PyList_Size(pyList);
-    wxList* list = new wxList;
-    if (! list) {
-        PyErr_SetString(PyExc_MemoryError, "Unable to allocate wxList object");
-        wxPyEndBlockThreads(state);
-        return NULL;
-    }
-    for (int x=0; x<count; x++) {
-        PyObject* pyo = PyList_GetItem(pyList, x);
-
-        if (PyTuple_Check(pyo)) {
-            PyObject* o1 = PyNumber_Float(PyTuple_GetItem(pyo, 0));
-            PyObject* o2 = PyNumber_Float(PyTuple_GetItem(pyo, 1));
-
-            double val1 = (o1 ? PyFloat_AsDouble(o1) : 0.0);
-            double val2 = (o2 ? PyFloat_AsDouble(o2) : 0.0);
-
-            list->Append((wxObject*) new wxRealPoint(val1, val2));
-
-        } else {
-            wxRealPoint* wxo = NULL;
-            if (SWIG_GetPtrObj(pyo, (void **)&wxo, "_wxRealPoint_p")) {
-                PyErr_SetString(PyExc_TypeError, "Type error, expected list of wxRealPoint objects or 2-tuples");
-                wxPyEndBlockThreads(state);
-                return NULL;
-            }
-            list->Append((wxObject*) new wxRealPoint(*wxo));
-        }
-    }
-    wxPyEndBlockThreads(state);
-    return list;
-}
-
-
-//---------------------------------------------------------------------------
-
-IMPLEMENT_DYNAMIC_CLASS(wxPyShapeCanvas, wxShapeCanvas);
-IMPLEMENT_DYNAMIC_CLASS(wxPyShapeEvtHandler, wxShapeEvtHandler);
-IMPLEMENT_ABSTRACT_CLASS(wxPyShape, wxShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyRectangleShape, wxRectangleShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyControlPoint, wxControlPoint);
-IMPLEMENT_DYNAMIC_CLASS(wxPyBitmapShape, wxBitmapShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyDrawnShape, wxDrawnShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyCompositeShape, wxCompositeShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyDividedShape, wxDividedShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyDivisionShape, wxDivisionShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyEllipseShape, wxEllipseShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyCircleShape, wxCircleShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyLineShape, wxLineShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyPolygonShape, wxPolygonShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyTextShape, wxTextShape);
-
-//---------------------------------------------------------------------------
-
-extern "C" SWIGEXPORT(void) initoglbasicc();
-extern "C" SWIGEXPORT(void) initoglshapesc();
-extern "C" SWIGEXPORT(void) initoglshapes2c();
-extern "C" SWIGEXPORT(void) initoglcanvasc();
-#ifdef __cplusplus
-extern "C" {
-#endif
-static PyObject *_wrap_wxOGLInitialize(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    char *_kwnames[] = {  NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxOGLInitialize",_kwnames)) 
-        return NULL;
-{
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxOGLInitialize();
-
-    wxPy_END_ALLOW_THREADS;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-static PyObject *_wrap_wxOGLCleanUp(PyObject *self, PyObject *args, PyObject *kwargs) {
-    PyObject * _resultobj;
-    char *_kwnames[] = {  NULL };
-
-    self = self;
-    if(!PyArg_ParseTupleAndKeywords(args,kwargs,":wxOGLCleanUp",_kwnames)) 
-        return NULL;
-{
-    wxPy_BEGIN_ALLOW_THREADS;
-        wxOGLCleanUp();
-
-    wxPy_END_ALLOW_THREADS;
-}    Py_INCREF(Py_None);
-    _resultobj = Py_None;
-    return _resultobj;
-}
-
-static PyMethodDef oglcMethods[] = {
-	 { "wxOGLCleanUp", (PyCFunction) _wrap_wxOGLCleanUp, METH_VARARGS | METH_KEYWORDS },
-	 { "wxOGLInitialize", (PyCFunction) _wrap_wxOGLInitialize, METH_VARARGS | METH_KEYWORDS },
-	 { NULL, NULL }
-};
-#ifdef __cplusplus
-}
-#endif
-/*
- * This table is used by the pointer type-checker
- */
-static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
-    { "_signed_long","_long",0},
-    { "_wxPrintQuality","_wxCoord",0},
-    { "_wxPrintQuality","_int",0},
-    { "_wxPrintQuality","_signed_int",0},
-    { "_wxPrintQuality","_unsigned_int",0},
-    { "_wxPrintQuality","_wxWindowID",0},
-    { "_wxPrintQuality","_uint",0},
-    { "_wxPrintQuality","_EBool",0},
-    { "_wxPrintQuality","_size_t",0},
-    { "_wxPrintQuality","_time_t",0},
-    { "_byte","_unsigned_char",0},
-    { "_long","_unsigned_long",0},
-    { "_long","_signed_long",0},
-    { "_size_t","_wxCoord",0},
-    { "_size_t","_wxPrintQuality",0},
-    { "_size_t","_time_t",0},
-    { "_size_t","_unsigned_int",0},
-    { "_size_t","_int",0},
-    { "_size_t","_wxWindowID",0},
-    { "_size_t","_uint",0},
-    { "_uint","_wxCoord",0},
-    { "_uint","_wxPrintQuality",0},
-    { "_uint","_time_t",0},
-    { "_uint","_size_t",0},
-    { "_uint","_unsigned_int",0},
-    { "_uint","_int",0},
-    { "_uint","_wxWindowID",0},
-    { "_wxChar","_char",0},
-    { "_char","_wxChar",0},
-    { "_struct_wxNativeFontInfo","_wxNativeFontInfo",0},
-    { "_EBool","_wxCoord",0},
-    { "_EBool","_wxPrintQuality",0},
-    { "_EBool","_signed_int",0},
-    { "_EBool","_int",0},
-    { "_EBool","_wxWindowID",0},
-    { "_unsigned_long","_long",0},
-    { "_wxNativeFontInfo","_struct_wxNativeFontInfo",0},
-    { "_signed_int","_wxCoord",0},
-    { "_signed_int","_wxPrintQuality",0},
-    { "_signed_int","_EBool",0},
-    { "_signed_int","_wxWindowID",0},
-    { "_signed_int","_int",0},
-    { "_WXTYPE","_wxDateTime_t",0},
-    { "_WXTYPE","_short",0},
-    { "_WXTYPE","_signed_short",0},
-    { "_WXTYPE","_unsigned_short",0},
-    { "_unsigned_short","_wxDateTime_t",0},
-    { "_unsigned_short","_WXTYPE",0},
-    { "_unsigned_short","_short",0},
-    { "_signed_short","_WXTYPE",0},
-    { "_signed_short","_short",0},
-    { "_unsigned_char","_byte",0},
-    { "_unsigned_int","_wxCoord",0},
-    { "_unsigned_int","_wxPrintQuality",0},
-    { "_unsigned_int","_time_t",0},
-    { "_unsigned_int","_size_t",0},
-    { "_unsigned_int","_uint",0},
-    { "_unsigned_int","_wxWindowID",0},
-    { "_unsigned_int","_int",0},
-    { "_short","_wxDateTime_t",0},
-    { "_short","_WXTYPE",0},
-    { "_short","_unsigned_short",0},
-    { "_short","_signed_short",0},
-    { "_wxWindowID","_wxCoord",0},
-    { "_wxWindowID","_wxPrintQuality",0},
-    { "_wxWindowID","_time_t",0},
-    { "_wxWindowID","_size_t",0},
-    { "_wxWindowID","_EBool",0},
-    { "_wxWindowID","_uint",0},
-    { "_wxWindowID","_int",0},
-    { "_wxWindowID","_signed_int",0},
-    { "_wxWindowID","_unsigned_int",0},
-    { "_int","_wxCoord",0},
-    { "_int","_wxPrintQuality",0},
-    { "_int","_time_t",0},
-    { "_int","_size_t",0},
-    { "_int","_EBool",0},
-    { "_int","_uint",0},
-    { "_int","_wxWindowID",0},
-    { "_int","_unsigned_int",0},
-    { "_int","_signed_int",0},
-    { "_wxDateTime_t","_unsigned_short",0},
-    { "_wxDateTime_t","_short",0},
-    { "_wxDateTime_t","_WXTYPE",0},
-    { "_time_t","_wxCoord",0},
-    { "_time_t","_wxPrintQuality",0},
-    { "_time_t","_unsigned_int",0},
-    { "_time_t","_int",0},
-    { "_time_t","_wxWindowID",0},
-    { "_time_t","_uint",0},
-    { "_time_t","_size_t",0},
-    { "_wxCoord","_int",0},
-    { "_wxCoord","_signed_int",0},
-    { "_wxCoord","_unsigned_int",0},
-    { "_wxCoord","_wxWindowID",0},
-    { "_wxCoord","_uint",0},
-    { "_wxCoord","_EBool",0},
-    { "_wxCoord","_size_t",0},
-    { "_wxCoord","_time_t",0},
-    { "_wxCoord","_wxPrintQuality",0},
-{0,0,0}};
-
-static PyObject *SWIG_globals;
-#ifdef __cplusplus
-extern "C" 
-#endif
-SWIGEXPORT(void) initoglc() {
-	 PyObject *m, *d;
-	 SWIG_globals = SWIG_newvarlink();
-	 m = Py_InitModule("oglc", oglcMethods);
-	 d = PyModule_GetDict(m);
-	 PyDict_SetItemString(d,"KEY_SHIFT", PyInt_FromLong((long) KEY_SHIFT));
-	 PyDict_SetItemString(d,"KEY_CTRL", PyInt_FromLong((long) KEY_CTRL));
-	 PyDict_SetItemString(d,"ARROW_NONE", PyInt_FromLong((long) ARROW_NONE));
-	 PyDict_SetItemString(d,"ARROW_END", PyInt_FromLong((long) ARROW_END));
-	 PyDict_SetItemString(d,"ARROW_BOTH", PyInt_FromLong((long) ARROW_BOTH));
-	 PyDict_SetItemString(d,"ARROW_MIDDLE", PyInt_FromLong((long) ARROW_MIDDLE));
-	 PyDict_SetItemString(d,"ARROW_START", PyInt_FromLong((long) ARROW_START));
-	 PyDict_SetItemString(d,"ARROW_HOLLOW_CIRCLE", PyInt_FromLong((long) ARROW_HOLLOW_CIRCLE));
-	 PyDict_SetItemString(d,"ARROW_FILLED_CIRCLE", PyInt_FromLong((long) ARROW_FILLED_CIRCLE));
-	 PyDict_SetItemString(d,"ARROW_ARROW", PyInt_FromLong((long) ARROW_ARROW));
-	 PyDict_SetItemString(d,"ARROW_SINGLE_OBLIQUE", PyInt_FromLong((long) ARROW_SINGLE_OBLIQUE));
-	 PyDict_SetItemString(d,"ARROW_DOUBLE_OBLIQUE", PyInt_FromLong((long) ARROW_DOUBLE_OBLIQUE));
-	 PyDict_SetItemString(d,"ARROW_METAFILE", PyInt_FromLong((long) ARROW_METAFILE));
-	 PyDict_SetItemString(d,"ARROW_POSITION_END", PyInt_FromLong((long) ARROW_POSITION_END));
-	 PyDict_SetItemString(d,"ARROW_POSITION_START", PyInt_FromLong((long) ARROW_POSITION_START));
-	 PyDict_SetItemString(d,"CONTROL_POINT_VERTICAL", PyInt_FromLong((long) CONTROL_POINT_VERTICAL));
-	 PyDict_SetItemString(d,"CONTROL_POINT_HORIZONTAL", PyInt_FromLong((long) CONTROL_POINT_HORIZONTAL));
-	 PyDict_SetItemString(d,"CONTROL_POINT_DIAGONAL", PyInt_FromLong((long) CONTROL_POINT_DIAGONAL));
-	 PyDict_SetItemString(d,"CONTROL_POINT_ENDPOINT_TO", PyInt_FromLong((long) CONTROL_POINT_ENDPOINT_TO));
-	 PyDict_SetItemString(d,"CONTROL_POINT_ENDPOINT_FROM", PyInt_FromLong((long) CONTROL_POINT_ENDPOINT_FROM));
-	 PyDict_SetItemString(d,"CONTROL_POINT_LINE", PyInt_FromLong((long) CONTROL_POINT_LINE));
-	 PyDict_SetItemString(d,"FORMAT_NONE", PyInt_FromLong((long) FORMAT_NONE));
-	 PyDict_SetItemString(d,"FORMAT_CENTRE_HORIZ", PyInt_FromLong((long) FORMAT_CENTRE_HORIZ));
-	 PyDict_SetItemString(d,"FORMAT_CENTRE_VERT", PyInt_FromLong((long) FORMAT_CENTRE_VERT));
-	 PyDict_SetItemString(d,"FORMAT_SIZE_TO_CONTENTS", PyInt_FromLong((long) FORMAT_SIZE_TO_CONTENTS));
-	 PyDict_SetItemString(d,"LINE_ALIGNMENT_HORIZ", PyInt_FromLong((long) LINE_ALIGNMENT_HORIZ));
-	 PyDict_SetItemString(d,"LINE_ALIGNMENT_VERT", PyInt_FromLong((long) LINE_ALIGNMENT_VERT));
-	 PyDict_SetItemString(d,"LINE_ALIGNMENT_TO_NEXT_HANDLE", PyInt_FromLong((long) LINE_ALIGNMENT_TO_NEXT_HANDLE));
-	 PyDict_SetItemString(d,"LINE_ALIGNMENT_NONE", PyInt_FromLong((long) LINE_ALIGNMENT_NONE));
-	 PyDict_SetItemString(d,"SHADOW_NONE", PyInt_FromLong((long) SHADOW_NONE));
-	 PyDict_SetItemString(d,"SHADOW_LEFT", PyInt_FromLong((long) SHADOW_LEFT));
-	 PyDict_SetItemString(d,"SHADOW_RIGHT", PyInt_FromLong((long) SHADOW_RIGHT));
-	 PyDict_SetItemString(d,"OP_CLICK_LEFT", PyInt_FromLong((long) OP_CLICK_LEFT));
-	 PyDict_SetItemString(d,"OP_CLICK_RIGHT", PyInt_FromLong((long) OP_CLICK_RIGHT));
-	 PyDict_SetItemString(d,"OP_DRAG_LEFT", PyInt_FromLong((long) OP_DRAG_LEFT));
-	 PyDict_SetItemString(d,"OP_DRAG_RIGHT", PyInt_FromLong((long) OP_DRAG_RIGHT));
-	 PyDict_SetItemString(d,"OP_ALL", PyInt_FromLong((long) OP_ALL));
-	 PyDict_SetItemString(d,"ATTACHMENT_MODE_NONE", PyInt_FromLong((long) ATTACHMENT_MODE_NONE));
-	 PyDict_SetItemString(d,"ATTACHMENT_MODE_EDGE", PyInt_FromLong((long) ATTACHMENT_MODE_EDGE));
-	 PyDict_SetItemString(d,"ATTACHMENT_MODE_BRANCHING", PyInt_FromLong((long) ATTACHMENT_MODE_BRANCHING));
-	 PyDict_SetItemString(d,"BRANCHING_ATTACHMENT_NORMAL", PyInt_FromLong((long) BRANCHING_ATTACHMENT_NORMAL));
-	 PyDict_SetItemString(d,"BRANCHING_ATTACHMENT_BLOB", PyInt_FromLong((long) BRANCHING_ATTACHMENT_BLOB));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_CENTRED_VERTICALLY", PyInt_FromLong((long) gyCONSTRAINT_CENTRED_VERTICALLY));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_CENTRED_HORIZONTALLY", PyInt_FromLong((long) gyCONSTRAINT_CENTRED_HORIZONTALLY));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_CENTRED_BOTH", PyInt_FromLong((long) gyCONSTRAINT_CENTRED_BOTH));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_LEFT_OF", PyInt_FromLong((long) gyCONSTRAINT_LEFT_OF));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_RIGHT_OF", PyInt_FromLong((long) gyCONSTRAINT_RIGHT_OF));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_ABOVE", PyInt_FromLong((long) gyCONSTRAINT_ABOVE));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_BELOW", PyInt_FromLong((long) gyCONSTRAINT_BELOW));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_ALIGNED_TOP", PyInt_FromLong((long) gyCONSTRAINT_ALIGNED_TOP));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_ALIGNED_BOTTOM", PyInt_FromLong((long) gyCONSTRAINT_ALIGNED_BOTTOM));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_ALIGNED_LEFT", PyInt_FromLong((long) gyCONSTRAINT_ALIGNED_LEFT));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_ALIGNED_RIGHT", PyInt_FromLong((long) gyCONSTRAINT_ALIGNED_RIGHT));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_MIDALIGNED_TOP", PyInt_FromLong((long) gyCONSTRAINT_MIDALIGNED_TOP));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_MIDALIGNED_BOTTOM", PyInt_FromLong((long) gyCONSTRAINT_MIDALIGNED_BOTTOM));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_MIDALIGNED_LEFT", PyInt_FromLong((long) gyCONSTRAINT_MIDALIGNED_LEFT));
-	 PyDict_SetItemString(d,"gyCONSTRAINT_MIDALIGNED_RIGHT", PyInt_FromLong((long) gyCONSTRAINT_MIDALIGNED_RIGHT));
-	 PyDict_SetItemString(d,"DIVISION_SIDE_NONE", PyInt_FromLong((long) DIVISION_SIDE_NONE));
-	 PyDict_SetItemString(d,"DIVISION_SIDE_LEFT", PyInt_FromLong((long) DIVISION_SIDE_LEFT));
-	 PyDict_SetItemString(d,"DIVISION_SIDE_TOP", PyInt_FromLong((long) DIVISION_SIDE_TOP));
-	 PyDict_SetItemString(d,"DIVISION_SIDE_RIGHT", PyInt_FromLong((long) DIVISION_SIDE_RIGHT));
-	 PyDict_SetItemString(d,"DIVISION_SIDE_BOTTOM", PyInt_FromLong((long) DIVISION_SIDE_BOTTOM));
-
-
-    initoglbasicc();
-    initoglshapesc();
-    initoglshapes2c();
-    initoglcanvasc();
-
-
-    wxClassInfo::CleanUpClasses();
-    wxClassInfo::InitializeClasses();
-
-    wxPyPtrTypeMap_Add("wxControlPoint", "wxPyControlPoint");
-    wxPyPtrTypeMap_Add("wxShapeCanvas", "wxPyShapeCanvas");
-    wxPyPtrTypeMap_Add("wxShapeEvtHandler", "wxPyShapeEvtHandler");
-    wxPyPtrTypeMap_Add("wxShape", "wxPyShape");
-    wxPyPtrTypeMap_Add("wxRectangleShape", "wxPyRectangleShape");
-    wxPyPtrTypeMap_Add("wxDrawnShape", "wxPyDrawnShape");
-    wxPyPtrTypeMap_Add("wxCompositeShape", "wxPyCompositeShape");
-    wxPyPtrTypeMap_Add("wxDividedShape", "wxPyDividedShape");
-    wxPyPtrTypeMap_Add("wxDivisionShape", "wxPyDivisionShape");
-    wxPyPtrTypeMap_Add("wxEllipseShape", "wxPyEllipseShape");
-    wxPyPtrTypeMap_Add("wxCircleShape", "wxPyCircleShape");
-    wxPyPtrTypeMap_Add("wxLineShape", "wxPyLineShape");
-    wxPyPtrTypeMap_Add("wxPolygonShape", "wxPyPolygonShape");
-    wxPyPtrTypeMap_Add("wxTextShape", "wxPyTextShape");
-
-{
-   int i;
-   for (i = 0; _swig_mapping[i].n1; i++)
-        SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
-}
-}

wxPython/contrib/ogl/ogl.i

@@ -1,277 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        ogl.i
-// Purpose:     SWIG definitions for the wxWindows Object Graphics Library
-//
-// Author:      Robin Dunn
-//
-// Created:     30-June-1999
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-
-%module ogl
-
-%{
-#include "export.h"
-#include "oglhelpers.h"
-%}
-
-//---------------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-%extern wx.i
-%import windows.i
-%extern _defs.i
-%extern misc.i
-%extern gdi.i
-
-%include _ogldefs.i
-
-%import oglbasic.i
-%import oglshapes.i
-%import oglshapes2.i
-%import oglcanvas.i
-
-
-%pragma(python) code = "import wx"
-
-//---------------------------------------------------------------------------
-
-
-enum {
-    KEY_SHIFT,
-    KEY_CTRL,
-    ARROW_NONE,
-    ARROW_END,
-    ARROW_BOTH,
-    ARROW_MIDDLE,
-    ARROW_START,
-    ARROW_HOLLOW_CIRCLE,
-    ARROW_FILLED_CIRCLE,
-    ARROW_ARROW,
-    ARROW_SINGLE_OBLIQUE,
-    ARROW_DOUBLE_OBLIQUE,
-    ARROW_METAFILE,
-    ARROW_POSITION_END,
-    ARROW_POSITION_START,
-    CONTROL_POINT_VERTICAL,
-    CONTROL_POINT_HORIZONTAL,
-    CONTROL_POINT_DIAGONAL,
-    CONTROL_POINT_ENDPOINT_TO,
-    CONTROL_POINT_ENDPOINT_FROM,
-    CONTROL_POINT_LINE,
-    FORMAT_NONE,
-    FORMAT_CENTRE_HORIZ,
-    FORMAT_CENTRE_VERT,
-    FORMAT_SIZE_TO_CONTENTS,
-    LINE_ALIGNMENT_HORIZ,
-    LINE_ALIGNMENT_VERT,
-    LINE_ALIGNMENT_TO_NEXT_HANDLE,
-    LINE_ALIGNMENT_NONE,
-    SHADOW_NONE,
-    SHADOW_LEFT,
-    SHADOW_RIGHT,
-//      SHAPE_BASIC,
-//      SHAPE_RECTANGLE,
-//      SHAPE_ELLIPSE,
-//      SHAPE_POLYGON,
-//      SHAPE_CIRCLE,
-//      SHAPE_LINE,
-//      SHAPE_DIVIDED_RECTANGLE,
-//      SHAPE_COMPOSITE,
-//      SHAPE_CONTROL_POINT,
-//      SHAPE_DRAWN,
-//      SHAPE_DIVISION,
-//      SHAPE_LABEL_OBJECT,
-//      SHAPE_BITMAP,
-//      SHAPE_DIVIDED_OBJECT_CONTROL_POINT,
-//      OBJECT_REGION,
-    OP_CLICK_LEFT,
-    OP_CLICK_RIGHT,
-    OP_DRAG_LEFT,
-    OP_DRAG_RIGHT,
-    OP_ALL,
-    ATTACHMENT_MODE_NONE,
-    ATTACHMENT_MODE_EDGE,
-    ATTACHMENT_MODE_BRANCHING,
-    BRANCHING_ATTACHMENT_NORMAL,
-    BRANCHING_ATTACHMENT_BLOB,
-
-    gyCONSTRAINT_CENTRED_VERTICALLY,
-    gyCONSTRAINT_CENTRED_HORIZONTALLY,
-    gyCONSTRAINT_CENTRED_BOTH,
-    gyCONSTRAINT_LEFT_OF,
-    gyCONSTRAINT_RIGHT_OF,
-    gyCONSTRAINT_ABOVE,
-    gyCONSTRAINT_BELOW,
-    gyCONSTRAINT_ALIGNED_TOP,
-    gyCONSTRAINT_ALIGNED_BOTTOM,
-    gyCONSTRAINT_ALIGNED_LEFT,
-    gyCONSTRAINT_ALIGNED_RIGHT,
-    gyCONSTRAINT_MIDALIGNED_TOP,
-    gyCONSTRAINT_MIDALIGNED_BOTTOM,
-    gyCONSTRAINT_MIDALIGNED_LEFT,
-    gyCONSTRAINT_MIDALIGNED_RIGHT,
-
-    DIVISION_SIDE_NONE,
-    DIVISION_SIDE_LEFT,
-    DIVISION_SIDE_TOP,
-    DIVISION_SIDE_RIGHT,
-    DIVISION_SIDE_BOTTOM,
-
-};
-
-
-
-//---------------------------------------------------------------------------
-
-void wxOGLInitialize();
-void wxOGLCleanUp();
-
-
-%{
-//---------------------------------------------------------------------------
-// This one will work for any class for the VERY generic cases, but beyond that
-// the helper needs to know more about the type.
-
-wxList* wxPy_wxListHelper(PyObject* pyList, char* className) {
-    wxPyTState* state = wxPyBeginBlockThreads();
-    if (!PyList_Check(pyList)) {
-        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
-        wxPyEndBlockThreads(state);
-        return NULL;
-    }
-    int count = PyList_Size(pyList);
-    wxList* list = new wxList;
-    if (! list) {
-        PyErr_SetString(PyExc_MemoryError, "Unable to allocate wxList object");
-        wxPyEndBlockThreads(state);
-        return NULL;
-    }
-    for (int x=0; x<count; x++) {
-        PyObject* pyo = PyList_GetItem(pyList, x);
-        wxObject* wxo = NULL;
-
-        if (SWIG_GetPtrObj(pyo, (void **)&wxo, className)) {
-            char errmsg[1024];
-            sprintf(errmsg, "Type error, expected list of %s objects", className);
-            PyErr_SetString(PyExc_TypeError, errmsg);
-             wxPyEndBlockThreads(state);
-            return NULL;
-        }
-        list->Append(wxo);
-    }
-    wxPyEndBlockThreads(state);
-    return list;
-}
-
-//---------------------------------------------------------------------------
-
-wxList* wxPy_wxRealPoint_ListHelper(PyObject* pyList) {
-    wxPyTState* state = wxPyBeginBlockThreads();
-    if (!PyList_Check(pyList)) {
-        PyErr_SetString(PyExc_TypeError, "Expected a list object.");
-        wxPyEndBlockThreads(state);
-        return NULL;
-    }
-    int count = PyList_Size(pyList);
-    wxList* list = new wxList;
-    if (! list) {
-        PyErr_SetString(PyExc_MemoryError, "Unable to allocate wxList object");
-        wxPyEndBlockThreads(state);
-        return NULL;
-    }
-    for (int x=0; x<count; x++) {
-        PyObject* pyo = PyList_GetItem(pyList, x);
-
-        if (PyTuple_Check(pyo)) {
-            PyObject* o1 = PyNumber_Float(PyTuple_GetItem(pyo, 0));
-            PyObject* o2 = PyNumber_Float(PyTuple_GetItem(pyo, 1));
-
-            double val1 = (o1 ? PyFloat_AsDouble(o1) : 0.0);
-            double val2 = (o2 ? PyFloat_AsDouble(o2) : 0.0);
-
-            list->Append((wxObject*) new wxRealPoint(val1, val2));
-
-        } else {
-            wxRealPoint* wxo = NULL;
-            if (SWIG_GetPtrObj(pyo, (void **)&wxo, "_wxRealPoint_p")) {
-                PyErr_SetString(PyExc_TypeError, "Type error, expected list of wxRealPoint objects or 2-tuples");
-                wxPyEndBlockThreads(state);
-                return NULL;
-            }
-            list->Append((wxObject*) new wxRealPoint(*wxo));
-        }
-    }
-    wxPyEndBlockThreads(state);
-    return list;
-}
-
-
-//---------------------------------------------------------------------------
-
-IMPLEMENT_DYNAMIC_CLASS(wxPyShapeCanvas, wxShapeCanvas);
-IMPLEMENT_DYNAMIC_CLASS(wxPyShapeEvtHandler, wxShapeEvtHandler);
-IMPLEMENT_ABSTRACT_CLASS(wxPyShape, wxShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyRectangleShape, wxRectangleShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyControlPoint, wxControlPoint);
-IMPLEMENT_DYNAMIC_CLASS(wxPyBitmapShape, wxBitmapShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyDrawnShape, wxDrawnShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyCompositeShape, wxCompositeShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyDividedShape, wxDividedShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyDivisionShape, wxDivisionShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyEllipseShape, wxEllipseShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyCircleShape, wxCircleShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyLineShape, wxLineShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyPolygonShape, wxPolygonShape);
-IMPLEMENT_DYNAMIC_CLASS(wxPyTextShape, wxTextShape);
-
-//---------------------------------------------------------------------------
-
-extern "C" SWIGEXPORT(void) initoglbasicc();
-extern "C" SWIGEXPORT(void) initoglshapesc();
-extern "C" SWIGEXPORT(void) initoglshapes2c();
-extern "C" SWIGEXPORT(void) initoglcanvasc();
-%}
-
-
-%init %{
-
-    initoglbasicc();
-    initoglshapesc();
-    initoglshapes2c();
-    initoglcanvasc();
-
-
-    wxClassInfo::CleanUpClasses();
-    wxClassInfo::InitializeClasses();
-
-    wxPyPtrTypeMap_Add("wxControlPoint", "wxPyControlPoint");
-    wxPyPtrTypeMap_Add("wxShapeCanvas", "wxPyShapeCanvas");
-    wxPyPtrTypeMap_Add("wxShapeEvtHandler", "wxPyShapeEvtHandler");
-    wxPyPtrTypeMap_Add("wxShape", "wxPyShape");
-    wxPyPtrTypeMap_Add("wxRectangleShape", "wxPyRectangleShape");
-    wxPyPtrTypeMap_Add("wxDrawnShape", "wxPyDrawnShape");
-    wxPyPtrTypeMap_Add("wxCompositeShape", "wxPyCompositeShape");
-    wxPyPtrTypeMap_Add("wxDividedShape", "wxPyDividedShape");
-    wxPyPtrTypeMap_Add("wxDivisionShape", "wxPyDivisionShape");
-    wxPyPtrTypeMap_Add("wxEllipseShape", "wxPyEllipseShape");
-    wxPyPtrTypeMap_Add("wxCircleShape", "wxPyCircleShape");
-    wxPyPtrTypeMap_Add("wxLineShape", "wxPyLineShape");
-    wxPyPtrTypeMap_Add("wxPolygonShape", "wxPyPolygonShape");
-    wxPyPtrTypeMap_Add("wxTextShape", "wxPyTextShape");
-
-%}
-
-//----------------------------------------------------------------------
-// And this gets appended to the shadow class file.
-//----------------------------------------------------------------------
-
-%pragma(python) include="_oglextras.py";
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------

wxPython/contrib/ogl/ogl.py

@@ -1,170 +0,0 @@
-# This file was created automatically by SWIG.
-import oglc
-
-from misc import *
-
-from misc2 import *
-
-from windows import *
-
-from gdi import *
-
-from clip_dnd import *
-
-from events import *
-
-from streams import *
-
-from mdi import *
-
-from frames import *
-
-from stattool import *
-
-from controls import *
-
-from controls2 import *
-
-from windows2 import *
-
-from cmndlgs import *
-
-from windows3 import *
-
-from image import *
-
-from printfw import *
-
-from sizers import *
-
-from filesys import *
-
-from utils import *
-
-from oglbasic import *
-
-from oglshapes import *
-
-from oglshapes2 import *
-
-from oglcanvas import *
-import wx
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-wxOGLInitialize = oglc.wxOGLInitialize
-
-wxOGLCleanUp = oglc.wxOGLCleanUp
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-
-KEY_SHIFT = oglc.KEY_SHIFT
-KEY_CTRL = oglc.KEY_CTRL
-ARROW_NONE = oglc.ARROW_NONE
-ARROW_END = oglc.ARROW_END
-ARROW_BOTH = oglc.ARROW_BOTH
-ARROW_MIDDLE = oglc.ARROW_MIDDLE
-ARROW_START = oglc.ARROW_START
-ARROW_HOLLOW_CIRCLE = oglc.ARROW_HOLLOW_CIRCLE
-ARROW_FILLED_CIRCLE = oglc.ARROW_FILLED_CIRCLE
-ARROW_ARROW = oglc.ARROW_ARROW
-ARROW_SINGLE_OBLIQUE = oglc.ARROW_SINGLE_OBLIQUE
-ARROW_DOUBLE_OBLIQUE = oglc.ARROW_DOUBLE_OBLIQUE
-ARROW_METAFILE = oglc.ARROW_METAFILE
-ARROW_POSITION_END = oglc.ARROW_POSITION_END
-ARROW_POSITION_START = oglc.ARROW_POSITION_START
-CONTROL_POINT_VERTICAL = oglc.CONTROL_POINT_VERTICAL
-CONTROL_POINT_HORIZONTAL = oglc.CONTROL_POINT_HORIZONTAL
-CONTROL_POINT_DIAGONAL = oglc.CONTROL_POINT_DIAGONAL
-CONTROL_POINT_ENDPOINT_TO = oglc.CONTROL_POINT_ENDPOINT_TO
-CONTROL_POINT_ENDPOINT_FROM = oglc.CONTROL_POINT_ENDPOINT_FROM
-CONTROL_POINT_LINE = oglc.CONTROL_POINT_LINE
-FORMAT_NONE = oglc.FORMAT_NONE
-FORMAT_CENTRE_HORIZ = oglc.FORMAT_CENTRE_HORIZ
-FORMAT_CENTRE_VERT = oglc.FORMAT_CENTRE_VERT
-FORMAT_SIZE_TO_CONTENTS = oglc.FORMAT_SIZE_TO_CONTENTS
-LINE_ALIGNMENT_HORIZ = oglc.LINE_ALIGNMENT_HORIZ
-LINE_ALIGNMENT_VERT = oglc.LINE_ALIGNMENT_VERT
-LINE_ALIGNMENT_TO_NEXT_HANDLE = oglc.LINE_ALIGNMENT_TO_NEXT_HANDLE
-LINE_ALIGNMENT_NONE = oglc.LINE_ALIGNMENT_NONE
-SHADOW_NONE = oglc.SHADOW_NONE
-SHADOW_LEFT = oglc.SHADOW_LEFT
-SHADOW_RIGHT = oglc.SHADOW_RIGHT
-OP_CLICK_LEFT = oglc.OP_CLICK_LEFT
-OP_CLICK_RIGHT = oglc.OP_CLICK_RIGHT
-OP_DRAG_LEFT = oglc.OP_DRAG_LEFT
-OP_DRAG_RIGHT = oglc.OP_DRAG_RIGHT
-OP_ALL = oglc.OP_ALL
-ATTACHMENT_MODE_NONE = oglc.ATTACHMENT_MODE_NONE
-ATTACHMENT_MODE_EDGE = oglc.ATTACHMENT_MODE_EDGE
-ATTACHMENT_MODE_BRANCHING = oglc.ATTACHMENT_MODE_BRANCHING
-BRANCHING_ATTACHMENT_NORMAL = oglc.BRANCHING_ATTACHMENT_NORMAL
-BRANCHING_ATTACHMENT_BLOB = oglc.BRANCHING_ATTACHMENT_BLOB
-gyCONSTRAINT_CENTRED_VERTICALLY = oglc.gyCONSTRAINT_CENTRED_VERTICALLY
-gyCONSTRAINT_CENTRED_HORIZONTALLY = oglc.gyCONSTRAINT_CENTRED_HORIZONTALLY
-gyCONSTRAINT_CENTRED_BOTH = oglc.gyCONSTRAINT_CENTRED_BOTH
-gyCONSTRAINT_LEFT_OF = oglc.gyCONSTRAINT_LEFT_OF
-gyCONSTRAINT_RIGHT_OF = oglc.gyCONSTRAINT_RIGHT_OF
-gyCONSTRAINT_ABOVE = oglc.gyCONSTRAINT_ABOVE
-gyCONSTRAINT_BELOW = oglc.gyCONSTRAINT_BELOW
-gyCONSTRAINT_ALIGNED_TOP = oglc.gyCONSTRAINT_ALIGNED_TOP
-gyCONSTRAINT_ALIGNED_BOTTOM = oglc.gyCONSTRAINT_ALIGNED_BOTTOM
-gyCONSTRAINT_ALIGNED_LEFT = oglc.gyCONSTRAINT_ALIGNED_LEFT
-gyCONSTRAINT_ALIGNED_RIGHT = oglc.gyCONSTRAINT_ALIGNED_RIGHT
-gyCONSTRAINT_MIDALIGNED_TOP = oglc.gyCONSTRAINT_MIDALIGNED_TOP
-gyCONSTRAINT_MIDALIGNED_BOTTOM = oglc.gyCONSTRAINT_MIDALIGNED_BOTTOM
-gyCONSTRAINT_MIDALIGNED_LEFT = oglc.gyCONSTRAINT_MIDALIGNED_LEFT
-gyCONSTRAINT_MIDALIGNED_RIGHT = oglc.gyCONSTRAINT_MIDALIGNED_RIGHT
-DIVISION_SIDE_NONE = oglc.DIVISION_SIDE_NONE
-DIVISION_SIDE_LEFT = oglc.DIVISION_SIDE_LEFT
-DIVISION_SIDE_TOP = oglc.DIVISION_SIDE_TOP
-DIVISION_SIDE_RIGHT = oglc.DIVISION_SIDE_RIGHT
-DIVISION_SIDE_BOTTOM = oglc.DIVISION_SIDE_BOTTOM
-
-
-#-------------- USER INCLUDE -----------------------
-
-
-# aliases
-wxShapeCanvas =       wxPyShapeCanvas
-wxShapeEvtHandler =   wxPyShapeEvtHandler
-wxShape =             wxPyShape
-wxRectangleShape =    wxPyRectangleShape
-wxBitmapShape =       wxPyBitmapShape
-wxDrawnShape =        wxPyDrawnShape
-wxCompositeShape =    wxPyCompositeShape
-wxDividedShape =      wxPyDividedShape
-wxDivisionShape =     wxPyDivisionShape
-wxEllipseShape =      wxPyEllipseShape
-wxCircleShape =       wxPyCircleShape
-wxLineShape =         wxPyLineShape
-wxPolygonShape =      wxPyPolygonShape
-wxTextShape =         wxPyTextShape
-wxControlPoint =      wxPyControlPoint
-
-# Stuff these names into the wx namespace so wxPyConstructObject can find them
-import wx
-wx.wxArrowHeadPtr         = wxArrowHeadPtr
-wx.wxControlPointPtr      = wxPyControlPointPtr
-wx.wxDiagramPtr           = wxDiagramPtr
-wx.wxOGLConstraintPtr     = wxOGLConstraintPtr
-wx.wxPseudoMetaFilePtr    = wxPseudoMetaFile
-wx.wxPyBitmapShapePtr     = wxPyBitmapShapePtr
-wx.wxPyCircleShapePtr     = wxPyCircleShapePtr
-wx.wxPyCompositeShapePtr  = wxPyCompositeShapePtr
-wx.wxPyControlPointPtr    = wxPyControlPointPtr
-wx.wxPyDividedShapePtr    = wxPyDividedShapePtr
-wx.wxPyDivisionShapePtr   = wxPyDivisionShapePtr
-wx.wxPyDrawnShapePtr      = wxPyDrawnShapePtr
-wx.wxPyEllipseShapePtr    = wxPyEllipseShapePtr
-wx.wxPyLineShapePtr       = wxPyLineShapePtr
-wx.wxPyPolygonShapePtr    = wxPyPolygonShapePtr
-wx.wxPyRectangleShapePtr  = wxPyRectangleShapePtr
-wx.wxPyShapeCanvasPtr     = wxPyShapeCanvasPtr
-wx.wxPyShapeEvtHandlerPtr = wxPyShapeEvtHandlerPtr
-wx.wxPyShapePtr           = wxPyShapePtr
-wx.wxPyTextShapePtr       = wxPyTextShapePtr
-wx.wxShapeRegionPtr       = wxShapeRegionPtr

wxPython/contrib/ogl/oglbasic.i

@@ -1,401 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        oglbasic.i
-// Purpose:     SWIG definitions for the wxWindows Object Graphics Library
-//
-// Author:      Robin Dunn
-//
-// Created:     3-Sept-1999
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-
-%module oglbasic
-
-%{
-#include "export.h"
-#include "oglhelpers.h"
-%}
-
-//---------------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-%extern wx.i
-%import windows.i
-%extern _defs.i
-%extern misc.i
-%extern gdi.i
-
-%include _ogldefs.i
-
-//%extern oglcanvas.i
-
-
-%pragma(python) code = "import wx"
-%pragma(python) code = "from oglcanvas import wxPyShapeCanvasPtr"
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-
-
-class wxShapeRegion : public wxObject {
-public:
-    wxShapeRegion();
-    //~wxShapeRegion();
-
-    void SetText(const wxString& s);
-    void SetFont(wxFont *f);
-    void SetMinSize(double w, double h);
-    void SetSize(double w, double h);
-    void SetPosition(double x, double y);
-    void SetProportions(double x, double y);
-    void SetFormatMode(int mode);
-    void SetName(const wxString& s);
-    void SetColour(const wxString& col);
-
-    wxString GetText();
-    wxFont *GetFont();
-    void GetMinSize(double *OUTPUT, double *OUTPUT);
-    void GetProportion(double *OUTPUT, double *OUTPUT);
-    void GetSize(double *OUTPUT, double *OUTPUT);
-    void GetPosition(double *OUTPUT, double *OUTPUT);
-    int GetFormatMode();
-    wxString GetName();
-    wxString GetColour();
-    wxColour *GetActualColourObject();
-    wxList& GetFormattedText();
-    wxString GetPenColour();
-    int GetPenStyle();
-    void SetPenStyle(int style);
-    void SetPenColour(const wxString& col);
-    wxPen *GetActualPen();
-    double GetWidth();
-    double GetHeight();
-
-    void ClearText();
-};
-
-
-//---------------------------------------------------------------------------
-
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyShapeEvtHandler,wxShapeEvtHandler);
-%}
-
-
-class wxPyShapeEvtHandler : public wxObject {
-public:
-    wxPyShapeEvtHandler(wxPyShapeEvtHandler *prev = NULL,
-                        wxPyShape *shape = NULL);
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyShapeEvtHandler)"
-
-    %addmethods { void Destroy() { delete self; } }
-
-    void SetShape(wxPyShape *sh);
-    wxPyShape *GetShape();
-    void SetPreviousHandler(wxPyShapeEvtHandler* handler);
-    wxPyShapeEvtHandler* GetPreviousHandler();
-    wxPyShapeEvtHandler* CreateNewCopy();
-
-    void base_OnDelete();
-    void base_OnDraw(wxDC& dc);
-    void base_OnDrawContents(wxDC& dc);
-    void base_OnDrawBranches(wxDC& dc, bool erase = FALSE);
-    void base_OnMoveLinks(wxDC& dc);
-    void base_OnErase(wxDC& dc);
-    void base_OnEraseContents(wxDC& dc);
-    void base_OnHighlight(wxDC& dc);
-    void base_OnLeftClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnLeftDoubleClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnRightClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnSize(double x, double y);
-    bool base_OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
-    void base_OnDrawControlPoints(wxDC& dc);
-    void base_OnEraseControlPoints(wxDC& dc);
-    void base_OnMoveLink(wxDC& dc, bool moveControlPoints = TRUE);
-    void base_OnSizingDragLeft(wxPyControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingBeginDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingEndDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginSize(double w, double h);
-    void base_OnEndSize(double w, double h);
-//    void base_OnChangeAttachment(int attachment, wxPyLineShape* line, wxList& ordering);
-};
-
-//---------------------------------------------------------------------------
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyShape, wxShape);
-%}
-
-
-class wxPyShape : public wxPyShapeEvtHandler {
-public:
-    // wxPyShape(wxPyShapeCanvas *can = NULL);     abstract base class...
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyShape)"
-
-    %addmethods {
-        void Destroy() { delete self; }
-    }
-
-    void GetBoundingBoxMax(double *OUTPUT, double *OUTPUT);
-    void GetBoundingBoxMin(double *OUTPUT, double *OUTPUT);
-    bool GetPerimeterPoint(double x1, double y1,
-                           double x2, double y2,
-                           double *OUTPUT, double *OUTPUT);
-    wxPyShapeCanvas *GetCanvas();
-    void SetCanvas(wxPyShapeCanvas *the_canvas);
-    void AddToCanvas(wxPyShapeCanvas *the_canvas, wxPyShape *addAfter = NULL);
-    void InsertInCanvas(wxPyShapeCanvas *the_canvas);
-    void RemoveFromCanvas(wxPyShapeCanvas *the_canvas);
-    double GetX();
-    double GetY();
-    void SetX(double x);
-    void SetY(double y);
-    wxPyShape *GetParent();
-    void SetParent(wxPyShape *p);
-    wxPyShape *GetTopAncestor();
-
-
-    // wxList& GetChildren();
-    %addmethods {
-        PyObject* GetChildren() {
-            wxList& list = self->GetChildren();
-            return wxPy_ConvertList(&list, "wxPyShape");
-        }
-    }
-
-
-    void Unlink();
-    void SetDrawHandles(bool drawH);
-    bool GetDrawHandles();
-    void MakeControlPoints();
-    void DeleteControlPoints(wxDC *dc = NULL);
-    void ResetControlPoints();
-    wxPyShapeEvtHandler *GetEventHandler();
-    void SetEventHandler(wxPyShapeEvtHandler *handler);
-    void MakeMandatoryControlPoints();
-    void ResetMandatoryControlPoints();
-    bool Recompute();
-    void CalculateSize();
-    void Select(bool select = TRUE, wxDC* dc = NULL);
-    void SetHighlight(bool hi = TRUE, bool recurse = FALSE);
-    bool IsHighlighted() ;
-    bool Selected();
-    bool AncestorSelected();
-    void SetSensitivityFilter(int sens = OP_ALL, bool recursive = FALSE);
-    int GetSensitivityFilter();
-    void SetDraggable(bool drag, bool recursive = FALSE);
-    void SetFixedSize(bool x, bool y);
-    void GetFixedSize(bool *OUTPUT, bool *OUTPUT) ;
-    bool GetFixedWidth();
-    bool GetFixedHeight();
-    void SetSpaceAttachments(bool sp);
-    bool GetSpaceAttachments() ;
-    void SetShadowMode(int mode, bool redraw = FALSE);
-    int GetShadowMode();
-    bool HitTest(double x, double y, int *OUTPUT, double *OUTPUT);
-    void SetCentreResize(bool cr);
-    bool GetCentreResize();
-    void SetMaintainAspectRatio(bool ar);
-    bool GetMaintainAspectRatio();
-
-
-    // wxList& GetLines();
-    %addmethods {
-        PyObject* GetLines() {
-            wxList& list = self->GetLines();
-            return wxPy_ConvertList(&list, "wxPyLineShape");
-        }
-    }
-
-    void SetDisableLabel(bool flag);
-    bool GetDisableLabel();
-    void SetAttachmentMode(int mode);
-    int GetAttachmentMode();
-    void SetId(long i);
-    long GetId();
-
-    void SetPen(wxPen *pen);
-    void SetBrush(wxBrush *brush);
-
-
-    // void SetClientData(wxObject *client_data);
-    // wxObject *GetClientData();
-    %addmethods {
-        void SetClientData(PyObject* userData) {
-            wxPyUserData* data = NULL;
-            if (userData)
-                data = new wxPyUserData(userData);
-            self->SetClientData(data);
-        }
-
-        PyObject* GetClientData() {
-            wxPyUserData* data = (wxPyUserData*)self->GetClientData();
-            if (data) {
-                Py_INCREF(data->m_obj);
-                return data->m_obj;
-            } else {
-                Py_INCREF(Py_None);
-                return Py_None;
-            }
-        }
-    }
-
-    void Show(bool show);
-    bool IsShown();
-    void Move(wxDC& dc, double x1, double y1, bool display = TRUE);
-    void Erase(wxDC& dc);
-    void EraseContents(wxDC& dc);
-    void Draw(wxDC& dc);
-    void Flash();
-    void MoveLinks(wxDC& dc);
-    void DrawContents(wxDC& dc);
-    void SetSize(double x, double y, bool recursive = TRUE);
-    void SetAttachmentSize(double x, double y);
-    void Attach(wxPyShapeCanvas *can);
-    void Detach();
-    bool Constrain();
-    void AddLine(wxPyLineShape *line, wxPyShape *other,
-                 int attachFrom = 0, int attachTo = 0,
-                 int positionFrom = -1, int positionTo = -1);
-    int GetLinePosition(wxPyLineShape* line);
-    void AddText(const wxString& string);
-    wxPen *GetPen();
-    wxBrush *GetBrush();
-    void SetDefaultRegionSize();
-    void FormatText(wxDC& dc, const wxString& s, int regionId = 0);
-    void SetFormatMode(int mode, int regionId = 0);
-    int GetFormatMode(int regionId = 0);
-    void SetFont(wxFont *font, int regionId = 0);
-    wxFont *GetFont(int regionId = 0);
-    void SetTextColour(const wxString& colour, int regionId = 0);
-    wxString GetTextColour(int regionId = 0);
-    int GetNumberOfTextRegions();
-    void SetRegionName(const wxString& name, int regionId = 0);
-    wxString GetRegionName(int regionId);
-    int GetRegionId(const wxString& name);
-    void NameRegions(const wxString& parentName = "");
-
-    // wxList& GetRegions();
-    %addmethods {
-        PyObject* GetRegions() {
-            wxList& list = self->GetRegions();
-            return wxPy_ConvertList(&list, "wxShapeRegion");
-        }
-    }
-
-    void AddRegion(wxShapeRegion *region);
-    void ClearRegions();
-    void AssignNewIds();
-    wxPyShape *FindRegion(const wxString& regionName, int *OUTPUT);
-    void FindRegionNames(wxStringList& list);
-    void ClearText(int regionId = 0);
-    void RemoveLine(wxPyLineShape *line);
-
-#ifdef PROLOGIO
-    void WriteAttributes(wxExpr *clause);
-    void ReadAttributes(wxExpr *clause);
-    void ReadConstraints(wxExpr *clause, wxExprDatabase *database);
-    void WriteRegions(wxExpr *clause);
-    void ReadRegions(wxExpr *clause);
-#endif
-
-    bool GetAttachmentPosition(int attachment, double *OUTPUT, double *OUTPUT,
-                               int nth = 0, int no_arcs = 1, wxPyLineShape *line = NULL);
-    int GetNumberOfAttachments();
-    bool AttachmentIsValid(int attachment);
-    bool GetAttachmentPositionEdge(int attachment, double *OUTPUT, double *OUTPUT,
-                                   int nth = 0, int no_arcs = 1, wxPyLineShape *line = NULL);
-    wxRealPoint CalcSimpleAttachment(const wxRealPoint& pt1, const wxRealPoint& pt2,
-                                     int nth, int noArcs, wxPyLineShape* line);
-    bool AttachmentSortTest(int attachmentPoint, const wxRealPoint& pt1, const wxRealPoint& pt2);
-    void EraseLinks(wxDC& dc, int attachment = -1, bool recurse = FALSE);
-    void DrawLinks(wxDC& dc, int attachment = -1, bool recurse = FALSE);
-    bool MoveLineToNewAttachment(wxDC& dc, wxPyLineShape *to_move,
-                                 double x, double y);
-
-    //void ApplyAttachmentOrdering(wxList& linesToSort);
-    %addmethods {
-        void ApplyAttachmentOrdering(PyObject* linesToSort) {
-            wxList* list = wxPy_wxListHelper(linesToSort, "_wxPyLineShape_p");
-            self->ApplyAttachmentOrdering(*list);
-            delete list;
-        }
-    }
-
-    wxRealPoint GetBranchingAttachmentRoot(int attachment);
-    bool GetBranchingAttachmentInfo(int attachment, wxRealPoint& root, wxRealPoint& neck,
-                                    wxRealPoint& shoulder1, wxRealPoint& shoulder2);
-    bool GetBranchingAttachmentPoint(int attachment, int n, wxRealPoint& attachmentPoint,
-                                     wxRealPoint& stemPoint);
-    int GetAttachmentLineCount(int attachment);
-    void SetBranchNeckLength(int len);
-    int GetBranchNeckLength();
-    void SetBranchStemLength(int len);
-    int GetBranchStemLength();
-    void SetBranchSpacing(int len);
-    int GetBranchSpacing();
-    void SetBranchStyle(long style);
-    long GetBranchStyle();
-    int PhysicalToLogicalAttachment(int physicalAttachment);
-    int LogicalToPhysicalAttachment(int logicalAttachment);
-    bool Draggable();
-    bool HasDescendant(wxPyShape *image);
-    wxPyShape *CreateNewCopy(bool resetMapping = TRUE, bool recompute = TRUE);
-    void Copy(wxPyShape& copy);
-    void CopyWithHandler(wxPyShape& copy);
-    void Rotate(double x, double y, double theta);
-    double GetRotation();
-    void ClearAttachments();
-    void Recentre(wxDC& dc);
-    void ClearPointList(wxList& list);
-
-    void base_OnDelete();
-    void base_OnDraw(wxDC& dc);
-    void base_OnDrawContents(wxDC& dc);
-    void base_OnDrawBranches(wxDC& dc, bool erase = FALSE);
-    void base_OnMoveLinks(wxDC& dc);
-    void base_OnErase(wxDC& dc);
-    void base_OnEraseContents(wxDC& dc);
-    void base_OnHighlight(wxDC& dc);
-    void base_OnLeftClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnLeftDoubleClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnRightClick(double x, double y, int keys = 0, int attachment = 0);
-    void base_OnSize(double x, double y);
-    bool base_OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display = TRUE);
-    void base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragLeft(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnEndDragRight(double x, double y, int keys=0, int attachment = 0);
-    void base_OnDrawOutline(wxDC& dc, double x, double y, double w, double h);
-    void base_OnDrawControlPoints(wxDC& dc);
-    void base_OnEraseControlPoints(wxDC& dc);
-    void base_OnMoveLink(wxDC& dc, bool moveControlPoints = TRUE);
-    void base_OnSizingDragLeft(wxPyControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingBeginDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnSizingEndDragLeft(wxPyControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
-    void base_OnBeginSize(double w, double h);
-    void base_OnEndSize(double w, double h);
-//    void base_OnChangeAttachment(int attachment, wxPyLineShape* line, wxList& ordering);
-};
-
-//---------------------------------------------------------------------------
-

wxPython/contrib/ogl/oglbasic.py

@@ -1,789 +0,0 @@
-# This file was created automatically by SWIG.
-import oglbasicc
-
-from misc import *
-
-from misc2 import *
-
-from windows import *
-
-from gdi import *
-
-from clip_dnd import *
-
-from events import *
-
-from streams import *
-
-from mdi import *
-
-from frames import *
-
-from stattool import *
-
-from controls import *
-
-from controls2 import *
-
-from windows2 import *
-
-from cmndlgs import *
-
-from windows3 import *
-
-from image import *
-
-from printfw import *
-
-from sizers import *
-
-from filesys import *
-
-from utils import *
-import wx
-from oglcanvas import wxPyShapeCanvasPtr
-class wxShapeRegionPtr(wxObjectPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def SetText(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetText,(self,) + _args, _kwargs)
-        return val
-    def SetFont(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetFont,(self,) + _args, _kwargs)
-        return val
-    def SetMinSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetMinSize,(self,) + _args, _kwargs)
-        return val
-    def SetSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetSize,(self,) + _args, _kwargs)
-        return val
-    def SetPosition(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetPosition,(self,) + _args, _kwargs)
-        return val
-    def SetProportions(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetProportions,(self,) + _args, _kwargs)
-        return val
-    def SetFormatMode(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetFormatMode,(self,) + _args, _kwargs)
-        return val
-    def SetName(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetName,(self,) + _args, _kwargs)
-        return val
-    def SetColour(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetColour,(self,) + _args, _kwargs)
-        return val
-    def GetText(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetText,(self,) + _args, _kwargs)
-        return val
-    def GetFont(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetFont,(self,) + _args, _kwargs)
-        if val: val = wxFontPtr(val) 
-        return val
-    def GetMinSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetMinSize,(self,) + _args, _kwargs)
-        return val
-    def GetProportion(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetProportion,(self,) + _args, _kwargs)
-        return val
-    def GetSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetSize,(self,) + _args, _kwargs)
-        return val
-    def GetPosition(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetPosition,(self,) + _args, _kwargs)
-        return val
-    def GetFormatMode(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetFormatMode,(self,) + _args, _kwargs)
-        return val
-    def GetName(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetName,(self,) + _args, _kwargs)
-        return val
-    def GetColour(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetColour,(self,) + _args, _kwargs)
-        return val
-    def GetActualColourObject(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetActualColourObject,(self,) + _args, _kwargs)
-        if val: val = wxColourPtr(val) 
-        return val
-    def GetFormattedText(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetFormattedText,(self,) + _args, _kwargs)
-        return val
-    def GetPenColour(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetPenColour,(self,) + _args, _kwargs)
-        return val
-    def GetPenStyle(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetPenStyle,(self,) + _args, _kwargs)
-        return val
-    def SetPenStyle(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetPenStyle,(self,) + _args, _kwargs)
-        return val
-    def SetPenColour(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_SetPenColour,(self,) + _args, _kwargs)
-        return val
-    def GetActualPen(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetActualPen,(self,) + _args, _kwargs)
-        if val: val = wxPenPtr(val) 
-        return val
-    def GetWidth(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetWidth,(self,) + _args, _kwargs)
-        return val
-    def GetHeight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_GetHeight,(self,) + _args, _kwargs)
-        return val
-    def ClearText(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxShapeRegion_ClearText,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxShapeRegion instance at %s>" % (self.this,)
-class wxShapeRegion(wxShapeRegionPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglbasicc.new_wxShapeRegion,_args,_kwargs)
-        self.thisown = 1
-
-
-
-
-class wxPyShapeEvtHandlerPtr(wxObjectPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def _setSelf(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler__setSelf,(self,) + _args, _kwargs)
-        return val
-    def Destroy(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_Destroy,(self,) + _args, _kwargs)
-        return val
-    def SetShape(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_SetShape,(self,) + _args, _kwargs)
-        return val
-    def GetShape(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_GetShape,(self,) + _args, _kwargs)
-        return val
-    def SetPreviousHandler(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_SetPreviousHandler,(self,) + _args, _kwargs)
-        return val
-    def GetPreviousHandler(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_GetPreviousHandler,(self,) + _args, _kwargs)
-        return val
-    def CreateNewCopy(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_CreateNewCopy,(self,) + _args, _kwargs)
-        return val
-    def base_OnDelete(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnDelete,(self,) + _args, _kwargs)
-        return val
-    def base_OnDraw(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnDraw,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawContents(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnDrawContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawBranches(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnDrawBranches,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLinks(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnMoveLinks,(self,) + _args, _kwargs)
-        return val
-    def base_OnErase(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnErase,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseContents(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnEraseContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnHighlight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnHighlight,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftClick(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnLeftClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftDoubleClick(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnLeftDoubleClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnRightClick(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnRightClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePre(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnMovePre,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePost(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnMovePost,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragRight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragRight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnBeginDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragRight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnEndDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawOutline(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnDrawOutline,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawControlPoints(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnDrawControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseControlPoints(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnEraseControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLink(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnMoveLink,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnSizingDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnSizingBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnSizingEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnBeginSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShapeEvtHandler_base_OnEndSize,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxPyShapeEvtHandler instance at %s>" % (self.this,)
-class wxPyShapeEvtHandler(wxPyShapeEvtHandlerPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglbasicc.new_wxPyShapeEvtHandler,_args,_kwargs)
-        self.thisown = 1
-        self._setSelf(self, wxPyShapeEvtHandler)
-
-
-
-
-class wxPyShapePtr(wxPyShapeEvtHandlerPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def _setSelf(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape__setSelf,(self,) + _args, _kwargs)
-        return val
-    def Destroy(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Destroy,(self,) + _args, _kwargs)
-        return val
-    def GetBoundingBoxMax(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBoundingBoxMax,(self,) + _args, _kwargs)
-        return val
-    def GetBoundingBoxMin(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBoundingBoxMin,(self,) + _args, _kwargs)
-        return val
-    def GetPerimeterPoint(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetPerimeterPoint,(self,) + _args, _kwargs)
-        return val
-    def GetCanvas(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetCanvas,(self,) + _args, _kwargs)
-        return val
-    def SetCanvas(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetCanvas,(self,) + _args, _kwargs)
-        return val
-    def AddToCanvas(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_AddToCanvas,(self,) + _args, _kwargs)
-        return val
-    def InsertInCanvas(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_InsertInCanvas,(self,) + _args, _kwargs)
-        return val
-    def RemoveFromCanvas(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_RemoveFromCanvas,(self,) + _args, _kwargs)
-        return val
-    def GetX(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetX,(self,) + _args, _kwargs)
-        return val
-    def GetY(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetY,(self,) + _args, _kwargs)
-        return val
-    def SetX(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetX,(self,) + _args, _kwargs)
-        return val
-    def SetY(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetY,(self,) + _args, _kwargs)
-        return val
-    def GetParent(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetParent,(self,) + _args, _kwargs)
-        return val
-    def SetParent(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetParent,(self,) + _args, _kwargs)
-        return val
-    def GetTopAncestor(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetTopAncestor,(self,) + _args, _kwargs)
-        return val
-    def GetChildren(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetChildren,(self,) + _args, _kwargs)
-        return val
-    def Unlink(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Unlink,(self,) + _args, _kwargs)
-        return val
-    def SetDrawHandles(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetDrawHandles,(self,) + _args, _kwargs)
-        return val
-    def GetDrawHandles(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetDrawHandles,(self,) + _args, _kwargs)
-        return val
-    def MakeControlPoints(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_MakeControlPoints,(self,) + _args, _kwargs)
-        return val
-    def DeleteControlPoints(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_DeleteControlPoints,(self,) + _args, _kwargs)
-        return val
-    def ResetControlPoints(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_ResetControlPoints,(self,) + _args, _kwargs)
-        return val
-    def GetEventHandler(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetEventHandler,(self,) + _args, _kwargs)
-        return val
-    def SetEventHandler(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetEventHandler,(self,) + _args, _kwargs)
-        return val
-    def MakeMandatoryControlPoints(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_MakeMandatoryControlPoints,(self,) + _args, _kwargs)
-        return val
-    def ResetMandatoryControlPoints(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_ResetMandatoryControlPoints,(self,) + _args, _kwargs)
-        return val
-    def Recompute(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Recompute,(self,) + _args, _kwargs)
-        return val
-    def CalculateSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_CalculateSize,(self,) + _args, _kwargs)
-        return val
-    def Select(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Select,(self,) + _args, _kwargs)
-        return val
-    def SetHighlight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetHighlight,(self,) + _args, _kwargs)
-        return val
-    def IsHighlighted(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_IsHighlighted,(self,) + _args, _kwargs)
-        return val
-    def Selected(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Selected,(self,) + _args, _kwargs)
-        return val
-    def AncestorSelected(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_AncestorSelected,(self,) + _args, _kwargs)
-        return val
-    def SetSensitivityFilter(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetSensitivityFilter,(self,) + _args, _kwargs)
-        return val
-    def GetSensitivityFilter(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetSensitivityFilter,(self,) + _args, _kwargs)
-        return val
-    def SetDraggable(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetDraggable,(self,) + _args, _kwargs)
-        return val
-    def SetFixedSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetFixedSize,(self,) + _args, _kwargs)
-        return val
-    def GetFixedSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetFixedSize,(self,) + _args, _kwargs)
-        return val
-    def GetFixedWidth(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetFixedWidth,(self,) + _args, _kwargs)
-        return val
-    def GetFixedHeight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetFixedHeight,(self,) + _args, _kwargs)
-        return val
-    def SetSpaceAttachments(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetSpaceAttachments,(self,) + _args, _kwargs)
-        return val
-    def GetSpaceAttachments(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetSpaceAttachments,(self,) + _args, _kwargs)
-        return val
-    def SetShadowMode(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetShadowMode,(self,) + _args, _kwargs)
-        return val
-    def GetShadowMode(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetShadowMode,(self,) + _args, _kwargs)
-        return val
-    def HitTest(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_HitTest,(self,) + _args, _kwargs)
-        return val
-    def SetCentreResize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetCentreResize,(self,) + _args, _kwargs)
-        return val
-    def GetCentreResize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetCentreResize,(self,) + _args, _kwargs)
-        return val
-    def SetMaintainAspectRatio(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetMaintainAspectRatio,(self,) + _args, _kwargs)
-        return val
-    def GetMaintainAspectRatio(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetMaintainAspectRatio,(self,) + _args, _kwargs)
-        return val
-    def GetLines(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetLines,(self,) + _args, _kwargs)
-        return val
-    def SetDisableLabel(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetDisableLabel,(self,) + _args, _kwargs)
-        return val
-    def GetDisableLabel(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetDisableLabel,(self,) + _args, _kwargs)
-        return val
-    def SetAttachmentMode(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetAttachmentMode,(self,) + _args, _kwargs)
-        return val
-    def GetAttachmentMode(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetAttachmentMode,(self,) + _args, _kwargs)
-        return val
-    def SetId(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetId,(self,) + _args, _kwargs)
-        return val
-    def GetId(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetId,(self,) + _args, _kwargs)
-        return val
-    def SetPen(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetPen,(self,) + _args, _kwargs)
-        return val
-    def SetBrush(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetBrush,(self,) + _args, _kwargs)
-        return val
-    def SetClientData(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetClientData,(self,) + _args, _kwargs)
-        return val
-    def GetClientData(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetClientData,(self,) + _args, _kwargs)
-        return val
-    def Show(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Show,(self,) + _args, _kwargs)
-        return val
-    def IsShown(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_IsShown,(self,) + _args, _kwargs)
-        return val
-    def Move(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Move,(self,) + _args, _kwargs)
-        return val
-    def Erase(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Erase,(self,) + _args, _kwargs)
-        return val
-    def EraseContents(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_EraseContents,(self,) + _args, _kwargs)
-        return val
-    def Draw(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Draw,(self,) + _args, _kwargs)
-        return val
-    def Flash(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Flash,(self,) + _args, _kwargs)
-        return val
-    def MoveLinks(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_MoveLinks,(self,) + _args, _kwargs)
-        return val
-    def DrawContents(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_DrawContents,(self,) + _args, _kwargs)
-        return val
-    def SetSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetSize,(self,) + _args, _kwargs)
-        return val
-    def SetAttachmentSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetAttachmentSize,(self,) + _args, _kwargs)
-        return val
-    def Attach(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Attach,(self,) + _args, _kwargs)
-        return val
-    def Detach(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Detach,(self,) + _args, _kwargs)
-        return val
-    def Constrain(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Constrain,(self,) + _args, _kwargs)
-        return val
-    def AddLine(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_AddLine,(self,) + _args, _kwargs)
-        return val
-    def GetLinePosition(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetLinePosition,(self,) + _args, _kwargs)
-        return val
-    def AddText(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_AddText,(self,) + _args, _kwargs)
-        return val
-    def GetPen(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetPen,(self,) + _args, _kwargs)
-        if val: val = wxPenPtr(val) 
-        return val
-    def GetBrush(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBrush,(self,) + _args, _kwargs)
-        if val: val = wxBrushPtr(val) 
-        return val
-    def SetDefaultRegionSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetDefaultRegionSize,(self,) + _args, _kwargs)
-        return val
-    def FormatText(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_FormatText,(self,) + _args, _kwargs)
-        return val
-    def SetFormatMode(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetFormatMode,(self,) + _args, _kwargs)
-        return val
-    def GetFormatMode(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetFormatMode,(self,) + _args, _kwargs)
-        return val
-    def SetFont(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetFont,(self,) + _args, _kwargs)
-        return val
-    def GetFont(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetFont,(self,) + _args, _kwargs)
-        if val: val = wxFontPtr(val) 
-        return val
-    def SetTextColour(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetTextColour,(self,) + _args, _kwargs)
-        return val
-    def GetTextColour(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetTextColour,(self,) + _args, _kwargs)
-        return val
-    def GetNumberOfTextRegions(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetNumberOfTextRegions,(self,) + _args, _kwargs)
-        return val
-    def SetRegionName(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetRegionName,(self,) + _args, _kwargs)
-        return val
-    def GetRegionName(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetRegionName,(self,) + _args, _kwargs)
-        return val
-    def GetRegionId(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetRegionId,(self,) + _args, _kwargs)
-        return val
-    def NameRegions(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_NameRegions,(self,) + _args, _kwargs)
-        return val
-    def GetRegions(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetRegions,(self,) + _args, _kwargs)
-        return val
-    def AddRegion(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_AddRegion,(self,) + _args, _kwargs)
-        return val
-    def ClearRegions(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_ClearRegions,(self,) + _args, _kwargs)
-        return val
-    def AssignNewIds(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_AssignNewIds,(self,) + _args, _kwargs)
-        return val
-    def FindRegion(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_FindRegion,(self,) + _args, _kwargs)
-        return val
-    def FindRegionNames(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_FindRegionNames,(self,) + _args, _kwargs)
-        return val
-    def ClearText(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_ClearText,(self,) + _args, _kwargs)
-        return val
-    def RemoveLine(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_RemoveLine,(self,) + _args, _kwargs)
-        return val
-    def GetAttachmentPosition(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetAttachmentPosition,(self,) + _args, _kwargs)
-        return val
-    def GetNumberOfAttachments(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetNumberOfAttachments,(self,) + _args, _kwargs)
-        return val
-    def AttachmentIsValid(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_AttachmentIsValid,(self,) + _args, _kwargs)
-        return val
-    def GetAttachmentPositionEdge(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetAttachmentPositionEdge,(self,) + _args, _kwargs)
-        return val
-    def CalcSimpleAttachment(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_CalcSimpleAttachment,(self,) + _args, _kwargs)
-        if val: val = wxRealPointPtr(val) ; val.thisown = 1
-        return val
-    def AttachmentSortTest(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_AttachmentSortTest,(self,) + _args, _kwargs)
-        return val
-    def EraseLinks(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_EraseLinks,(self,) + _args, _kwargs)
-        return val
-    def DrawLinks(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_DrawLinks,(self,) + _args, _kwargs)
-        return val
-    def MoveLineToNewAttachment(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_MoveLineToNewAttachment,(self,) + _args, _kwargs)
-        return val
-    def ApplyAttachmentOrdering(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_ApplyAttachmentOrdering,(self,) + _args, _kwargs)
-        return val
-    def GetBranchingAttachmentRoot(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBranchingAttachmentRoot,(self,) + _args, _kwargs)
-        if val: val = wxRealPointPtr(val) ; val.thisown = 1
-        return val
-    def GetBranchingAttachmentInfo(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBranchingAttachmentInfo,(self,) + _args, _kwargs)
-        return val
-    def GetBranchingAttachmentPoint(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBranchingAttachmentPoint,(self,) + _args, _kwargs)
-        return val
-    def GetAttachmentLineCount(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetAttachmentLineCount,(self,) + _args, _kwargs)
-        return val
-    def SetBranchNeckLength(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetBranchNeckLength,(self,) + _args, _kwargs)
-        return val
-    def GetBranchNeckLength(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBranchNeckLength,(self,) + _args, _kwargs)
-        return val
-    def SetBranchStemLength(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetBranchStemLength,(self,) + _args, _kwargs)
-        return val
-    def GetBranchStemLength(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBranchStemLength,(self,) + _args, _kwargs)
-        return val
-    def SetBranchSpacing(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetBranchSpacing,(self,) + _args, _kwargs)
-        return val
-    def GetBranchSpacing(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBranchSpacing,(self,) + _args, _kwargs)
-        return val
-    def SetBranchStyle(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_SetBranchStyle,(self,) + _args, _kwargs)
-        return val
-    def GetBranchStyle(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetBranchStyle,(self,) + _args, _kwargs)
-        return val
-    def PhysicalToLogicalAttachment(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_PhysicalToLogicalAttachment,(self,) + _args, _kwargs)
-        return val
-    def LogicalToPhysicalAttachment(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_LogicalToPhysicalAttachment,(self,) + _args, _kwargs)
-        return val
-    def Draggable(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Draggable,(self,) + _args, _kwargs)
-        return val
-    def HasDescendant(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_HasDescendant,(self,) + _args, _kwargs)
-        return val
-    def CreateNewCopy(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_CreateNewCopy,(self,) + _args, _kwargs)
-        return val
-    def Copy(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Copy,(self,) + _args, _kwargs)
-        return val
-    def CopyWithHandler(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_CopyWithHandler,(self,) + _args, _kwargs)
-        return val
-    def Rotate(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Rotate,(self,) + _args, _kwargs)
-        return val
-    def GetRotation(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_GetRotation,(self,) + _args, _kwargs)
-        return val
-    def ClearAttachments(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_ClearAttachments,(self,) + _args, _kwargs)
-        return val
-    def Recentre(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_Recentre,(self,) + _args, _kwargs)
-        return val
-    def ClearPointList(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_ClearPointList,(self,) + _args, _kwargs)
-        return val
-    def base_OnDelete(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnDelete,(self,) + _args, _kwargs)
-        return val
-    def base_OnDraw(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnDraw,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawContents(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnDrawContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawBranches(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnDrawBranches,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLinks(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnMoveLinks,(self,) + _args, _kwargs)
-        return val
-    def base_OnErase(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnErase,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseContents(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnEraseContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnHighlight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnHighlight,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftClick(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnLeftClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftDoubleClick(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnLeftDoubleClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnRightClick(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnRightClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePre(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnMovePre,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePost(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnMovePost,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragRight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragRight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnBeginDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragRight(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnEndDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawOutline(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnDrawOutline,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawControlPoints(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnDrawControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseControlPoints(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnEraseControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLink(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnMoveLink,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnSizingDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnSizingBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnSizingEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnBeginSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndSize(self, *_args, **_kwargs):
-        val = apply(oglbasicc.wxPyShape_base_OnEndSize,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxPyShape instance at %s>" % (self.this,)
-class wxPyShape(wxPyShapePtr):
-    def __init__(self,this):
-        self.this = this
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

wxPython/contrib/ogl/oglcanvas.i

@@ -1,157 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        oglcanvas.i
-// Purpose:     SWIG definitions for the wxWindows Object Graphics Library
-//
-// Author:      Robin Dunn
-//
-// Created:     7-Sept-1999
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-
-%module oglcanvas
-
-%{
-#include "export.h"
-#include "oglhelpers.h"
-%}
-
-//---------------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-%extern wx.i
-%import windows.i
-%extern _defs.i
-%extern misc.i
-%extern gdi.i
-
-%include _ogldefs.i
-
-%import oglbasic.i
-
-
-%pragma(python) code = "import wx"
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-
-class wxDiagram : public wxObject {
-public:
-    wxDiagram();
-    //~wxDiagram();
-
-    void AddShape(wxPyShape* shape, wxPyShape *addAfter = NULL);
-    void Clear(wxDC& dc);
-    void DeleteAllShapes();
-    void DrawOutline(wxDC& dc, double x1, double y1, double x2, double y2);
-    wxPyShape* FindShape(long id);
-    wxPyShapeCanvas* GetCanvas();
-    int GetCount();
-    double GetGridSpacing();
-    int GetMouseTolerance();
-
-    // wxList* GetShapeList();
-    %addmethods {
-        PyObject* GetShapeList() {
-            wxList* list = self->GetShapeList();
-            return wxPy_ConvertList(list, "wxPyShape");
-        }
-    }
-
-    bool GetQuickEditMode();
-    bool GetSnapToGrid();
-    void InsertShape(wxPyShape *shape);
-    bool LoadFile(const wxString& filename);
-
-    // **** Have to deal with wxExpr and wxExprDatabase first...
-    //void OnDatabaseLoad(wxExprDatabase& database);
-    //void OnDatabaseSave(wxExprDatabase& database);
-    //bool OnHeaderLoad(wxExprDatabase& database, wxExpr& expr);
-    //bool OnHeaderSave(wxExprDatabase& database, wxExpr& expr);
-    //bool OnShapeLoad(wxExprDatabase& database, wxPyShape& shape, wxExpr& expr);
-    //bool OnShapeSave(wxExprDatabase& database, wxPyShape& shape, wxExpr& expr);
-
-
-    void ReadContainerGeometry(wxExprDatabase& database);
-    void ReadLines(wxExprDatabase& database);
-    void ReadNodes(wxExprDatabase& database);
-    void RecentreAll(wxDC& dc);
-    void Redraw(wxDC& dc);
-    void RemoveAllShapes();
-    void RemoveShape(wxPyShape* shape);
-    bool SaveFile(const wxString& filename);
-    void SetCanvas(wxPyShapeCanvas* canvas);
-    void SetGridSpacing(double spacing);
-    void SetMouseTolerance(int tolerance);
-    void SetQuickEditMode(bool mode);
-    void SetSnapToGrid(bool snap);
-    void ShowAll(bool show);
-    void Snap(double *INOUT, double *INOUT);
-
-};
-
-//---------------------------------------------------------------------------
-
-%{
-    IMP_PYCALLBACK__2DBLINT(wxPyShapeCanvas, wxShapeCanvas, OnBeginDragLeft);
-    IMP_PYCALLBACK__2DBLINT(wxPyShapeCanvas, wxShapeCanvas, OnBeginDragRight);
-    IMP_PYCALLBACK__2DBLINT(wxPyShapeCanvas, wxShapeCanvas, OnEndDragLeft);
-    IMP_PYCALLBACK__2DBLINT(wxPyShapeCanvas, wxShapeCanvas, OnEndDragRight);
-    IMP_PYCALLBACK__BOOL2DBLINT(wxPyShapeCanvas, wxShapeCanvas, OnDragLeft);
-    IMP_PYCALLBACK__BOOL2DBLINT(wxPyShapeCanvas, wxShapeCanvas, OnDragRight);
-    IMP_PYCALLBACK__2DBLINT(wxPyShapeCanvas, wxShapeCanvas, OnLeftClick);
-    IMP_PYCALLBACK__2DBLINT(wxPyShapeCanvas, wxShapeCanvas, OnRightClick);
-%}
-
-
-class wxPyShapeCanvas : public wxScrolledWindow {
-public:
-    wxPyShapeCanvas(wxWindow* parent = NULL, wxWindowID id = -1,
-                    const wxPoint& pos = wxDefaultPosition,
-                    const wxSize& size = wxDefaultSize,
-                    long style = wxBORDER);
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyShapeCanvas)"
-
-    %pragma(python) addtomethod = "__init__:#wx._StdWindowCallbacks(self)"
-    %pragma(python) addtomethod = "__init__:#wx._StdOnScrollCallbacks(self)"
-
-    void AddShape(wxPyShape *shape, wxPyShape *addAfter = NULL);
-
-    // ****  Need a typemap for wxClassInfo, or implement wxObject, etc.....
-    wxPyShape* FindShape(double x1, double y, int *OUTPUT,
-                       wxClassInfo *info = NULL, wxPyShape* notImage = NULL);
-
-    wxPyShape * FindFirstSensitiveShape(double x1, double y, int *OUTPUT, int op);
-    wxDiagram* GetDiagram();
-
-    bool GetQuickEditMode();
-    void InsertShape(wxPyShape* shape);
-
-
-    void base_OnBeginDragLeft(double x, double y, int keys = 0);
-    void base_OnBeginDragRight(double x, double y, int keys = 0);
-    void base_OnEndDragLeft(double x, double y, int keys = 0);
-    void base_OnEndDragRight(double x, double y, int keys = 0);
-    void base_OnDragLeft(bool draw, double x, double y, int keys = 0);
-    void base_OnDragRight(bool draw, double x, double y, int keys = 0);
-    void base_OnLeftClick(double x, double y, int keys = 0);
-    void base_OnRightClick(double x, double y, int keys = 0);
-
-    void Redraw(wxDC& dc);
-    void RemoveShape(wxPyShape *shape);
-    void SetDiagram(wxDiagram *diagram);
-    void Snap(double *INOUT, double *INOUT);
-
-};
-
-
-//---------------------------------------------------------------------------
-
-

wxPython/contrib/ogl/oglcanvas.py

@@ -1,228 +0,0 @@
-# This file was created automatically by SWIG.
-import oglcanvasc
-
-from misc import *
-
-from misc2 import *
-
-from windows import *
-
-from gdi import *
-
-from clip_dnd import *
-
-from events import *
-
-from streams import *
-
-from mdi import *
-
-from frames import *
-
-from stattool import *
-
-from controls import *
-
-from controls2 import *
-
-from windows2 import *
-
-from cmndlgs import *
-
-from windows3 import *
-
-from image import *
-
-from printfw import *
-
-from sizers import *
-
-from filesys import *
-
-from utils import *
-
-from oglbasic import *
-import wx
-class wxDiagramPtr(wxObjectPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def AddShape(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_AddShape,(self,) + _args, _kwargs)
-        return val
-    def Clear(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_Clear,(self,) + _args, _kwargs)
-        return val
-    def DeleteAllShapes(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_DeleteAllShapes,(self,) + _args, _kwargs)
-        return val
-    def DrawOutline(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_DrawOutline,(self,) + _args, _kwargs)
-        return val
-    def FindShape(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_FindShape,(self,) + _args, _kwargs)
-        return val
-    def GetCanvas(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_GetCanvas,(self,) + _args, _kwargs)
-        return val
-    def GetCount(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_GetCount,(self,) + _args, _kwargs)
-        return val
-    def GetGridSpacing(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_GetGridSpacing,(self,) + _args, _kwargs)
-        return val
-    def GetMouseTolerance(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_GetMouseTolerance,(self,) + _args, _kwargs)
-        return val
-    def GetShapeList(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_GetShapeList,(self,) + _args, _kwargs)
-        return val
-    def GetQuickEditMode(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_GetQuickEditMode,(self,) + _args, _kwargs)
-        return val
-    def GetSnapToGrid(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_GetSnapToGrid,(self,) + _args, _kwargs)
-        return val
-    def InsertShape(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_InsertShape,(self,) + _args, _kwargs)
-        return val
-    def LoadFile(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_LoadFile,(self,) + _args, _kwargs)
-        return val
-    def ReadContainerGeometry(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_ReadContainerGeometry,(self,) + _args, _kwargs)
-        return val
-    def ReadLines(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_ReadLines,(self,) + _args, _kwargs)
-        return val
-    def ReadNodes(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_ReadNodes,(self,) + _args, _kwargs)
-        return val
-    def RecentreAll(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_RecentreAll,(self,) + _args, _kwargs)
-        return val
-    def Redraw(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_Redraw,(self,) + _args, _kwargs)
-        return val
-    def RemoveAllShapes(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_RemoveAllShapes,(self,) + _args, _kwargs)
-        return val
-    def RemoveShape(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_RemoveShape,(self,) + _args, _kwargs)
-        return val
-    def SaveFile(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_SaveFile,(self,) + _args, _kwargs)
-        return val
-    def SetCanvas(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_SetCanvas,(self,) + _args, _kwargs)
-        return val
-    def SetGridSpacing(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_SetGridSpacing,(self,) + _args, _kwargs)
-        return val
-    def SetMouseTolerance(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_SetMouseTolerance,(self,) + _args, _kwargs)
-        return val
-    def SetQuickEditMode(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_SetQuickEditMode,(self,) + _args, _kwargs)
-        return val
-    def SetSnapToGrid(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_SetSnapToGrid,(self,) + _args, _kwargs)
-        return val
-    def ShowAll(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_ShowAll,(self,) + _args, _kwargs)
-        return val
-    def Snap(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxDiagram_Snap,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxDiagram instance at %s>" % (self.this,)
-class wxDiagram(wxDiagramPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglcanvasc.new_wxDiagram,_args,_kwargs)
-        self.thisown = 1
-
-
-
-
-class wxPyShapeCanvasPtr(wxScrolledWindowPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def _setSelf(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas__setSelf,(self,) + _args, _kwargs)
-        return val
-    def AddShape(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_AddShape,(self,) + _args, _kwargs)
-        return val
-    def FindShape(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_FindShape,(self,) + _args, _kwargs)
-        return val
-    def FindFirstSensitiveShape(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_FindFirstSensitiveShape,(self,) + _args, _kwargs)
-        return val
-    def GetDiagram(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_GetDiagram,(self,) + _args, _kwargs)
-        return val
-    def GetQuickEditMode(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_GetQuickEditMode,(self,) + _args, _kwargs)
-        return val
-    def InsertShape(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_InsertShape,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_base_OnBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragRight(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_base_OnBeginDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_base_OnEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragRight(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_base_OnEndDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragLeft(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_base_OnDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragRight(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_base_OnDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftClick(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_base_OnLeftClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnRightClick(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_base_OnRightClick,(self,) + _args, _kwargs)
-        return val
-    def Redraw(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_Redraw,(self,) + _args, _kwargs)
-        return val
-    def RemoveShape(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_RemoveShape,(self,) + _args, _kwargs)
-        return val
-    def SetDiagram(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_SetDiagram,(self,) + _args, _kwargs)
-        return val
-    def Snap(self, *_args, **_kwargs):
-        val = apply(oglcanvasc.wxPyShapeCanvas_Snap,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxPyShapeCanvas instance at %s>" % (self.this,)
-class wxPyShapeCanvas(wxPyShapeCanvasPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglcanvasc.new_wxPyShapeCanvas,_args,_kwargs)
-        self.thisown = 1
-        self._setSelf(self, wxPyShapeCanvas)
-        #wx._StdWindowCallbacks(self)
-        #wx._StdOnScrollCallbacks(self)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

wxPython/contrib/ogl/oglhelpers.h

@@ -1,278 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        oglhelpers.h
-// Purpose:     Some Helper functions to help in data conversions in OGL
-//
-// Author:      Robin Dunn
-//
-// Created:     9-Sept-1999
-// RCS-ID:      $Id$
-// Copyright:   (c) 1998 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-#ifndef __wxp_ogl_helpers__
-#define __wxp_ogl_helpers__
-
-
-#include <wx/ogl/ogl.h>
-#include <wx/ogl/basicp.h>
-#include <wx/ogl/constrnt.h>
-#include <wx/ogl/bmpshape.h>
-#include <wx/ogl/drawn.h>
-
-
-//---------------------------------------------------------------------------
-// Define a macro that will be used in the class definintions below
-
-#define WXSHAPE_DEC_CALLBACKS()       \
-    DEC_PYCALLBACK__                (OnDelete);             \
-    DEC_PYCALLBACK__DC              (OnDraw);               \
-    DEC_PYCALLBACK__DC              (OnDrawContents);       \
-    DEC_PYCALLBACK__DCBOOL          (OnDrawBranches);       \
-    DEC_PYCALLBACK__DC              (OnMoveLinks);          \
-    DEC_PYCALLBACK__DC              (OnErase);              \
-    DEC_PYCALLBACK__DC              (OnEraseContents);      \
-    DEC_PYCALLBACK__DC              (OnHighlight);          \
-    DEC_PYCALLBACK__2DBL2INT        (OnLeftClick);          \
-    DEC_PYCALLBACK__2DBL2INT        (OnLeftDoubleClick);    \
-    DEC_PYCALLBACK__2DBL2INT        (OnRightClick);         \
-    DEC_PYCALLBACK__2DBL            (OnSize);               \
-    DEC_PYCALLBACK_BOOL_DC4DBLBOOL  (OnMovePre);            \
-    DEC_PYCALLBACK__DC4DBLBOOL      (OnMovePost);           \
-    DEC_PYCALLBACK__BOOL2DBL2INT    (OnDragLeft);           \
-    DEC_PYCALLBACK__2DBL2INT        (OnBeginDragLeft);      \
-    DEC_PYCALLBACK__2DBL2INT        (OnEndDragLeft);        \
-    DEC_PYCALLBACK__BOOL2DBL2INT    (OnDragRight);          \
-    DEC_PYCALLBACK__2DBL2INT        (OnBeginDragRight);     \
-    DEC_PYCALLBACK__2DBL2INT        (OnEndDragRight);       \
-    DEC_PYCALLBACK__DC4DBL          (OnDrawOutline);        \
-    DEC_PYCALLBACK__DC              (OnDrawControlPoints);  \
-    DEC_PYCALLBACK__DC              (OnEraseControlPoints); \
-    DEC_PYCALLBACK__DCBOOL          (OnMoveLink);           \
-    DEC_PYCALLBACK__WXCPBOOL2DBL2INT(OnSizingDragLeft);     \
-    DEC_PYCALLBACK__WXCP2DBL2INT    (OnSizingBeginDragLeft);\
-    DEC_PYCALLBACK__WXCP2DBL2INT    (OnSizingEndDragLeft);  \
-    DEC_PYCALLBACK__2DBL            (OnBeginSize);          \
-    DEC_PYCALLBACK__2DBL            (OnEndSize);            \
-                                                            \
-    PYPRIVATE;
-
-
-#define WXSHAPE_IMP_CALLBACKS(CLASS, PARENT)       \
-    IMP_PYCALLBACK__                (CLASS, PARENT,  OnDelete);             \
-    IMP_PYCALLBACK__DC              (CLASS, PARENT,  OnDraw);               \
-    IMP_PYCALLBACK__DC              (CLASS, PARENT,  OnDrawContents);       \
-    IMP_PYCALLBACK__DCBOOL          (CLASS, PARENT,  OnDrawBranches);       \
-    IMP_PYCALLBACK__DC              (CLASS, PARENT,  OnMoveLinks);          \
-    IMP_PYCALLBACK__DC              (CLASS, PARENT,  OnErase);              \
-    IMP_PYCALLBACK__DC              (CLASS, PARENT,  OnEraseContents);      \
-    IMP_PYCALLBACK__DC              (CLASS, PARENT,  OnHighlight);          \
-    IMP_PYCALLBACK__2DBL2INT        (CLASS, PARENT,  OnLeftClick);          \
-    IMP_PYCALLBACK__2DBL2INT        (CLASS, PARENT,  OnLeftDoubleClick);    \
-    IMP_PYCALLBACK__2DBL2INT        (CLASS, PARENT,  OnRightClick);         \
-    IMP_PYCALLBACK__2DBL            (CLASS, PARENT,  OnSize);               \
-    IMP_PYCALLBACK_BOOL_DC4DBLBOOL  (CLASS, PARENT,  OnMovePre);            \
-    IMP_PYCALLBACK__DC4DBLBOOL      (CLASS, PARENT,  OnMovePost);           \
-    IMP_PYCALLBACK__BOOL2DBL2INT    (CLASS, PARENT,  OnDragLeft);           \
-    IMP_PYCALLBACK__2DBL2INT        (CLASS, PARENT,  OnBeginDragLeft);      \
-    IMP_PYCALLBACK__2DBL2INT        (CLASS, PARENT,  OnEndDragLeft);        \
-    IMP_PYCALLBACK__BOOL2DBL2INT    (CLASS, PARENT,  OnDragRight);          \
-    IMP_PYCALLBACK__2DBL2INT        (CLASS, PARENT,  OnBeginDragRight);     \
-    IMP_PYCALLBACK__2DBL2INT        (CLASS, PARENT,  OnEndDragRight);       \
-    IMP_PYCALLBACK__DC4DBL          (CLASS, PARENT,  OnDrawOutline);        \
-    IMP_PYCALLBACK__DC              (CLASS, PARENT,  OnDrawControlPoints);  \
-    IMP_PYCALLBACK__DC              (CLASS, PARENT,  OnEraseControlPoints); \
-    IMP_PYCALLBACK__DCBOOL          (CLASS, PARENT,  OnMoveLink);           \
-    IMP_PYCALLBACK__WXCPBOOL2DBL2INT(CLASS, PARENT,  OnSizingDragLeft);     \
-    IMP_PYCALLBACK__WXCP2DBL2INT    (CLASS, PARENT,  OnSizingBeginDragLeft);\
-    IMP_PYCALLBACK__WXCP2DBL2INT    (CLASS, PARENT,  OnSizingEndDragLeft);  \
-    IMP_PYCALLBACK__2DBL            (CLASS, PARENT,  OnBeginSize);          \
-    IMP_PYCALLBACK__2DBL            (CLASS, PARENT,  OnEndSize);            \
-
-
-    //  This one may be difficult...
-    //PYCALLBACK__???????       (PARENT,  OnChangeAttachment);
-
-
-
-//---------------------------------------------------------------------------
-// These are prototypes of some helper functions found in oglhelpers.cpp
-
-wxList* wxPy_wxListHelper(PyObject* pyList, char* className);
-wxList* wxPy_wxRealPoint_ListHelper(PyObject* pyList);
-
-
-
-//---------------------------------------------------------------------------
-// Classes that derive from the shapes and such, but which know how to turn
-// virtual callbacks into Python callbacks.
-
-class wxPyShapeCanvas : public wxShapeCanvas {
-    DECLARE_DYNAMIC_CLASS(wxPyShapeCanvas);
-public:
-    wxPyShapeCanvas(wxWindow* parent = NULL, wxWindowID id = -1,
-                    const wxPoint& pos = wxDefaultPosition,
-                    const wxSize& size = wxDefaultSize,
-                    long style = wxBORDER)
-        : wxShapeCanvas(parent, id, pos, size, style) {}
-
-    DEC_PYCALLBACK__2DBLINT(OnBeginDragLeft);
-    DEC_PYCALLBACK__2DBLINT(OnBeginDragRight);
-    DEC_PYCALLBACK__2DBLINT(OnEndDragLeft);
-    DEC_PYCALLBACK__2DBLINT(OnEndDragRight);
-    DEC_PYCALLBACK__BOOL2DBLINT(OnDragLeft);
-    DEC_PYCALLBACK__BOOL2DBLINT(OnDragRight);
-    DEC_PYCALLBACK__2DBLINT(OnLeftClick);
-    DEC_PYCALLBACK__2DBLINT(OnRightClick);
-
-    PYPRIVATE;
-};
-
-
-
-class wxPyShapeEvtHandler : public wxShapeEvtHandler {
-    DECLARE_DYNAMIC_CLASS(wxPyShapeEvtHandler);
-public:
-    wxPyShapeEvtHandler(wxShapeEvtHandler *prev = NULL, wxShape *shape = NULL)
-        : wxShapeEvtHandler(prev, shape) {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-class wxPyShape : public wxShape {
-    DECLARE_ABSTRACT_CLASS(wxPyShape);
-public:
-    wxPyShape(wxPyShapeCanvas *can = NULL)
-        : wxShape(can) {}
-
-    WXSHAPE_DEC_CALLBACKS();
-
-};
-
-
-class wxPyRectangleShape : public wxRectangleShape {
-    DECLARE_DYNAMIC_CLASS(wxPyRectangleShape);
-public:
-    wxPyRectangleShape(double width = 0.0, double height = 0.0)
-        : wxRectangleShape(width, height) {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-class wxPyControlPoint : public wxControlPoint {
-    DECLARE_DYNAMIC_CLASS(wxPyControlPoint);
-public:
-    wxPyControlPoint(wxPyShapeCanvas *the_canvas = NULL,
-                     wxPyShape *object = NULL,
-                     double size = 0.0, double the_xoffset = 0.0,
-                     double the_yoffset = 0.0, int the_type = 0)
-        : wxControlPoint(the_canvas, object, size,
-                         the_xoffset, the_yoffset, the_type) {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-
-class wxPyBitmapShape : public wxBitmapShape {
-    DECLARE_DYNAMIC_CLASS(wxPyBitmapShape);
-public:
-    wxPyBitmapShape() : wxBitmapShape() {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-
-class wxPyDrawnShape : public wxDrawnShape {
-    DECLARE_DYNAMIC_CLASS(wxPyDrawnShape);
-public:
-    wxPyDrawnShape() : wxDrawnShape() {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-class wxPyCompositeShape : public wxCompositeShape {
-    DECLARE_DYNAMIC_CLASS(wxPyCompositeShape);
-public:
-    wxPyCompositeShape() : wxCompositeShape() {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-class wxPyDividedShape : public wxDividedShape {
-    DECLARE_DYNAMIC_CLASS(wxPyDividedShape);
-public:
-    wxPyDividedShape(double width = 0.0, double height = 0.0)
-        : wxDividedShape(width, height) {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-class wxPyDivisionShape : public wxDivisionShape {
-    DECLARE_DYNAMIC_CLASS(wxPyDivisionShape);
-public:
-    wxPyDivisionShape() : wxDivisionShape() {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-class wxPyEllipseShape : public wxEllipseShape {
-    DECLARE_DYNAMIC_CLASS(wxPyEllipseShape);
-public:
-    wxPyEllipseShape(double width = 0.0, double height = 0.0)
-        : wxEllipseShape(width, height) {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-class wxPyCircleShape : public wxCircleShape {
-    DECLARE_DYNAMIC_CLASS(wxPyCircleShape);
-public:
-    wxPyCircleShape(double width = 0.0)
-        : wxCircleShape(width) {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-class wxPyLineShape : public wxLineShape {
-    DECLARE_DYNAMIC_CLASS(wxPyLineShape);
-public:
-    wxPyLineShape() : wxLineShape() {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-class wxPyPolygonShape : public wxPolygonShape {
-    DECLARE_DYNAMIC_CLASS(wxPyPolygonShape);
-public:
-    wxPyPolygonShape() : wxPolygonShape() {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-class wxPyTextShape : public wxTextShape {
-    DECLARE_DYNAMIC_CLASS(wxPyTextShape);
-public:
-    wxPyTextShape(double width = 0.0, double height = 0.0)
-        : wxTextShape(width, height) {}
-
-    WXSHAPE_DEC_CALLBACKS();
-};
-
-
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-#endif
-
-