This commit was manufactured by cvs2svn to create tag

'b4_mousewheel'.

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

docs/latex/wx/mouseevt.tex

@@ -0,0 +1,347 @@
+\section{\class{wxMouseEvent}}\label{wxmouseevent}
+
+This event class contains information about mouse events.
+See \helpref{wxWindow::OnMouseEvent}{wxwindowonmouseevent}.
+
+{\bf NB: } Note that under Windows mouse enter and leave events are not natively supported
+by the system but are generated by wxWindows itself. This has several
+drawbacks: the LEAVE\_WINDOW event might be received some time after the mouse
+left the window and the state variables for it may have changed during this
+time.
+
+{\bf NB: } Note the difference between methods like 
+\helpref{LeftDown}{wxmouseeventleftdown} and 
+\helpref{LeftIsDown}{wxmouseeventleftisdown}: the formet returns {\tt TRUE}
+when the event corresponds to the left mouse button click while the latter
+returns {\tt TRUE} if the left mouse button is currently being pressed. For
+example, when the user is dragging the mouse you can use 
+\helpref{LeftIsDown}{wxmouseeventleftisdown} to test
+whether the left mouse button is (still) depressed. Also, by convention, if
+\helpref{LeftDown}{wxmouseeventleftdown} returns {\tt TRUE}, 
+\helpref{LeftIsDown}{wxmouseeventleftisdown} will also return {\tt TRUE} in
+wxWindows whatever the underlying GUI behaviour is (which is
+platform-dependent). The same applies, of course, to other mouse buttons as
+well.
+
+\wxheading{Derived from}
+
+\helpref{wxEvent}{wxevent}
+
+\wxheading{Include files}
+
+<wx/event.h>
+
+\wxheading{Event table macros}
+
+To process a mouse event, use these event handler macros to direct input to member
+functions that take a wxMouseEvent argument.
+
+\twocolwidtha{7cm}
+\begin{twocollist}\itemsep=0pt
+\twocolitem{{\bf EVT\_LEFT\_DOWN(func)}}{Process a wxEVT\_LEFT\_DOWN event.}
+\twocolitem{{\bf EVT\_LEFT\_UP(func)}}{Process a wxEVT\_LEFT\_UP event.}
+\twocolitem{{\bf EVT\_LEFT\_DCLICK(func)}}{Process a wxEVT\_LEFT\_DCLICK event.}
+\twocolitem{{\bf EVT\_MIDDLE\_DOWN(func)}}{Process a wxEVT\_MIDDLE\_DOWN event.}
+\twocolitem{{\bf EVT\_MIDDLE\_UP(func)}}{Process a wxEVT\_MIDDLE\_UP event.}
+\twocolitem{{\bf EVT\_MIDDLE\_DCLICK(func)}}{Process a wxEVT\_MIDDLE\_DCLICK event.}
+\twocolitem{{\bf EVT\_RIGHT\_DOWN(func)}}{Process a wxEVT\_RIGHT\_DOWN event.}
+\twocolitem{{\bf EVT\_RIGHT\_UP(func)}}{Process a wxEVT\_RIGHT\_UP event.}
+\twocolitem{{\bf EVT\_RIGHT\_DCLICK(func)}}{Process a wxEVT\_RIGHT\_DCLICK event.}
+\twocolitem{{\bf EVT\_MOTION(func)}}{Process a wxEVT\_MOTION event.}
+\twocolitem{{\bf EVT\_ENTER\_WINDOW(func)}}{Process a wxEVT\_ENTER\_WINDOW event.}
+\twocolitem{{\bf EVT\_LEAVE\_WINDOW(func)}}{Process a wxEVT\_LEAVE\_WINDOW event.}
+\twocolitem{{\bf EVT\_MOUSE\_EVENTS(func)}}{Process all mouse events.}
+\end{twocollist}%
+
+\latexignore{\rtfignore{\wxheading{Members}}}
+
+\membersection{wxMouseEvent::m\_altDown}
+
+\member{bool}{m\_altDown}
+
+TRUE if the Alt key is pressed down.
+
+\membersection{wxMouseEvent::m\_controlDown}
+
+\member{bool}{m\_controlDown}
+
+TRUE if control key is pressed down.
+
+\membersection{wxMouseEvent::m\_leftDown}
+
+\member{bool}{m\_leftDown}
+
+TRUE if the left mouse button is currently pressed down.
+
+\membersection{wxMouseEvent::m\_middleDown}
+
+\member{bool}{m\_middleDown}
+
+TRUE if the middle mouse button is currently pressed down.
+
+\membersection{wxMouseEvent::m\_rightDown}
+
+\member{bool}{m\_rightDown}
+
+TRUE if the right mouse button is currently pressed down.
+
+\membersection{wxMouseEvent::m\_leftDown}
+
+\member{bool}{m\_leftDown}
+
+TRUE if the left mouse button is currently pressed down.
+
+\membersection{wxMouseEvent::m\_metaDown}
+
+\member{bool}{m\_metaDown}
+
+TRUE if the Meta key is pressed down.
+
+\membersection{wxMouseEvent::m\_shiftDown}
+
+\member{bool}{m\_shiftDown}
+
+TRUE if shift is pressed down.
+
+\membersection{wxMouseEvent::m\_x}
+
+\member{long}{m\_x}
+
+X-coordinate of the event.
+
+\membersection{wxMouseEvent::m\_y}
+
+\member{long}{m\_y}
+
+Y-coordinate of the event.
+
+\membersection{wxMouseEvent::wxMouseEvent}
+
+\func{}{wxMouseEvent}{\param{WXTYPE}{ mouseEventType = 0}, \param{int}{ id = 0}}
+
+Constructor. Valid event types are:
+
+\begin{itemize}
+\itemsep=0pt
+\item {\bf wxEVT\_ENTER\_WINDOW}
+\item {\bf wxEVT\_LEAVE\_WINDOW}
+\item {\bf wxEVT\_LEFT\_DOWN}
+\item {\bf wxEVT\_LEFT\_UP}
+\item {\bf wxEVT\_LEFT\_DCLICK}
+\item {\bf wxEVT\_MIDDLE\_DOWN}
+\item {\bf wxEVT\_MIDDLE\_UP}
+\item {\bf wxEVT\_MIDDLE\_DCLICK}
+\item {\bf wxEVT\_RIGHT\_DOWN}
+\item {\bf wxEVT\_RIGHT\_UP}
+\item {\bf wxEVT\_RIGHT\_DCLICK}
+\item {\bf wxEVT\_MOTION}
+\end{itemize}
+
+\membersection{wxMouseEvent::AltDown}
+
+\func{bool}{AltDown}{\void}
+
+Returns TRUE if the Alt key was down at the time of the event.
+
+\membersection{wxMouseEvent::Button}
+
+\func{bool}{Button}{\param{int}{ button}}
+
+Returns TRUE if the identified mouse button is changing state. Valid
+values of {\it button} are 1, 2 or 3 for left, middle and right
+buttons respectively.
+
+Not all mice have middle buttons so a portable application should avoid
+this one.
+
+\membersection{wxMouseEvent::ButtonDClick}\label{buttondclick}
+
+\func{bool}{ButtonDClick}{\param{int}{ but = -1}}
+
+If the argument is omitted, this returns TRUE if the event was a mouse
+double click event. Otherwise the argument specifies which double click event
+was generated (1, 2 or 3 for left, middle and right buttons respectively).
+
+\membersection{wxMouseEvent::ButtonDown}
+
+\func{bool}{ButtonDown}{\param{int}{ but = -1}}
+
+If the argument is omitted, this returns TRUE if the event was a mouse
+button down event. Otherwise the argument specifies which button-down event
+was generated (1, 2 or 3 for left, middle and right buttons respectively).
+
+\membersection{wxMouseEvent::ButtonUp}
+
+\func{bool}{ButtonUp}{\param{int}{ but = -1}}
+
+If the argument is omitted, this returns TRUE if the event was a mouse
+button up event. Otherwise the argument specifies which button-up event
+was generated (1, 2 or 3 for left, middle and right buttons respectively).
+
+\membersection{wxMouseEvent::ControlDown}
+
+\func{bool}{ControlDown}{\void}
+
+Returns TRUE if the control key was down at the time of the event.
+
+\membersection{wxMouseEvent::Dragging}
+
+\func{bool}{Dragging}{\void}
+
+Returns TRUE if this was a dragging event (motion while a button is depressed).
+
+\membersection{wxMouseEvent::Entering}\label{wxmouseevententering}
+
+\func{bool}{Entering}{\void}
+
+Returns TRUE if the mouse was entering the window.
+
+See also \helpref{wxMouseEvent::Leaving}{wxmouseeventleaving}.
+
+\membersection{wxMouseEvent::GetPosition}\label{wxmouseeventgetposition}
+
+\constfunc{wxPoint}{GetPosition}{\void}
+
+\constfunc{void}{GetPosition}{\param{wxCoord*}{ x}, \param{wxCoord*}{ y}}
+
+\constfunc{void}{GetPosition}{\param{long*}{ x}, \param{long*}{ y}}
+
+Sets *x and *y to the position at which the event occurred.
+
+Returns the physical mouse position in pixels.
+
+\membersection{wxMouseEvent::GetLogicalPosition}\label{wxmouseeventgetlogicalposition}
+
+\constfunc{wxPoint}{GetLogicalPosition}{\param{const wxDC\&}{ dc}}
+
+Returns the logical mouse position in pixels (i.e. translated according to the
+translation set for the DC, which usually indicates that the window has been scrolled).
+
+\membersection{wxMouseEvent::GetX}\label{wxmouseeventgetx}
+
+\constfunc{long}{GetX}{\void}
+
+Returns X coordinate of the physical mouse event position.
+
+\membersection{wxMouseEvent::GetY}\label{wxmouseeventgety}
+
+\func{long}{GetY}{\void}
+
+Returns Y coordinate of the physical mouse event position.
+
+\membersection{wxMouseEvent::IsButton}
+
+\constfunc{bool}{IsButton}{\void}
+
+Returns TRUE if the event was a mouse button event (not necessarily a button down event -
+that may be tested using {\it ButtonDown}).
+
+\membersection{wxMouseEvent::Leaving}\label{wxmouseeventleaving}
+
+\constfunc{bool}{Leaving}{\void}
+
+Returns TRUE if the mouse was leaving the window.
+
+See also \helpref{wxMouseEvent::Entering}{wxmouseevententering}.
+
+\membersection{wxMouseEvent::LeftDClick}
+
+\constfunc{bool}{LeftDClick}{\void}
+
+Returns TRUE if the event was a left double click.
+
+\membersection{wxMouseEvent::LeftDown}\label{wxmouseeventleftdown}
+
+\constfunc{bool}{LeftDown}{\void}
+
+Returns TRUE if the left mouse button changed to down.
+
+\membersection{wxMouseEvent::LeftIsDown}\label{wxmouseeventleftisdown}
+
+\constfunc{bool}{LeftIsDown}{\void}
+
+Returns TRUE if the left mouse button is currently down, independent
+of the current event type.
+
+Please notice that it is {\bf not} the same as 
+\helpref{LeftDown}{wxmouseeventleftdown} which returns TRUE if the left mouse
+button was just pressed. Rather, it describes the state of the mouse button
+before the event happened.
+
+This event is usually used in the mouse event handlers which process "move
+mouse" messages to determine whether the user is (still) dragging the mouse.
+
+\membersection{wxMouseEvent::LeftUp}
+
+\constfunc{bool}{LeftUp}{\void}
+
+Returns TRUE if the left mouse button changed to up.
+
+\membersection{wxMouseEvent::MetaDown}
+
+\constfunc{bool}{MetaDown}{\void}
+
+Returns TRUE if the Meta key was down at the time of the event.
+
+\membersection{wxMouseEvent::MiddleDClick}
+
+\constfunc{bool}{MiddleDClick}{\void}
+
+Returns TRUE if the event was a middle double click.
+
+\membersection{wxMouseEvent::MiddleDown}
+
+\constfunc{bool}{MiddleDown}{\void}
+
+Returns TRUE if the middle mouse button changed to down.
+
+\membersection{wxMouseEvent::MiddleIsDown}\label{wxmouseeventmiddleisdown}
+
+\constfunc{bool}{MiddleIsDown}{\void}
+
+Returns TRUE if the middle mouse button is currently down, independent
+of the current event type.
+
+\membersection{wxMouseEvent::MiddleUp}
+
+\constfunc{bool}{MiddleUp}{\void}
+
+Returns TRUE if the middle mouse button changed to up.
+
+\membersection{wxMouseEvent::Moving}
+
+\constfunc{bool}{Moving}{\void}
+
+Returns TRUE if this was a motion event (no buttons depressed).
+
+\membersection{wxMouseEvent::RightDClick}
+
+\constfunc{bool}{RightDClick}{\void}
+
+Returns TRUE if the event was a right double click.
+
+\membersection{wxMouseEvent::RightDown}
+
+\constfunc{bool}{RightDown}{\void}
+
+Returns TRUE if the right mouse button changed to down.
+
+\membersection{wxMouseEvent::RightIsDown}\label{wxmouseeventrightisdown}
+
+\constfunc{bool}{RightIsDown}{\void}
+
+Returns TRUE if the right mouse button is currently down, independent
+of the current event type.
+
+\membersection{wxMouseEvent::RightUp}
+
+\constfunc{bool}{RightUp}{\void}
+
+Returns TRUE if the right mouse button changed to up.
+
+\membersection{wxMouseEvent::ShiftDown}
+
+\constfunc{bool}{ShiftDown}{\void}
+
+Returns TRUE if the shift key was down at the time of the event.
+

include/wx/generic/scrolwin.h

@@ -0,0 +1,154 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/generic/scrolwin.h
+// Purpose:     wxScrolledWindow class
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart and Markus Holzem
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GENERIC_SCROLLWIN_H_
+#define _WX_GENERIC_SCROLLWIN_H_
+
+#ifdef __GNUG__
+    #pragma interface "scrolwin.h"
+#endif
+
+// ----------------------------------------------------------------------------
+// headers and constants
+// ----------------------------------------------------------------------------
+
+#include "wx/window.h"
+#include "wx/panel.h"
+
+WXDLLEXPORT_DATA(extern const wxChar*) wxPanelNameStr;
+
+// default scrolled window style
+#ifndef wxScrolledWindowStyle
+#define wxScrolledWindowStyle (wxHSCROLL | wxVSCROLL)
+#endif
+
+// ----------------------------------------------------------------------------
+// wxGenericScrolledWindow
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGenericScrolledWindow : public wxPanel
+{
+public:
+    wxGenericScrolledWindow();
+    wxGenericScrolledWindow(wxWindow *parent,
+                     wxWindowID id = -1,
+                     const wxPoint& pos = wxDefaultPosition,
+                     const wxSize& size = wxDefaultSize,
+                     long style = wxScrolledWindowStyle,
+                     const wxString& name = wxPanelNameStr)
+    {
+        Create(parent, id, pos, size, style, name);
+    }
+
+    ~wxGenericScrolledWindow();
+
+    bool Create(wxWindow *parent,
+                wxWindowID id,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = wxScrolledWindowStyle,
+                const wxString& name = wxPanelNameStr);
+
+    // Normally the wxGenericScrolledWindow will scroll itself, but in
+    // some rare occasions you might want it to scroll another
+    // window (e.g. a child of it in order to scroll only a portion
+    // the area between the scrollbars (spreadsheet: only cell area
+    // will move).
+    virtual void SetTargetWindow( wxWindow *target );
+    virtual wxWindow *GetTargetWindow();
+
+    // Number of pixels per user unit (0 or -1 for no scrollbar)
+    // Length of virtual canvas in user units
+    // Length of page in user units
+    virtual void SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY,
+                             int noUnitsX, int noUnitsY,
+                             int xPos = 0, int yPos = 0,
+                             bool noRefresh = FALSE );
+
+    // Physically scroll the window
+    virtual void Scroll(int x_pos, int y_pos);
+
+#if WXWIN_COMPATIBILITY
+    virtual void GetScrollUnitsPerPage(int *x_page, int *y_page) const;
+    virtual void CalcUnscrolledPosition(int x, int y, float *xx, float *yy) const;
+#endif
+
+    int GetScrollPageSize(int orient) const;
+    void SetScrollPageSize(int orient, int pageSize);
+
+    virtual void GetScrollPixelsPerUnit(int *x_unit, int *y_unit) const;
+
+    // Enable/disable Windows scrolling in either direction.
+    // If TRUE, wxWindows scrolls the canvas and only a bit of
+    // the canvas is invalidated; no Clear() is necessary.
+    // If FALSE, the whole canvas is invalidated and a Clear() is
+    // necessary. Disable for when the scroll increment is used
+    // to actually scroll a non-constant distance
+    virtual void EnableScrolling(bool x_scrolling, bool y_scrolling);
+
+    // Get the view start
+    virtual void GetViewStart(int *x, int *y) const;
+    // Compatibility
+    void ViewStart(int *x, int *y) const
+       { GetViewStart( x, y ); }
+
+    // Actual size in pixels when scrolling is taken into account
+    virtual void GetVirtualSize(int *x, int *y) const;
+
+    // Set the scale factor, used in PrepareDC
+    void SetScale(double xs, double ys) { m_scaleX = xs; m_scaleY = ys; }
+    double GetScaleX() const { return m_scaleX; }
+    double GetScaleY() const { return m_scaleY; }
+
+    virtual void CalcScrolledPosition(int x, int y, int *xx, int *yy) const;
+    virtual void CalcUnscrolledPosition(int x, int y, int *xx, int *yy) const;
+
+    // Adjust the scrollbars
+    virtual void AdjustScrollbars(void);
+
+    // Override this function to draw the graphic (or just process EVT_PAINT)
+    virtual void OnDraw(wxDC& WXUNUSED(dc)) {};
+
+    // Override this function if you don't want to have wxGenericScrolledWindow
+    // automatically change the origin according to the scroll position.
+    virtual void PrepareDC(wxDC& dc);
+
+    // implementation from now on
+    void OnScroll(wxScrollWinEvent& event);
+    void OnSize(wxSizeEvent& event);
+    void OnPaint(wxPaintEvent& event);
+    void OnChar(wxKeyEvent& event);
+
+    // Calculate scroll increment
+    virtual int CalcScrollInc(wxScrollWinEvent& event);
+
+protected:
+    wxWindow             *m_targetWindow;
+    int                   m_xScrollPixelsPerLine;
+    int                   m_yScrollPixelsPerLine;
+    bool                  m_xScrollingEnabled;
+    bool                  m_yScrollingEnabled;
+    int                   m_xScrollPosition;
+    int                   m_yScrollPosition;
+    int                   m_xScrollLines;
+    int                   m_yScrollLines;
+    int                   m_xScrollLinesPerPage;
+    int                   m_yScrollLinesPerPage;
+    double                m_scaleX;
+    double                m_scaleY;
+
+private:
+    DECLARE_EVENT_TABLE()
+    DECLARE_ABSTRACT_CLASS(wxGenericScrolledWindow)
+};
+
+#endif
+    // _WX_GENERIC_SCROLLWIN_H_

include/wx/msw/setup0.h

@@ -0,0 +1,936 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/msw/setup.h
+// Purpose:     Configuration for the library
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_SETUP_H_
+#define _WX_SETUP_H_
+
+// ----------------------------------------------------------------------------
+// global settings
+// ----------------------------------------------------------------------------
+
+// define this to 0 when building wxBase library - this can also be done from
+// makefile/project file overriding the value here
+#ifndef wxUSE_GUI
+    #define wxUSE_GUI            1
+#endif // wxUSE_GUI
+
+// ----------------------------------------------------------------------------
+// compatibility settings
+// ----------------------------------------------------------------------------
+
+// This setting determines the compatibility with 1.68 API:
+// Level 0: no backward compatibility, all new features
+// Level 1: some extra methods are defined for compatibility.
+//
+// Default is 0.
+//
+// Recommended setting: 0 (in fact the compatibility code is now very minimal
+// so there is little advantage to setting it to 1.
+#define WXWIN_COMPATIBILITY  0
+
+// in wxMSW version 2.1.11 and earlier, wxIcon always derives from wxBitmap,
+// but this is very dangerous because you can mistakenly pass an icon instead
+// of a bitmap to a function taking "const wxBitmap&" - which will *not* work
+// because an icon is not a valid bitmap
+//
+// Starting from 2.1.12, you have the choice under this backwards compatible
+// behaviour (your code will still compile, but probably won't behave as
+// expected!) and not deriving wxIcon class from wxBitmap, but providing a
+// conversion ctor wxBitmap(const wxIcon&) instead.
+//
+// Recommended setting: 0
+#define wxICON_IS_BITMAP    0
+
+// Define as 1 for font size to be backward compatible to 1.63 and earlier.
+// 1.64 and later define point sizes to be compatible with Windows.
+//
+// Default is 0
+//
+// Recommended setting: 0
+#define wxFONT_SIZE_COMPATIBILITY    0
+
+// Set to 0 for accurate dialog units, else 1 to be as per 2.1.16 and before.
+// If migrating between versions, your dialogs may seem to shrink.
+//
+// Default is 1
+//
+// Recommended setting: 0 (the new calculations are more correct!)
+#define wxDIALOG_UNIT_COMPATIBILITY   1
+
+// ----------------------------------------------------------------------------
+// debugging settings
+// ----------------------------------------------------------------------------
+
+// Generic comment about debugging settings: they are very useful if you don't
+// use any other memory leak detection tools such as Purify/BoundsChecker, but
+// are probably redundant otherwise. Also, Visual C++ CRT has the same features
+// as wxWindows memory debugging subsystem built in since version 5.0 and you
+// may prefer to use it instead of built in memory debugging code because it is
+// faster and more fool proof.
+//
+// Using VC++ CRT memory debugging is enabled by default in debug mode
+// (__WXDEBUG__) if wxUSE_GLOBAL_MEMORY_OPERATORS is *not* enabled (i.e. is 0)
+// and if __NO_VC_CRTDBG__ is not defined.
+
+// If 1, enables wxDebugContext, for writing error messages to file, etc. If
+// __WXDEBUG__ is not defined, will still use normal memory operators. It's
+// recommended to set this to 1, since you may well need to output an error log
+// in a production version (or non-debugging beta).
+//
+// Default is 1.
+//
+// Recommended setting: 1 but see comment above
+#define wxUSE_DEBUG_CONTEXT 1
+
+// If 1, enables debugging versions of wxObject::new and wxObject::delete *IF*
+// __WXDEBUG__ is also defined.
+//
+// WARNING: this code may not work with all architectures, especially if
+// alignment is an issue. This switch is currently ignored for mingw / cygwin
+//
+// Default is 1
+//
+// Recommended setting: 1 but see comment in the beginning of this section
+#define wxUSE_MEMORY_TRACING 1
+
+// In debug mode, cause new and delete to be redefined globally.
+// If this causes problems (e.g. link errors), set this to 0.
+// This switch is currently ignored for mingw / cygwin
+//
+// Default is 1
+//
+// Recommended setting: 1 but see comment in the beginning of this section
+#define wxUSE_GLOBAL_MEMORY_OPERATORS 1
+
+// In debug mode, causes new to be defined to be WXDEBUG_NEW (see object.h). If
+// this causes problems (e.g. link errors), set this to 0. You may need to set
+// this to 0 if using templates (at least for VC++). This switch is currently
+// ignored for mingw / cygwin
+//
+// Default is 1
+//
+// Recommended setting: 1 but see comment in the beginning of this section
+#define wxUSE_DEBUG_NEW_ALWAYS 1
+
+// wxHandleFatalExceptions() may be used to catch the program faults at run
+// time and, instead of terminating the program with a usual GPF message box,
+// call the user-defined wxApp::OnFatalException() function. If you set
+// wxUSE_ON_FATAL_EXCEPTION to 0, wxHandleFatalExceptions() will not work.
+//
+// This setting is for Win32 only and can only be enabled if your compiler
+// supports Win32 structured exception handling (currently only VC++ does)
+//
+// Default is 1
+//
+// Recommended setting: 1 if your compiler supports it.
+#ifdef _MSC_VER
+    #define wxUSE_ON_FATAL_EXCEPTION 1
+#else
+    #define wxUSE_ON_FATAL_EXCEPTION 0
+#endif
+
+// ----------------------------------------------------------------------------
+// Unicode support
+// ----------------------------------------------------------------------------
+
+// Set wxUSE_UNICODE to 1 to compile wxWindows in Unicode mode: wxChar will be
+// defined as wchar_t, wxString will use Unicode internally. If you set this
+// to 1, you must use wxT() macro for all literal strings in the program.
+//
+// Unicode is currently only fully supported under Windows NT/2000 (Windows 9x
+// doesn't support it and the programs compiled in Unicode mode will not run
+// under 9x).
+//
+// Default is 0
+//
+// Recommended setting: 0 (unless you only plan to use Windows NT/2000)
+#define wxUSE_UNICODE 0
+
+// Setting wxUSE_WCHAR_T to 1 gives you some degree of Unicode support without
+// compiling the program in Unicode mode. More precisely, it will be possible
+// to construct wxString from a wide (Unicode) string and convert any wxString
+// to Unicode.
+//
+// Default is 1
+//
+// Recommended setting: 1
+#define wxUSE_WCHAR_T 1
+
+// ----------------------------------------------------------------------------
+// global features
+// ----------------------------------------------------------------------------
+
+// Support for message/error logging. This includes wxLogXXX() functions and
+// wxLog and derived classes. Don't set this to 0 unless you really know what
+// you are doing.
+//
+// Default is 1
+//
+// Recommended setting: 1 (always)
+#define wxUSE_LOG 1
+
+// Support for multithreaded applications: if 1, compile in thread classes
+// (thread.h) and make the library a bit more thread safe. Although thread
+// support is quite stable by now, you may still consider recompiling the
+// library without it if you have no use for it - this will result in a
+// somewhat smaller and faster operation.
+//
+// This is ignored under Win16, threads are only supported under Win32.
+//
+// Default is 1
+//
+// Recommended setting: 0 unless you do plan to develop MT applications
+#define wxUSE_THREADS 1
+
+// If enabled (1), compiles wxWindows streams classes
+#define wxUSE_STREAMS       1
+
+// Use standard C++ streams if 1. If 0, use wxWin streams implementation.
+#define wxUSE_STD_IOSTREAM  0
+
+// Use serialization (requires utils/serialize)
+#define wxUSE_SERIAL        0
+
+// ----------------------------------------------------------------------------
+// non GUI features selection
+// ----------------------------------------------------------------------------
+
+// Set wxUSE_LONGLONG to 1 to compile the wxLongLong class. This is a 64 bit
+// integer which is implemented in terms of native 64 bit integers if any or
+// uses emulation otherwise.
+//
+// This class is required by wxDateTime and so you should enable it if you want
+// to use wxDateTime. For most modern platforms, it will use the native 64 bit
+// integers in which case (almost) all of its functions are inline and it
+// almost does not take any space, so there should be no reason to switch it
+// off.
+//
+// Recommended setting: 1
+#define wxUSE_LONGLONG      1
+
+// Set wxUSE_TIMEDATE to 1 to compile the wxDateTime and related classes which
+// allow to manipulate dates, times and time intervals. wxDateTime replaces the
+// old wxTime and wxDate classes which are still provided for backwards
+// compatibility (and implemented in terms of wxDateTime).
+//
+// Note that this class is relatively new and is still officially in alpha
+// stage because some features are not yet (fully) implemented. It is already
+// quite useful though and should only be disabled if you are aiming at
+// absolutely minimal version of the library.
+//
+// Requires: wxUSE_LONGLONG
+//
+// Recommended setting: 1
+#define wxUSE_TIMEDATE      1
+
+// Setting wxUSE_CONFIG to 1 enables the use of wxConfig and related classes
+// which allow the application to store its settings in the persistent
+// storage. Setting this to 1 will also enable on-demand creation of the
+// global config object in wxApp.
+//
+// See also wxUSE_CONFIG_NATIVE below.
+//
+// Recommended setting: 1
+#define wxUSE_CONFIG           1
+
+// If wxUSE_CONFIG is 1, you may choose to use either the native config
+// classes under Windows (using .INI files under Win16 and the registry under
+// Win32) or the portable text file format used by the config classes under
+// Unix.
+//
+// Default is 1 to use native classes. Note that you may still use
+// wxFileConfig even if you set this to 1 - just the config object created by
+// default for the applications needs will be a wxRegConfig or wxIniConfig and
+// not wxFileConfig.
+//
+// Recommended setting: 1
+#define wxUSE_CONFIG_NATIVE   1
+
+// If wxUSE_DIALUP_MANAGER is 1, compile in wxDialUpManager class which allows
+// to connect/disconnect from the network and be notified whenever the dial-up
+// network connection is established/terminated. Requires wxUSE_DYNLIB_CLASS.
+//
+// Default is 1.
+//
+// Recommended setting: 1
+#define wxUSE_DIALUP_MANAGER   1
+
+// Compile in wxLibrary class for run-time DLL loading and function calling.
+// Required by wxUSE_DIALUP_MANAGER.
+//
+// This setting is for Win32 only
+//
+// Default is 1.
+//
+// Recommended setting: 1
+#define wxUSE_DYNLIB_CLASS  1
+
+// Set to 1 to use socket classes
+#define wxUSE_SOCKETS       1
+
+// Set to 1 to enable virtual file systems (required by wxHTML)
+#define wxUSE_FILESYSTEM    1
+
+// Set to 1 to enable virtual ZIP filesystem (requires wxUSE_FILESYSTEM)
+#define wxUSE_FS_ZIP        1
+
+// Set to 1 to enable virtual Internet filesystem (requires wxUSE_FILESYSTEM)
+#define wxUSE_FS_INET       1
+
+// Set to 1 to compile wxZipInput/OutputStream classes.
+#define wxUSE_ZIPSTREAM     1
+
+// Set to 1 to compile wxZlibInput/OutputStream classes. Also required by
+// wxUSE_LIBPNG.
+#define wxUSE_ZLIB          1
+
+// If enabled, the code written by Apple will be used to write, in a portable
+// way, float on the disk. See extended.c for the license which is different
+// from wxWindows one.
+//
+// Default is 1.
+//
+// Recommended setting: 1 unless you don't like the license terms (unlikely)
+#define wxUSE_APPLE_IEEE          1
+
+// Use wxFile class.
+//
+// Default is 1.
+//
+// Recommended setting: 1 (highly recommended, required i18n code, wxConfig...)
+#define wxUSE_FILE                1
+
+// use wxTextFile class: requires wxFile, required by wxFileConfig
+#define wxUSE_TEXTFILE            1
+
+// i18n support: _() macro, wxLocale class. Requires wxTextFile.
+#define wxUSE_INTL                1
+
+// ----------------------------------------------------------------------------
+// Optional controls
+// ----------------------------------------------------------------------------
+
+// wxToolBar related settings: if wxUSE_TOOLBAR is 0, don't compile any toolbar
+// classes at all. Otherwise, use the native toolbar class unless
+// wxUSE_TOOLBAR_NATIVE is 0. Additionally, the generic toolbar class which
+// supports some features which might not be supported by the native wxToolBar
+// class may be compiled in if wxUSE_TOOLBAR_SIMPLE is 1.
+//
+// Default is 1 for all settings.
+//
+// Recommended setting: 1 for wxUSE_TOOLBAR and wxUSE_TOOLBAR_NATIVE and 0 for
+// wxUSE_TOOLBAR_SIMPLE (the default is 1 mainly for backwards compatibility).
+#define wxUSE_TOOLBAR 1
+#define wxUSE_TOOLBAR_NATIVE 1
+#define wxUSE_TOOLBAR_SIMPLE 1
+
+// wxNotebook is a control with several "tabs" located on one of its sides. It
+// may be used ot logically organise the data presented to the user instead of
+// putting everything in one huge dialog. It replaces wxTabControl and related
+// classes of wxWin 1.6x.
+//
+// Default is 1.
+//
+// Recommended setting: 1
+#define wxUSE_NOTEBOOK 1
+
+// The corresponding controls will be compiled in if wxUSE_<CONTROL> is set to
+// 1 and not compiled into the library otherwise.
+//
+// Default is 1 for everything.
+//
+// Recommended setting: 1 (library might fail to compile for some combinations
+// of disabled controls)
+#define wxUSE_CARET        1
+#define wxUSE_CHECKBOX     1
+#define wxUSE_CHECKLISTBOX 1        // requires wxUSE_OWNER_DRAWN
+#define wxUSE_CHOICE       1
+#define wxUSE_COMBOBOX     1
+#define wxUSE_GAUGE        1
+#define wxUSE_LISTBOX      1
+#define wxUSE_RADIOBOX     1
+#define wxUSE_RADIOBTN     1
+#define wxUSE_SASH         1        // wxSashWindow
+#define wxUSE_SCROLLBAR    1
+#define wxUSE_SLIDER       1
+#define wxUSE_SPINBTN      1
+#define wxUSE_SPINCTRL     1
+#define wxUSE_STATLINE     1
+#define wxUSE_STATUSBAR    1
+#define wxUSE_TOGGLEBTN    1        // requires wxButton
+#define wxUSE_TOOLTIPS     1        // wxToolTip and wxWindow::SetToolTip()
+
+// Two status bar implementations are available under Win32: the generic one
+// or the wrapper around native control. For native look and feel the native
+// version should be used.
+//
+// Default is 1.
+//
+// Recommended setting: 1
+#define wxUSE_NATIVE_STATUSBAR        1
+
+// this setting is obsolete, value is ignored
+#define wxUSE_BUTTONBAR    1
+
+// wxGrid class comes in two flavours: the original (pre wxWin 2.2) one and
+// the new, much imporved and enhanced version. The new version is backwards
+// compatible with the old one and should be used whenever possible, i.e. if
+// you set wxUSE_GRID to 1, set wxUSE_NEW_GRID to 1 too.
+//
+// Default is 1 for both options.
+//
+// Recommended setting: 1 for wxUSE_NEW_GRID, 0 if you have an old code using
+// wxGrid and 100% backwards compatibality (with all old wxGrid quirks) is
+// essential.
+//
+// WIN16/BC++ resets wxUSE_NEW_GRID to 0 because it exceeds the data limit.
+#define wxUSE_GRID         1
+#define wxUSE_NEW_GRID     1
+
+// wxValidator class and related methods
+#define wxUSE_VALIDATORS 1
+
+// wxAcceleratorTable/Entry classes and support for them in wxMenu(Bar)
+#define wxUSE_ACCEL 1
+
+// ----------------------------------------------------------------------------
+// common dialogs
+// ----------------------------------------------------------------------------
+
+// Define 1 to use generic dialogs in Windows, even though they duplicate
+// native common dialog (e.g. wxColourDialog). This is mainly useful for
+// testing.
+//
+// Default is 0
+//
+// Recommended setting: 0
+#define wxUSE_GENERIC_DIALOGS_IN_MSW 0
+
+// On rare occasions (e.g. using DJGPP) may want to omit common dialogs (e.g.
+// file selector, printer dialog). Switching this off also switches off the
+// printing architecture and interactive wxPrinterDC.
+//
+// Default is 1
+//
+// Recommended setting: 1 (unless it really doesn't work)
+#define wxUSE_COMMON_DIALOGS 1
+
+// text entry dialog and wxGetTextFromUser function
+#define wxUSE_TEXTDLG 1
+
+// progress dialog class for lengthy operations
+#define wxUSE_PROGRESSDLG 1
+
+// wxBusyInfo displays window with message when app is busy. Works in same way
+// as wxBusyCursor
+#define wxUSE_BUSYINFO      1
+
+// wxDirDlg class for getting a directory name from user
+#define wxUSE_DIRDLG 1
+
+// support for startup tips (wxShowTip &c)
+#define wxUSE_STARTUP_TIPS 1
+
+// ----------------------------------------------------------------------------
+// Metafiles support
+// ----------------------------------------------------------------------------
+
+// Windows supports the graphics format known as metafile which is, though not
+// portable, is widely used under Windows and so is supported by wxWin (under
+// Windows only, of course). Win16 (Win3.1) used the so-called "Window
+// MetaFiles" or WMFs which were replaced with "Enhanced MetaFiles" or EMFs in
+// Win32 (Win9x, NT, 2000). Both of these are supported in wxWin and, by
+// default, WMFs will be used under Win16 and EMFs under Win32. This may be
+// changed by setting wxUSE_WIN_METAFILES_ALWAYS to 1 and/or setting
+// wxUSE_ENH_METAFILE to 0. You may also set wxUSE_METAFILE to 0 to not compile
+// in any metafile related classes at all.
+//
+// Default is 1 for wxUSE_ENH_METAFILE and 0 for wxUSE_WIN_METAFILES_ALWAYS.
+//
+// Recommended setting: default or 0 for everything for portable programs.
+#define wxUSE_METAFILE              1
+#define wxUSE_ENH_METAFILE          1
+#define wxUSE_WIN_METAFILES_ALWAYS  0
+
+// ----------------------------------------------------------------------------
+// Big GUI components
+// ----------------------------------------------------------------------------
+
+// Set to 0 to disable document/view architecture
+#define wxUSE_DOC_VIEW_ARCHITECTURE 1
+
+// Set to 0 to disable MDI document/view architecture
+#define wxUSE_MDI_ARCHITECTURE    1
+
+// Set to 0 to disable print/preview architecture code
+#define wxUSE_PRINTING_ARCHITECTURE  1
+
+// wxHTML sublibrary allows to display HTML in wxWindow programs and much,
+// much more.
+//
+// Default is 1.
+//
+// Recommended setting: 1 (wxHTML is great!), set to 0 if you want compile a
+// smaller library.
+#define wxUSE_HTML          1
+
+// wxPlot is a class to display functions plots in wxWindow.
+//
+// Default is 1.
+//
+// Recommended setting: 1
+#define wxUSE_PLOT           1
+
+// OpenGL canvas
+#define wxUSE_GLCANVAS       0
+
+// wxTreeLayout class
+#define wxUSE_TREELAYOUT     1
+
+// ----------------------------------------------------------------------------
+// miscellaneous settings
+// ----------------------------------------------------------------------------
+
+#define wxUSE_IPC         1
+                                // 0 for no interprocess comms
+#define wxUSE_HELP        1
+                                // 0 for no help facility
+#define wxUSE_MS_HTML_HELP 0
+                                // 0 for no MS HTML Help
+#define wxUSE_RESOURCES   1
+                                // 0 for no wxGetResource/wxWriteResource
+#define wxUSE_CONSTRAINTS 1
+                                // 0 for no window layout constraint system
+
+#define wxUSE_CLIPBOARD   1
+                                // 0 for no clipboard functions
+
+#define wxUSE_SPLINES     1
+                                // 0 for no splines
+
+#define wxUSE_DRAG_AND_DROP 1
+                                // 0 for no drag and drop
+
+#define wxUSE_XPM_IN_MSW   1
+                                // 0 for no XPM support in wxBitmap.
+                                // Default is 1, as XPM is now fully
+                                // supported this makes easier the issue
+                                // of portable icons and bitmaps.
+#define wxUSE_IMAGE_LOADING_IN_MSW        1
+                                // Use dynamic DIB loading/saving code in utils/dib under MSW.
+#define wxUSE_RESOURCE_LOADING_IN_MSW     1
+                                // Use dynamic icon/cursor loading/saving code
+                                // under MSW.
+#define wxUSE_WX_RESOURCES        1
+                                // Use .wxr resource mechanism (requires PrologIO library)
+
+// ----------------------------------------------------------------------------
+// postscript support settings
+// ----------------------------------------------------------------------------
+
+// Set to 1 for PostScript device context.
+#define wxUSE_POSTSCRIPT  0
+
+// Set to 1 to use font metric files in GetTextExtent
+#define wxUSE_AFM_FOR_POSTSCRIPT 0
+
+// Set to 0 to disable PostScript print/preview architecture code under Windows
+// (just use Windows printing).
+#define wxUSE_POSTSCRIPT_ARCHITECTURE_IN_MSW 1
+
+// ----------------------------------------------------------------------------
+// database classes
+// ----------------------------------------------------------------------------
+
+// Define 1 to use ODBC classes
+#define wxUSE_ODBC          0
+
+// For backward compatibility reasons, this parameter now only controls the
+// default scrolling method used by cursors.  This default behavior can be
+// overriden by setting the second param of wxDB::wxDbGetConnection() or 
+// wxDb() constructor to indicate whether the connection (and any wxDbTable()s
+// that use the connection) should support forward only scrolling of cursors, 
+// or both forward and backward support for backward scrolling cursors is 
+// dependent on the data source as well as the ODBC driver being used.
+#define wxODBC_FWD_ONLY_CURSORS	 1
+
+// Default is 0.  Set to 1 to use the deprecated classes, enum types, function,
+// member variables.  With a setting of 1, full backward compatability with the
+// 2.0.x release is possible. It is STRONGLY recommended that this be set to 0,
+// as future development will be done only on the non-deprecated
+// functions/classes/member variables/etc.
+#define wxODBC_BACKWARD_COMPATABILITY 0
+
+// ----------------------------------------------------------------------------
+// other compiler (mis)features
+// ----------------------------------------------------------------------------
+
+// Set this to 0 if your compiler can't cope with omission of prototype
+// parameters.
+//
+// Default is 1.
+//
+// Recommended setting: 1 (should never need to set this to 0)
+#define REMOVE_UNUSED_ARG   1
+
+// VC++ 4.2 and above allows <iostream> and <iostream.h> but you can't mix
+// them. Set to 1 for <iostream.h>, 0 for <iostream>
+//
+// Default is 1.
+//
+// Recommended setting: whatever your compiler likes more
+#define wxUSE_IOSTREAMH     1
+
+// ----------------------------------------------------------------------------
+// image format support
+// ----------------------------------------------------------------------------
+
+// wxImage supports many different image formats which can be configured at
+// compile-time. BMP is always supported, others are optional and can be safely
+// disabled if you don't plan to use images in such format sometimes saving
+// substantial amount of code in the final library.
+//
+// Some formats require an extra library which is included in wxWin sources
+// which is mentioned if it is the case.
+
+// Set to 1 for wxImage support (recommended).
+#define wxUSE_IMAGE         1
+
+// Set to 1 for PNG format support (requires libpng). Also requires wxUSE_ZLIB.
+#define wxUSE_LIBPNG        1
+
+// Set to 1 for JPEG format support (requires libjpeg)
+#define wxUSE_LIBJPEG       1
+
+// Set to 1 for TIFF format support (requires libtiff)
+#define wxUSE_LIBTIFF       1
+
+// Set to 1 for GIF format support
+#define wxUSE_GIF           1
+
+// Set to 1 for PNM format support
+#define wxUSE_PNM           1
+
+// Set to 1 for PCX format support
+#define wxUSE_PCX           1
+
+// Set to 1 for XPM format support
+#define wxUSE_XPM           1
+
+// ----------------------------------------------------------------------------
+// Windows-only settings
+// ----------------------------------------------------------------------------
+
+// Set this to 1 if you want to use wxWindows and MFC in the same program. This
+// will override some other settings (see below)
+//
+// Default is 0.
+//
+// Recommended setting: 0 unless you really have to use MFC
+#define wxUSE_MFC           0
+
+// Set this to 1 for generic OLE support: this is required for drag-and-drop,
+// clipboard, OLE Automation. Only set it to 0 if your compiler is very old and
+// can't compile/doesn't have the OLE headers.
+//
+// Default is 1.
+//
+// Recommended setting: 1
+#define wxUSE_OLE           1
+
+// Set this to 1 to use Microsoft CTL3D library for "3D-look" under Win16 or NT
+// 3.x. This setting is ignored under Win9x and NT 4.0+.
+//
+// Default is 0 for (most) Win32 (systems), 1 for Win16
+//
+// Recommended setting: same as default
+#if defined(__WIN95__)
+#define wxUSE_CTL3D                      0
+#else
+#define wxUSE_CTL3D                      1
+#endif
+
+// Define as 1 to use Microsoft's ItsyBitsy small title bar library, for
+// wxMiniFrame. This setting is only used for Win3.1; Win9x and NT use native
+// miniframes support instead.
+//
+// Default is 0 for (most) Win32 (systems), 1 for Win16
+//
+// Recommended setting: same as default
+#if defined(__WIN95__)
+#define wxUSE_ITSY_BITSY             0
+#else
+#define wxUSE_ITSY_BITSY             1
+#endif
+
+// Set this to 1 to use RICHEDIT controls for wxTextCtrl with style wxTE_RICH
+// which allows to put more than ~32Kb of text in it even under Win9x (NT
+// doesn't have such limitation).
+//
+// Default is 1 for compilers which support it
+//
+// Recommended setting: 1, only set it to 0 if your compiler doesn't have
+//                      or can't compile <richedit.h>
+#if defined(__WIN95__) && !defined(__TWIN32__) && !defined(__GNUWIN32_OLD__)
+#define wxUSE_RICHEDIT 1
+#else
+#define wxUSE_RICHEDIT 0
+#endif
+
+// Set this to 1 to enable support for the owner-drawn menu and listboxes. This
+// is required by wxUSE_CHECKLISTBOX.
+//
+// Default is 1.
+//
+// Recommended setting: 1, set to 0 for a small library size reduction
+#define wxUSE_OWNER_DRAWN 1
+
+// ----------------------------------------------------------------------------
+// obsolete settings
+// ----------------------------------------------------------------------------
+
+// NB: all settings in this section are obsolete and should not be used/changed
+//     at all, they will disappear
+
+// Set to 1 to use PenWindows
+#define wxUSE_PENWINDOWS             0
+
+// Define 1 to use bitmap messages.
+#define wxUSE_BITMAP_MESSAGE         1
+
+// If 1, enables provision of run-time type information.
+// NOW MANDATORY: don't change.
+#define wxUSE_DYNAMIC_CLASSES     1
+
+// ----------------------------------------------------------------------------
+// disable the settings which don't work for some compilers
+// ----------------------------------------------------------------------------
+
+#ifndef wxUSE_NORLANDER_HEADERS
+#if (defined(__MINGW32__) || defined(__CYGWIN__)) && ((__GNUC__>2) ||((__GNUC__==2) && (__GNUC_MINOR__>=95)))
+#   define wxUSE_NORLANDER_HEADERS 1
+#else
+#   define wxUSE_NORLANDER_HEADERS 0
+#endif
+#endif
+
+#if defined(__GNUWIN32__)
+// These don't work as expected for mingw32 and cygwin32
+#undef  wxUSE_MEMORY_TRACING
+#define wxUSE_MEMORY_TRACING            0
+
+#undef  wxUSE_GLOBAL_MEMORY_OPERATORS
+#define wxUSE_GLOBAL_MEMORY_OPERATORS   0
+
+#undef  wxUSE_DEBUG_NEW_ALWAYS
+#define wxUSE_DEBUG_NEW_ALWAYS          0
+
+#undef wxUSE_MS_HTML_HELP
+#define wxUSE_MS_HTML_HELP 0
+
+// Cygwin betas don't have wcslen
+#if defined(__CYGWIN__) || defined(__CYGWIN32__)
+#  if ! ((__GNUC__>2) ||((__GNUC__==2) && (__GNUC_MINOR__>=95)))
+#    undef wxUSE_WCHAR_T
+#    define wxUSE_WCHAR_T 0
+#  endif
+#endif
+
+#endif // __GNUWIN32__
+
+// MFC duplicates these operators
+#if wxUSE_MFC
+#undef  wxUSE_GLOBAL_MEMORY_OPERATORS
+#define wxUSE_GLOBAL_MEMORY_OPERATORS   0
+
+#undef  wxUSE_DEBUG_NEW_ALWAYS
+#define wxUSE_DEBUG_NEW_ALWAYS          0
+#endif // wxUSE_MFC
+
+// ODBC classes aren't Unicode-compatible yet
+#if wxUSE_UNICODE
+#undef wxUSE_ODBC
+#define wxUSE_ODBC 0
+#endif
+
+#if (!defined(WIN32) && !defined(__WIN32__)) || (defined(__GNUWIN32__) && !wxUSE_NORLANDER_HEADERS)
+// Can't use OLE drag and drop in Windows 3.1 because we don't know how
+// to implement UUIDs
+// GnuWin32 doesn't have appropriate headers for e.g. IUnknown.
+#undef wxUSE_DRAG_AND_DROP
+#define wxUSE_DRAG_AND_DROP 0
+#endif
+
+// Only WIN32 supports wxStatusBar95
+#if !defined(__WIN32__) && wxUSE_NATIVE_STATUSBAR
+#undef  wxUSE_NATIVE_STATUSBAR
+#define wxUSE_NATIVE_STATUSBAR 0
+#endif
+
+#if !wxUSE_OWNER_DRAWN
+#undef wxUSE_CHECKLISTBOX
+#define wxUSE_CHECKLISTBOX 0
+#endif
+
+// Salford C++ doesn't like some of the memory operator definitions
+#ifdef __SALFORDC__
+#undef  wxUSE_MEMORY_TRACING
+#define wxUSE_MEMORY_TRACING      0
+
+#undef wxUSE_GLOBAL_MEMORY_OPERATORS
+#define wxUSE_GLOBAL_MEMORY_OPERATORS 0
+
+#undef wxUSE_DEBUG_NEW_ALWAYS
+#define wxUSE_DEBUG_NEW_ALWAYS 0
+
+#undef wxUSE_THREADS
+#define wxUSE_THREADS 0
+
+#undef wxUSE_OWNER_DRAWN
+#define wxUSE_OWNER_DRAWN 0
+#endif // __SALFORDC__
+
+#ifdef __TWIN32__
+
+#undef wxUSE_THREADS
+#define wxUSE_THREADS 0
+
+#undef wxUSE_ODBC
+#define wxUSE_ODBC 0
+
+#endif // __TWIN32__
+
+// BC++/Win16 can't cope with the amount of data in resource.cpp
+#if defined(__WIN16__) && defined(__BORLANDC__)
+#undef wxUSE_WX_RESOURCES
+#define wxUSE_WX_RESOURCES        0
+
+#undef wxUSE_ODBC
+#define wxUSE_ODBC                0
+
+#undef wxUSE_NEW_GRID
+#define wxUSE_NEW_GRID            0
+#endif
+
+#if defined(__BORLANDC__) && (__BORLANDC__ < 0x500)
+// BC++ 4.0 can't compile JPEG library
+#undef wxUSE_LIBJPEG
+#define wxUSE_LIBJPEG 0
+#endif
+
+#if defined(__BORLANDC__)
+// Need a BC++-specific htmlhelp.lib before we can enable this
+#undef wxUSE_MS_HTML_HELP
+#define wxUSE_MS_HTML_HELP 0
+#endif
+
+// wxUSE_DEBUG_NEW_ALWAYS = 1 not compatible with BC++ in DLL mode
+#if defined(__BORLANDC__) && (defined(WXMAKINGDLL) || defined(WXUSINGDLL))
+#undef wxUSE_DEBUG_NEW_ALWAYS
+#define wxUSE_DEBUG_NEW_ALWAYS 0
+#endif
+
+#if defined(__WXMSW__) && defined(__WATCOMC__)
+/*
+#undef  wxUSE_GLCANVAS
+#define wxUSE_GLCANVAS 0
+*/
+
+#undef wxUSE_MS_HTML_HELP
+#define wxUSE_MS_HTML_HELP 0
+
+#undef wxUSE_WCHAR_T
+#define wxUSE_WCHAR_T 0
+#endif
+
+#if defined(__WXMSW__) && !defined(__WIN32__)
+
+#undef wxUSE_SOCKETS
+#define wxUSE_SOCKETS 0
+
+#undef wxUSE_THREADS
+#define wxUSE_THREADS 0
+
+#undef wxUSE_TOOLTIPS
+#define wxUSE_TOOLTIPS 0
+
+#undef wxUSE_SPINCTRL
+#define wxUSE_SPINCTRL 0
+
+#undef wxUSE_SPINBTN
+#define wxUSE_SPINBTN 0
+
+#undef wxUSE_LIBPNG
+#define wxUSE_LIBPNG 0
+
+#undef wxUSE_LIBJPEG
+#define wxUSE_LIBJPEG 0
+
+#undef wxUSE_LIBTIFF
+#define wxUSE_LIBTIFF 0
+
+#undef wxUSE_GIF
+#define wxUSE_GIF 0
+
+#undef wxUSE_PNM
+#define wxUSE_PNM 0
+
+#undef wxUSE_PCX
+#define wxUSE_PCX 0
+
+#undef wxUSE_GLCANVAS
+#define wxUSE_GLCANVAS 0
+
+#undef wxUSE_MS_HTML_HELP
+#define wxUSE_MS_HTML_HELP 0
+
+#undef wxUSE_WCHAR_T
+#define wxUSE_WCHAR_T 0
+
+#endif // Win16
+
+// ----------------------------------------------------------------------------
+// undef the things which don't make sense for wxBase build
+// ----------------------------------------------------------------------------
+
+#if !wxUSE_GUI
+
+#undef wxUSE_HTML
+#define wxUSE_HTML 0
+
+#endif // !wxUSE_GUI
+
+// ----------------------------------------------------------------------------
+// check the settings consistency: do it here to abort compilation immediately
+// and not almost in the very end when the relevant file fails to compile and
+// you need to modify setup.h and rebuild everything
+// ----------------------------------------------------------------------------
+
+#if wxUSE_TIMEDATE && !wxUSE_LONGLONG
+    #error wxDateTime requires wxLongLong
+#endif
+
+#if wxUSE_TEXTFILE && !wxUSE_FILE
+    #error You cannot compile wxTextFile without wxFile
+#endif
+
+#if wxUSE_FILESYSTEM && !wxUSE_STREAMS
+    #error You cannot compile virtual file systems without wxUSE_STREAMS
+#endif
+
+#if wxUSE_HTML && !wxUSE_FILESYSTEM
+    #error You cannot compile wxHTML without virtual file systems
+#endif
+
+// add more tests here...
+
+#endif
+    // _WX_SETUP_H_

include/wx/msw/window.h

@@ -0,0 +1,451 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        window.h
+// Purpose:     wxWindow class
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart and Markus Holzem
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_WINDOW_H_
+#define _WX_WINDOW_H_
+
+// ---------------------------------------------------------------------------
+// headers
+// ---------------------------------------------------------------------------
+
+#ifdef __GNUG__
+    #pragma interface "window.h"
+#endif
+
+// #include "wx/msw/winundef.h"
+
+// VZ: apparently some version of Windows send extra mouse move messages after
+//     a mouse click. My tests under NT 4.0 and 95 didn't show it so I'm
+//     tempted to think that it was just an effect of a poor mouse and so the
+//     code to work around this is currently disabled - just define this as 1
+//     to reenable it
+#define wxUSE_MOUSEEVENT_HACK 0
+
+// ---------------------------------------------------------------------------
+// forward declarations
+// ---------------------------------------------------------------------------
+
+class WXDLLEXPORT wxButton;
+
+// ---------------------------------------------------------------------------
+// constants
+// ---------------------------------------------------------------------------
+
+// FIXME does anybody use those? they're unused by wxWindows...
+enum
+{
+    wxKEY_SHIFT = 1,
+    wxKEY_CTRL  = 2
+};
+
+// ---------------------------------------------------------------------------
+// wxWindow declaration for MSW
+// ---------------------------------------------------------------------------
+
+class WXDLLEXPORT wxWindow : public wxWindowBase
+{
+public:
+    wxWindow() { Init(); }
+
+    wxWindow(wxWindow *parent,
+             wxWindowID id,
+             const wxPoint& pos = wxDefaultPosition,
+             const wxSize& size = wxDefaultSize,
+             long style = 0,
+             const wxString& name = wxPanelNameStr)
+    {
+        Init();
+        Create(parent, id, pos, size, style, name);
+    }
+
+    virtual ~wxWindow();
+
+    bool Create(wxWindow *parent,
+                wxWindowID id,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = 0,
+                const wxString& name = wxPanelNameStr);
+
+    // implement base class pure virtuals
+    virtual void SetTitle( const wxString& title);
+    virtual wxString GetTitle() const;
+
+    virtual void Raise();
+    virtual void Lower();
+
+    virtual bool Show( bool show = TRUE );
+    virtual bool Enable( bool enable = TRUE );
+
+    virtual void SetFocus();
+
+    virtual bool Reparent( wxWindowBase *newParent );
+
+    virtual void WarpPointer(int x, int y);
+    virtual void CaptureMouse();
+    virtual void ReleaseMouse();
+
+    virtual void Refresh( bool eraseBackground = TRUE,
+                          const wxRect *rect = (const wxRect *) NULL );
+    virtual void Clear();
+
+    virtual bool SetCursor( const wxCursor &cursor );
+    virtual bool SetFont( const wxFont &font );
+
+    virtual int GetCharHeight() const;
+    virtual int GetCharWidth() const;
+    virtual void GetTextExtent(const wxString& string,
+                               int *x, int *y,
+                               int *descent = (int *) NULL,
+                               int *externalLeading = (int *) NULL,
+                               const wxFont *theFont = (const wxFont *) NULL)
+                               const;
+
+    virtual bool DoPopupMenu( wxMenu *menu, int x, int y );
+
+    virtual void SetScrollbar( int orient, int pos, int thumbVisible,
+                               int range, bool refresh = TRUE );
+    virtual void SetScrollPos( int orient, int pos, bool refresh = TRUE );
+    virtual int GetScrollPos( int orient ) const;
+    virtual int GetScrollThumb( int orient ) const;
+    virtual int GetScrollRange( int orient ) const;
+    virtual void ScrollWindow( int dx, int dy,
+                               const wxRect* rect = (wxRect *) NULL );
+
+#if wxUSE_DRAG_AND_DROP
+    virtual void SetDropTarget( wxDropTarget *dropTarget );
+#endif // wxUSE_DRAG_AND_DROP
+
+    // Accept files for dragging
+    virtual void DragAcceptFiles(bool accept);
+
+#if WXWIN_COMPATIBILITY
+    // Set/get scroll attributes
+    virtual void SetScrollRange(int orient, int range, bool refresh = TRUE);
+    virtual void SetScrollPage(int orient, int page, bool refresh = TRUE);
+    virtual int OldGetScrollRange(int orient) const;
+    virtual int GetScrollPage(int orient) const;
+
+    // event handlers
+        // Handle a control command
+    virtual void OnCommand(wxWindow& win, wxCommandEvent& event);
+
+        // Override to define new behaviour for default action (e.g. double
+        // clicking on a listbox)
+    virtual void OnDefaultAction(wxControl * WXUNUSED(initiatingItem)) { }
+#endif // WXWIN_COMPATIBILITY
+
+#if wxUSE_CARET && WXWIN_COMPATIBILITY
+    // caret manipulation (old MSW only functions, see wxCaret class for the
+    // new API)
+    void CreateCaret(int w, int h);
+    void CreateCaret(const wxBitmap *bitmap);
+    void DestroyCaret();
+    void ShowCaret(bool show);
+    void SetCaretPos(int x, int y);
+    void GetCaretPos(int *x, int *y) const;
+#endif // wxUSE_CARET
+
+    // Native resource loading (implemented in src/msw/nativdlg.cpp)
+    // FIXME: should they really be all virtual?
+    virtual bool LoadNativeDialog(wxWindow* parent, wxWindowID& id);
+    virtual bool LoadNativeDialog(wxWindow* parent, const wxString& name);
+    wxWindow* GetWindowChild1(wxWindowID id);
+    wxWindow* GetWindowChild(wxWindowID id);
+
+    // a MSW only function which sends a size event to the window using its
+    // current size - this has an effect of refreshing the window layout
+/*
+FUNCTION IS NOW A MEMBER OF wxFrame - gt
+    void SendSizeEvent();
+*/
+
+    // implementation from now on
+    // --------------------------
+
+    // simple accessors
+    // ----------------
+
+    WXHWND GetHWND() const { return m_hWnd; }
+    void SetHWND(WXHWND hWnd) { m_hWnd = hWnd; }
+    virtual WXWidget GetHandle() const { return GetHWND(); }
+
+    bool GetUseCtl3D() const { return m_useCtl3D; }
+    bool GetTransparentBackground() const { return m_backgroundTransparent; }
+    void SetTransparent(bool t = TRUE) { m_backgroundTransparent = t; }
+
+    // event handlers
+    // --------------
+
+    void OnSetFocus(wxFocusEvent& event);
+    void OnEraseBackground(wxEraseEvent& event);
+    void OnIdle(wxIdleEvent& event);
+    void OnPaint(wxPaintEvent& event);
+
+public:
+    // For implementation purposes - sometimes decorations make the client area
+    // smaller
+    virtual wxPoint GetClientAreaOrigin() const;
+
+    // Makes an adjustment to the window position (for example, a frame that has
+    // a toolbar that it manages itself).
+    virtual void AdjustForParentClientOrigin(int& x, int& y, int sizeFlags);
+
+    // Windows subclassing
+    void SubclassWin(WXHWND hWnd);
+    void UnsubclassWin();
+
+    WXFARPROC MSWGetOldWndProc() const { return m_oldWndProc; }
+    void MSWSetOldWndProc(WXFARPROC proc) { m_oldWndProc = proc; }
+
+    wxWindow *FindItem(long id) const;
+    wxWindow *FindItemByHWND(WXHWND hWnd, bool controlOnly = FALSE) const;
+
+    // Make a Windows extended style from the given wxWindows window style
+    static WXDWORD MakeExtendedStyle(long style,
+                                     bool eliminateBorders = FALSE);
+    // Determine whether 3D effects are wanted
+    WXDWORD Determine3DEffects(WXDWORD defaultBorderStyle, bool *want3D) const;
+
+    // MSW only: TRUE if this control is part of the main control
+    virtual bool ContainsHWND(WXHWND WXUNUSED(hWnd)) const { return FALSE; };
+
+    // returns TRUE if the window has been created
+    bool MSWCreate(int id,
+                   wxWindow *parent,
+                   const wxChar *wclass,
+                   wxWindow *wx_win,
+                   const wxChar *title,
+                   int x, int y, int width, int height,
+                   WXDWORD style,
+                   const wxChar *dialog_template = NULL,
+                   WXDWORD exendedStyle = 0);
+    virtual bool MSWCommand(WXUINT param, WXWORD id);
+
+#if WXWIN_COMPATIBILITY
+    wxObject *GetChild(int number) const;
+    virtual void MSWDeviceToLogical(float *x, float *y) const;
+#endif // WXWIN_COMPATIBILITY
+
+    // Create an appropriate wxWindow from a HWND
+    virtual wxWindow* CreateWindowFromHWND(wxWindow* parent, WXHWND hWnd);
+
+    // Make sure the window style reflects the HWND style (roughly)
+    virtual void AdoptAttributesFromHWND();
+
+    // Setup background and foreground colours correctly
+    virtual void SetupColours();
+
+    // ------------------------------------------------------------------------
+    // helpers for message handlers: these perform the same function as the
+    // message crackers from <windowsx.h> - they unpack WPARAM and LPARAM into
+    // the correct parameters
+    // ------------------------------------------------------------------------
+
+    void UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
+                       WXWORD *id, WXHWND *hwnd, WXWORD *cmd);
+    void UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
+                        WXWORD *state, WXWORD *minimized, WXHWND *hwnd);
+    void UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
+                      WXWORD *code, WXWORD *pos, WXHWND *hwnd);
+    void UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
+                        WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd);
+    void UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
+                          WXWORD *item, WXWORD *flags, WXHMENU *hmenu);
+
+    // ------------------------------------------------------------------------
+    // internal handlers for MSW messages: all handlers return a boolean value:
+    // TRUE means that the handler processed the event and FALSE that it didn't
+    // ------------------------------------------------------------------------
+
+    // there are several cases where we have virtual functions for Windows
+    // message processing: this is because these messages often require to be
+    // processed in a different manner in the derived classes. For all other
+    // messages, however, we do *not* have corresponding MSWOnXXX() function
+    // and if the derived class wants to process them, it should override
+    // MSWWindowProc() directly.
+
+    // scroll event (both horizontal and vertical)
+    virtual bool MSWOnScroll(int orientation, WXWORD nSBCode,
+                             WXWORD pos, WXHWND control);
+
+    // child control notifications
+#ifdef __WIN95__
+    virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result);
+#endif // __WIN95__
+
+    // owner-drawn controls need to process these messages
+    virtual bool MSWOnDrawItem(int id, WXDRAWITEMSTRUCT *item);
+    virtual bool MSWOnMeasureItem(int id, WXMEASUREITEMSTRUCT *item);
+
+    // the rest are not virtual
+    bool HandleCreate(WXLPCREATESTRUCT cs, bool *mayCreate);
+    bool HandleInitDialog(WXHWND hWndFocus);
+    bool HandleDestroy();
+
+    bool HandlePaint();
+    bool HandleEraseBkgnd(WXHDC pDC);
+
+    bool HandleMinimize();
+    bool HandleMaximize();
+    bool HandleSize(int x, int y, WXUINT flag);
+    bool HandleGetMinMaxInfo(void *mmInfo);
+
+    bool HandleShow(bool show, int status);
+    bool HandleActivate(int flag, bool minimized, WXHWND activate);
+
+    bool HandleCommand(WXWORD id, WXWORD cmd, WXHWND control);
+    bool HandleSysCommand(WXWPARAM wParam, WXLPARAM lParam);
+
+    bool HandleCtlColor(WXHBRUSH *hBrush,
+                        WXHDC hdc,
+                        WXHWND hWnd,
+                        WXUINT nCtlColor,
+                        WXUINT message,
+                        WXWPARAM wParam,
+                        WXLPARAM lParam);
+
+    bool HandlePaletteChanged(WXHWND hWndPalChange);
+    bool HandleQueryNewPalette();
+    bool HandleSysColorChange();
+
+    bool HandleQueryEndSession(long logOff, bool *mayEnd);
+    bool HandleEndSession(bool endSession, long logOff);
+
+    bool HandleSetFocus(WXHWND wnd);
+    bool HandleKillFocus(WXHWND wnd);
+
+    bool HandleDropFiles(WXWPARAM wParam);
+
+    bool HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags);
+    bool HandleMouseMove(int x, int y, WXUINT flags);
+
+    bool HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII = FALSE);
+    bool HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam);
+    bool HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam);
+
+    bool HandleQueryDragIcon(WXHICON *hIcon);
+
+    bool HandleSetCursor(WXHWND hWnd, short nHitTest, int mouseMsg);
+
+    // Window procedure
+    virtual long MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
+
+    // Calls an appropriate default window procedure
+    virtual long MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
+    virtual bool MSWProcessMessage(WXMSG* pMsg);
+    virtual bool MSWTranslateMessage(WXMSG* pMsg);
+    virtual void MSWDestroyWindow();
+
+    // Detach "Window" menu from menu bar so it doesn't get deleted
+    void MSWDetachWindowMenu();
+
+    // this function should return the brush to paint the window background
+    // with or 0 for the default brush
+    virtual WXHBRUSH OnCtlColor(WXHDC hDC,
+                                WXHWND hWnd,
+                                WXUINT nCtlColor,
+                                WXUINT message,
+                                WXWPARAM wParam,
+                                WXLPARAM lParam);
+
+#if WXWIN_COMPATIBILITY
+    void SetShowing(bool show) { (void)Show(show); }
+    bool IsUserEnabled() const { return IsEnabled(); }
+#endif // WXWIN_COMPATIBILITY
+
+    // Responds to colour changes: passes event on to children.
+    void OnSysColourChanged(wxSysColourChangedEvent& event);
+
+    // initialize various fields of wxMouseEvent (common part of MSWOnMouseXXX)
+    void InitMouseEvent(wxMouseEvent& event, int x, int y, WXUINT flags);
+
+protected:
+    // the window handle
+    WXHWND                m_hWnd;
+
+    // the old window proc (we subclass all windows)
+    WXFARPROC             m_oldWndProc;
+
+    // additional (MSW specific) flags
+    bool                  m_useCtl3D:1; // Using CTL3D for this control
+    bool                  m_backgroundTransparent:1;
+    bool                  m_mouseInWindow:1;
+    bool                  m_doubleClickAllowed:1;
+    bool                  m_winCaptured:1;
+
+    // the size of one page for scrolling
+    int                   m_xThumbSize;
+    int                   m_yThumbSize;
+
+#if wxUSE_MOUSEEVENT_HACK
+    // the coordinates of the last mouse event and the type of it
+    long                  m_lastMouseX,
+                          m_lastMouseY;
+    int                   m_lastMouseEvent;
+#endif // wxUSE_MOUSEEVENT_HACK
+
+    WXHMENU               m_hMenu; // Menu, if any
+
+    // the return value of WM_GETDLGCODE handler
+    long m_lDlgCode;
+
+    // implement the base class pure virtuals
+    virtual void DoClientToScreen( int *x, int *y ) const;
+    virtual void DoScreenToClient( int *x, int *y ) const;
+    virtual void DoGetPosition( int *x, int *y ) const;
+    virtual void DoGetSize( int *width, int *height ) const;
+    virtual void DoGetClientSize( int *width, int *height ) const;
+    virtual void DoSetSize(int x, int y,
+                           int width, int height,
+                           int sizeFlags = wxSIZE_AUTO);
+    virtual void DoSetClientSize(int width, int height);
+
+    // move the window to the specified location and resize it: this is called
+    // from both DoSetSize() and DoSetClientSize() and would usually just call
+    // ::MoveWindow() except for composite controls which will want to arrange
+    // themselves inside the given rectangle
+    virtual void DoMoveWindow(int x, int y, int width, int height);
+
+#if wxUSE_TOOLTIPS
+    virtual void DoSetToolTip( wxToolTip *tip );
+#endif // wxUSE_TOOLTIPS
+
+private:
+    // common part of all ctors
+    void Init();
+
+    // the (non-virtual) handlers for the events
+    bool HandleMove(int x, int y);
+    bool HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags);
+
+#ifdef __WIN95__
+    bool HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result);
+#endif // __WIN95__
+
+    // the helper functions used by HandleChar/KeyXXX methods
+    wxKeyEvent CreateKeyEvent(wxEventType evType, int id, WXLPARAM lp) const;
+
+    DECLARE_DYNAMIC_CLASS(wxWindow);
+    DECLARE_NO_COPY_CLASS(wxWindow);
+    DECLARE_EVENT_TABLE()
+};
+
+// ---------------------------------------------------------------------------
+// global functions
+// ---------------------------------------------------------------------------
+
+// kbd code translation
+WXDLLEXPORT int wxCharCodeMSWToWX(int keySym);
+WXDLLEXPORT int wxCharCodeWXToMSW(int id, bool *IsVirtual);
+
+#endif
+    // _WX_WINDOW_H_

src/generic/scrolwin.cpp

@@ -0,0 +1,704 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        generic/scrolwin.cpp
+// Purpose:     wxGenericScrolledWindow implementation
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart and Markus Holzem
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#ifdef __GNUG__
+    #pragma implementation "scrolwin.h"
+#endif
+
+#ifdef __VMS
+#define XtDisplay XTDISPLAY
+#endif
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+    #pragma hdrstop
+#endif
+
+#include "wx/utils.h"
+#include "wx/dcclient.h"
+
+#include "wx/generic/scrolwin.h"
+#include "wx/panel.h"
+
+#ifdef __WXMSW__
+    #include "windows.h"
+#endif
+
+#ifdef __WXMOTIF__
+// For wxRETAINED implementation
+#ifdef __VMS__ //VMS's Xm.h is not (yet) compatible with C++
+               //This code switches off the compiler warnings
+# pragma message disable nosimpint
+#endif
+#include <Xm/Xm.h>
+#ifdef __VMS__
+# pragma message enable nosimpint
+#endif
+#endif
+
+#ifndef __WXGTK__
+#include "wx/scrolwin.h"
+IMPLEMENT_CLASS(wxScrolledWindow, wxGenericScrolledWindow)
+#endif
+
+// ----------------------------------------------------------------------------
+// event tables
+// ----------------------------------------------------------------------------
+
+BEGIN_EVENT_TABLE(wxGenericScrolledWindow, wxPanel)
+    EVT_SCROLLWIN(wxGenericScrolledWindow::OnScroll)
+    EVT_SIZE(wxGenericScrolledWindow::OnSize)
+    EVT_PAINT(wxGenericScrolledWindow::OnPaint)
+    EVT_CHAR(wxGenericScrolledWindow::OnChar)
+END_EVENT_TABLE()
+
+IMPLEMENT_DYNAMIC_CLASS(wxGenericScrolledWindow, wxPanel)
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxGenericScrolledWindow creation
+// ----------------------------------------------------------------------------
+
+wxGenericScrolledWindow::wxGenericScrolledWindow()
+{
+    m_xScrollPixelsPerLine = 0;
+    m_yScrollPixelsPerLine = 0;
+    m_xScrollingEnabled = TRUE;
+    m_yScrollingEnabled = TRUE;
+    m_xScrollPosition = 0;
+    m_yScrollPosition = 0;
+    m_xScrollLines = 0;
+    m_yScrollLines = 0;
+    m_xScrollLinesPerPage = 0;
+    m_yScrollLinesPerPage = 0;
+    m_scaleX = 1.0;
+    m_scaleY = 1.0;
+    m_targetWindow = (wxWindow*) NULL;
+}
+
+bool wxGenericScrolledWindow::Create(wxWindow *parent,
+                              wxWindowID id,
+                              const wxPoint& pos,
+                              const wxSize& size,
+                              long style,
+                              const wxString& name)
+{
+    m_xScrollPixelsPerLine = 0;
+    m_yScrollPixelsPerLine = 0;
+    m_xScrollingEnabled = TRUE;
+    m_yScrollingEnabled = TRUE;
+    m_xScrollPosition = 0;
+    m_yScrollPosition = 0;
+    m_xScrollLines = 0;
+    m_yScrollLines = 0;
+    m_xScrollLinesPerPage = 0;
+    m_yScrollLinesPerPage = 0;
+    m_scaleX = 1.0;
+    m_scaleY = 1.0;
+
+    m_targetWindow = this;
+
+    bool ok = wxPanel::Create(parent, id, pos, size, style, name);
+
+#ifdef __WXMSW__
+    // we need to process arrows ourselves for scrolling
+    m_lDlgCode |= DLGC_WANTARROWS;
+#endif // __WXMSW__
+
+    return ok;
+}
+
+wxGenericScrolledWindow::~wxGenericScrolledWindow()
+{
+}
+
+// ----------------------------------------------------------------------------
+// setting scrolling parameters
+// ----------------------------------------------------------------------------
+
+/*
+ * pixelsPerUnitX/pixelsPerUnitY: number of pixels per unit (e.g. pixels per text line)
+ * noUnitsX/noUnitsY:        : no. units per scrollbar
+ */
+void wxGenericScrolledWindow::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY,
+               int noUnitsX, int noUnitsY,
+               int xPos, int yPos, bool noRefresh )
+{
+    int xpos, ypos;
+
+    CalcUnscrolledPosition(xPos, yPos, &xpos, &ypos);
+    bool do_refresh =
+    (
+      (noUnitsX != 0 && m_xScrollLines == 0) ||
+      (noUnitsX < m_xScrollLines && xpos > pixelsPerUnitX*noUnitsX) || 
+
+      (noUnitsY != 0 && m_yScrollLines == 0) ||
+      (noUnitsY < m_yScrollLines && ypos > pixelsPerUnitY*noUnitsY) ||
+      (xPos != m_xScrollPosition) ||
+      (yPos != m_yScrollPosition)
+//       (pixelsPerUnitX != m_xScrollPixelsPerLine) ||
+//       (pixelsPerUnitY != m_yScrollPixelsPerLine)
+    );
+
+    m_xScrollPixelsPerLine = pixelsPerUnitX;
+    m_yScrollPixelsPerLine = pixelsPerUnitY;
+    m_xScrollPosition = xPos;
+    m_yScrollPosition = yPos;
+    m_xScrollLines = noUnitsX;
+    m_yScrollLines = noUnitsY;
+
+#ifdef __WXMOTIF__
+    // Sorry, some Motif-specific code to implement a backing pixmap
+    // for the wxRETAINED style. Implementing a backing store can't
+    // be entirely generic because it relies on the wxWindowDC implementation
+    // to duplicate X drawing calls for the backing pixmap.
+
+    if ((m_windowStyle & wxRETAINED) == wxRETAINED)
+    {
+        Display* dpy = XtDisplay((Widget) GetMainWidget());
+
+        int totalPixelWidth = m_xScrollLines * m_xScrollPixelsPerLine;
+        int totalPixelHeight = m_yScrollLines * m_yScrollPixelsPerLine;
+        if (m_backingPixmap &&
+           !((m_pixmapWidth == totalPixelWidth) &&
+             (m_pixmapHeight == totalPixelHeight)))
+        {
+            XFreePixmap (dpy, (Pixmap) m_backingPixmap);
+            m_backingPixmap = (WXPixmap) 0;
+        }
+
+        if (!m_backingPixmap &&
+           (noUnitsX != 0) && (noUnitsY != 0))
+        {
+            int depth = wxDisplayDepth();
+            m_pixmapWidth = totalPixelWidth;
+            m_pixmapHeight = totalPixelHeight;
+            m_backingPixmap = (WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
+            m_pixmapWidth, m_pixmapHeight, depth);
+        }
+
+    }
+#endif // Motif
+
+    AdjustScrollbars();
+
+    if (do_refresh && !noRefresh)
+        m_targetWindow->Refresh();
+
+#ifdef __WXMSW__
+    // GRG: if this turns out to be really necessary, we could
+    //   at least move it to the above if { ... } so that it is
+    //   only done if noRefresh = FALSE (the default). OTOH, if
+    //   this doesn't break anything, which seems to be the
+    //   case, we could just leave it out.
+
+    // Necessary?
+    // UpdateWindow ((HWND) m_targetWindow->GetHWND());
+#endif
+#ifdef __WXMAC__
+    m_targetWindow->MacUpdateImmediately() ;
+#endif
+}
+
+// ----------------------------------------------------------------------------
+// target window handling
+// ----------------------------------------------------------------------------
+
+void wxGenericScrolledWindow::SetTargetWindow( wxWindow *target )
+{
+    wxASSERT_MSG( target, wxT("target window must not be NULL") );
+    m_targetWindow = target;
+}
+
+wxWindow *wxGenericScrolledWindow::GetTargetWindow()
+{
+    return m_targetWindow;
+}
+
+// ----------------------------------------------------------------------------
+// scrolling implementation itself
+// ----------------------------------------------------------------------------
+
+void wxGenericScrolledWindow::OnScroll(wxScrollWinEvent& event)
+{
+    int orient = event.GetOrientation();
+
+    int nScrollInc = CalcScrollInc(event);
+    if (nScrollInc == 0) return;
+
+    if (orient == wxHORIZONTAL)
+    {
+        int newPos = m_xScrollPosition + nScrollInc;
+        SetScrollPos(wxHORIZONTAL, newPos, TRUE );
+    }
+    else
+    {
+        int newPos = m_yScrollPosition + nScrollInc;
+        SetScrollPos(wxVERTICAL, newPos, TRUE );
+    }
+
+    if (orient == wxHORIZONTAL)
+    {
+        m_xScrollPosition += nScrollInc;
+    }
+    else
+    {
+        m_yScrollPosition += nScrollInc;
+    }
+
+    if (orient == wxHORIZONTAL)
+    {
+       if (m_xScrollingEnabled)
+            m_targetWindow->ScrollWindow(-m_xScrollPixelsPerLine * nScrollInc, 0, (const wxRect *) NULL);
+       else
+            m_targetWindow->Refresh();
+    }
+    else
+    {
+        if (m_yScrollingEnabled)
+            m_targetWindow->ScrollWindow(0, -m_yScrollPixelsPerLine * nScrollInc, (const wxRect *) NULL);
+        else
+            m_targetWindow->Refresh();
+    }
+#ifdef __WXMAC__
+    m_targetWindow->MacUpdateImmediately() ;
+#endif
+}
+
+int wxGenericScrolledWindow::CalcScrollInc(wxScrollWinEvent& event)
+{
+    int pos = event.GetPosition();
+    int orient = event.GetOrientation();
+
+    int nScrollInc = 0;
+    if (event.GetEventType() == wxEVT_SCROLLWIN_TOP)
+    {
+            if (orient == wxHORIZONTAL)
+                nScrollInc = - m_xScrollPosition;
+            else
+                nScrollInc = - m_yScrollPosition;
+    } else
+    if (event.GetEventType() == wxEVT_SCROLLWIN_BOTTOM)
+    {
+            if (orient == wxHORIZONTAL)
+                nScrollInc = m_xScrollLines - m_xScrollPosition;
+            else
+                nScrollInc = m_yScrollLines - m_yScrollPosition;
+    } else
+    if (event.GetEventType() == wxEVT_SCROLLWIN_LINEUP)
+    {
+            nScrollInc = -1;
+    } else
+    if (event.GetEventType() == wxEVT_SCROLLWIN_LINEDOWN)
+    {
+            nScrollInc = 1;
+    } else
+    if (event.GetEventType() == wxEVT_SCROLLWIN_PAGEUP)
+    {
+            if (orient == wxHORIZONTAL)
+                nScrollInc = -GetScrollPageSize(wxHORIZONTAL);
+            else
+                nScrollInc = -GetScrollPageSize(wxVERTICAL);
+    } else
+    if (event.GetEventType() == wxEVT_SCROLLWIN_PAGEDOWN)
+    {
+            if (orient == wxHORIZONTAL)
+                nScrollInc = GetScrollPageSize(wxHORIZONTAL);
+            else
+                nScrollInc = GetScrollPageSize(wxVERTICAL);
+    } else
+    if ((event.GetEventType() == wxEVT_SCROLLWIN_THUMBTRACK) ||
+        (event.GetEventType() == wxEVT_SCROLLWIN_THUMBRELEASE))
+    {
+            if (orient == wxHORIZONTAL)
+                nScrollInc = pos - m_xScrollPosition;
+            else
+                nScrollInc = pos - m_yScrollPosition;
+    }
+
+    if (orient == wxHORIZONTAL)
+    {
+        if (m_xScrollPixelsPerLine > 0)
+        {
+            int w, h;
+            m_targetWindow->GetClientSize(&w, &h);
+
+            int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine;
+            int noPositions = (int) ( ((nMaxWidth - w)/(double)m_xScrollPixelsPerLine) + 0.5 );
+            if (noPositions < 0)
+                noPositions = 0;
+
+            if ( (m_xScrollPosition + nScrollInc) < 0 )
+                nScrollInc = -m_xScrollPosition; // As -ve as we can go
+            else if ( (m_xScrollPosition + nScrollInc) > noPositions )
+                nScrollInc = noPositions - m_xScrollPosition; // As +ve as we can go
+        }
+        else
+            m_targetWindow->Refresh();
+    }
+    else
+    {
+        if (m_yScrollPixelsPerLine > 0)
+        {
+            int w, h;
+            m_targetWindow->GetClientSize(&w, &h);
+
+            int nMaxHeight = m_yScrollLines*m_yScrollPixelsPerLine;
+            int noPositions = (int) ( ((nMaxHeight - h)/(double)m_yScrollPixelsPerLine) + 0.5 );
+            if (noPositions < 0)
+                noPositions = 0;
+
+            if ( (m_yScrollPosition + nScrollInc) < 0 )
+                nScrollInc = -m_yScrollPosition; // As -ve as we can go
+            else if ( (m_yScrollPosition + nScrollInc) > noPositions )
+                nScrollInc = noPositions - m_yScrollPosition; // As +ve as we can go
+        }
+        else
+            m_targetWindow->Refresh();
+    }
+
+    return nScrollInc;
+}
+
+// Adjust the scrollbars - new version.
+void wxGenericScrolledWindow::AdjustScrollbars()
+{
+    int w, h;
+    m_targetWindow->GetClientSize(&w, &h);
+
+    int oldXScroll = m_xScrollPosition;
+    int oldYScroll = m_yScrollPosition;
+
+    if (m_xScrollLines > 0)
+    {
+        // Calculate page size i.e. number of scroll units you get on the
+        // current client window
+        int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 );
+        if (noPagePositions < 1) noPagePositions = 1;
+
+        // Correct position if greater than extent of canvas minus
+        // the visible portion of it or if below zero
+        m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition);
+        m_xScrollPosition = wxMax( 0, m_xScrollPosition );
+
+        SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, m_xScrollLines);
+        // The amount by which we scroll when paging
+        SetScrollPageSize(wxHORIZONTAL, noPagePositions);
+    }
+    else
+    {
+        m_xScrollPosition = 0;
+        SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE);
+    }
+
+    if (m_yScrollLines > 0)
+    {
+        // Calculate page size i.e. number of scroll units you get on the
+        // current client window
+        int noPagePositions = (int) ( (h/(double)m_yScrollPixelsPerLine) + 0.5 );
+        if (noPagePositions < 1) noPagePositions = 1;
+
+        // Correct position if greater than extent of canvas minus
+        // the visible portion of it or if below zero
+        m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
+        m_yScrollPosition = wxMax( 0, m_yScrollPosition );
+
+        SetScrollbar(wxVERTICAL, m_yScrollPosition, noPagePositions, m_yScrollLines);
+        // The amount by which we scroll when paging
+        SetScrollPageSize(wxVERTICAL, noPagePositions);
+    }
+    else
+    {
+        m_yScrollPosition = 0;
+        SetScrollbar (wxVERTICAL, 0, 0, 0, FALSE);
+    }
+
+    if (oldXScroll != m_xScrollPosition)
+    {
+       if (m_xScrollingEnabled)
+            m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll-m_xScrollPosition), 0, (const wxRect *) NULL );
+       else
+            m_targetWindow->Refresh();
+    }
+
+    if (oldYScroll != m_yScrollPosition)
+    {
+        if (m_yScrollingEnabled)
+            m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition), (const wxRect *) NULL );
+        else
+            m_targetWindow->Refresh();
+    }
+}
+
+// Override this function if you don't want to have wxGenericScrolledWindow
+// automatically change the origin according to the scroll position.
+void wxGenericScrolledWindow::PrepareDC(wxDC& dc)
+{
+    dc.SetDeviceOrigin( -m_xScrollPosition * m_xScrollPixelsPerLine,
+                        -m_yScrollPosition * m_yScrollPixelsPerLine );
+    dc.SetUserScale( m_scaleX, m_scaleY );
+}
+
+#if WXWIN_COMPATIBILITY
+void wxGenericScrolledWindow::GetScrollUnitsPerPage (int *x_page, int *y_page) const
+{
+      *x_page = GetScrollPageSize(wxHORIZONTAL);
+      *y_page = GetScrollPageSize(wxVERTICAL);
+}
+
+void wxGenericScrolledWindow::CalcUnscrolledPosition(int x, int y, float *xx, float *yy) const
+{
+    if ( xx )
+        *xx = (float)(x + m_xScrollPosition * m_xScrollPixelsPerLine);
+    if ( yy )
+        *yy = (float)(y + m_yScrollPosition * m_yScrollPixelsPerLine);
+}
+#endif // WXWIN_COMPATIBILITY
+
+void wxGenericScrolledWindow::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const
+{
+    if ( x_unit )
+        *x_unit = m_xScrollPixelsPerLine;
+    if ( y_unit )
+        *y_unit = m_yScrollPixelsPerLine;
+}
+
+int wxGenericScrolledWindow::GetScrollPageSize(int orient) const
+{
+    if ( orient == wxHORIZONTAL )
+        return m_xScrollLinesPerPage;
+    else
+        return m_yScrollLinesPerPage;
+}
+
+void wxGenericScrolledWindow::SetScrollPageSize(int orient, int pageSize)
+{
+    if ( orient == wxHORIZONTAL )
+        m_xScrollLinesPerPage = pageSize;
+    else
+        m_yScrollLinesPerPage = pageSize;
+}
+
+/*
+ * Scroll to given position (scroll position, not pixel position)
+ */
+void wxGenericScrolledWindow::Scroll( int x_pos, int y_pos )
+{
+    if (!m_targetWindow)
+        return;
+
+    if (((x_pos == -1) || (x_pos == m_xScrollPosition)) &&
+        ((y_pos == -1) || (y_pos == m_yScrollPosition))) return;
+
+    int w, h;
+    m_targetWindow->GetClientSize(&w, &h);
+
+    if ((x_pos != -1) && (m_xScrollPixelsPerLine))
+    {
+        int old_x = m_xScrollPosition;
+        m_xScrollPosition = x_pos;
+
+        // Calculate page size i.e. number of scroll units you get on the
+        // current client window
+        int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 );
+        if (noPagePositions < 1) noPagePositions = 1;
+
+        // Correct position if greater than extent of canvas minus
+        // the visible portion of it or if below zero
+        m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition );
+        m_xScrollPosition = wxMax( 0, m_xScrollPosition );
+
+        if (old_x != m_xScrollPosition) {
+            m_targetWindow->SetScrollPos( wxHORIZONTAL, m_xScrollPosition, TRUE );
+            m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0 );
+        }
+    }
+    if ((y_pos != -1) && (m_yScrollPixelsPerLine))
+    {
+        int old_y = m_yScrollPosition;
+        m_yScrollPosition = y_pos;
+
+        // Calculate page size i.e. number of scroll units you get on the
+        // current client window
+        int noPagePositions = (int) ( (h/(double)m_yScrollPixelsPerLine) + 0.5 );
+        if (noPagePositions < 1) noPagePositions = 1;
+
+        // Correct position if greater than extent of canvas minus
+        // the visible portion of it or if below zero
+        m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
+        m_yScrollPosition = wxMax( 0, m_yScrollPosition );
+        
+        if (old_y != m_yScrollPosition) {
+            m_targetWindow->SetScrollPos( wxVERTICAL, m_yScrollPosition, TRUE );
+            m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine );
+        }
+    }
+
+#ifdef __WXMAC__
+    m_targetWindow->MacUpdateImmediately();
+#endif
+}
+
+void wxGenericScrolledWindow::EnableScrolling (bool x_scroll, bool y_scroll)
+{
+    m_xScrollingEnabled = x_scroll;
+    m_yScrollingEnabled = y_scroll;
+}
+
+void wxGenericScrolledWindow::GetVirtualSize (int *x, int *y) const
+{
+    if ( x )
+        *x = m_xScrollPixelsPerLine * m_xScrollLines;
+    if ( y )
+        *y = m_yScrollPixelsPerLine * m_yScrollLines;
+}
+
+// Where the current view starts from
+void wxGenericScrolledWindow::GetViewStart (int *x, int *y) const
+{
+    if ( x )
+        *x = m_xScrollPosition;
+    if ( y )
+        *y = m_yScrollPosition;
+}
+
+void wxGenericScrolledWindow::CalcScrolledPosition(int x, int y, int *xx, int *yy) const
+{
+    if ( xx )
+        *xx = x - m_xScrollPosition * m_xScrollPixelsPerLine;
+    if ( yy )
+        *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine;
+}
+
+void wxGenericScrolledWindow::CalcUnscrolledPosition(int x, int y, int *xx, int *yy) const
+{
+    if ( xx )
+        *xx = x + m_xScrollPosition * m_xScrollPixelsPerLine;
+    if ( yy )
+        *yy = y + m_yScrollPosition * m_yScrollPixelsPerLine;
+}
+
+// ----------------------------------------------------------------------------
+// event handlers
+// ----------------------------------------------------------------------------
+
+// Default OnSize resets scrollbars, if any
+void wxGenericScrolledWindow::OnSize(wxSizeEvent& WXUNUSED(event))
+{
+#if wxUSE_CONSTRAINTS
+    if (GetAutoLayout())
+        Layout();
+#endif
+
+    AdjustScrollbars();
+}
+
+// This calls OnDraw, having adjusted the origin according to the current
+// scroll position
+void wxGenericScrolledWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
+{
+    wxPaintDC dc(this);
+    PrepareDC(dc);
+
+    OnDraw(dc);
+}
+
+// kbd handling: notice that we use OnChar() and not OnKeyDown() for
+// compatibility here - if we used OnKeyDown(), the programs which process
+// arrows themselves in their OnChar() would never get the message and like
+// this they always have the priority
+void wxGenericScrolledWindow::OnChar(wxKeyEvent& event)
+{
+    int stx, sty,       // view origin
+        szx, szy,       // view size (total)
+        clix, cliy;     // view size (on screen)
+
+    ViewStart(&stx, &sty);
+    GetClientSize(&clix, &cliy);
+    GetVirtualSize(&szx, &szy);
+
+    if( m_xScrollPixelsPerLine )
+    {
+        clix /= m_xScrollPixelsPerLine;
+        szx /= m_xScrollPixelsPerLine;
+    }
+    else
+    {
+        clix = 0;
+        szx = -1;
+    }
+    if( m_yScrollPixelsPerLine )
+    {
+        cliy /= m_yScrollPixelsPerLine;
+        szy /= m_yScrollPixelsPerLine;
+    }
+    else
+    {
+        cliy = 0;
+        szy = -1;
+    }
+
+    int dsty;
+    switch ( event.KeyCode() )
+    {
+        case WXK_PAGEUP:
+        case WXK_PRIOR:
+            dsty = sty - (5 * cliy / 6);
+            Scroll(-1, (dsty == -1) ? 0 : dsty);
+            break;
+
+        case WXK_PAGEDOWN:
+        case WXK_NEXT:
+            Scroll(-1, sty + (5 * cliy / 6));
+            break;
+
+        case WXK_HOME:
+            Scroll(0, event.ControlDown() ? 0 : -1);
+            break;
+
+        case WXK_END:
+            Scroll(szx - clix, event.ControlDown() ? szy - cliy : -1);
+            break;
+
+        case WXK_UP:
+            Scroll(-1, sty - 1);
+            break;
+
+        case WXK_DOWN:
+            Scroll(-1, sty + 1);
+            break;
+
+        case WXK_LEFT:
+            Scroll(stx - 1, -1);
+            break;
+
+        case WXK_RIGHT:
+            Scroll(stx + 1, -1);
+            break;
+
+        default:
+            // not for us
+            event.Skip();
+    }
+}

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
-
-

wxPython/contrib/ogl/oglshapes.i

@@ -1,575 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        oglshapes.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 oglshapes
-
-%{
-#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 wxPseudoMetaFile : public wxObject {
-public:
-  wxPseudoMetaFile();
-  ~wxPseudoMetaFile();
-
-    void Draw(wxDC& dc, double xoffset, double yoffset);
-
-    void WriteAttributes(wxExpr *clause, int whichAngle);
-    void ReadAttributes(wxExpr *clause, int whichAngle);
-    void Clear();
-    void Copy(wxPseudoMetaFile& copy);
-    void Scale(double sx, double sy);
-    void ScaleTo(double w, double h);
-    void Translate(double x, double y);
-    void Rotate(double x, double y, double theta);
-    bool LoadFromMetaFile(char* filename, double *width, double *height);
-    void GetBounds(double *minX, double *minY, double *maxX, double *maxY);
-    void CalculateSize(wxDrawnShape* shape);
-
-    // ****  fix these...  is it even possible?  these are lists of various GDI opperations (not the objects...)
-    // wxList& GetOutlineColours();
-    // wxList& GetFillColours();
-    // wxList& GetOps();
-
-    void SetRotateable(bool rot);
-    bool GetRotateable();
-    void SetSize(double w, double h);
-    void SetFillBrush(wxBrush* brush);
-    wxBrush* GetFillBrush();
-    void SetOutlinePen(wxPen* pen);
-    wxPen* GetOutlinePen();
-    void SetOutlineOp(int op);
-    int GetOutlineOp();
-
-
-    bool IsValid();
-    void DrawLine(const wxPoint& pt1, const wxPoint& pt2);
-    void DrawRectangle(const wxRect& rect);
-    void DrawRoundedRectangle(const wxRect& rect, double radius);
-    void DrawArc(const wxPoint& centrePt, const wxPoint& startPt, const wxPoint& endPt);
-    void DrawEllipticArc(const wxRect& rect, double startAngle, double endAngle);
-    void DrawEllipse(const wxRect& rect);
-    void DrawPoint(const wxPoint& pt);
-    void DrawText(const wxString& text, const wxPoint& pt);
-    void DrawLines(int PCOUNT, wxPoint* points);
-    void DrawPolygon(int PCOUNT, wxPoint* points, int flags = 0);
-    void DrawSpline(int PCOUNT, wxPoint* points);
-    void SetClippingRect(const wxRect& rect);
-    void DestroyClippingRect();
-    void SetPen(wxPen* pen, bool isOutline = FALSE);
-    void SetBrush(wxBrush* brush, bool isFill = FALSE);
-    void SetFont(wxFont* font);
-    void SetTextColour(const wxColour& colour);
-    void SetBackgroundColour(const wxColour& colour);
-    void SetBackgroundMode(int mode);
-};
-
-
-//---------------------------------------------------------------------------
-
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyRectangleShape, wxRectangleShape);
-%}
-
-class wxPyRectangleShape : public wxPyShape {
-public:
-    wxPyRectangleShape(double width = 0.0, double height = 0.0);
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyRectangleShape)"
-
-    void SetCornerRadius(double radius);
-
-    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(wxPyControlPoint, wxControlPoint);
-%}
-
-class wxPyControlPoint : public wxPyRectangleShape {
-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);
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyControlPoint)"
-
-    void SetCornerRadius(double radius);
-
-    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(wxPyBitmapShape, wxBitmapShape);
-%}
-
-
-class wxPyBitmapShape : public wxPyRectangleShape {
-public:
-    wxPyBitmapShape();
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyBitmapShape)"
-
-    wxBitmap& GetBitmap();
-    wxString GetFilename();
-    void SetBitmap(const wxBitmap& bitmap);
-    void SetFilename(const wxString& filename);
-
-    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(wxPyDrawnShape, wxDrawnShape);
-%}
-
-class wxPyDrawnShape : public wxPyRectangleShape {
-public:
-    wxPyDrawnShape();
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyDrawnShape)"
-
-    void CalculateSize();
-    void DestroyClippingRect();
-    void DrawArc(const wxPoint& centrePoint, const wxPoint& startPoint,
-                 const wxPoint& endPoint);
-    void DrawAtAngle(int angle);
-    void DrawEllipticArc(const wxRect& rect, double startAngle, double endAngle);
-    void DrawLine(const wxPoint& point1, const wxPoint& point2);
-    void DrawLines(int PCOUNT, wxPoint* points);
-    void DrawPoint(const wxPoint& point);
-    void DrawPolygon(int PCOUNT, wxPoint* points, int flags = 0);
-    void DrawRectangle(const wxRect& rect);
-    void DrawRoundedRectangle(const wxRect& rect, double radius);
-    void DrawSpline(int PCOUNT, wxPoint* points);
-    void DrawText(const wxString& text, const wxPoint& point);
-    int GetAngle();
-
-    wxPseudoMetaFile& GetMetaFile();
-
-    double GetRotation();
-    bool LoadFromMetaFile(char * filename);
-    void Rotate(double x, double y, double theta);
-    void SetClippingRect(const wxRect& rect);
-    void SetDrawnBackgroundColour(const wxColour& colour);
-    void SetDrawnBackgroundMode(int mode);
-    void SetDrawnBrush(wxBrush* pen, bool isOutline = FALSE);
-    void SetDrawnFont(wxFont* font);
-    void SetDrawnPen(wxPen* pen, bool isOutline = FALSE);
-    void SetDrawnTextColour(const wxColour& colour);
-    void Scale(double sx, double sy);
-    void SetSaveToFile(bool save);
-    void Translate(double x, double y);
-
-
-    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);
-
-};
-
-
-//---------------------------------------------------------------------------
-
-class wxOGLConstraint : public wxObject {
-public:
-    //wxOGLConstraint(int type, wxPyShape *constraining, wxList& constrained);
-    %addmethods {
-        wxOGLConstraint(int type, wxPyShape *constraining, PyObject* constrained) {
-            wxList* list = wxPy_wxListHelper(constrained, "_wxPyShape_p");
-            wxOGLConstraint* rv = new wxOGLConstraint(type, constraining, *list);
-            delete list;
-            return rv;
-        }
-    }
-
-    //~wxOGLConstraint();  The wxCompositShape takes ownership of the constraint
-
-    bool Evaluate();
-    void SetSpacing(double x, double y);
-    bool Equals(double a, double b);
-
-};
-
-
-
-//---------------------------------------------------------------------------
-
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyCompositeShape, wxCompositeShape);
-%}
-
-class wxPyCompositeShape : public wxPyRectangleShape {
-public:
-    wxPyCompositeShape();
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyCompositeShape)"
-
-    void AddChild(wxPyShape *child, wxPyShape *addAfter = NULL);
-
-    wxOGLConstraint * AddConstraint(wxOGLConstraint *constraint);
-
-
-    //wxOGLConstraint * AddConstraint(int type,
-    //                                wxPyShape *constraining,
-    //                                wxList& constrained);
-    %addmethods {
-        wxOGLConstraint * AddConstrainedShapes(int type, wxPyShape *constraining,
-                                               PyObject* constrained) {
-            wxList* list = wxPy_wxListHelper(constrained, "_wxPyShape_p");
-            wxOGLConstraint* rv = self->AddConstraint(type, constraining, *list);
-            delete list;
-            return rv;
-        }
-    }
-
-    %name(AddSimpleConstraint)wxOGLConstraint* AddConstraint(int type,
-                                                             wxPyShape *constraining,
-                                                             wxPyShape *constrained);
-
-    void CalculateSize();
-    bool ContainsDivision(wxPyDivisionShape *division);
-    void DeleteConstraint(wxOGLConstraint *constraint);
-    void DeleteConstraintsInvolvingChild(wxPyShape *child);
-
-    // ****  Needs an output typemap
-    //wxOGLConstraint * FindConstraint(long id, wxPyCompositeShape **actualComposite);
-
-    wxPyShape * FindContainerImage();
-
-    // wxList& GetConstraints();
-    // wxList& GetDivisions();
-    %addmethods {
-        PyObject* GetConstraints() {
-            wxList& list = self->GetConstraints();
-            return wxPy_ConvertList(&list, "wxOGLConstraint");
-        }
-
-        PyObject* GetDivisions() {
-            wxList& list = self->GetDivisions();
-            return wxPy_ConvertList(&list, "wxPyDivisionShape");
-        }
-    }
-
-    void MakeContainer();
-    bool Recompute();
-    void RemoveChild(wxPyShape *child);
-
-
-    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(wxPyDividedShape, wxDividedShape);
-%}
-
-class wxPyDividedShape : public wxPyRectangleShape {
-public:
-    wxPyDividedShape(double width = 0.0, double height = 0.0);
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyDividedShape)"
-
-    void EditRegions();
-    void SetRegionSizes();
-
-    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(wxPyDivisionShape, wxDivisionShape);
-%}
-
-class wxPyDivisionShape : public wxPyCompositeShape {
-public:
-    wxPyDivisionShape();
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyDivisionShape)"
-
-    void AdjustBottom(double bottom, bool test);
-    void AdjustLeft(double left, bool test);
-    void AdjustRight(double right, bool test);
-    void AdjustTop(double top, bool test);
-    void Divide(int direction);
-    void EditEdge(int side);
-    wxPyDivisionShape * GetBottomSide();
-    int GetHandleSide();
-    wxPyDivisionShape * GetLeftSide();
-    wxString GetLeftSideColour();
-    wxPen * GetLeftSidePen();
-    wxPyDivisionShape * GetRightSide();
-    wxPyDivisionShape * GetTopSide();
-    wxPen * GetTopSidePen();
-    void ResizeAdjoining(int side, double newPos, bool test);
-    void PopupMenu(double x, double y);
-    void SetBottomSide(wxPyDivisionShape *shape);
-    void SetHandleSide(int side);
-    void SetLeftSide(wxPyDivisionShape *shape);
-    void SetLeftSideColour(const wxString& colour);
-    void SetLeftSidePen(wxPen *pen);
-    void SetRightSide(wxPyDivisionShape *shape);
-    void SetTopSide(wxPyDivisionShape *shape);
-    void SetTopSideColour(const wxString& colour);
-    void SetTopSidePen(wxPen *pen);
-
-
-
-    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/oglshapes2.i

@@ -1,377 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        oglshapes2.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 oglshapes2
-
-%{
-#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
-
-
-%pragma(python) code = "import wx"
-
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyEllipseShape, wxEllipseShape);
-%}
-
-class wxPyEllipseShape : public wxPyShape {
-public:
-    wxPyEllipseShape(double width = 0.0, double height = 0.0);
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyEllipseShape)"
-
-    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(wxPyCircleShape, wxCircleShape);
-%}
-
-class wxPyCircleShape : public wxPyEllipseShape {
-public:
-    wxPyCircleShape(double width = 0.0);
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyCircleShape)"
-
-    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);
-};
-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-class wxArrowHead : public wxObject {
-public:
-    wxArrowHead(int type = 0,
-                int end = 0,
-                double size = 0.0,
-                double dist = 0.0,
-                const char * name = "",
-                wxPseudoMetaFile *mf = NULL,
-                long arrowId = -1);
-    ~wxArrowHead();
-
-    int _GetType();
-    int GetPosition();
-    void SetPosition(int pos);
-    double GetXOffset();
-    double GetYOffset();
-    double GetSpacing();
-    double GetSize();
-    wxString GetName();
-    void SetXOffset(double x);
-    void SetYOffset(double y);
-    wxPseudoMetaFile *GetMetaFile();
-    long GetId();
-    int GetArrowEnd();
-    double GetArrowSize();
-    void SetSize(double size);
-    void SetSpacing(double sp);
-};
-//---------------------------------------------------------------------------
-%{
-    WXSHAPE_IMP_CALLBACKS(wxPyLineShape, wxLineShape);
-%}
-
-class wxPyLineShape : public wxPyShape {
-public:
-    wxPyLineShape();
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyLineShape)"
-
-    void AddArrow(int type, int end = ARROW_POSITION_END,
-                  double arrowSize = 10.0, double xOffset = 0.0,
-                  char* name = "", wxPseudoMetaFile *mf = NULL,
-                  long arrowId = -1);
-
-    //void AddArrowOrdered(wxArrowHead *arrow, wxList& referenceList, int end);
-    %addmethods {
-        void AddArrowOrdered(wxArrowHead *arrow, PyObject* referenceList, int end) {
-            wxList* list = wxPy_wxListHelper(referenceList, "_wxArrowHead_p");
-            self->AddArrowOrdered(arrow, *list, end);
-            delete list;
-        }
-    }
-    bool ClearArrow(const wxString& name);
-    void ClearArrowsAtPosition(int position = -1);
-    void DrawArrow(wxDC& dc, wxArrowHead *arrow, double xOffset, bool proportionalOffset);
-    %name(DeleteArrowHeadId)bool DeleteArrowHead(long arrowId);
-    bool DeleteArrowHead(int position, const wxString& name);
-    bool DeleteLineControlPoint();
-    void DrawArrows(wxDC& dc);
-    void DrawRegion(wxDC& dc, wxShapeRegion *region, double x, double y);
-    void EraseRegion(wxDC& dc, wxShapeRegion *region, double x, double y);
-    %name(FindArrowHeadId)wxArrowHead * FindArrowHead(long arrowId);
-    wxArrowHead * FindArrowHead(int position, const wxString& name);
-    void FindLineEndPoints(double *OUTPUT, double *OUTPUT,
-                           double *OUTPUT, double *OUTPUT);
-    int FindLinePosition(double x, double y);
-    double FindMinimumWidth();
-    void FindNth(wxPyShape *image, int *OUTPUT, int *OUTPUT, bool incoming);
-    int GetAttachmentFrom();
-    int GetAttachmentTo();
-    void GetEnds(double *OUTPUT, double *OUTPUT, double *OUTPUT, double *OUTPUT);
-    wxPyShape * GetFrom();
-    void GetLabelPosition(int position, double *OUTPUT, double *OUTPUT);
-    wxPoint * GetNextControlPoint(wxPyShape *shape);
-    wxPyShape * GetTo();
-    void Initialise();
-    void InsertLineControlPoint(wxDC* dc);
-    bool IsEnd(wxPyShape *shape);
-    bool IsSpline();
-    void MakeLineControlPoints(int n);
-
-    //   inline wxList *GetLineControlPoints() { return m_lineControlPoints; }
-    %addmethods {
-        PyObject* GetLineControlPoints() {
-            wxList* list = self->GetLineControlPoints();
-            return wxPy_ConvertList(list, "wxPyControlPoint");
-        }
-    }
-
-    void SetAttachmentFrom(int fromAttach);
-    void SetAttachments(int fromAttach, int toAttach);
-    void SetAttachmentTo(int toAttach);
-    void SetEnds(double x1, double y1, double x2, double y2);
-    void SetFrom(wxPyShape *object);
-    void SetIgnoreOffsets(bool ignore);
-    void SetSpline(bool spline);
-    void SetTo(wxPyShape *object);
-    void Straighten(wxDC* dc = NULL);
-    void Unlink();
-
-
-    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(wxPyPolygonShape, wxPolygonShape);
-%}
-
-class wxPyPolygonShape : public wxPyShape {
-public:
-    wxPyPolygonShape();
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyPolygonShape)"
-
-
-    // void Create(wxList* points);
-    %addmethods {
-        PyObject* Create(PyObject* points) {
-            wxList* list = wxPy_wxRealPoint_ListHelper(points);
-            if (list) {
-                self->Create(list);
-                Py_INCREF(Py_None);
-                return Py_None;
-            }
-            else return NULL;
-        }
-    }
-
-    void AddPolygonPoint(int pos = 0);
-    void CalculatePolygonCentre();
-    void DeletePolygonPoint(int pos = 0);
-
-    // wxList* GetPoints();
-    %addmethods {
-        PyObject* GetPoints() {
-            wxList* list = self->GetPoints();
-            return wxPy_ConvertList(list, "wxRealPoint");
-        }
-    }
-
-    void UpdateOriginalPoints();
-
-
-    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(wxPyTextShape, wxTextShape);
-%}
-
-class wxPyTextShape : public wxPyRectangleShape {
-public:
-    wxPyTextShape(double width = 0.0, double height = 0.0);
-
-    void _setSelf(PyObject* self, PyObject* _class);
-    %pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyTextShape)"
-
-
-    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/oglshapes2.py

@@ -1,772 +0,0 @@
-# This file was created automatically by SWIG.
-import oglshapes2c
-
-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 *
-import wx
-class wxPyEllipseShapePtr(wxPyShapePtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def _setSelf(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape__setSelf,(self,) + _args, _kwargs)
-        return val
-    def base_OnDraw(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnDraw,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnDrawContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawBranches(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnDrawBranches,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLinks(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnMoveLinks,(self,) + _args, _kwargs)
-        return val
-    def base_OnErase(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnErase,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnEraseContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnHighlight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnHighlight,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnLeftClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftDoubleClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnLeftDoubleClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnRightClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnRightClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePre(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnMovePre,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePost(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnMovePost,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnBeginDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnEndDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawOutline(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnDrawOutline,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnDrawControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnEraseControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLink(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnMoveLink,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnSizingDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnSizingBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnSizingEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnBeginSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyEllipseShape_base_OnEndSize,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxPyEllipseShape instance at %s>" % (self.this,)
-class wxPyEllipseShape(wxPyEllipseShapePtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglshapes2c.new_wxPyEllipseShape,_args,_kwargs)
-        self.thisown = 1
-        self._setSelf(self, wxPyEllipseShape)
-
-
-
-
-class wxPyCircleShapePtr(wxPyEllipseShapePtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def _setSelf(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape__setSelf,(self,) + _args, _kwargs)
-        return val
-    def base_OnDraw(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnDraw,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnDrawContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawBranches(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnDrawBranches,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLinks(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnMoveLinks,(self,) + _args, _kwargs)
-        return val
-    def base_OnErase(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnErase,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnEraseContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnHighlight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnHighlight,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnLeftClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftDoubleClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnLeftDoubleClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnRightClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnRightClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePre(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnMovePre,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePost(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnMovePost,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnBeginDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnEndDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawOutline(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnDrawOutline,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnDrawControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnEraseControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLink(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnMoveLink,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnSizingDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnSizingBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnSizingEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnBeginSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyCircleShape_base_OnEndSize,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxPyCircleShape instance at %s>" % (self.this,)
-class wxPyCircleShape(wxPyCircleShapePtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglshapes2c.new_wxPyCircleShape,_args,_kwargs)
-        self.thisown = 1
-        self._setSelf(self, wxPyCircleShape)
-
-
-
-
-class wxArrowHeadPtr(wxObjectPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self,oglshapes2c=oglshapes2c):
-        if self.thisown == 1 :
-            oglshapes2c.delete_wxArrowHead(self)
-    def _GetType(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead__GetType,(self,) + _args, _kwargs)
-        return val
-    def GetPosition(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetPosition,(self,) + _args, _kwargs)
-        return val
-    def SetPosition(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_SetPosition,(self,) + _args, _kwargs)
-        return val
-    def GetXOffset(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetXOffset,(self,) + _args, _kwargs)
-        return val
-    def GetYOffset(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetYOffset,(self,) + _args, _kwargs)
-        return val
-    def GetSpacing(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetSpacing,(self,) + _args, _kwargs)
-        return val
-    def GetSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetSize,(self,) + _args, _kwargs)
-        return val
-    def GetName(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetName,(self,) + _args, _kwargs)
-        return val
-    def SetXOffset(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_SetXOffset,(self,) + _args, _kwargs)
-        return val
-    def SetYOffset(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_SetYOffset,(self,) + _args, _kwargs)
-        return val
-    def GetMetaFile(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetMetaFile,(self,) + _args, _kwargs)
-        return val
-    def GetId(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetId,(self,) + _args, _kwargs)
-        return val
-    def GetArrowEnd(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetArrowEnd,(self,) + _args, _kwargs)
-        return val
-    def GetArrowSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_GetArrowSize,(self,) + _args, _kwargs)
-        return val
-    def SetSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_SetSize,(self,) + _args, _kwargs)
-        return val
-    def SetSpacing(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxArrowHead_SetSpacing,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxArrowHead instance at %s>" % (self.this,)
-class wxArrowHead(wxArrowHeadPtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglshapes2c.new_wxArrowHead,_args,_kwargs)
-        self.thisown = 1
-
-
-
-
-class wxPyLineShapePtr(wxPyShapePtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def _setSelf(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape__setSelf,(self,) + _args, _kwargs)
-        return val
-    def AddArrow(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_AddArrow,(self,) + _args, _kwargs)
-        return val
-    def AddArrowOrdered(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_AddArrowOrdered,(self,) + _args, _kwargs)
-        return val
-    def ClearArrow(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_ClearArrow,(self,) + _args, _kwargs)
-        return val
-    def ClearArrowsAtPosition(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_ClearArrowsAtPosition,(self,) + _args, _kwargs)
-        return val
-    def DrawArrow(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_DrawArrow,(self,) + _args, _kwargs)
-        return val
-    def DeleteArrowHeadId(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_DeleteArrowHeadId,(self,) + _args, _kwargs)
-        return val
-    def DeleteArrowHead(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_DeleteArrowHead,(self,) + _args, _kwargs)
-        return val
-    def DeleteLineControlPoint(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_DeleteLineControlPoint,(self,) + _args, _kwargs)
-        return val
-    def DrawArrows(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_DrawArrows,(self,) + _args, _kwargs)
-        return val
-    def DrawRegion(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_DrawRegion,(self,) + _args, _kwargs)
-        return val
-    def EraseRegion(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_EraseRegion,(self,) + _args, _kwargs)
-        return val
-    def FindArrowHeadId(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_FindArrowHeadId,(self,) + _args, _kwargs)
-        return val
-    def FindArrowHead(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_FindArrowHead,(self,) + _args, _kwargs)
-        return val
-    def FindLineEndPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_FindLineEndPoints,(self,) + _args, _kwargs)
-        return val
-    def FindLinePosition(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_FindLinePosition,(self,) + _args, _kwargs)
-        return val
-    def FindMinimumWidth(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_FindMinimumWidth,(self,) + _args, _kwargs)
-        return val
-    def FindNth(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_FindNth,(self,) + _args, _kwargs)
-        return val
-    def GetAttachmentFrom(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_GetAttachmentFrom,(self,) + _args, _kwargs)
-        return val
-    def GetAttachmentTo(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_GetAttachmentTo,(self,) + _args, _kwargs)
-        return val
-    def GetEnds(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_GetEnds,(self,) + _args, _kwargs)
-        return val
-    def GetFrom(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_GetFrom,(self,) + _args, _kwargs)
-        return val
-    def GetLabelPosition(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_GetLabelPosition,(self,) + _args, _kwargs)
-        return val
-    def GetNextControlPoint(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_GetNextControlPoint,(self,) + _args, _kwargs)
-        if val: val = wxPointPtr(val) 
-        return val
-    def GetTo(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_GetTo,(self,) + _args, _kwargs)
-        return val
-    def Initialise(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_Initialise,(self,) + _args, _kwargs)
-        return val
-    def InsertLineControlPoint(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_InsertLineControlPoint,(self,) + _args, _kwargs)
-        return val
-    def IsEnd(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_IsEnd,(self,) + _args, _kwargs)
-        return val
-    def IsSpline(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_IsSpline,(self,) + _args, _kwargs)
-        return val
-    def MakeLineControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_MakeLineControlPoints,(self,) + _args, _kwargs)
-        return val
-    def GetLineControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_GetLineControlPoints,(self,) + _args, _kwargs)
-        return val
-    def SetAttachmentFrom(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_SetAttachmentFrom,(self,) + _args, _kwargs)
-        return val
-    def SetAttachments(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_SetAttachments,(self,) + _args, _kwargs)
-        return val
-    def SetAttachmentTo(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_SetAttachmentTo,(self,) + _args, _kwargs)
-        return val
-    def SetEnds(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_SetEnds,(self,) + _args, _kwargs)
-        return val
-    def SetFrom(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_SetFrom,(self,) + _args, _kwargs)
-        return val
-    def SetIgnoreOffsets(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_SetIgnoreOffsets,(self,) + _args, _kwargs)
-        return val
-    def SetSpline(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_SetSpline,(self,) + _args, _kwargs)
-        return val
-    def SetTo(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_SetTo,(self,) + _args, _kwargs)
-        return val
-    def Straighten(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_Straighten,(self,) + _args, _kwargs)
-        return val
-    def Unlink(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_Unlink,(self,) + _args, _kwargs)
-        return val
-    def base_OnDraw(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnDraw,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnDrawContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawBranches(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnDrawBranches,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLinks(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnMoveLinks,(self,) + _args, _kwargs)
-        return val
-    def base_OnErase(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnErase,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnEraseContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnHighlight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnHighlight,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnLeftClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftDoubleClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnLeftDoubleClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnRightClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnRightClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePre(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnMovePre,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePost(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnMovePost,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnBeginDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnEndDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawOutline(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnDrawOutline,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnDrawControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnEraseControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLink(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnMoveLink,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnSizingDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnSizingBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnSizingEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnBeginSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyLineShape_base_OnEndSize,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxPyLineShape instance at %s>" % (self.this,)
-class wxPyLineShape(wxPyLineShapePtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglshapes2c.new_wxPyLineShape,_args,_kwargs)
-        self.thisown = 1
-        self._setSelf(self, wxPyLineShape)
-
-
-
-
-class wxPyPolygonShapePtr(wxPyShapePtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def _setSelf(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape__setSelf,(self,) + _args, _kwargs)
-        return val
-    def Create(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_Create,(self,) + _args, _kwargs)
-        return val
-    def AddPolygonPoint(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_AddPolygonPoint,(self,) + _args, _kwargs)
-        return val
-    def CalculatePolygonCentre(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_CalculatePolygonCentre,(self,) + _args, _kwargs)
-        return val
-    def DeletePolygonPoint(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_DeletePolygonPoint,(self,) + _args, _kwargs)
-        return val
-    def GetPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_GetPoints,(self,) + _args, _kwargs)
-        return val
-    def UpdateOriginalPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_UpdateOriginalPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnDraw(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnDraw,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnDrawContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawBranches(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnDrawBranches,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLinks(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnMoveLinks,(self,) + _args, _kwargs)
-        return val
-    def base_OnErase(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnErase,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnEraseContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnHighlight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnHighlight,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnLeftClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftDoubleClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnLeftDoubleClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnRightClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnRightClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePre(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnMovePre,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePost(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnMovePost,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnBeginDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnEndDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawOutline(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnDrawOutline,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnDrawControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnEraseControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLink(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnMoveLink,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnSizingDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnSizingBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnSizingEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnBeginSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyPolygonShape_base_OnEndSize,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxPyPolygonShape instance at %s>" % (self.this,)
-class wxPyPolygonShape(wxPyPolygonShapePtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglshapes2c.new_wxPyPolygonShape,_args,_kwargs)
-        self.thisown = 1
-        self._setSelf(self, wxPyPolygonShape)
-
-
-
-
-class wxPyTextShapePtr(wxPyRectangleShapePtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def _setSelf(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape__setSelf,(self,) + _args, _kwargs)
-        return val
-    def base_OnDelete(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnDelete,(self,) + _args, _kwargs)
-        return val
-    def base_OnDraw(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnDraw,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnDrawContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawBranches(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnDrawBranches,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLinks(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnMoveLinks,(self,) + _args, _kwargs)
-        return val
-    def base_OnErase(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnErase,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseContents(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnEraseContents,(self,) + _args, _kwargs)
-        return val
-    def base_OnHighlight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnHighlight,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnLeftClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnLeftDoubleClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnLeftDoubleClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnRightClick(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnRightClick,(self,) + _args, _kwargs)
-        return val
-    def base_OnSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePre(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnMovePre,(self,) + _args, _kwargs)
-        return val
-    def base_OnMovePost(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnMovePost,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnBeginDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndDragRight(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnEndDragRight,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawOutline(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnDrawOutline,(self,) + _args, _kwargs)
-        return val
-    def base_OnDrawControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnDrawControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnEraseControlPoints(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnEraseControlPoints,(self,) + _args, _kwargs)
-        return val
-    def base_OnMoveLink(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnMoveLink,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnSizingDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingBeginDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnSizingBeginDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnSizingEndDragLeft(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnSizingEndDragLeft,(self,) + _args, _kwargs)
-        return val
-    def base_OnBeginSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnBeginSize,(self,) + _args, _kwargs)
-        return val
-    def base_OnEndSize(self, *_args, **_kwargs):
-        val = apply(oglshapes2c.wxPyTextShape_base_OnEndSize,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxPyTextShape instance at %s>" % (self.this,)
-class wxPyTextShape(wxPyTextShapePtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(oglshapes2c.new_wxPyTextShape,_args,_kwargs)
-        self.thisown = 1
-        self._setSelf(self, wxPyTextShape)
-
-
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-

wxPython/contrib/stc/.cvsignore

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

wxPython/contrib/stc/README.txt

@@ -1,7 +0,0 @@
-Since STC 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/stc/_stcextras.py

@@ -1,4 +0,0 @@
-# Stuff these names into the wx namespace so wxPyConstructObject can find them
-
-wx.wxStyledTextEventPtr       = wxStyledTextEventPtr
-wx.wxStyledTextCtrlPtr        = wxStyledTextCtrlPtr

wxPython/contrib/stc/stc.py

@@ -1,7 +0,0 @@
-
-# The name "stc.cpp" was causing the debugger to get confused with the
-# same module name in the stc library, so I changed the name of this
-# one to stc_.cpp and this little stub to make the "stc" Python module
-# name still usesable for everything that matters.
-
-from stc_ import *

wxPython/contrib/stc/stc_.i

@@ -1,119 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        stc.i
-// Purpose:     Wrappers for the wxStyledTextCtrl.
-//
-// Author:      Robin Dunn
-//
-// Created:     12-Oct-1999
-// RCS-ID:      $Id$
-// Copyright:   (c) 2000 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-%module stc_
-
-
-%{
-#include "export.h"
-#include "wx/stc/stc.h"
-%}
-
-//---------------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-%extern wx.i
-%extern windows.i
-%extern _defs.i
-%extern events.i
-%extern controls.i
-
-
-//----------------------------------------------------------------------
-// Get all our defs from the REAL header file.
-
-%include stc.h
-
-//----------------------------------------------------------------------
-// Python functions to act like the event macros
-
-%pragma(python) code = "
-def EVT_STC_CHANGE(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_CHANGE, func)
-
-def EVT_STC_STYLENEEDED(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_STYLENEEDED, func)
-
-def EVT_STC_CHARADDED(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_CHARADDED, func)
-
-def EVT_STC_SAVEPOINTREACHED(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_SAVEPOINTREACHED, func)
-
-def EVT_STC_SAVEPOINTLEFT(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_SAVEPOINTLEFT, func)
-
-def EVT_STC_ROMODIFYATTEMPT(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_ROMODIFYATTEMPT, func)
-
-def EVT_STC_KEY(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_KEY, func)
-
-def EVT_STC_DOUBLECLICK(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_DOUBLECLICK, func)
-
-def EVT_STC_UPDATEUI(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_UPDATEUI, func)
-
-def EVT_STC_MODIFIED(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_MODIFIED, func)
-
-def EVT_STC_MACRORECORD(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_MACRORECORD, func)
-
-def EVT_STC_MARGINCLICK(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_MARGINCLICK, func)
-
-def EVT_STC_NEEDSHOWN(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_NEEDSHOWN, func)
-
-def EVT_STC_POSCHANGED(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_POSCHANGED, func)
-
-def EVT_STC_PAINTED(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_PAINTED, func)
-
-def EVT_STC_USERLISTSELECTION(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_USERLISTSELECTION, func)
-
-def EVT_STC_URIDROPPED(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_URIDROPPED, func)
-
-def EVT_STC_DWELLSTART(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_DWELLSTART, func)
-
-def EVT_STC_DWELLEND(win, id, func):
-    win.Connect(id, -1, wxEVT_STC_DWELLEND, func)
-
-
-"
-
-//----------------------------------------------------------------------
-
-%init %{
-
-    wxClassInfo::CleanUpClasses();
-    wxClassInfo::InitializeClasses();
-
-%}
-
-
-//----------------------------------------------------------------------
-
-%pragma(python) include="_stcextras.py";
-
-//----------------------------------------------------------------------
-//----------------------------------------------------------------------
-
-

wxPython/contrib/xrc/.cvsignore

@@ -1 +0,0 @@
-contrib

wxPython/contrib/xrc/b.bat

@@ -1,5 +0,0 @@
-@echo off
-cd %WXWIN%\wxPython
-call b.bat %$
-cd -
-

wxPython/contrib/xrc/xrc.i

@@ -1,161 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-// Name:        xrc.i
-// Purpose:     Wrappers for the XML based Resource system
-//
-// Author:      Robin Dunn
-//
-// Created:     4-June-2001
-// RCS-ID:      $Id$
-// Copyright:   (c) 2001 by Total Control Software
-// Licence:     wxWindows license
-/////////////////////////////////////////////////////////////////////////////
-
-%module xrc
-
-
-%{
-#include "export.h"
-#include "wx/xrc/xmlres.h"
-%}
-
-//---------------------------------------------------------------------------
-
-%include typemaps.i
-%include my_typemaps.i
-
-%extern wx.i
-%extern windows.i
-%extern _defs.i
-%extern events.i
-%extern controls.i
-
-
-//---------------------------------------------------------------------------
-
-// This class holds XML resources from one or more .xml files
-// (or derived forms, either binary or zipped -- see manual for
-// details).
-
-class wxXmlResource : public wxObject
-{
-public:
-    // Ctor. If use_locale is TRUE, translatable strings are
-    // translated via _(). You can disable it by passing use_locale=FALSE
-    // (for example if you provide resource file for each locale)
-    %name(wxXmlResourceEmpty)wxXmlResource(bool use_locale = TRUE);   // TODO, a better %name
-
-    %addmethods {
-        wxXmlResource(const wxString* filemask, bool use_locale = TRUE) {
-            wxXmlResource* res = new wxXmlResource(*filemask, use_locale);
-            res->InitAllHandlers();
-            return res;
-        }
-    }
-
-    ~wxXmlResource();
-
-
-    // Loads resources from XML files that match given filemask.
-    // This method understands VFS (see filesys.h).
-    bool Load(const wxString& filemask);
-
-    // Initialize handlers for all supported controls/windows. This will
-    // make the executable quite big because it forces linking against
-    // most of wxWin library
-    void InitAllHandlers();
-
-    // Initialize only specific handler (or custom handler). Convention says
-    // that handler name is equal to control's name plus 'XmlHandler', e.g.
-    // wxTextCtrlXmlHandler, wxHtmlWindowXmlHandler. XML resource compiler
-    // (xmlres) can create include file that contains initialization code for
-    // all controls used within the resource.
-    void AddHandler(wxXmlResourceHandler *handler);
-
-    // Removes all handlers
-    void ClearHandlers();
-
-    // Loads menu from resource. Returns NULL on failure.
-    wxMenu *LoadMenu(const wxString& name);
-
-    // Loads menubar from resource. Returns NULL on failure.
-    wxMenuBar *LoadMenuBar(const wxString& name);
-
-    // Loads toolbar
-    wxToolBar *LoadToolBar(wxWindow *parent, const wxString& name);
-
-    // Loads dialog. dlg points to parent window (if any). Second form
-    // is used to finish creation of already existing instance (main reason
-    // for this is that you may want to use derived class with new event table)
-    // Example (typical usage):
-    //      MyDialog dlg;
-    //      wxTheXmlResource->LoadDialog(&dlg, mainFrame, "my_dialog");
-    //      dlg->ShowModal();
-    wxDialog *LoadDialog(wxWindow *parent, const wxString& name);
-    %name(LoadOnDialog)bool LoadDialog(wxDialog *dlg, wxWindow *parent, const wxString& name);
-
-    // Loads panel. panel points to parent window (if any). Second form
-    // is used to finish creation of already existing instance.
-    wxPanel *LoadPanel(wxWindow *parent, const wxString& name);
-    %name(LoadOnPanel)bool LoadPanel(wxPanel *panel, wxWindow *parent, const wxString& name);
-
-    bool LoadFrame(wxFrame* frame, wxWindow *parent, const wxString& name);
-
-    // Loads bitmap or icon resource from file:
-    wxBitmap LoadBitmap(const wxString& name);
-    wxIcon LoadIcon(const wxString& name);
-
-    // Attaches unknown control into given panel/window/dialog:
-    // (unknown controls are used in conjunction with <object class="unknown">)
-    bool AttachUnknownControl(const wxString& name, wxWindow *control,
-                              wxWindow *parent = NULL);
-
-    // Returns numeric ID that is equivalent to string id used in XML
-    // resource. To be used in event tables
-    // Macro XMLID is provided for convenience
-    static int GetXMLID(const char *str_id);
-
-    // Returns version info (a.b.c.d = d+ 256*c + 256^2*b + 256^3*a)
-    long GetVersion() const;
-
-    // Compares resources version to argument. Returns -1 if resources version
-    // is less than the argument, +1 if greater and 0 if they equal.
-    int CompareVersion(int major, int minor, int release, int revision) const;
-
-};
-
-//----------------------------------------------------------------------
-
-%readonly
-// Global instance of resource class. For your convenience.
-wxXmlResource *wxTheXmlResource;
-%readwrite
-
-//----------------------------------------------------------------------
-
-%pragma(python) code = "
-def XMLID(str_id):
-    return wxXmlResource_GetXMLID(str_id)
-
-def XMLCTRL(window, str_id, *args):
-    return window.FindWindowById(XMLID(str_id))
-
-"
-
-//----------------------------------------------------------------------
-
-// TODO:  Add wxXmlResourceHandler and etc.
-
-//----------------------------------------------------------------------
-
-%init %{
-
-    wxClassInfo::CleanUpClasses();
-    wxClassInfo::InitializeClasses();
-
-    wxXmlInitXmlModule();
-    wxXmlInitResourceModule();
-    wxTheXmlResource->InitAllHandlers();
-
-%}
-
-//---------------------------------------------------------------------------

wxPython/contrib/xrc/xrc.py

@@ -1,139 +0,0 @@
-# This file was created automatically by SWIG.
-import xrcc
-
-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 *
-
-def XMLID(str_id):
-    return wxXmlResource_GetXMLID(str_id)
-
-def XMLCTRL(window, str_id, *args):
-    return window.FindWindowById(XMLID(str_id))
-
-
-class wxXmlResourcePtr(wxObjectPtr):
-    def __init__(self,this):
-        self.this = this
-        self.thisown = 0
-    def __del__(self,xrcc=xrcc):
-        if self.thisown == 1 :
-            xrcc.delete_wxXmlResource(self)
-    def Load(self, *_args, **_kwargs):
-        val = apply(xrcc.wxXmlResource_Load,(self,) + _args, _kwargs)
-        return val
-    def InitAllHandlers(self, *_args, **_kwargs):
-        val = apply(xrcc.wxXmlResource_InitAllHandlers,(self,) + _args, _kwargs)
-        return val
-    def AddHandler(self, *_args, **_kwargs):
-        val = apply(xrcc.wxXmlResource_AddHandler,(self,) + _args, _kwargs)
-        return val
-    def ClearHandlers(self, *_args, **_kwargs):
-        val = apply(xrcc.wxXmlResource_ClearHandlers,(self,) + _args, _kwargs)
-        return val
-    def LoadMenu(self, *_args, **_kwargs):
-        val = apply(xrcc.wxXmlResource_LoadMenu,(self,) + _args, _kwargs)
-        return val
-    def LoadMenuBar(self, *_args, **_kwargs):
-        val = apply(xrcc.wxXmlResource_LoadMenuBar,(self,) + _args, _kwargs)
-        return val
-    def LoadToolBar(self, *_args, **_kwargs):
-        val = apply(xrcc.wxXmlResource_LoadToolBar,(self,) + _args, _kwargs)
-        return val
-    def LoadDialog(self, *_args, **_kwargs):
-        val = apply(xrcc.wxXmlResource_LoadDialog,(self,) + _args, _kwargs)
-        if val: val = wxDialogPtr(val) 
-        return val
-    def LoadOnDialog(self, *_args, **_kwargs):
-        val = apply(xrcc.wxXmlResource_LoadOnDialog,(self,) + _args, _kwargs)
-        return val
-    def LoadPanel(self, *_args, **_kwargs):
-        val = apply(xrcc.wxXmlResource_LoadPanel,(self,) + _args, _kwargs)
-        if val: val = wxPanelPtr(val) 
-        return val
-    def LoadOnPanel(self, *_args, **_kwargs):
-        val = apply(xrcc.wxXmlResource_LoadOnPanel,(self,) + _args, _kwargs)
-        return val
-    def LoadFrame(self, *_args, **_kwargs):
-        val = apply(xrcc.wxXmlResource_LoadFrame,(self,) + _args, _kwargs)
-        return val
-    def LoadBitmap(self, *_args, **_kwargs):
-        val = apply(xrcc.wxXmlResource_LoadBitmap,(self,) + _args, _kwargs)
-        if val: val = wxBitmapPtr(val) ; val.thisown = 1
-        return val
-    def LoadIcon(self, *_args, **_kwargs):
-        val = apply(xrcc.wxXmlResource_LoadIcon,(self,) + _args, _kwargs)
-        if val: val = wxIconPtr(val) ; val.thisown = 1
-        return val
-    def AttachUnknownControl(self, *_args, **_kwargs):
-        val = apply(xrcc.wxXmlResource_AttachUnknownControl,(self,) + _args, _kwargs)
-        return val
-    def GetVersion(self, *_args, **_kwargs):
-        val = apply(xrcc.wxXmlResource_GetVersion,(self,) + _args, _kwargs)
-        return val
-    def CompareVersion(self, *_args, **_kwargs):
-        val = apply(xrcc.wxXmlResource_CompareVersion,(self,) + _args, _kwargs)
-        return val
-    def __repr__(self):
-        return "<C wxXmlResource instance at %s>" % (self.this,)
-class wxXmlResource(wxXmlResourcePtr):
-    def __init__(self,*_args,**_kwargs):
-        self.this = apply(xrcc.new_wxXmlResourceEmpty,_args,_kwargs)
-        self.thisown = 1
-
-
-
-def wxXmlResource(*_args,**_kwargs):
-    val = wxXmlResourcePtr(apply(xrcc.new_wxXmlResource,_args,_kwargs))
-    val.thisown = 1
-    return val
-
-
-
-
-#-------------- FUNCTION WRAPPERS ------------------
-
-wxXmlResource_GetXMLID = xrcc.wxXmlResource_GetXMLID
-
-
-
-#-------------- VARIABLE WRAPPERS ------------------
-
-cvar = xrcc.cvar
-wxTheXmlResource = wxXmlResourcePtr(xrcc.cvar.wxTheXmlResource)

wxPython/demo/.cvsignore

@@ -1,7 +0,0 @@
-*.pyc
-.emacs.desktop
-b.bat
-hangman_dict.txt
-setup.bat
-test.out
-tmphtml.txt

wxPython/demo/About.py

@@ -1,62 +0,0 @@
-import sys, string
-
-from   wxPython.wx       import *
-from   wxPython.html     import *
-import wxPython.lib.wxpTag
-
-#---------------------------------------------------------------------------
-
-class MyAboutBox(wxDialog):
-    text = '''
-<html>
-<body bgcolor="#AC76DE">
-<center><table bgcolor="#458154" width="100%%" cellspacing="0"
-cellpadding="0" border="1">
-<tr>
-    <td align="center">
-    <h1>wxPython %s</h1>
-    Running on Python %s<br>
-    </td>
-</tr>
-</table>
-
-<p><b>wxPython</b> is a Python extension module that
-encapsulates the wxWindows GUI classes.</p>
-
-<p>This demo shows off some of the capabilities
-of <b>wxPython</b>.  Select items from the menu or tree control,
-sit back and enjoy.  Be sure to take a peek at the source code for each
-demo item so you can learn how to use the classes yourself.</p>
-
-<p><b>wxPython</b> is brought to you by <b>Robin Dunn</b> and<br>
-<b>Total Control Software</b>, Copyright (c) 1997-2001.</p>
-
-<p>
-<font size="-1">Please see <i>license.txt</i> for licensing information.</font>
-</p>
-
-<p><wxp class="wxButton">
-    <param name="label" value="Okay">
-    <param name="id"    value="wxID_OK">
-</wxp></p>
-</center>
-</body>
-</html>
-'''
-    def __init__(self, parent):
-        wxDialog.__init__(self, parent, -1, 'About the wxPython demo',)
-        html = wxHtmlWindow(self, -1, size=(420, -1))
-        py_version = string.split(sys.version)[0]
-        html.SetPage(self.text % (wx.__version__, py_version))
-        ir = html.GetInternalRepresentation()
-        html.SetSize( (ir.GetWidth()+5, ir.GetHeight()+5) )
-        self.SetClientSize(html.GetSize())
-        self.CentreOnParent(wxBOTH)
-
-#---------------------------------------------------------------------------
-
-
-
-
-
-

wxPython/demo/ActiveXWrapper_Acrobat.py

@@ -1,131 +0,0 @@
-"""
-<html><body>
-This demo shows how to embed an ActiveX control in a wxPython application, (Win32 only.)
-<p>
-The MakeActiveXClass function dynamically builds a new Class on the fly, that has the
-same signature and semantics as wxWindow.  This means that when you call the function
-you get back a new class that you can use just like wxWindow, (set the size and position,
-use in a sizer, etc.) except its contents will be the COM control.
-<p>
-This demo embeds the Adobe Acrobat Reader, and gives you some buttons for opening a PDF
-file, changing pages, etc. that show how to call methods on the COM object.  If you don't
-have Acrobat Reader 4.0 installed it won't work.
-</body></html>
-"""
-
-from wxPython.wx import *
-
-if wxPlatform == '__WXMSW__':
-    from wxPython.lib.activexwrapper import MakeActiveXClass
-    import win32com.client.gencache
-
-    try:
-        acrobat = win32com.client.gencache.EnsureModule('{CA8A9783-280D-11CF-A24D-444553540000}', 0x0, 1, 3)
-    except:
-        raise ImportError("Can't load PDF.OCX, install Acrobat 4.0")
-
-
-
-#----------------------------------------------------------------------
-
-class TestPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-        self.pdf = None
-
-        sizer = wxBoxSizer(wxVERTICAL)
-        btnSizer = wxBoxSizer(wxHORIZONTAL)
-
-        # this function creates a new class that can be used as
-        # a wxWindow, but contains the given ActiveX control.
-        ActiveXWrapper = MakeActiveXClass(acrobat.Pdf)
-
-        # create an instance of the new class
-        self.pdf = ActiveXWrapper( self, -1, style=wxSUNKEN_BORDER)
-
-        sizer.Add(self.pdf, 1, wxEXPAND)
-
-        btn = wxButton(self, wxNewId(), "Open PDF File")
-        EVT_BUTTON(self, btn.GetId(), self.OnOpenButton)
-        btnSizer.Add(btn, 1, wxEXPAND|wxALL, 5)
-
-        btn = wxButton(self, wxNewId(), "<-- Previous Page")
-        EVT_BUTTON(self, btn.GetId(), self.OnPrevPageButton)
-        btnSizer.Add(btn, 1, wxEXPAND|wxALL, 5)
-
-        btn = wxButton(self, wxNewId(), "Next Page -->")
-        EVT_BUTTON(self, btn.GetId(), self.OnNextPageButton)
-        btnSizer.Add(btn, 1, wxEXPAND|wxALL, 5)
-
-
-        btnSizer.Add(50, -1, 2, wxEXPAND)
-        sizer.Add(btnSizer, 0, wxEXPAND)
-
-        self.SetSizer(sizer)
-        self.SetAutoLayout(true)
-
-    def __del__(self):
-        if self.pdf:
-            self.pdf.Cleanup()
-            self.pdf = None
-
-
-
-    def OnOpenButton(self, event):
-        dlg = wxFileDialog(self, wildcard="*.pdf")
-        if dlg.ShowModal() == wxID_OK:
-            wxBeginBusyCursor()
-            self.pdf.LoadFile(dlg.GetPath())
-            wxEndBusyCursor()
-
-        dlg.Destroy()
-
-
-    def OnPrevPageButton(self, event):
-        self.pdf.gotoPreviousPage()
-
-
-    def OnNextPageButton(self, event):
-        self.pdf.gotoNextPage()
-
-
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    if wxPlatform == '__WXMSW__':
-        win = TestPanel(nb, log)
-        return win
-    else:
-        dlg = wxMessageDialog(frame, 'This demo only works on MSW.',
-                          'Sorry', wxOK | wxICON_INFORMATION)
-        dlg.ShowModal()
-        dlg.Destroy()
-
-
-overview = __doc__
-
-#----------------------------------------------------------------------
-
-
-if __name__ == '__main__':
-    class TestFrame(wxFrame):
-        def __init__(self):
-            wxFrame.__init__(self, None, -1, "ActiveX test -- Acrobat", size=(640, 480),
-                             style=wxDEFAULT_FRAME_STYLE|wxNO_FULL_REPAINT_ON_RESIZE)
-            self.tp = TestPanel(self, sys.stdout)
-            EVT_CLOSE(self, self.OnCloseWindow)
-
-        def OnCloseWindow(self, event):
-
-            self.tp.pdf.Cleanup()
-            self.Destroy()
-
-
-    app = wxPySimpleApp()
-    frame = TestFrame()
-    frame.Show(true)
-    app.MainLoop()
-
-
-

wxPython/demo/ActiveXWrapper_IE.py

@@ -1,205 +0,0 @@
-"""
-<html><body>
-This demo shows how to embed an ActiveX control in a wxPython
-application, (Win32 only.)
-
-<p>
-The MakeActiveXClass function dynamically builds a new Class on the
-fly, that has the same signature and semantics as wxWindow.  This
-means that when you call the function you get back a new class that
-you can use just like wxWindow, (set the size and position, use in a
-sizer, etc.) except its contents will be the COM control.
-
-<p>
-This demo embeds the Internet Exploer WebBrowser control, and shows
-how to receive events from the COM control.  (The title bar and status
-bar are updated as pages change, in addition to the log messages being
-shown.)
-</body></html>
-"""
-
-from wxPython.wx import *
-
-if wxPlatform == '__WXMSW__':
-    from wxPython.lib.activexwrapper import MakeActiveXClass
-    import win32com.client.gencache
-
-    try:
-        browserModule = win32com.client.gencache.EnsureModule("{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}", 0, 1, 1)
-    except:
-        raise ImportError("IE4 or greater does not appear to be installed.")
-
-
-#----------------------------------------------------------------------
-
-class TestPanel(wxWindow):
-    def __init__(self, parent, log, frame=None):
-        wxWindow.__init__(self, parent, -1)#, style=wxCLIP_CHILDREN)
-        self.ie = None
-        self.log = log
-        self.current = "http://wxPython.org/"
-        self.frame = frame
-        if frame:
-            self.titleBase = frame.GetTitle()
-
-
-        sizer = wxBoxSizer(wxVERTICAL)
-        btnSizer = wxBoxSizer(wxHORIZONTAL)
-
-        # Make a new class that derives from the WebBrowser class in the
-        # COM module imported above.  This class also derives from wxWindow and
-        # implements the machinery needed to integrate the two worlds.
-        theClass = MakeActiveXClass(browserModule.WebBrowser,
-                                    eventObj = self)
-
-        # Create an instance of that class
-        self.ie = theClass(self, -1, style=wxSUNKEN_BORDER)
-
-
-        #btn = wxButton(self, wxNewId(), " Open ")
-        #EVT_BUTTON(self, btn.GetId(), self.OnOpenButton)
-        #btnSizer.Add(btn, 0, wxEXPAND|wxALL, 5)
-
-        btn = wxButton(self, wxNewId(), " Home ")
-        EVT_BUTTON(self, btn.GetId(), self.OnHomeButton)
-        btnSizer.Add(btn, 0, wxEXPAND|wxALL, 5)
-
-        btn = wxButton(self, wxNewId(), " <-- ")
-        EVT_BUTTON(self, btn.GetId(), self.OnPrevPageButton)
-        btnSizer.Add(btn, 0, wxEXPAND|wxALL, 5)
-
-        btn = wxButton(self, wxNewId(), " --> ")
-        EVT_BUTTON(self, btn.GetId(), self.OnNextPageButton)
-        btnSizer.Add(btn, 0, wxEXPAND|wxALL, 5)
-
-        txt = wxStaticText(self, -1, "Location:")
-        btnSizer.Add(txt, 0, wxCENTER|wxALL, 5)
-
-        self.location = wxComboBox(self, wxNewId(), "", style=wxCB_DROPDOWN)
-        EVT_COMBOBOX(self, self.location.GetId(), self.OnLocationSelect)
-        EVT_KEY_UP(self.location, self.OnLocationKey)
-        #EVT_CHAR(self.location, self.IgnoreReturn)
-        btnSizer.Add(self.location, 1, wxEXPAND|wxALL, 5)
-
-        sizer.Add(btnSizer, 0, wxEXPAND)
-        sizer.Add(self.ie, 1, wxEXPAND)
-
-        self.ie.Navigate(self.current)
-        self.location.Append(self.current)
-
-        self.SetSizer(sizer)
-        self.SetAutoLayout(true)
-        EVT_SIZE(self, self.OnSize)
-
-
-    def OnSize(self, evt):
-        self.Layout()
-
-    def __del__(self):
-        if self.ie:
-            self.ie.Cleanup()
-            self.ie = None
-
-    def OnLocationSelect(self, evt):
-        url = self.location.GetStringSelection()
-        self.log.write('OnLocationSelect: %s\n' % url)
-        self.ie.Navigate(url)
-
-    def OnLocationKey(self, evt):
-        if evt.KeyCode() == WXK_RETURN:
-            URL = self.location.GetValue()
-            self.location.Append(URL)
-            self.ie.Navigate(URL)
-        else:
-            evt.Skip()
-
-    def IgnoreReturn(self, evt):
-        print 'IgnoreReturn'
-        if evt.KeyCode() != WXK_RETURN:
-            evt.Skip()
-
-    def OnOpenButton(self, event):
-        dlg = wxTextEntryDialog(self, "Open Location",
-                                "Enter a full URL or local path",
-                                self.current, wxOK|wxCANCEL)
-        dlg.CentreOnParent()
-        if dlg.ShowModal() == wxID_OK:
-            self.current = dlg.GetValue()
-            self.ie.Navigate(self.current)
-        dlg.Destroy()
-
-    def OnHomeButton(self, event):
-        self.ie.GoHome()    ## ET Phone Home!
-
-    def OnPrevPageButton(self, event):
-        self.ie.GoBack()
-
-
-    def OnNextPageButton(self, event):
-        self.ie.GoForward()
-
-
-    # The following event handlers are called by the web browser COM
-    # control since  we passed self to MakeActiveXClass.  It will look
-    # here for matching attributes and call them if they exist.  See the
-    # module generated by makepy for details of method names, etc.
-    def OnBeforeNavigate2(self, pDisp, URL, *args):
-        self.log.write('OnBeforeNavigate2: %s\n' % URL)
-
-    def OnNavigateComplete2(self, pDisp, URL):
-        self.log.write('OnNavigateComplete2: %s\n' % URL)
-        self.current = URL
-        self.location.SetValue(URL)
-
-    def OnTitleChange(self, text):
-        self.log.write('OnTitleChange: %s\n' % text)
-        if self.frame:
-            self.frame.SetTitle(self.titleBase + ' -- ' + text)
-
-    def OnStatusTextChange(self, text):
-        self.log.write('OnStatusTextChange: %s\n' % text)
-        if self.frame:
-            self.frame.SetStatusText(text)
-
-
-#----------------------------------------------------------------------
-# for the demo framework...
-
-def runTest(frame, nb, log):
-    if wxPlatform == '__WXMSW__':
-        win = TestPanel(nb, log, frame)
-        return win
-    else:
-        dlg = wxMessageDialog(frame, 'This demo only works on MSW.',
-                          'Sorry', wxOK | wxICON_INFORMATION)
-        dlg.ShowModal()
-        dlg.Destroy()
-
-
-overview = __doc__
-
-#----------------------------------------------------------------------
-
-
-if __name__ == '__main__':
-    class TestFrame(wxFrame):
-        def __init__(self):
-            wxFrame.__init__(self, None, -1, "ActiveX test -- Internet Explorer",
-                             size=(640, 480),
-                             style=wxDEFAULT_FRAME_STYLE|wxNO_FULL_REPAINT_ON_RESIZE)
-            self.CreateStatusBar()
-            self.tp = TestPanel(self, sys.stdout, self)
-            EVT_CLOSE(self, self.OnCloseWindow)
-
-        def OnCloseWindow(self, event):
-            self.tp.ie.Cleanup()
-            self.Destroy()
-
-
-    app = wxPySimpleApp()
-    frame = TestFrame()
-    frame.Show(true)
-    app.MainLoop()
-
-
-

wxPython/demo/ColorPanel.py

@@ -1,13 +0,0 @@
-
-from wxPython.wx import *
-
-#---------------------------------------------------------------------------
-
-
-class ColoredPanel(wxWindow):
-    def __init__(self, parent, color):
-        wxWindow.__init__(self, parent, -1,
-                          wxDefaultPosition, wxDefaultSize, wxRAISED_BORDER)
-        self.SetBackgroundColour(color)
-
-#---------------------------------------------------------------------------

wxPython/demo/ColourDB.py

@@ -1,128 +0,0 @@
-
-from wxPython.wx import *
-from wxPython.lib import colourdb
-
-import images
-
-
-# This loads a whole bunch of new color names and values
-# into wxTheColourDatabase
-
-colourdb.updateColourDB()
-
-#----------------------------------------------------------------------
-
-class TestWindow(wxScrolledWindow):
-    def __init__(self, parent):
-        wxScrolledWindow.__init__(self, parent, -1)
-
-        self.clrList = colourdb.getColourList()
-        self.bg_bmp = images.getGridBGBitmap()
-
-        EVT_PAINT(self, self.OnPaint)
-        EVT_ERASE_BACKGROUND(self, self.OnEraseBackground)
-        #self.SetBackgroundColour("WHITE")
-
-        self.font = wxFont(10, wxSWISS, wxNORMAL, wxNORMAL)
-        dc = wxClientDC(self)
-        dc.SetFont(self.font)
-
-        w,h,d,e = dc.GetFullTextExtent("Wy") # a wide character and one that decends
-        self.textHeight = h + d
-        self.lineHeight = self.textHeight + 5
-        self.cellWidth = w
-
-        numCells = 24
-        self.SetScrollbars(self.cellWidth, self.lineHeight, numCells, len(self.clrList) + 2)
-
-
-    def TileBackground(self, dc):
-        # tile the background bitmap
-        sz = self.GetClientSize()
-        w = self.bg_bmp.GetWidth()
-        h = self.bg_bmp.GetHeight()
-
-        # adjust for scrolled position
-        spx, spy = self.GetScrollPixelsPerUnit()
-        vsx, vsy = self.GetViewStart()
-        dx,  dy  = (spx * vsx) % w, (spy * vsy) % h
-
-        x = -dx
-        while x < sz.width:
-            y = -dy
-            while y < sz.height:
-                dc.DrawBitmap(self.bg_bmp, x, y)
-                y = y + h
-            x = x + w
-
-
-    def OnEraseBackground(self, evt):
-        dc = evt.GetDC()
-        if not dc:
-            dc = wxClientDC(self)
-            rect = self.GetUpdateRegion().GetBox()
-            dc.SetClippingRegion(rect.x, rect.y, rect.width, rect.height)
-        self.TileBackground(dc)
-
-
-    def OnPaint(self, evt):
-        dc = wxPaintDC(self)
-        self.PrepareDC(dc)
-        self.Draw(dc, self.GetUpdateRegion(), self.GetViewStart())
-
-
-    def Draw(self, dc, rgn=None, vs=None):
-        dc.BeginDrawing()
-        dc.SetTextForeground("BLACK")
-        dc.SetPen(wxPen("BLACK", 1, wxSOLID))
-        dc.SetFont(self.font)
-        colours = self.clrList
-        numColours = len(colours)
-
-        if rgn:
-            # determine the subset that has been exposed and needs drawn
-            rect = rgn.GetBox()
-            pixStart = vs[1]*self.lineHeight + rect.y
-            pixStop  = pixStart + rect.height
-            start = pixStart / self.lineHeight - 1
-            stop = pixStop / self.lineHeight
-        else:
-            start = 0
-            stop = numColours
-
-        for line in range(max(0,start), min(stop,numColours)):
-            clr = colours[line]
-            y = (line+1) * self.lineHeight + 2
-            dc.DrawText(clr, self.cellWidth, y)
-
-            brush = wxBrush(clr, wxSOLID)
-            dc.SetBrush(brush)
-            dc.DrawRectangle(12 * self.cellWidth, y, 6 * self.cellWidth, self.textHeight)
-
-        dc.EndDrawing()
-
-
-# On wxGTK there needs to be a panel under wxScrolledWindows if they are
-# going to be in a wxNotebook...
-class TestPanel(wxPanel):
-    def __init__(self, parent):
-        wxPanel.__init__(self, parent, -1)
-        self.win = TestWindow(self)
-        EVT_SIZE(self, self.OnSize)
-
-    def OnSize(self, evt):
-        self.win.SetSize(evt.GetSize())
-
-
-
-#----------------------------------------------------------------------
-
-
-def runTest(frame, nb, log):
-    win = TestPanel(nb)
-    return win
-
-#----------------------------------------------------------------------
-
-overview = """
-"""

wxPython/demo/ColourSelect.py

@@ -1,91 +0,0 @@
-
-#----------------------------------------------------------------------------
-# Name:         ColourSelect.py
-# Purpose:      Colour Selection control display testing on panel for wxPython demo
-#
-# Author:       Lorne White (email: lorne.white@telusplanet.net)
-#
-# Version       0.5
-# Date:         Feb 26, 2001
-# Licence:      wxWindows license
-#----------------------------------------------------------------------------
-
-from wxPython.wx import *
-from wxPython.lib.colourselect import *
-import string
-
-#---------------------------------------------------------------------------
-
-class TestColourSelect(wxPanel):
-    def __init__(self, parent, log):
-        self.log = log
-        wxPanel.__init__(self, parent, -1)
-
-        wxStaticText(self, -1, "This example uses a colour selection control based on the wxButton and wxColourDialog Classes.  Click Button to get Colour Values",
-                               wxPoint(10, 20), wxSize(400, 60))
-
-        self.x_pos = 30
-        self.y_pos = 100
-        delta = 40
-
-        mID = NewId()
-        wxButton(self, mID, "Get All Colours", wxPoint(self.x_pos, self.y_pos))
-        EVT_BUTTON(self, mID, self.OnClick)
-        self.y_pos = self.y_pos + delta
-
-        wxStaticText(self, -1, "Default", wxPoint(self.x_pos, self.y_pos), wxSize(-1, -1))   # name
-        self.colour_def = ColourSelect(self, -1, pos=wxPoint(self.x_pos+100, self.y_pos))   # default colour selection control
-
-        self.y_pos = self.y_pos + delta
-        colours = [[255, 255, 0], [255, 0, 255], [0, 255, 0], [0, 0, 255]]   # list of initial colours for display
-        self.names = names = [ "Default Size", "Another Size", "Another Colour", "Larger"]    # display names
-        sizes = [ wxDefaultSize, wxSize(60, 20), wxDefaultSize, wxSize(60, 60)]       # button sizes
-        self.set_val = []
-
-        for i in range(len(colours)):
-            wxStaticText(self, -1, names[i], wxPoint(self.x_pos, self.y_pos), wxSize(-1, -1))   # name
-
-            val = ColourSelect(self, -1, colours[i], wxPoint(self.x_pos+100, self.y_pos), sizes[i])     # colour selection button
-            self.set_val.append(val)     # store control for reference
-            self.y_pos = self.y_pos + delta
-
-
-    def OnClick(self, event):
-        result = []
-        colour = self.colour_def.GetColour()        # default control value
-        result.append("Default: " + str(colour))
-
-        for i in range(len(self.set_val)):
-            val = self.set_val[i]
-            colour = val.GetColour()        # get the colour selection button result
-            name = self.names[i]
-            result.append(name + ": " + str(colour))        # create string list for easy viewing of results
-        out_result = string.joinfields(result, ',  ')
-        self.log.WriteText("Colour Results :" + out_result)
-
-#---------------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestColourSelect(nb, log)
-    return win
-
-#---------------------------------------------------------------------------
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-overview = """\
-A checkbox is a labelled box which is either on (checkmark is visible) or off (no checkmark).
-
-"""

wxPython/demo/ContextHelp.py

@@ -1,92 +0,0 @@
-
-from wxPython.wx import *
-from wxPython.help import *
-
-#----------------------------------------------------------------------
-# We first have to set an application wide help provider.  Normally you
-# would do this in your app's OnInit or in other startup code...
-
-provider = wxSimpleHelpProvider()
-wxHelpProvider_Set(provider)
-
-
-class TestPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-        self.log = log
-
-        self.SetHelpText("This is a wxPanel.")
-        sizer = wxBoxSizer(wxVERTICAL)
-
-        cBtn = wxContextHelpButton(self)
-        cBtn.SetHelpText("wxContextHelpButton")
-        cBtnText = wxStaticText(self, -1, "This is a wxContextHelpButton.  Clicking it puts the\n"
-                                          "app into context sensitive help mode.")
-        cBtnText.SetHelpText("Some helpful text...")
-
-        s = wxBoxSizer(wxHORIZONTAL)
-        s.Add(cBtn, 0, wxALL, 5)
-        s.Add(cBtnText, 0, wxALL, 5)
-        sizer.Add(20,20)
-        sizer.Add(s)
-
-        text = wxTextCtrl(self, -1, "Each sub-window can have its own help message",
-                          size=(240, 60), style = wxTE_MULTILINE)
-        text.SetHelpText("This is my very own help message.  This is a really long long long long long long long long long long long long long long long long long long long long message!")
-        sizer.Add(20,20)
-        sizer.Add(text)
-
-        text = wxTextCtrl(self, -1, "You can also intercept the help event if you like.  Watch the log window when you click here...",
-                          size=(240, 60), style = wxTE_MULTILINE)
-        text.SetHelpText("Yet another context help message.")
-        sizer.Add(20,20)
-        sizer.Add(text)
-        EVT_HELP(text, text.GetId(), self.OnCtxHelp)
-
-        text = wxTextCtrl(self, -1, "This one displays the tip itself...",
-                          size=(240, 60), style = wxTE_MULTILINE)
-        sizer.Add(20,20)
-        sizer.Add(text)
-        EVT_HELP(text, text.GetId(), self.OnCtxHelp2)
-
-
-        border = wxBoxSizer(wxVERTICAL)
-        border.Add(sizer, 0, wxALL, 25)
-
-        self.SetAutoLayout(true)
-        self.SetSizer(border)
-        self.Layout()
-
-
-    def OnCtxHelp(self, evt):
-        self.log.write("OnCtxHelp: %s" % evt)
-        evt.Skip()
-
-
-    def OnCtxHelp2(self, evt):
-         self.log.write("OnCtxHelp: %s" % evt)
-         tip = wxTipWindow(self, "This is a wxTipWindow")
-
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestPanel(nb, log)
-    return win
-
-
-#----------------------------------------------------------------------
-
-
-
-
-overview = """
-This demo shows how to encorporate Context Sensitive
-help into your applicaiton using the wxSimpleHelpProvider class.
-
-"""
-
-
-
-#----------------------------------------------------------------------
-

wxPython/demo/CustomDragAndDrop.py

@@ -1,285 +0,0 @@
-
-from wxPython.wx import *
-
-import cPickle
-
-#----------------------------------------------------------------------
-
-
-class DoodlePad(wxWindow):
-    def __init__(self, parent, log):
-        wxWindow.__init__(self, parent, -1, style=wxSUNKEN_BORDER)
-        self.log = log
-        self.SetBackgroundColour(wxWHITE)
-        self.lines = []
-        self.x = self.y = 0
-        self.SetCursor(wxStockCursor(wxCURSOR_PENCIL))
-
-        EVT_LEFT_DOWN(self, self.OnLeftDown)
-        EVT_LEFT_UP(self, self.OnLeftUp)
-        EVT_RIGHT_UP(self, self.OnRightUp)
-        EVT_MOTION(self, self.OnMotion)
-        EVT_PAINT(self, self.OnPaint)
-
-
-    def OnPaint(self, event):
-        dc = wxPaintDC(self)
-        self.DrawSavedLines(dc)
-
-    def DrawSavedLines(self, dc):
-        dc.BeginDrawing()
-        dc.SetPen(wxPen(wxBLUE, 3))
-        for line in self.lines:
-            for coords in line:
-                apply(dc.DrawLine, coords)
-        dc.EndDrawing()
-
-
-    def OnLeftDown(self, event):
-        if event.ControlDown():
-            self.StartDragOpperation()
-        else:
-            self.curLine = []
-            self.x, self.y = event.GetPositionTuple()
-            self.CaptureMouse()
-
-
-    def OnLeftUp(self, event):
-        self.lines.append(self.curLine)
-        self.curLine = []
-        self.ReleaseMouse()
-
-    def OnRightUp(self, event):
-        self.lines = []
-        self.Refresh()
-
-    def OnMotion(self, event):
-        if event.Dragging() and not event.ControlDown():
-            dc = wxClientDC(self)
-            dc.BeginDrawing()
-            dc.SetPen(wxPen(wxBLUE, 3))
-            coords = (self.x, self.y) + event.GetPositionTuple()
-            self.curLine.append(coords)
-            apply(dc.DrawLine, coords)
-            self.x, self.y = event.GetPositionTuple()
-            dc.EndDrawing()
-
-
-    def StartDragOpperation(self):
-        # pickle the lines list
-        linesdata = cPickle.dumps(self.lines, 1)
-
-        # create our own data format and use it in a
-        # custom data object
-        ldata = wxCustomDataObject(wxCustomDataFormat("DoodleLines"))
-        ldata.SetData(linesdata)
-
-        # Also create a Bitmap version of the drawing
-        size = self.GetSize()
-        bmp = wxEmptyBitmap(size.width, size.height)
-        dc = wxMemoryDC()
-        dc.SelectObject(bmp)
-        dc.SetBackground(wxWHITE_BRUSH)
-        dc.Clear()
-        self.DrawSavedLines(dc)
-        dc.SelectObject(wxNullBitmap)
-
-        # Now make a data object for the bitmap and also a composite
-        # data object holding both of the others.
-        bdata = wxBitmapDataObject(bmp)
-        data = wxDataObjectComposite()
-        data.Add(ldata)
-        data.Add(bdata)
-
-        # And finally, create the drop source and begin the drag
-        # and drop opperation
-        dropSource = wxDropSource(self)
-        dropSource.SetData(data)
-        self.log.WriteText("Begining DragDrop\n")
-        result = dropSource.DoDragDrop()
-        self.log.WriteText("DragDrop completed: %d\n" % result)
-
-
-
-#----------------------------------------------------------------------
-
-
-class DoodleDropTarget(wxPyDropTarget):
-    def __init__(self, window, log):
-        wxPyDropTarget.__init__(self)
-        self.log = log
-        self.dv = window
-
-        # specify the type of data we will accept
-        self.data = wxCustomDataObject(wxCustomDataFormat("DoodleLines"))
-        self.SetDataObject(self.data)
-
-
-    # some virtual methods that track the progress of the drag
-    def OnEnter(self, x, y, d):
-        self.log.WriteText("OnEnter: %d, %d, %d\n" % (x, y, d))
-        return wxDragCopy
-    def OnLeave(self):
-        self.log.WriteText("OnLeave\n")
-    def OnDrop(self, x, y):
-        self.log.WriteText("OnDrop: %d %d\n" % (x, y))
-        return true
-    #def OnDragOver(self, x, y, d):
-    #    self.log.WriteText("OnDragOver: %d, %d, %d\n" % (x, y, d))
-    #    return wxDragCopy
-
-
-    # Called when OnDrop returns true.  We need to get the data and
-    # do something with it.
-    def OnData(self, x, y, d):
-        self.log.WriteText("OnData: %d, %d, %d\n" % (x, y, d))
-
-        # copy the data from the drag source to out data object
-        if self.GetData():
-            # convert it back to a list of lines and give it to the viewer
-            linesdata = self.data.GetData()
-            lines = cPickle.loads(linesdata)
-            self.dv.SetLines(lines)
-        return d
-
-
-
-
-class DoodleViewer(wxWindow):
-    def __init__(self, parent, log):
-        wxWindow.__init__(self, parent, -1, style=wxSUNKEN_BORDER)
-        self.log = log
-        self.SetBackgroundColour(wxWHITE)
-        self.lines = []
-        self.x = self.y = 0
-        dt = DoodleDropTarget(self, log)
-        self.SetDropTarget(dt)
-        EVT_PAINT(self, self.OnPaint)
-
-    def SetLines(self, lines):
-        self.lines = lines
-        self.Refresh()
-
-    def OnPaint(self, event):
-        dc = wxPaintDC(self)
-        self.DrawSavedLines(dc)
-
-    def DrawSavedLines(self, dc):
-        dc.BeginDrawing()
-        dc.SetPen(wxPen(wxRED, 3))
-        for line in self.lines:
-            for coords in line:
-                apply(dc.DrawLine, coords)
-        dc.EndDrawing()
-
-#----------------------------------------------------------------------
-
-class CustomDnDPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-
-        self.SetFont(wxFont(10, wxSWISS, wxNORMAL, wxBOLD, false))
-
-        sizer = wxBoxSizer(wxHORIZONTAL)
-        text = wxStaticText(self, -1,
-                            "Draw a little picture in this window\n"
-                            "then Ctrl-Drag it to the lower \n"
-                            "window or to another application\n"
-                            "that accepts BMP's as a drop target.\n\n"
-                            "The lower window is accepting a\n"
-                            "custom data type that is a pickled\n"
-                            "Python list of lines data.")
-        sizer.Add(text, 1, wxALL, 10)
-
-        insizer = wxBoxSizer(wxVERTICAL)
-        insizer.Add(DoodlePad(self, log), 1, wxEXPAND|wxALL, 5)
-        insizer.Add(DoodleViewer(self, log), 1, wxEXPAND|wxALL, 5)
-
-        sizer.Add(insizer, 1, wxEXPAND)
-        self.SetAutoLayout(true)
-        self.SetSizer(sizer)
-
-
-
-
-#----------------------------------------------------------------------
-#----------------------------------------------------------------------
-
-class TestPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-
-        self.SetAutoLayout(true)
-        sizer = wxBoxSizer(wxVERTICAL)
-
-        msg = "Custom Drag-And-Drop"
-        text = wxStaticText(self, -1, "", style=wxALIGN_CENTRE)
-        text.SetFont(wxFont(24, wxSWISS, wxNORMAL, wxBOLD, false))
-        text.SetLabel(msg)
-        w,h = text.GetTextExtent(msg)
-        text.SetSize(wxSize(w,h+1))
-        text.SetForegroundColour(wxBLUE)
-        sizer.Add(text, 0, wxEXPAND|wxALL, 5)
-        sizer.Add(wxStaticLine(self, -1), 0, wxEXPAND)
-
-        sizer.Add(CustomDnDPanel(self, log), 1, wxEXPAND)
-
-        self.SetSizer(sizer)
-
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestPanel(nb, log)
-    return win
-
-
-if __name__ == '__main__':
-    import sys
-    class DummyLog:
-        def WriteText(self, text):
-            sys.stdout.write(text)
-
-    class TestApp(wxApp):
-        def OnInit(self):
-            self.MakeFrame()
-            return true
-
-        def MakeFrame(self, event=None):
-            frame = wxFrame(None, -1, "Custom Drag and Drop", size=(550,400))
-            menu = wxMenu()
-            menu.Append(6543, "Window")
-            mb = wxMenuBar()
-            mb.Append(menu, "New")
-            frame.SetMenuBar(mb)
-            EVT_MENU(frame, 6543, self.MakeFrame)
-            panel = TestPanel(frame, DummyLog())
-            frame.Show(true)
-            self.SetTopWindow(frame)
-
-
-
-    app = TestApp(0)
-    app.MainLoop()
-
-#----------------------------------------------------------------------
-
-
-
-
-
-
-
-
-
-
-
-
-overview = """\
-This demo shows Drag and Drop using a custom data type and a custom data object.  A type called "DoodleLines" is created and a Python Pickle of a list is actually transfered in the drag and drop opperation.
-
-A second data object is also created containing a bitmap of the image and is made available to any drop target that accepts bitmaps, such as MS Word.
-
-The two data objects are combined in a wxDataObjectComposite and the rest is handled by the framework.
-"""
-

wxPython/demo/DialogUnits.py

@@ -1,127 +0,0 @@
-#!/usr/bin/env python
-#----------------------------------------------------------------------------
-# Name:         DialogUnits.py
-# Purpose:      A minimal wxPython program that is a bit smarter than test1.
-#
-# Author:       Robin Dunn
-#
-# Created:      A long time ago, in a galaxy far, far away...
-# RCS-ID:       $Id$
-# Copyright:    (c) 1998 by Total Control Software
-# Licence:      wxWindows license
-#----------------------------------------------------------------------------
-
-
-## import all of the wxPython GUI package
-from wxPython.wx import *
-
-
-#---------------------------------------------------------------------------
-
-## Create a new frame class, derived from the wxPython Frame.
-class MyFrame(wxFrame):
-
-    def __init__(self, parent, id, title):
-        # First, call the base class' __init__ method to create the frame
-        wxFrame.__init__(self, parent, id, title,
-                         wxPoint(100, 100), wxSize(160, 100))
-
-        # Associate some events with methods of this class
-        EVT_SIZE(self, self.OnSize)
-        EVT_MOVE(self, self.OnMove)
-        EVT_CLOSE(self, self.OnCloseWindow)
-
-        # Add a panel and some controls to display the size and position
-        panel = wxPanel(self, -1)
-        wxStaticText(panel, -1, "Size:",
-                     wxDLG_PNT(panel, wxPoint(4, 4)),  wxDefaultSize)
-        wxStaticText(panel, -1, "Pos:",
-                     wxDLG_PNT(panel, wxPoint(4, 16)), wxDefaultSize)
-        self.sizeCtrl = wxTextCtrl(panel, -1, "",
-                                   wxDLG_PNT(panel, wxPoint(24, 4)),
-                                   wxDLG_SZE(panel, wxSize(36, -1)),
-                                   wxTE_READONLY)
-
-        self.posCtrl = wxTextCtrl(panel, -1, "",
-                                  wxDLG_PNT(panel, wxPoint(24, 16)),
-                                  wxDLG_SZE(panel, wxSize(36, -1)),
-                                  wxTE_READONLY)
-
-        #print wxDLG_PNT(panel, wxPoint(24, 4)), wxDLG_SZE(panel, wxSize(36, -1))
-        #print wxDLG_PNT(panel, wxPoint(24, 16)),wxDLG_SZE(panel, wxSize(36, -1))
-
-
-    # This method is called automatically when the CLOSE event is
-    # sent to this window
-    def OnCloseWindow(self, event):
-        # tell the window to kill itself
-        self.Destroy()
-
-
-    # This method is called by the System when the window is resized,
-    # because of the association above.
-    def OnSize(self, event):
-        size = event.GetSize()
-        self.sizeCtrl.SetValue("%s, %s" % (size.width, size.height))
-
-        # tell the event system to continue looking for an event handler,
-        # so the default handler will get called.
-        event.Skip()
-
-    # This method is called by the System when the window is moved,
-    # because of the association above.
-    def OnMove(self, event):
-        pos = event.GetPosition()
-        self.posCtrl.SetValue("%s, %s" % (pos.x, pos.y))
-
-
-
-#---------------------------------------------------------------------------
-# if running standalone
-
-if __name__ == "__main__":
-    # Every wxWindows application must have a class derived from wxApp
-    class MyApp(wxApp):
-
-        # wxWindows calls this method to initialize the application
-        def OnInit(self):
-
-            # Create an instance of our customized Frame class
-            frame = MyFrame(None, -1, "This is a test")
-            frame.Show(true)
-
-            # Tell wxWindows that this is our main window
-            self.SetTopWindow(frame)
-
-            # Return a success flag
-            return true
-
-
-    app = MyApp(0)     # Create an instance of the application class
-    app.MainLoop()     # Tell it to start processing events
-
-
-#---------------------------------------------------------------------------
-# if running as part of the Demo Framework...
-
-def runTest(frame, nb, log):
-    win = MyFrame(frame, -1, "This is a test")
-    frame.otherWin = win
-    win.Show(true)
-
-
-overview = """\
-A simple example that shows how to use Dialog Units.
-"""
-
-#----------------------------------------------------------------------------
-#
-
-
-
-
-
-
-
-
-

wxPython/demo/DragAndDrop.py

@@ -1,196 +0,0 @@
-
-from wxPython.wx import *
-
-#----------------------------------------------------------------------
-
-class ClipTextPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-        self.log = log
-
-        #self.SetFont(wxFont(10, wxSWISS, wxNORMAL, wxBOLD, false))
-
-        sizer = wxBoxSizer(wxVERTICAL)
-        sizer.Add(wxStaticText(self, -1,
-                               "Copy/Paste text to/from\n"
-                               "this window and other apps"), 0, wxEXPAND|wxALL, 2)
-
-        self.text = wxTextCtrl(self, -1, "", style=wxTE_MULTILINE|wxHSCROLL)
-        sizer.Add(self.text, 1, wxEXPAND)
-
-        hsz = wxBoxSizer(wxHORIZONTAL)
-        hsz.Add(wxButton(self, 6050, " Copy "), 1, wxEXPAND|wxALL, 2)
-        hsz.Add(wxButton(self, 6051, " Paste "), 1, wxEXPAND|wxALL, 2)
-        sizer.Add(hsz, 0, wxEXPAND)
-        sizer.Add(wxButton(self, 6052, " Copy Bitmap "), 0, wxEXPAND|wxALL, 2)
-
-        EVT_BUTTON(self, 6050, self.OnCopy)
-        EVT_BUTTON(self, 6051, self.OnPaste)
-        EVT_BUTTON(self, 6052, self.OnCopyBitmap)
-
-        self.SetAutoLayout(true)
-        self.SetSizer(sizer)
-
-
-    def OnCopy(self, evt):
-        self.do = wxTextDataObject()
-        self.do.SetText(self.text.GetValue())
-        wxTheClipboard.Open()
-        wxTheClipboard.SetData(self.do)
-        wxTheClipboard.Close()
-
-
-    def OnPaste(self, evt):
-        do = wxTextDataObject()
-        wxTheClipboard.Open()
-        success = wxTheClipboard.GetData(do)
-        wxTheClipboard.Close()
-        if success:
-            self.text.SetValue(do.GetText())
-        else:
-            wxMessageBox("There is no data in the clipboard in the required format",
-                         "Error")
-
-    def OnCopyBitmap(self, evt):
-        dlg = wxFileDialog(self, "Choose a bitmap to copy", wildcard="*.bmp")
-        if dlg.ShowModal() == wxID_OK:
-            bmp = wxBitmap(dlg.GetFilename(), wxBITMAP_TYPE_BMP)
-            bmpdo = wxBitmapDataObject(bmp)
-            wxTheClipboard.Open()
-            wxTheClipboard.SetData(bmpdo)
-            wxTheClipboard.Close()
-
-            wxMessageBox("The bitmap is now in the Clipboard.  Switch to a graphics\n"
-                         "editor and try pasting it in...")
-        dlg.Destroy()
-
-#----------------------------------------------------------------------
-
-class OtherDropTarget(wxPyDropTarget):
-    def __init__(self, window, log):
-        wxPyDropTarget.__init__(self)
-        self.log = log
-        self.do = wxFileDataObject()
-        self.SetDataObject(self.do)
-
-    def OnEnter(self, x, y, d):
-        self.log.WriteText("OnEnter: %d, %d, %d\n" % (x, y, d))
-        return wxDragCopy
-
-    #def OnDragOver(self, x, y, d):
-    #    self.log.WriteText("OnDragOver: %d, %d, %d\n" % (x, y, d))
-    #    return wxDragCopy
-
-    def OnLeave(self):
-        self.log.WriteText("OnLeave\n")
-
-    def OnDrop(self, x, y):
-        self.log.WriteText("OnDrop: %d %d\n" % (x, y))
-        return true
-
-    def OnData(self, x, y, d):
-        self.log.WriteText("OnData: %d, %d, %d\n" % (x, y, d))
-        self.GetData()
-        self.log.WriteText("%s\n" % self.do.GetFilenames())
-        return d
-
-
-
-
-class MyFileDropTarget(wxFileDropTarget):
-    def __init__(self, window, log):
-        wxFileDropTarget.__init__(self)
-        self.window = window
-        self.log = log
-
-    def OnDropFiles(self, x, y, filenames):
-        self.window.SetInsertionPointEnd()
-        self.window.WriteText("\n%d file(s) dropped at %d,%d:\n" %
-                              (len(filenames), x, y))
-        for file in filenames:
-            self.window.WriteText(file + '\n')
-
-
-
-class FileDropPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-
-        #self.SetFont(wxFont(10, wxSWISS, wxNORMAL, wxBOLD, false))
-
-        sizer = wxBoxSizer(wxVERTICAL)
-        sizer.Add(wxStaticText(self, -1, " \nDrag some files here:"),
-                  0, wxEXPAND|wxALL, 2)
-
-        self.text = wxTextCtrl(self, -1, "",
-                               style = wxTE_MULTILINE|wxHSCROLL|wxTE_READONLY)
-        dt = MyFileDropTarget(self, log)
-        self.text.SetDropTarget(dt)
-        sizer.Add(self.text, 1, wxEXPAND)
-
-        self.SetAutoLayout(true)
-        self.SetSizer(sizer)
-
-
-    def WriteText(self, text):
-        self.text.WriteText(text)
-
-    def SetInsertionPointEnd(self):
-        self.text.SetInsertionPointEnd()
-
-
-#----------------------------------------------------------------------
-#----------------------------------------------------------------------
-
-class TestPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-
-        self.SetAutoLayout(true)
-        outsideSizer = wxBoxSizer(wxVERTICAL)
-
-        msg = "Clipboard / Drag-And-Drop"
-        text = wxStaticText(self, -1, "", style=wxALIGN_CENTRE)
-        text.SetFont(wxFont(24, wxSWISS, wxNORMAL, wxBOLD, false))
-        text.SetLabel(msg)
-        w,h = text.GetTextExtent(msg)
-        text.SetSize(wxSize(w,h+1))
-        text.SetForegroundColour(wxBLUE)
-        outsideSizer.Add(text, 0, wxEXPAND|wxALL, 5)
-        outsideSizer.Add(wxStaticLine(self, -1), 0, wxEXPAND)
-
-        inSizer = wxBoxSizer(wxHORIZONTAL)
-        inSizer.Add(ClipTextPanel(self, log), 1, wxEXPAND)
-        inSizer.Add(FileDropPanel(self, log), 1, wxEXPAND)
-
-        outsideSizer.Add(inSizer, 1, wxEXPAND)
-        self.SetSizer(outsideSizer)
-
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestPanel(nb, log)
-    return win
-
-#----------------------------------------------------------------------
-
-
-
-
-
-
-
-
-
-
-
-
-overview = """\
-This demo shows some examples of data transfer through clipboard or drag and drop. In wxWindows, these two ways to transfer data (either between different applications or inside one and the same) are very similar which allows to implement both of them using almost the same code - or, in other words, if you implement drag and drop support for your application, you get clipboard support for free and vice versa.
-
-At the heart of both clipboard and drag and drop operations lies the wxDataObject class. The objects of this class (or, to be precise, classes derived from it) represent the data which is being carried by the mouse during drag and drop operation or copied to or pasted from the clipboard. wxDataObject is a "smart" piece of data because it knows which formats it supports (see GetFormatCount and GetAllFormats) and knows how to render itself in any of them (see GetDataHere). It can also receive its value from the outside in a format it supports if it implements the SetData method. Please see the documentation of this class for more details.
-
-Both clipboard and drag and drop operations have two sides: the source and target, the data provider and the data receiver. These which may be in the same application and even the same window when, for example, you drag some text from one position to another in a word processor. Let us describe what each of them should do.
-
-"""

wxPython/demo/FancyText.py

@@ -1,41 +0,0 @@
-
-from wxPython.wx import *
-from wxPython.lib import fancytext
-
-#----------------------------------------------------------------------
-
-test_str = ('<font style="italic" family="swiss" color="red" weight="bold" >'
-            'some  |<sup>23</sup> <angle/>text<sub>with <angle/> subscript</sub>'
-            '</font> some other text')
-
-test_str2 = '<font family="swiss" color="dark green" size="40">big green text</font>'
-
-
-class TestPanel(wxPanel):
-    def __init__(self, parent):
-        wxPanel.__init__(self, parent, -1)
-        EVT_PAINT(self, self.OnPaint)
-
-
-    def OnPaint(self, evt):
-        dc = wxPaintDC(self)
-
-        sz = fancytext.getExtent(test_str, dc)
-        fancytext.renderToDC(test_str, dc, 20, 20)
-
-        fancytext.renderToDC(test_str2, dc, 20, 20 + sz.height + 10)
-
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestPanel(nb)
-    return win
-
-#----------------------------------------------------------------------
-
-
-
-import string
-overview = string.replace(fancytext.__doc__, "<", "&lt;")
-

wxPython/demo/FileBrowseButton.py

@@ -1,76 +0,0 @@
-""" Demonstrate filebrowsebutton module of the wxPython.lib Library.
-
-14.1.2001 Bernhard Reiter <bernhard@intevation.de>
-    Added demo for DirBrowseButton and improved overview text.
-"""
-from wxPython.wx import *
-from wxPython.lib.filebrowsebutton import FileBrowseButton, FileBrowseButtonWithHistory,DirBrowseButton
-
-
-#----------------------------------------------------------------------
-
-class TestPanel(wxPanel):
-    def __init__(self, parent, ID, log):
-        wxPanel.__init__(self, parent, ID)
-        self.log = log
-        self.fbb = FileBrowseButton(self, -1, wxPoint(20,20), wxSize(450, -1),
-                                    changeCallback = self.fbbCallback)
-        self.fbbh = FileBrowseButtonWithHistory(self, -1, wxPoint(20, 50),
-                                                wxSize(450, -1),
-                                                #changeCallback = self.fbbhCallback
-                                                )
-        self.dbb = DirBrowseButton(self, -1, wxPoint(20,80), wxSize(450,-1),
-                                    changeCallback = self.dbbCallback)
-
-
-        self.fbbh.SetHistory(['You', 'can', 'put', 'some', 'file', 'names', 'here'])
-
-
-    def fbbCallback(self, evt):
-        self.log.write('FileBrowseButton: %s\n' % evt.GetString())
-
-
-
-    def fbbhCallback(self, evt):
-        if hasattr(self, 'fbbh'):
-            value = evt.GetString()
-            self.log.write('FileBrowseButtonWithHistory: %s\n' % value)
-            history = self.fbbh.GetHistory()
-            history.append(value)
-            self.fbbh.SetHistory(history)
-
-    def dbbCallback(self, evt):
-        self.log.write('DirBrowseButton: %s\n' % evt.GetString())
-
-
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestPanel(nb, -1, log)
-    return win
-
-
-
-#----------------------------------------------------------------------
-
-overview = """<html><body>
-<h2>class FileBrowseButton:</h2>
-<small><pre>
-%s
-</pre></small>
-
-<h2>class FileBrowseButtonWithHistory(FileBrowseButton):</h2>
-<small><pre>
-%s
-</pre></small>
-
-<h2>class DirBrowseButton(FileBrowseButton):</h2>
-<small><pre>
-%s
-</pre></small>
-
-</body><</html>
-""" % ( FileBrowseButton.__doc__,
-        FileBrowseButtonWithHistory.__doc__ ,
-        str(DirBrowseButton.__doc__) )

wxPython/demo/FontEnumerator.py

@@ -1,61 +0,0 @@
-
-from wxPython.wx import *
-
-#----------------------------------------------------------------------
-
-## class MyFontEnumerator(wxFontEnumerator):
-##     def __init__(self, list):
-##         wxFontEnumerator.__init__(self)
-##         self.list = list
-
-##     def OnFacename(self, face):
-##         self.list.append(face)
-##         return true
-
-
-
-class TestPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-
-##         list = []
-##         e = MyFontEnumerator(list)
-##         e.EnumerateFacenames()
-
-        e = wxFontEnumerator()
-        e.EnumerateFacenames()
-        list = e.GetFacenames()
-
-        list.sort()
-
-        wxStaticText(self, -1, "Face names:", wxPoint(15, 50), wxSize(65, 18))
-        self.lb1 = wxListBox(self, 60, wxPoint(80, 50), wxSize(200, 250),
-                             list, wxLB_SINGLE)
-        self.lb1.SetSelection(0)
-
-
-
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestPanel(nb, log)
-    return win
-
-#----------------------------------------------------------------------
-
-
-
-
-
-
-
-
-
-
-
-
-overview = """\
-wxFontEnumerator enumerates either all available fonts on the system or only the ones with given attributes - either only fixed-width (suited for use in programs such as terminal emulators and the like) or the fonts available in the given encoding.
-
-"""

wxPython/demo/GenericButtons.py

@@ -1,106 +0,0 @@
-
-from wxPython.wx import *
-from wxPython.lib.buttons import *
-
-import images
-#----------------------------------------------------------------------
-
-
-class TestPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-        self.log = log
-
-        b = wxButton(self, -1, "A real button", (10,10))
-        b.SetDefault()
-        EVT_BUTTON(self, b.GetId(), self.OnButton)
-        b = wxButton(self, -1, "non-default", (140, 10))
-        EVT_BUTTON(self, b.GetId(), self.OnButton)
-        #wxTextCtrl(self, -1, "", (10,40))
-
-        b = wxGenButton(self, -1, 'Hello', (10,65))
-        EVT_BUTTON(self, b.GetId(), self.OnButton)
-        b = wxGenButton(self, -1, 'disabled', (140,65))
-        EVT_BUTTON(self, b.GetId(), self.OnButton)
-        b.Enable(false)
-
-        b = wxGenButton(self, -1, 'bigger', (250,50))
-        EVT_BUTTON(self, b.GetId(), self.OnButton)
-        b.SetFont(wxFont(20, wxSWISS, wxNORMAL, wxBOLD, false))
-        b.SetBezelWidth(5)
-        b.SetBestSize()
-        b.SetBackgroundColour(wxNamedColour("Navy"))
-        b.SetForegroundColour(wxWHITE)
-        #b.SetUseFocusIndicator(false)
-        b.SetToolTipString("This is a BIG button...")
-
-        bmp = images.getTest2Bitmap()
-        b = wxGenBitmapButton(self, -1, bmp, (10, 130))
-        EVT_BUTTON(self, b.GetId(), self.OnButton)
-
-
-        b = wxGenBitmapButton(self, -1, None, (140, 130))
-        EVT_BUTTON(self, b.GetId(), self.OnButton)
-        bmp = images.getBulb1Bitmap()
-        mask = wxMaskColour(bmp, wxBLUE)
-        bmp.SetMask(mask)
-        b.SetBitmapLabel(bmp)
-        bmp = images.getBulb2Bitmap()
-        mask = wxMaskColour(bmp, wxBLUE)
-        bmp.SetMask(mask)
-        b.SetBitmapSelected(bmp)
-        b.SetBestSize()
-
-        b = wxGenToggleButton(self, -1, "Toggle Button", (10, 230))
-        EVT_BUTTON(self, b.GetId(), self.OnToggleButton)
-
-
-        b = wxGenBitmapToggleButton(self, -1, None, (140, 230))
-        EVT_BUTTON(self, b.GetId(), self.OnToggleButton)
-        bmp = images.getBulb1Bitmap()
-        mask = wxMaskColour(bmp, wxBLUE)
-        bmp.SetMask(mask)
-        b.SetBitmapLabel(bmp)
-        bmp = images.getBulb2Bitmap()
-        mask = wxMaskColour(bmp, wxBLUE)
-        bmp.SetMask(mask)
-        b.SetBitmapSelected(bmp)
-        b.SetToggle(true)
-        b.SetBestSize()
-
-        b = wxGenBitmapTextButton(self, -1, None, "Bitmapped Text", (220, 230), size = (200, 45))
-        EVT_BUTTON(self, b.GetId(), self.OnButton)
-        bmp = images.getBulb1Bitmap()
-        mask = wxMaskColour(bmp, wxBLUE)
-        bmp.SetMask(mask)
-        b.SetBitmapLabel(bmp)
-        bmp = images.getBulb2Bitmap()
-        mask = wxMaskColour(bmp, wxBLUE)
-        bmp.SetMask(mask)
-        b.SetBitmapSelected(bmp)
-        b.SetUseFocusIndicator(false)
-        b.SetBestSize()
-
-
-    def OnButton(self, event):
-        self.log.WriteText("Button Clicked: %d\n" % event.GetId())
-
-    def OnToggleButton(self, event):
-        msg = (event.GetIsDown() and "on") or "off"
-        self.log.WriteText("Button %d Toggled: %s\n" % (event.GetId(), msg))
-
-
-
-#----------------------------------------------------------------------
-
-
-def runTest(frame, nb, log):
-    win = TestPanel(nb, log)
-    return win
-
-
-#----------------------------------------------------------------------
-
-
-import wxPython.lib.buttons
-overview = wxPython.lib.buttons.__doc__

wxPython/demo/GridCustEditor.py

@@ -1,233 +0,0 @@
-#!/usr/bin/env python
-
-from wxPython.wx import *
-from wxPython.grid import *
-
-#---------------------------------------------------------------------------
-class MyCellEditor(wxPyGridCellEditor):
-    """
-    This is a sample GridCellEditor that shows you how to make your own custom
-    grid editors.  All the methods that can be overridden are show here.  The
-    ones that must be overridden are marked with "*Must Override*" in the
-    docstring.
-
-    Notice that in order to call the base class version of these special
-    methods we use the method name preceded by "base_".  This is because these
-    methods are "virtual" in C++ so if we try to call wxGridCellEditor.Create
-    for example, then when the wxPython extension module tries to call
-    ptr->Create(...) then it actually calls the derived class version which
-    looks up the method in this class and calls it, causing a recursion loop.
-    If you don't understand any of this, don't worry, just call the "base_"
-    version instead.
-    """
-    def __init__(self, log):
-        self.log = log
-        self.log.write("MyCellEditor ctor\n")
-        wxPyGridCellEditor.__init__(self)
-
-
-    def Create(self, parent, id, evtHandler):
-        """
-        Called to create the control, which must derive from wxControl.
-        *Must Override*
-        """
-        self.log.write("MyCellEditor: Create\n")
-        self._tc = wxTextCtrl(parent, id, "")
-        self._tc.SetInsertionPoint(0)
-        self.SetControl(self._tc)
-        if evtHandler:
-            self._tc.PushEventHandler(evtHandler)
-
-
-    def SetSize(self, rect):
-        """
-        Called to position/size the edit control within the cell rectangle.
-        If you don't fill the cell (the rect) then be sure to override
-        PaintBackground and do something meaningful there.
-        """
-        self.log.write("MyCellEditor: SetSize %s\n" % rect)
-        self._tc.SetDimensions(rect.x, rect.y, rect.width+2, rect.height+2,
-                               wxSIZE_ALLOW_MINUS_ONE)
-
-
-    def Show(self, show, attr):
-        """
-        Show or hide the edit control.  You can use the attr (if not None)
-        to set colours or fonts for the control.
-        """
-        self.log.write("MyCellEditor: Show(self, %s, %s)\n" % (show, attr))
-        self.base_Show(show, attr)
-
-
-    def PaintBackground(self, rect, attr):
-        """
-        Draws the part of the cell not occupied by the edit control.  The
-        base  class version just fills it with background colour from the
-        attribute.  In this class the edit control fills the whole cell so
-        don't do anything at all in order to reduce flicker.
-        """
-        self.log.write("MyCellEditor: PaintBackground\n")
-
-
-    def BeginEdit(self, row, col, grid):
-        """
-        Fetch the value from the table and prepare the edit control
-        to begin editing.  Set the focus to the edit control.
-        *Must Override*
-        """
-        self.log.write("MyCellEditor: BeginEdit (%d,%d)\n" % (row, col))
-        self.startValue = grid.GetTable().GetValue(row, col)
-        self._tc.SetValue(self.startValue)
-        self._tc.SetInsertionPointEnd()
-        self._tc.SetFocus()
-
-        # For this example, select the text
-        self._tc.SetSelection(0, self._tc.GetLastPosition())
-
-
-    def EndEdit(self, row, col, grid):
-        """
-        Complete the editing of the current cell. Returns true if the value
-        has changed.  If necessary, the control may be destroyed.
-        *Must Override*
-        """
-        self.log.write("MyCellEditor: EndEdit (%d,%d)\n" % (row, col))
-        changed = false
-
-        val = self._tc.GetValue()
-        if val != self.startValue:
-            changed = true
-            grid.GetTable().SetValue(row, col, val) # update the table
-
-        self.startValue = ''
-        self._tc.SetValue('')
-        return changed
-
-
-    def Reset(self):
-        """
-        Reset the value in the control back to its starting value.
-        *Must Override*
-        """
-        self.log.write("MyCellEditor: Reset\n")
-        self._tc.SetValue(self.startValue)
-        self._tc.SetInsertionPointEnd()
-
-
-    def IsAcceptedKey(self, evt):
-        """
-        Return TRUE to allow the given key to start editing: the base class
-        version only checks that the event has no modifiers.  F2 is special
-        and will always start the editor.
-        """
-        self.log.write("MyCellEditor: IsAcceptedKey: %d\n" % (evt.GetKeyCode()))
-
-        ## Oops, there's a bug here, we'll have to do it ourself..
-        ##return self.base_IsAcceptedKey(evt)
-
-        return (not (evt.ControlDown() or evt.AltDown()) and
-                evt.GetKeyCode() != WXK_SHIFT)
-
-
-    def StartingKey(self, evt):
-        """
-        If the editor is enabled by pressing keys on the grid, this will be
-        called to let the editor do something about that first key if desired.
-        """
-        self.log.write("MyCellEditor: StartingKey %d\n" % evt.GetKeyCode())
-        key = evt.GetKeyCode()
-        ch = None
-        if key in [WXK_NUMPAD0, WXK_NUMPAD1, WXK_NUMPAD2, WXK_NUMPAD3, WXK_NUMPAD4,
-                   WXK_NUMPAD5, WXK_NUMPAD6, WXK_NUMPAD7, WXK_NUMPAD8, WXK_NUMPAD9]:
-            ch = ch = chr(ord('0') + key - WXK_NUMPAD0)
-
-        elif key < 256 and key >= 0 and chr(key) in string.printable:
-            ch = chr(key)
-            if not evt.ShiftDown():
-                ch = string.lower(ch)
-
-        if ch is not None:
-            # For this example, replace the text.  Normally we would append it.
-            #self._tc.AppendText(ch)
-            self._tc.SetValue(ch)
-        else:
-            evt.Skip()
-
-
-    def StartingClick(self):
-        """
-        If the editor is enabled by clicking on the cell, this method will be
-        called to allow the editor to simulate the click on the control if
-        needed.
-        """
-        self.log.write("MyCellEditor: StartingClick\n")
-
-
-    def Destroy(self):
-        """final cleanup"""
-        self.log.write("MyCellEditor: Destroy\n")
-        self.base_Destroy()
-
-
-    def Clone(self):
-        """
-        Create a new object which is the copy of this one
-        *Must Override*
-        """
-        self.log.write("MyCellEditor: Clone\n")
-        return MyCellEditor(self.log)
-
-
-#---------------------------------------------------------------------------
-class GridEditorTest(wxGrid):
-    def __init__(self, parent, log):
-        wxGrid.__init__(self, parent, -1)
-        self.log = log
-
-        self.CreateGrid(10, 3)
-
-        # Somebody changed the grid so the type registry takes precedence
-        # over the default attribute set for editors and renderers, so we
-        # have to set null handlers for the type registry before the
-        # default editor will get used otherwise...
-        #self.RegisterDataType(wxGRID_VALUE_STRING, None, None)
-        #self.SetDefaultEditor(MyCellEditor(self.log))
-
-        # Or we could just do it like this:
-        #self.RegisterDataType(wxGRID_VALUE_STRING,
-        #                      wxGridCellStringRenderer(),
-        #                      MyCellEditor(self.log))
-
-        # but for this example, we'll just set the custom editor on one cell
-        self.SetCellEditor(1, 0, MyCellEditor(self.log))
-        self.SetCellValue(1, 0, "Try to edit this box")
-
-        # and on a column
-        attr = wxGridCellAttr()
-        attr.SetEditor(MyCellEditor(self.log))
-        self.SetColAttr(2, attr)
-        self.SetCellValue(1, 2, "or any in this column")
-
-        self.SetColSize(0, 150)
-        self.SetColSize(1, 150)
-        self.SetColSize(2, 150)
-
-
-#---------------------------------------------------------------------------
-
-class TestFrame(wxFrame):
-    def __init__(self, parent, log):
-        wxFrame.__init__(self, parent, -1, "Custom Grid Cell Editor Test",
-                         size=(640,480))
-        grid = GridEditorTest(self, log)
-
-#---------------------------------------------------------------------------
-
-if __name__ == '__main__':
-    import sys
-    app = wxPySimpleApp()
-    frame = TestFrame(None, sys.stdout)
-    frame.Show(true)
-    app.MainLoop()
-
-

wxPython/demo/GridCustTable.py

@@ -1,153 +0,0 @@
-from wxPython.wx import *
-from wxPython.grid import *
-
-import string
-
-#---------------------------------------------------------------------------
-
-class CustomDataTable(wxPyGridTableBase):
-    """
-    """
-
-    def __init__(self, log):
-        wxPyGridTableBase.__init__(self)
-        self.log = log
-
-        self.colLabels = ['ID', 'Description', 'Severity', 'Priority', 'Platform',
-                          'Opened?', 'Fixed?', 'Tested?']
-
-        self.dataTypes = [wxGRID_VALUE_NUMBER,
-                          wxGRID_VALUE_STRING,
-                          wxGRID_VALUE_CHOICE + ':only in a million years!,wish list,minor,normal,major,critical',
-                          wxGRID_VALUE_NUMBER + ':1,5',
-                          wxGRID_VALUE_CHOICE + ':all,MSW,GTK,other',
-                          wxGRID_VALUE_BOOL,
-                          wxGRID_VALUE_BOOL,
-                          wxGRID_VALUE_BOOL]
-
-        self.data = [
-            [1010, "The foo doesn't bar", "major", 1, 'MSW', 1, 1, 1],
-            [1011, "I've got a wicket in my wocket", "wish list", 2, 'other', 0, 0, 0],
-            [1012, "Rectangle() returns a triangle", "critical", 5, 'all', 0, 0, 0]
-
-            ]
-
-
-    #--------------------------------------------------
-    # required methods for the wxPyGridTableBase interface
-
-    def GetNumberRows(self):
-        return len(self.data) + 1
-
-    def GetNumberCols(self):
-        return len(self.data[0])
-
-    def IsEmptyCell(self, row, col):
-        return not self.data[row][col]
-
-    # Get/Set values in the table.  The Python version of these
-    # methods can handle any data-type, (as long as the Editor and
-    # Renderer understands the type too,) not just strings as in the
-    # C++ version.
-    def GetValue(self, row, col):
-        try:
-            return self.data[row][col]
-        except IndexError:
-            return ''
-
-    def SetValue(self, row, col, value):
-        try:
-            self.data[row][col] = value
-        except IndexError:
-            # add a new row
-            self.data.append([''] * self.GetNumberCols())
-            self.SetValue(row, col, value)
-
-            # tell the grid we've added a row
-            msg = wxGridTableMessage(self,                             # The table
-                                     wxGRIDTABLE_NOTIFY_ROWS_APPENDED, # what we did to it
-                                     1)                                # how many
-
-            self.GetView().ProcessTableMessage(msg)
-
-
-    #--------------------------------------------------
-    # Some optional methods
-
-    # Called when the grid needs to display labels
-    def GetColLabelValue(self, col):
-        return self.colLabels[col]
-
-    # Called to determine the kind of editor/renderer to use by
-    # default, doesn't necessarily have to be the same type used
-    # nativly by the editor/renderer if they know how to convert.
-    def GetTypeName(self, row, col):
-        return self.dataTypes[col]
-
-    # Called to determine how the data can be fetched and stored by the
-    # editor and renderer.  This allows you to enforce some type-safety
-    # in the grid.
-    def CanGetValueAs(self, row, col, typeName):
-        colType = string.split(self.dataTypes[col], ':')[0]
-        if typeName == colType:
-            return true
-        else:
-            return false
-
-    def CanSetValueAs(self, row, col, typeName):
-        return self.CanGetValueAs(row, col, typeName)
-
-
-
-
-
-#---------------------------------------------------------------------------
-
-
-
-class CustTableGrid(wxGrid):
-    def __init__(self, parent, log):
-        wxGrid.__init__(self, parent, -1)
-
-        table = CustomDataTable(log)
-
-        # The second parameter means that the grid is to take ownership of the
-        # table and will destroy it when done.  Otherwise you would need to keep
-        # a reference to it and call it's Destroy method later.
-        self.SetTable(table, true)
-
-        self.SetRowLabelSize(0)
-        self.SetMargins(0,0)
-        self.AutoSizeColumns(false)
-
-        EVT_GRID_CELL_LEFT_DCLICK(self, self.OnLeftDClick)
-
-
-
-    # I do this because I don't like the default behaviour of not starting the
-    # cell editor on double clicks, but only a second click.
-    def OnLeftDClick(self, evt):
-        if self.CanEnableCellControl():
-            self.EnableCellEditControl()
-
-
-#---------------------------------------------------------------------------
-
-class TestFrame(wxFrame):
-    def __init__(self, parent, log):
-        wxFrame.__init__(self, parent, -1, "Custom Table, data driven Grid  Demo", size=(640,480))
-        grid = CustTableGrid(self, log)
-
-
-
-#---------------------------------------------------------------------------
-
-if __name__ == '__main__':
-    import sys
-    app = wxPySimpleApp()
-    frame = TestFrame(None, sys.stdout)
-    frame.Show(true)
-    app.MainLoop()
-
-
-#---------------------------------------------------------------------------

wxPython/demo/GridEnterHandler.py

@@ -1,62 +0,0 @@
-from wxPython.wx import *
-from wxPython.grid import *
-
-#---------------------------------------------------------------------------
-
-class NewEnterHandlingGrid(wxGrid):
-    def __init__(self, parent, log):
-        wxGrid.__init__(self, parent, -1)
-        self.log = log
-
-        self.CreateGrid(20, 6)
-
-        self.SetCellValue(0, 0, "Enter moves to the right")
-        self.SetCellValue(0, 5, "Enter wraps to next row")
-        self.SetColSize(0, 150)
-        self.SetColSize(5, 150)
-
-        EVT_KEY_DOWN(self, self.OnKeyDown)
-
-
-    def OnKeyDown(self, evt):
-        if evt.KeyCode() != WXK_RETURN:
-            evt.Skip()
-            return
-
-        if evt.ControlDown():   # the edit control needs this key
-            evt.Skip()
-            return
-
-        self.DisableCellEditControl()
-        success = self.MoveCursorRight(evt.ShiftDown())
-        if not success:
-            newRow = self.GetGridCursorRow() + 1
-            if newRow < self.GetTable().GetNumberRows():
-                self.SetGridCursor(newRow, 0)
-                self.MakeCellVisible(newRow, 0)
-            else:
-                # this would be a good place to add a new row if your app
-                # needs to do that
-                pass
-
-
-#---------------------------------------------------------------------------
-
-class TestFrame(wxFrame):
-    def __init__(self, parent, log):
-        wxFrame.__init__(self, parent, -1, "Simple Grid Demo", size=(640,480))
-        grid = NewEnterHandlingGrid(self, log)
-
-
-
-#---------------------------------------------------------------------------
-
-if __name__ == '__main__':
-    import sys
-    app = wxPySimpleApp()
-    frame = TestFrame(None, sys.stdout)
-    frame.Show(true)
-    app.MainLoop()
-
-
-#---------------------------------------------------------------------------

wxPython/demo/GridHugeTable.py

@@ -1,71 +0,0 @@
-from wxPython.wx import *
-from wxPython.grid import *
-
-#---------------------------------------------------------------------------
-
-class HugeTable(wxPyGridTableBase):
-
-    """
-    This is all it takes to make a custom data table to plug into a
-    wxGrid.  There are many more methods that can be overridden, but
-    the ones shown below are the required ones.  This table simply
-    provides strings containing the row and column values.
-    """
-
-    def __init__(self, log):
-        wxPyGridTableBase.__init__(self)
-        self.log = log
-
-    def GetNumberRows(self):
-        return 10000
-
-    def GetNumberCols(self):
-        return 10000
-
-    def IsEmptyCell(self, row, col):
-        return false
-
-    def GetValue(self, row, col):
-        return str( (row, col) )
-
-    def SetValue(self, row, col, value):
-        self.log.write('SetValue(%d, %d, "%s") ignored.\n' % (row, col, value))
-
-
-#---------------------------------------------------------------------------
-
-
-
-class HugeTableGrid(wxGrid):
-    def __init__(self, parent, log):
-        wxGrid.__init__(self, parent, -1)
-
-        table = HugeTable(log)
-
-        # The second parameter means that the grid is to take ownership of the
-        # table and will destroy it when done.  Otherwise you would need to keep
-        # a reference to it and call it's Destroy method later.
-        self.SetTable(table, true)
-
-
-
-#---------------------------------------------------------------------------
-
-class TestFrame(wxFrame):
-    def __init__(self, parent, log):
-        wxFrame.__init__(self, parent, -1, "Huge (virtual) Table Demo", size=(640,480))
-        grid = HugeTableGrid(self, log)
-
-        grid.SetReadOnly(5,5, true)
-
-#---------------------------------------------------------------------------
-
-if __name__ == '__main__':
-    import sys
-    app = wxPySimpleApp()
-    frame = TestFrame(None, sys.stdout)
-    frame.Show(true)
-    app.MainLoop()
-
-
-#---------------------------------------------------------------------------

wxPython/demo/GridSimple.py

@@ -1,206 +0,0 @@
-from wxPython.wx import *
-from wxPython.grid import *
-from wxPython.lib.mixins.grid import wxGridAutoEditMixin
-
-#---------------------------------------------------------------------------
-
-class SimpleGrid(wxGrid): ##, wxGridAutoEditMixin):
-    def __init__(self, parent, log):
-        wxGrid.__init__(self, parent, -1)
-        ##wxGridAutoEditMixin.__init__(self)
-        self.log = log
-        self.moveTo = None
-
-        EVT_IDLE(self, self.OnIdle)
-
-        self.CreateGrid(25, 25)
-
-        # simple cell formatting
-        self.SetColSize(3, 200)
-        self.SetRowSize(4, 45)
-        self.SetCellValue(0, 0, "First cell")
-        self.SetCellValue(1, 1, "Another cell")
-        self.SetCellValue(2, 2, "Yet another cell")
-        self.SetCellValue(3, 3, "This cell is read-only")
-        self.SetCellFont(0, 0, wxFont(12, wxROMAN, wxITALIC, wxNORMAL))
-        self.SetCellTextColour(1, 1, wxRED)
-        self.SetCellBackgroundColour(2, 2, wxCYAN)
-        self.SetReadOnly(3, 3, true)
-
-        self.SetCellEditor(5, 0, wxGridCellNumberEditor())
-        self.SetCellValue(5, 0, "123")
-        self.SetCellEditor(6, 0, wxGridCellFloatEditor())
-        self.SetCellValue(6, 0, "123.34")
-
-        # attribute objects let you keep a set of formatting values
-        # in one spot, and reuse them if needed
-        attr = wxGridCellAttr()
-        attr.SetTextColour(wxBLACK)
-        attr.SetBackgroundColour(wxRED)
-        attr.SetFont(wxFont(10, wxSWISS, wxNORMAL, wxBOLD))
-
-        # you can set cell attributes for the whole row (or column)
-        self.SetRowAttr(5, attr)
-
-        self.SetColLabelValue(0, "Custom")
-        self.SetColLabelValue(1, "column")
-        self.SetColLabelValue(2, "labels")
-
-        self.SetColLabelAlignment(wxALIGN_LEFT, wxALIGN_BOTTOM)
-
-        # test all the events
-        EVT_GRID_CELL_LEFT_CLICK(self, self.OnCellLeftClick)
-        EVT_GRID_CELL_RIGHT_CLICK(self, self.OnCellRightClick)
-        EVT_GRID_CELL_LEFT_DCLICK(self, self.OnCellLeftDClick)
-        EVT_GRID_CELL_RIGHT_DCLICK(self, self.OnCellRightDClick)
-
-        EVT_GRID_LABEL_LEFT_CLICK(self, self.OnLabelLeftClick)
-        EVT_GRID_LABEL_RIGHT_CLICK(self, self.OnLabelRightClick)
-        EVT_GRID_LABEL_LEFT_DCLICK(self, self.OnLabelLeftDClick)
-        EVT_GRID_LABEL_RIGHT_DCLICK(self, self.OnLabelRightDClick)
-
-        EVT_GRID_ROW_SIZE(self, self.OnRowSize)
-        EVT_GRID_COL_SIZE(self, self.OnColSize)
-
-        EVT_GRID_RANGE_SELECT(self, self.OnRangeSelect)
-        EVT_GRID_CELL_CHANGE(self, self.OnCellChange)
-        EVT_GRID_SELECT_CELL(self, self.OnSelectCell)
-
-        EVT_GRID_EDITOR_SHOWN(self, self.OnEditorShown)
-        EVT_GRID_EDITOR_HIDDEN(self, self.OnEditorHidden)
-        EVT_GRID_EDITOR_CREATED(self, self.OnEditorCreated)
-
-
-
-    def OnCellLeftClick(self, evt):
-        self.log.write("OnCellLeftClick: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnCellRightClick(self, evt):
-        self.log.write("OnCellRightClick: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnCellLeftDClick(self, evt):
-        self.log.write("OnCellLeftDClick: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnCellRightDClick(self, evt):
-        self.log.write("OnCellRightDClick: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnLabelLeftClick(self, evt):
-        self.log.write("OnLabelLeftClick: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnLabelRightClick(self, evt):
-        self.log.write("OnLabelRightClick: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnLabelLeftDClick(self, evt):
-        self.log.write("OnLabelLeftDClick: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnLabelRightDClick(self, evt):
-        self.log.write("OnLabelRightDClick: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-
-    def OnRowSize(self, evt):
-        self.log.write("OnRowSize: row %d, %s\n" %
-                       (evt.GetRowOrCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnColSize(self, evt):
-        self.log.write("OnColSize: col %d, %s\n" %
-                       (evt.GetRowOrCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnRangeSelect(self, evt):
-        if evt.Selecting():
-            self.log.write("OnRangeSelect: top-left %s, bottom-right %s\n" %
-                           (evt.GetTopLeftCoords(), evt.GetBottomRightCoords()))
-        evt.Skip()
-
-
-    def OnCellChange(self, evt):
-        self.log.write("OnCellChange: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-
-        # Show how to stay in a cell that has bad data.  We can't just
-        # call SetGridCursor here since we are nested inside one so it
-        # won't have any effect.  Instead, set coordinants to move to in
-        # idle time.
-        value = self.GetCellValue(evt.GetRow(), evt.GetCol())
-        if value == 'no good':
-            self.moveTo = evt.GetRow(), evt.GetCol()
-
-
-    def OnIdle(self, evt):
-        if self.moveTo != None:
-            self.SetGridCursor(self.moveTo[0], self.moveTo[1])
-            self.moveTo = None
-        evt.Skip()
-
-
-    def OnSelectCell(self, evt):
-        self.log.write("OnSelectCell: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-
-        # Another way to stay in a cell that has a bad value...
-        row = self.GetGridCursorRow()
-        col = self.GetGridCursorCol()
-        if self.IsCellEditControlEnabled():
-            self.HideCellEditControl()
-            self.DisableCellEditControl()
-        value = self.GetCellValue(row, col)
-        if value == 'no good 2':
-            return  # cancels the cell selection
-        evt.Skip()
-
-
-    def OnEditorShown(self, evt):
-        self.log.write("OnEditorShown: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnEditorHidden(self, evt):
-        self.log.write("OnEditorHidden: (%d,%d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
-        evt.Skip()
-
-    def OnEditorCreated(self, evt):
-        self.log.write("OnEditorCreated: (%d, %d) %s\n" %
-                       (evt.GetRow(), evt.GetCol(), evt.GetControl()))
-
-
-
-#---------------------------------------------------------------------------
-
-class TestFrame(wxFrame):
-    def __init__(self, parent, log):
-        wxFrame.__init__(self, parent, -1, "Simple Grid Demo", size=(640,480))
-        grid = SimpleGrid(self, log)
-
-
-
-#---------------------------------------------------------------------------
-
-if __name__ == '__main__':
-    import sys
-    app = wxPySimpleApp()
-    frame = TestFrame(None, sys.stdout)
-    frame.Show(true)
-    app.MainLoop()
-
-
-#---------------------------------------------------------------------------
-
-

wxPython/demo/GridStdEdRend.py

@@ -1,181 +0,0 @@
-from wxPython.wx import *
-from wxPython.grid import *
-
-import string, random
-
-#---------------------------------------------------------------------------
-
-class MyCustomRenderer(wxPyGridCellRenderer):
-    def __init__(self):
-        wxPyGridCellRenderer.__init__(self)
-
-    def Draw(self, grid, attr, dc, rect, row, col, isSelected):
-        dc.SetBackgroundMode(wxSOLID)
-        dc.SetBrush(wxBrush(wxBLACK, wxSOLID))
-        dc.SetPen(wxTRANSPARENT_PEN)
-        dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height)
-
-        dc.SetBackgroundMode(wxTRANSPARENT)
-        dc.SetFont(attr.GetFont())
-
-        text = grid.GetCellValue(row, col)
-        colors = [wxRED, wxWHITE, wxCYAN]
-        x = rect.x + 1
-        y = rect.y + 1
-        for ch in text:
-            dc.SetTextForeground(random.choice(colors))
-            dc.DrawText(ch, x, y)
-            w, h = dc.GetTextExtent(ch)
-            x = x + w
-            if x > rect.right - 5:
-                break
-
-
-    def GetBestSize(self, grid, attr, dc, row, col):
-        text = grid.GetCellValue(row, col)
-        dc.SetFont(attr.GetFont())
-        w, h = dc.GetTextExtent(text)
-        return wxSize(w, h)
-
-
-    def Clone(self):
-        return MyCustomRenderer()
-
-
-#---------------------------------------------------------------------------
-
-rendererDemoData = [
-    ('wxGridCellStringRenderer\n(the default)', 'this is a text value', wxGridCellStringRenderer, ()),
-    ('wxGridCellNumberRenderer', '12345', wxGridCellNumberRenderer, ()),
-    ('wxGridCellFloatRenderer', '1234.5678', wxGridCellFloatRenderer, (6,2)),
-    ('wxGridCellBoolRenderer', '1', wxGridCellBoolRenderer, ()),
-    ('MyCustomRenderer', 'This is my renderer', MyCustomRenderer, ()),
-    ]
-
-editorDemoData = [
-    ('wxGridCellTextEditor\n(the default)', 'Here is some more text', wxGridCellTextEditor, ()),
-    ('wxGridCellNumberEditor\nwith min,max', '101', wxGridCellNumberEditor, (5, 10005)),
-    ('wxGridCellNumberEditor\nwithout bounds', '101', wxGridCellNumberEditor, ()),
-    ('wxGridCellFloatEditor', '1234.5678', wxGridCellFloatEditor, ()),
-    ('wxGridCellBoolEditor', '1', wxGridCellBoolEditor, ()),
-    ('wxGridCellChoiceEditor', 'one', wxGridCellChoiceEditor, (['one', 'two', 'three', 'four',
-                                                         'kick', 'Microsoft', 'out the',
-                                                         'door'], false)),
-    ]
-
-
-comboDemoData = [
-    ('wxGridCellNumberRenderer\nwxGridCellNumberEditor', '20792', wxGridCellNumberRenderer, wxGridCellNumberEditor),
-    ('wxGridCellBoolRenderer\nwxGridCellBoolEditor', '1', wxGridCellBoolRenderer, wxGridCellBoolEditor),
-    ]
-
-
-class EditorsAndRenderersGrid(wxGrid):
-    def __init__(self, parent, log):
-        wxGrid.__init__(self, parent, -1)
-        self.log = log
-
-        self.CreateGrid(25, 8)
-        renCol = 1
-        edCol = 4
-
-
-        self.SetCellValue(0, renCol, '''\
-Cell Renderers are used to draw
-the contents of the cell when they
-need to be refreshed.  Different
-types of Renderers can be plugged in
-to different cells in the grid, it can
-even be automatically determined based
-on the type of data in the cell.
-''')
-
-        self.SetCellValue(0, edCol, '''\
-Cell Editors are used when the
-value of the cell is edited by
-the user.  An editor class is
-wrapped around a an object
-derived from wxControl and it
-implements some methods required
-to integrate with the grid.
-''')
-
-        self.SetCellValue(16, renCol, '''\
-Here are some combinations of Editors and
-Renderers used together.
-''')
-
-        row = 2
-        for label, value, renderClass, args in rendererDemoData:
-            renderer = apply(renderClass, args)
-            self.SetCellValue(row, renCol, label)
-            self.SetCellValue(row, renCol+1, value)
-            self.SetCellRenderer(row, renCol+1, renderer)
-            row = row + 2
-
-
-        row = 2
-        for label, value, editorClass, args in editorDemoData:
-            editor = apply(editorClass, args)
-            self.SetCellValue(row, edCol, label)
-            self.SetCellValue(row, edCol+1, value)
-            self.SetCellEditor(row, edCol+1, editor)
-            row = row + 2
-
-
-        row = 18
-        for label, value, renClass, edClass in comboDemoData:
-            self.SetCellValue(row, renCol, label)
-            self.SetCellValue(row, renCol+1, value)
-            editor = apply(edClass, ()) #args)
-            renderer = apply(renClass, ()) #args)
-            self.SetCellEditor(row, renCol+1, editor)
-            self.SetCellRenderer(row, renCol+1, renderer)
-            row = row + 2
-
-
-        font = self.GetFont()
-        font.SetWeight(wxBOLD)
-        attr = wxGridCellAttr()
-        attr.SetFont(font)
-        attr.SetBackgroundColour(wxLIGHT_GREY)
-        attr.SetReadOnly(true)
-        attr.SetAlignment(wxRIGHT, -1)
-        self.SetColAttr(renCol, attr)
-        attr.IncRef()
-        self.SetColAttr(edCol, attr)
-
-        # There is a bug in wxGTK for this method...
-        self.AutoSizeColumns(true)
-        self.AutoSizeRows(true)
-
-        EVT_GRID_CELL_LEFT_DCLICK(self, self.OnLeftDClick)
-
-
-    # I do this because I don't like the default behaviour of not starting the
-    # cell editor on double clicks, but only a second click.
-    def OnLeftDClick(self, evt):
-        if self.CanEnableCellControl():
-            self.EnableCellEditControl()
-
-
-#---------------------------------------------------------------------------
-
-class TestFrame(wxFrame):
-    def __init__(self, parent, log):
-        wxFrame.__init__(self, parent, -1, "Editors and Renderers Demo", size=(640,480))
-        grid = EditorsAndRenderersGrid(self, log)
-
-
-
-#---------------------------------------------------------------------------
-
-if __name__ == '__main__':
-    import sys
-    app = wxPySimpleApp()
-    frame = TestFrame(None, sys.stdout)
-    frame.Show(true)
-    app.MainLoop()
-
-
-#---------------------------------------------------------------------------

wxPython/demo/ImageBrowser.py

@@ -1,40 +0,0 @@
-#----------------------------------------------------------------------------
-# Name:         ImageBrowser.py
-# Purpose:      Image Selection dialog for wxPython demo
-#
-# Author:       Lorne White (email: lorne.white@telusplanet.net)
-#
-# Version       0.5 
-# Date:         Feb 26, 2001
-# Licence:      wxWindows license
-#----------------------------------------------------------------------------
-
-from wxPython.wx import *
-from wxPython.lib.imagebrowser import *
-import os
-
-#---------------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    dir = os.getcwd()       # get working directory
-    initial_dir = os.path.join(dir, 'bitmaps')  # set the initial directory for the demo bitmaps
-    win = ImageDialog(frame, initial_dir)   # open the image browser dialog
-    win.Centre()
-    if win.ShowModal() == wxID_OK:      
-        log.WriteText("You Selected File: " + win.GetFile())        # show the selected file
-    else:
-        log.WriteText("You pressed Cancel\n")
-            
-#---------------------------------------------------------------------------
-
-
-
-
-
-
-
-
-
-
-overview = """\
-"""

wxPython/demo/LayoutAnchors.py

@@ -1,140 +0,0 @@
-
-from wxPython.wx import *
-from wxPython.lib.anchors import LayoutAnchors
-
-#----------------------------------------------------------------------
-
-
-[wxID_ANCHORSDEMOFRAMEANCHOREDPANEL, wxID_ANCHORSDEMOFRAMEHELPSTATICTEXT,
- wxID_ANCHORSDEMOFRAMEMAINPANEL, wxID_ANCHORSDEMOFRAMEBACKGROUNDPANEL,
- wxID_ANCHORSDEMOFRAMERIGHTCHECKBOX, wxID_ANCHORSDEMOFRAMEOKBUTTON,
- wxID_ANCHORSDEMOFRAMETOPCHECKBOX, wxID_ANCHORSDEMOFRAMEBOTTOMCHECKBOX,
- wxID_ANCHORSDEMOFRAME, wxID_ANCHORSDEMOFRAMELEFTCHECKBOX,
- ] = map(lambda _init_ctrls: wxNewId(), range(10))
-
-class AnchorsDemoFrame(wxFrame):
-    def _init_utils(self):
-        pass
-
-    def _init_ctrls(self, prnt):
-        wxFrame.__init__(self, size = wxSize(328, 187), id = wxID_ANCHORSDEMOFRAME, title = 'LayoutAnchors Demonstration', parent = prnt, name = 'AnchorsDemoFrame', style = wxDEFAULT_FRAME_STYLE | wxCLIP_CHILDREN, pos = wxPoint(261, 123))
-        self._init_utils()
-
-        self.mainPanel = wxPanel(size = wxSize(320, 160), parent = self, id = wxID_ANCHORSDEMOFRAMEMAINPANEL, name = 'panel1', style = wxTAB_TRAVERSAL | wxCLIP_CHILDREN, pos = wxPoint(0, 0))
-        self.mainPanel.SetAutoLayout(true)
-
-        self.okButton = wxButton(label = 'OK', id = wxID_ANCHORSDEMOFRAMEOKBUTTON, parent = self.mainPanel, name = 'okButton', size = wxSize(72, 24), style = 0, pos = wxPoint(240, 128))
-        self.okButton.SetConstraints(LayoutAnchors(self.okButton, false, false, true, true))
-        EVT_BUTTON(self.okButton, wxID_ANCHORSDEMOFRAMEOKBUTTON, self.OnOkButtonButton)
-
-        self.backgroundPanel = wxPanel(size = wxSize(304, 80), parent = self.mainPanel, id = wxID_ANCHORSDEMOFRAMEBACKGROUNDPANEL, name = 'backgroundPanel', style = wxSIMPLE_BORDER | wxCLIP_CHILDREN, pos = wxPoint(8, 40))
-        self.backgroundPanel.SetBackgroundColour(wxColour(255, 255, 255))
-        self.backgroundPanel.SetConstraints(LayoutAnchors(self.backgroundPanel, true, true, true, true))
-
-        self.anchoredPanel = wxPanel(size = wxSize(88, 48), id = wxID_ANCHORSDEMOFRAMEANCHOREDPANEL, parent = self.backgroundPanel, name = 'anchoredPanel', style = wxSIMPLE_BORDER, pos = wxPoint(104, 16))
-        self.anchoredPanel.SetBackgroundColour(wxColour(0, 0, 222))
-        self.anchoredPanel.SetConstraints(LayoutAnchors(self.anchoredPanel, false, false, false, false))
-
-        self.leftCheckBox = wxCheckBox(label = 'Left', id = wxID_ANCHORSDEMOFRAMELEFTCHECKBOX, parent = self.mainPanel, name = 'leftCheckBox', size = wxSize(40, 16), style = 0, pos = wxPoint(8, 8))
-        self.leftCheckBox.SetConstraints(LayoutAnchors(self.leftCheckBox, false, true, false, false))
-        EVT_CHECKBOX(self.leftCheckBox, wxID_ANCHORSDEMOFRAMELEFTCHECKBOX, self.OnCheckboxCheckbox)
-
-        self.topCheckBox = wxCheckBox(label = 'Top', id = wxID_ANCHORSDEMOFRAMETOPCHECKBOX, parent = self.mainPanel, name = 'topCheckBox', size = wxSize(40, 16), style = 0, pos = wxPoint(88, 8))
-        self.topCheckBox.SetConstraints(LayoutAnchors(self.topCheckBox, false, true, false, false))
-        EVT_CHECKBOX(self.topCheckBox, wxID_ANCHORSDEMOFRAMETOPCHECKBOX, self.OnCheckboxCheckbox)
-
-        self.rightCheckBox = wxCheckBox(label = 'Right', id = wxID_ANCHORSDEMOFRAMERIGHTCHECKBOX, parent = self.mainPanel, name = 'rightCheckBox', size = wxSize(48, 16), style = 0, pos = wxPoint(168, 8))
-        self.rightCheckBox.SetConstraints(LayoutAnchors(self.rightCheckBox, false, true, false, false))
-        EVT_CHECKBOX(self.rightCheckBox, wxID_ANCHORSDEMOFRAMERIGHTCHECKBOX, self.OnCheckboxCheckbox)
-
-        self.bottomCheckBox = wxCheckBox(label = 'Bottom', id = wxID_ANCHORSDEMOFRAMEBOTTOMCHECKBOX, parent = self.mainPanel, name = 'bottomCheckBox', size = wxSize(56, 16), style = 0, pos = wxPoint(248, 8))
-        self.bottomCheckBox.SetConstraints(LayoutAnchors(self.bottomCheckBox, false, true, false, false))
-        EVT_CHECKBOX(self.bottomCheckBox, wxID_ANCHORSDEMOFRAMEBOTTOMCHECKBOX, self.OnCheckboxCheckbox)
-
-        self.helpStaticText = wxStaticText(label = 'Select anchor options above, then resize window to see the effect', id = wxID_ANCHORSDEMOFRAMEHELPSTATICTEXT, parent = self.mainPanel, name = 'helpStaticText', size = wxSize(224, 24), style = wxST_NO_AUTORESIZE, pos = wxPoint(8, 128))
-        self.helpStaticText.SetConstraints(LayoutAnchors(self.helpStaticText, true, false, true, true))
-
-    def __init__(self, parent):
-        self._init_ctrls(parent)
-
-    def OnCheckboxCheckbox(self, event):
-        self.anchoredPanel.SetConstraints(
-            LayoutAnchors(self.anchoredPanel,
-                          self.leftCheckBox.GetValue(), self.topCheckBox.GetValue(),
-                          self.rightCheckBox.GetValue(), self.bottomCheckBox.GetValue()) )
-
-    def OnOkButtonButton(self, event):
-        self.Close()
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = AnchorsDemoFrame(frame)
-    frame.otherWin = win
-    win.Show(true)
-
-
-
-
-#----------------------------------------------------------------------
-
-
-
-
-overview = """<html><body>
-<h2>LayoutAnchors</h2>
-        A class that implements Delphi's Anchors with wxLayoutConstraints.
-<p>
-        Anchored sides maintain the distance from the edge of the
-        control to the same edge of the parent.
-        When neither side is selected, the control keeps the same
-        relative position to both sides.
-<p>
-        The current position and size of the control and it's parent
-        is used when setting up the constraints. To change the size or
-        position of an already anchored control, set the constraints to
-        None, reposition or resize and reapply the anchors.
-<p>
-        Examples:
-<p>
-        Let's anchor the right and bottom edge of a control and
-        resize it's parent.
-<p>
-<pre>
-        ctrl.SetConstraints(LayoutAnchors(ctrl, left=0, top=0, right=1, bottom=1))
-
-        +=========+         +===================+
-        | +-----+ |         |                   |
-        | |     * |   ->    |                   |
-        | +--*--+ |         |           +-----+ |
-        +---------+         |           |     * |
-                            |           +--*--+ |
-                            +-------------------+
-        * = anchored edge
-</pre>
-<p>
-        When anchored on both sides the control will stretch horizontally.
-<p>
-<pre>
-        ctrl.SetConstraints(LayoutAnchors(ctrl, 1, 0, 1, 1))
-
-        +=========+         +===================+
-        | +-----+ |         |                   |
-        | *     * |   ->    |                   |
-        | +--*--+ |         | +---------------+ |
-        +---------+         | *     ctrl      * |
-                            | +-------*-------+ |
-                            +-------------------+
-        * = anchored edge
-</pre>
-</html></body>
-"""
-
-
-
-
-
-
-
-
-

wxPython/demo/Layoutf.py

@@ -1,62 +0,0 @@
-
-from wxPython.wx          import *
-from wxPython.lib.layoutf import Layoutf
-
-#---------------------------------------------------------------------------
-
-class TestLayoutf(wxPanel):
-    def __init__(self, parent):
-        wxPanel.__init__(self, parent, -1)
-
-        self.SetAutoLayout(true)
-        EVT_BUTTON(self, 100, self.OnButton)
-
-        self.panelA = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER)
-        self.panelA.SetBackgroundColour(wxBLUE)
-        self.panelA.SetConstraints(Layoutf('t=t10#1;l=l10#1;b=b10#1;r%r50#1',(self,)))
-
-        self.panelB = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER)
-        self.panelB.SetBackgroundColour(wxRED)
-        self.panelB.SetConstraints(Layoutf('t=t10#1;r=r10#1;b%b30#1;l>10#2', (self,self.panelA)))
-
-        self.panelC = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER)
-        self.panelC.SetBackgroundColour(wxWHITE)
-        self.panelC.SetConstraints(Layoutf('t_10#3;r=r10#1;b=b10#1;l>10#2', (self,self.panelA,self.panelB)))
-
-        b = wxButton(self.panelA, 100, ' Panel A ')
-        b.SetConstraints(Layoutf('X=X#1;Y=Y#1;h*;w%w50#1', (self.panelA,)))
-
-        b = wxButton(self.panelB, 100, ' Panel B ')
-        b.SetConstraints(Layoutf('t=t2#1;r=r4#1;h*;w*', (self.panelB,)))
-
-        self.panelD = wxWindow(self.panelC, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER)
-        self.panelD.SetBackgroundColour(wxGREEN)
-        self.panelD.SetConstraints(Layoutf('b%h50#1;r%w50#1;h=h#2;w=w#2', (self.panelC, b)))
-
-        b = wxButton(self.panelC, 100, ' Panel C ')
-        b.SetConstraints(Layoutf('t_#1;l>#1;h*;w*', (self.panelD,)))
-
-        wxStaticText(self.panelD, -1, "Panel D", wxPoint(4, 4)).SetBackgroundColour(wxGREEN)
-
-    def OnButton(self, event):
-        wxBell()
-
-
-
-#---------------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestLayoutf(nb)
-    return win
-
-#---------------------------------------------------------------------------
-
-
-
-
-
-
-
-
-
-overview = Layoutf.__doc__

wxPython/demo/MDIDemo.py

@@ -1,53 +0,0 @@
-#!/usr/bin/env python
-
-from wxPython.wx import *
-from wxScrolledWindow import MyCanvas
-
-#----------------------------------------------------------------------
-
-class MyParentFrame(wxMDIParentFrame):
-    def __init__(self):
-        wxMDIParentFrame.__init__(self, None, -1, "MDI Parent", size=(600,400))
-
-        self.winCount = 0
-        menu = wxMenu()
-        menu.Append(5000, "&New Window")
-        menu.AppendSeparator()
-        menu.Append(5001, "E&xit")
-
-        menubar = wxMenuBar()
-        menubar.Append(menu, "&File")
-        self.SetMenuBar(menubar)
-
-        self.CreateStatusBar()
-
-        EVT_MENU(self, 5000, self.OnNewWindow)
-        EVT_MENU(self, 5001, self.OnExit)
-
-
-    def OnExit(self, evt):
-        self.Close(true)
-
-
-    def OnNewWindow(self, evt):
-        self.winCount = self.winCount + 1
-        win = wxMDIChildFrame(self, -1, "Child Window: %d" % self.winCount)
-        canvas = MyCanvas(win)
-        win.Show(true)
-
-
-#----------------------------------------------------------------------
-
-class MyApp(wxApp):
-    def OnInit(self):
-        frame = MyParentFrame()
-        frame.Show(true)
-        self.SetTopWindow(frame)
-        return true
-
-
-app = MyApp(0)
-app.MainLoop()
-
-
-

wxPython/demo/MDISashDemo.py

@@ -1,140 +0,0 @@
-#!/usr/bin/env python
-
-from wxPython.wx import *
-from wxScrolledWindow import MyCanvas
-
-#----------------------------------------------------------------------
-
-class MyParentFrame(wxMDIParentFrame):
-    ID_WINDOW_TOP    = 5100
-    ID_WINDOW_LEFT1  = 5101
-    ID_WINDOW_LEFT2  = 5102
-    ID_WINDOW_BOTTOM = 5103
-
-    def __init__(self):
-        wxMDIParentFrame.__init__(self, None, -1, "MDI Parent", size=(600,400),
-                                  style = wxDEFAULT_FRAME_STYLE | wxHSCROLL | wxVSCROLL)
-
-        self.winCount = 0
-        menu = wxMenu()
-        menu.Append(5000, "&New Window")
-        menu.AppendSeparator()
-        menu.Append(5001, "E&xit")
-
-        menubar = wxMenuBar()
-        menubar.Append(menu, "&File")
-        self.SetMenuBar(menubar)
-
-        #self.CreateStatusBar()
-
-        EVT_MENU(self, 5000, self.OnNewWindow)
-        EVT_MENU(self, 5001, self.OnExit)
-
-
-        EVT_SASH_DRAGGED_RANGE(self,
-                               self.ID_WINDOW_TOP, self.ID_WINDOW_BOTTOM,
-                               self.OnSashDrag)
-        EVT_SIZE(self, self.OnSize)
-
-
-        # Create some layout windows
-        # A window like a toolbar
-        win = wxSashLayoutWindow(self, self.ID_WINDOW_TOP, style = wxNO_BORDER|wxSW_3D)
-        win.SetDefaultSize((1000, 30))
-        win.SetOrientation(wxLAYOUT_HORIZONTAL)
-        win.SetAlignment(wxLAYOUT_TOP)
-        win.SetBackgroundColour(wxColour(255, 0, 0))
-        win.SetSashVisible(wxSASH_BOTTOM, true)
-
-        self.topWindow = win
-
-
-        # A window like a statusbar
-        win = wxSashLayoutWindow(self, self.ID_WINDOW_BOTTOM, style = wxNO_BORDER|wxSW_3D)
-        win.SetDefaultSize((1000, 30))
-        win.SetOrientation(wxLAYOUT_HORIZONTAL)
-        win.SetAlignment(wxLAYOUT_BOTTOM)
-        win.SetBackgroundColour(wxColour(0, 0, 255))
-        win.SetSashVisible(wxSASH_TOP, true)
-
-        self.bottomWindow = win
-
-
-        # A window to the left of the client window
-        win =  wxSashLayoutWindow(self, self.ID_WINDOW_LEFT1, style = wxNO_BORDER|wxSW_3D)
-        win.SetDefaultSize((120, 1000))
-        win.SetOrientation(wxLAYOUT_VERTICAL)
-        win.SetAlignment(wxLAYOUT_LEFT)
-        win.SetBackgroundColour(wxColour(0, 255, 0))
-        win.SetSashVisible(wxSASH_RIGHT, TRUE)
-        win.SetExtraBorderSize(10)
-        textWindow = wxTextCtrl(win, -1, "", wxDefaultPosition, wxDefaultSize,
-                                wxTE_MULTILINE|wxSUNKEN_BORDER)
-        textWindow.SetValue("A sub window")
-
-        self.leftWindow1 = win
-
-
-        # Another window to the left of the client window
-        win = wxSashLayoutWindow(self, self.ID_WINDOW_LEFT2, style = wxNO_BORDER|wxSW_3D)
-        win.SetDefaultSize((120, 1000))
-        win.SetOrientation(wxLAYOUT_VERTICAL)
-        win.SetAlignment(wxLAYOUT_LEFT)
-        win.SetBackgroundColour(wxColour(0, 255, 255))
-        win.SetSashVisible(wxSASH_RIGHT, TRUE)
-
-        self.leftWindow2 = win
-
-
-    def OnSashDrag(self, event):
-        if event.GetDragStatus() == wxSASH_STATUS_OUT_OF_RANGE:
-            return
-
-        eID = event.GetId()
-        if eID == self.ID_WINDOW_TOP:
-            self.topWindow.SetDefaultSize(wxSize(1000, event.GetDragRect().height))
-
-        elif eID == self.ID_WINDOW_LEFT1:
-            self.leftWindow1.SetDefaultSize(wxSize(event.GetDragRect().width, 1000))
-
-
-        elif eID == self.ID_WINDOW_LEFT2:
-            self.leftWindow2.SetDefaultSize(wxSize(event.GetDragRect().width, 1000))
-
-        elif eID == self.ID_WINDOW_BOTTOM:
-            self.bottomWindow.SetDefaultSize(wxSize(1000, event.GetDragRect().height))
-
-        wxLayoutAlgorithm().LayoutMDIFrame(self)
-        self.GetClientWindow().Refresh()
-
-
-    def OnSize(self, event):
-        wxLayoutAlgorithm().LayoutMDIFrame(self)
-
-
-    def OnExit(self, evt):
-        self.Close(true)
-
-
-    def OnNewWindow(self, evt):
-        self.winCount = self.winCount + 1
-        win = wxMDIChildFrame(self, -1, "Child Window: %d" % self.winCount)
-        canvas = MyCanvas(win)
-        win.Show(true)
-
-
-#----------------------------------------------------------------------
-
-class MyApp(wxApp):
-    def OnInit(self):
-        frame = MyParentFrame()
-        frame.Show(true)
-        self.SetTopWindow(frame)
-        return true
-
-
-app = MyApp(0)
-app.MainLoop()
-
-
-

wxPython/demo/Main.py

@@ -1,579 +0,0 @@
-#!/bin/env python
-#----------------------------------------------------------------------------
-# Name:         Main.py
-# Purpose:      Testing lots of stuff, controls, window types, etc.
-#
-# Author:       Robin Dunn
-#
-# Created:      A long time ago, in a galaxy far, far away...
-# RCS-ID:       $Id$
-# Copyright:    (c) 1999 by Total Control Software
-# Licence:      wxWindows license
-#----------------------------------------------------------------------------
-
-import sys, os
-from   wxPython.wx import *
-from   wxPython.lib.splashscreen import SplashScreen
-from   wxPython.html import wxHtmlWindow
-
-import images
-
-#---------------------------------------------------------------------------
-
-
-_treeList = [
-    ('New since last release', ['ContextHelp',
-                                'PyCrust',
-                                'PyCrustWithFilling',
-                                'VirtualListCtrl',
-                                'wxListCtrl',
-                                'TablePrint',
-                                ]),
-
-    ('Windows', ['wxFrame', 'wxDialog', 'wxMiniFrame',
-                 'wxGrid', 'wxSashWindow',
-                 'wxScrolledWindow', 'wxSplitterWindow',
-                 'wxStatusBar', 'wxNotebook',
-                 'wxHtmlWindow',
-                 'wxStyledTextCtrl_1', 'wxStyledTextCtrl_2',]),
-
-    ('Common Dialogs', ['wxColourDialog', 'wxDirDialog', 'wxFileDialog',
-                        'wxSingleChoiceDialog', 'wxTextEntryDialog',
-                        'wxFontDialog', 'wxPageSetupDialog', 'wxPrintDialog',
-                        'wxMessageDialog', 'wxProgressDialog']),
-
-    ('Controls', ['wxButton', 'wxCheckBox', 'wxCheckListBox', 'wxChoice',
-                  'wxComboBox', 'wxGauge', 'wxListBox', 'wxListCtrl', 'wxTextCtrl',
-                  'wxTreeCtrl', 'wxSpinButton', 'wxSpinCtrl', 'wxStaticText',
-                  'wxStaticBitmap', 'wxRadioBox', 'wxSlider', 'wxToolBar',
-                  'wxCalendarCtrl', 'wxToggleButton',
-                  ]),
-
-    ('Window Layout', ['wxLayoutConstraints', 'LayoutAnchors', 'Sizers', 'XML_Resource']),
-
-    ('Miscellaneous', [ 'DragAndDrop', 'CustomDragAndDrop', 'FontEnumerator',
-                        'wxTimer', 'wxValidator', 'wxGLCanvas', 'DialogUnits',
-                        'wxImage', 'wxMask', 'PrintFramework', 'wxOGL',
-                        'PythonEvents', 'Threads',
-                        'ActiveXWrapper_Acrobat', 'ActiveXWrapper_IE',
-                        'wxDragImage', "wxProcess", "FancyText", "OOR", "wxWave",
-                        'wxJoystick',
-                        ]),
-
-    ('wxPython Library', ['Layoutf', 'wxScrolledMessageDialog',
-                          'wxMultipleChoiceDialog', 'wxPlotCanvas', 'wxFloatBar',
-                          'wxCalendar', 'wxMVCTree', 'wxVTKRenderWindow',
-                          'FileBrowseButton', 'GenericButtons', 'wxEditor',
-                          'ColourSelect', 'ImageBrowser',
-                          'infoframe', 'ColourDB', 'PyCrust', 'TablePrint',
-                          ]),
-
-    ('Cool Contribs', ['pyTree', 'hangman', 'SlashDot', 'XMLtreeview']),
-
-    ]
-
-#---------------------------------------------------------------------------
-
-class wxPythonDemo(wxFrame):
-
-    def __init__(self, parent, id, title):
-        wxFrame.__init__(self, parent, -1, title, size = (800, 600),
-                         style=wxDEFAULT_FRAME_STYLE|wxNO_FULL_REPAINT_ON_RESIZE)
-
-        self.cwd = os.getcwd()
-        self.curOverview = ""
-
-        if 1:
-            icon = wxIconFromXPMData(images.getMondrianData())
-        else:
-            # another way to do it
-            bmp = images.getMondrianBitmap()
-            icon = wxEmptyIcon()
-            icon.CopyFromBitmap(bmp)
-
-        self.SetIcon(icon)
-
-        if wxPlatform == '__WXMSW__':
-            # setup a taskbar icon, and catch some events from it
-            self.tbicon = wxTaskBarIcon()
-            self.tbicon.SetIcon(icon, "wxPython Demo")
-            EVT_TASKBAR_LEFT_DCLICK(self.tbicon, self.OnTaskBarActivate)
-            EVT_TASKBAR_RIGHT_UP(self.tbicon, self.OnTaskBarMenu)
-            EVT_MENU(self.tbicon, self.TBMENU_RESTORE, self.OnTaskBarActivate)
-            EVT_MENU(self.tbicon, self.TBMENU_CLOSE, self.OnTaskBarClose)
-
-
-        self.otherWin = None
-        EVT_IDLE(self, self.OnIdle)
-        EVT_CLOSE(self, self.OnCloseWindow)
-        EVT_ICONIZE(self, self.OnIconfiy)
-        EVT_MAXIMIZE(self, self.OnMaximize)
-
-        self.Centre(wxBOTH)
-        self.CreateStatusBar(1, wxST_SIZEGRIP)
-
-        splitter = wxSplitterWindow(self, -1, style=wxNO_3D|wxSP_3D)
-        splitter2 = wxSplitterWindow(splitter, -1, style=wxNO_3D|wxSP_3D)
-
-        def EmptyHandler(evt): pass
-        EVT_ERASE_BACKGROUND(splitter, EmptyHandler)
-        EVT_ERASE_BACKGROUND(splitter2, EmptyHandler)
-
-        # Prevent TreeCtrl from displaying all items after destruction when true
-        self.dying = false
-
-        # Make a File menu
-        self.mainmenu = wxMenuBar()
-        menu = wxMenu()
-        exitID = wxNewId()
-        menu.Append(exitID, 'E&xit\tAlt-X', 'Get the heck outta here!')
-        EVT_MENU(self, exitID, self.OnFileExit)
-        self.mainmenu.Append(menu, '&File')
-
-        # Make a Demo menu
-        menu = wxMenu()
-        for item in _treeList:
-            submenu = wxMenu()
-            for childItem in item[1]:
-                mID = wxNewId()
-                submenu.Append(mID, childItem)
-                EVT_MENU(self, mID, self.OnDemoMenu)
-            menu.AppendMenu(wxNewId(), item[0], submenu)
-        self.mainmenu.Append(menu, '&Demo')
-
-
-        # Make a Help menu
-        helpID = wxNewId()
-        menu = wxMenu()
-        menu.Append(helpID, '&About\tCtrl-H', 'wxPython RULES!!!')
-        EVT_MENU(self, helpID, self.OnHelpAbout)
-        self.mainmenu.Append(menu, '&Help')
-        self.SetMenuBar(self.mainmenu)
-
-        # set the menu accellerator table...
-        aTable = wxAcceleratorTable([(wxACCEL_ALT,  ord('X'), exitID),
-                                     (wxACCEL_CTRL, ord('H'), helpID)])
-        self.SetAcceleratorTable(aTable)
-
-
-        # Create a TreeCtrl
-        tID = wxNewId()
-        self.treeMap = {}
-        self.tree = wxTreeCtrl(splitter, tID,
-                               style=wxTR_HAS_BUTTONS |
-                               wxTR_EDIT_LABELS |
-                               wxTR_HAS_VARIABLE_ROW_HEIGHT |
-                               wxSUNKEN_BORDER)
-        #self.tree.SetBackgroundColour(wxNamedColour("Pink"))
-        root = self.tree.AddRoot("Overview")
-        firstChild = None
-        for item in _treeList:
-            child = self.tree.AppendItem(root, item[0])
-            if not firstChild: firstChild = child
-            for childItem in item[1]:
-                theDemo = self.tree.AppendItem(child, childItem)
-                self.treeMap[childItem] = theDemo
-
-        self.tree.Expand(root)
-        self.tree.Expand(firstChild)
-        EVT_TREE_ITEM_EXPANDED   (self.tree, tID, self.OnItemExpanded)
-        EVT_TREE_ITEM_COLLAPSED  (self.tree, tID, self.OnItemCollapsed)
-        EVT_TREE_SEL_CHANGED     (self.tree, tID, self.OnSelChanged)
-        EVT_LEFT_DOWN            (self.tree,      self.OnTreeLeftDown)
-
-        # Create a Notebook
-        self.nb = wxNotebook(splitter2, -1, style=wxCLIP_CHILDREN)
-
-        # Set up a wxHtmlWindow on the Overview Notebook page
-        # we put it in a panel first because there seems to be a
-        # refresh bug of some sort (wxGTK) when it is directly in
-        # the notebook...
-        if 0:  # the old way
-            self.ovr = wxHtmlWindow(self.nb, -1, size=(400, 400))
-            self.nb.AddPage(self.ovr, "Overview")
-
-        else:  # hopefully I can remove this hacky code soon, see bug #216861
-            panel = wxPanel(self.nb, -1, style=wxCLIP_CHILDREN)
-            self.ovr = wxHtmlWindow(panel, -1, size=(400, 400))
-            self.ovr.SetFonts("", "", [7, 8, 10, 12, 16, 22, 30])
-            self.nb.AddPage(panel, "Overview")
-
-            def OnOvrSize(evt, ovr=self.ovr):
-                ovr.SetSize(evt.GetSize())
-
-            EVT_SIZE(panel, OnOvrSize)
-            EVT_ERASE_BACKGROUND(panel, EmptyHandler)
-
-
-        self.SetOverview("Overview", overview)
-
-
-        # Set up a TextCtrl on the Demo Code Notebook page
-        self.txt = wxTextCtrl(self.nb, -1,
-                              style = wxTE_MULTILINE|wxTE_READONLY|wxHSCROLL)
-        self.nb.AddPage(self.txt, "Demo Code")
-
-
-        # Set up a log on the View Log Notebook page
-        self.log = wxTextCtrl(splitter2, -1,
-                              style = wxTE_MULTILINE|wxTE_READONLY|wxHSCROLL)
-        # Set the wxWindows log target to be this textctrl
-        wxLog_SetActiveTarget(wxLogTextCtrl(self.log))
-
-
-
-        self.Show(true)
-
-        # add the windows to the splitter and split it.
-        splitter2.SplitHorizontally(self.nb, self.log)
-        splitter2.SetSashPosition(450, true)
-        splitter2.SetMinimumPaneSize(20)
-
-        splitter.SplitVertically(self.tree, splitter2)
-        splitter.SetSashPosition(180, true)
-        splitter.SetMinimumPaneSize(20)
-
-
-        # select initial items
-        self.nb.SetSelection(0)
-        self.tree.SelectItem(root)
-
-        if len(sys.argv) == 2:
-            try:
-                selectedDemo = self.treeMap[sys.argv[1]]
-            except:
-                selectedDemo = None
-            if selectedDemo:
-                self.tree.SelectItem(selectedDemo)
-                self.tree.EnsureVisible(selectedDemo)
-
-
-        wxLogMessage('window handle: %s' % self.GetHandle())
-
-
-    #---------------------------------------------
-    def WriteText(self, text):
-        if text[-1:] == '\n':
-            text = text[:-1]
-        wxLogMessage(text)
-
-
-    def write(self, txt):
-        self.WriteText(txt)
-
-    #---------------------------------------------
-    def OnItemExpanded(self, event):
-        item = event.GetItem()
-        wxLogMessage("OnItemExpanded: %s" % self.tree.GetItemText(item))
-        event.Skip()
-
-    #---------------------------------------------
-    def OnItemCollapsed(self, event):
-        item = event.GetItem()
-        wxLogMessage("OnItemCollapsed: %s" % self.tree.GetItemText(item))
-        event.Skip()
-
-    #---------------------------------------------
-    def OnTreeLeftDown(self, event):
-        pt = event.GetPosition();
-        item, flags = self.tree.HitTest(pt)
-        if item == self.tree.GetSelection():
-            self.SetOverview(self.tree.GetItemText(item), self.curOverview)
-        event.Skip()
-
-    #---------------------------------------------
-    def OnSelChanged(self, event):
-        if self.dying:
-            return
-
-        item = event.GetItem()
-        itemText = self.tree.GetItemText(item)
-        self.RunDemo(itemText)
-
-
-    #---------------------------------------------
-    def RunDemo(self, itemText):
-        os.chdir(self.cwd)
-        if self.nb.GetPageCount() == 3:
-            if self.nb.GetSelection() == 2:
-                self.nb.SetSelection(0)
-            self.nb.DeletePage(2)
-
-        if itemText == 'Overview':
-            self.GetDemoFile('Main.py')
-            self.SetOverview('Overview', overview)
-            self.nb.Refresh();
-            self.window = None
-
-        else:
-            if os.path.exists(itemText + '.py'):
-                wxBeginBusyCursor()
-                wxLogMessage("Running demo %s.py..." % itemText)
-                try:
-                    self.GetDemoFile(itemText + '.py')
-                    module = __import__(itemText, globals())
-                    self.SetOverview(itemText, module.overview)
-                finally:
-                    wxEndBusyCursor()
-
-                # in case runTest is modal, make sure things look right...
-                self.nb.Refresh();
-                wxYield()
-
-                self.window = module.runTest(self, self.nb, self) ###
-                if self.window:
-                    self.nb.AddPage(self.window, 'Demo')
-                    wxYield()
-                    self.nb.SetSelection(2)
-
-            else:
-                self.ovr.SetPage("")
-                self.txt.Clear()
-                self.window = None
-
-
-
-    #---------------------------------------------
-    # Get the Demo files
-    def GetDemoFile(self, filename):
-        self.txt.Clear()
-        try:
-            self.txt.SetValue(open(filename).read())
-        except IOError:
-            self.txt.WriteText("Cannot open %s file." % filename)
-
-        self.txt.SetInsertionPoint(0)
-        self.txt.ShowPosition(0)
-
-    #---------------------------------------------
-    def SetOverview(self, name, text):
-        self.curOverview = text
-        lead = text[:6]
-        if lead != '<html>' and lead != '<HTML>':
-            text = string.join(string.split(text, '\n'), '<br>')
-            #text = '<font size="-1"><pre>' + text + '</pre></font>'
-        self.ovr.SetPage(text)
-        self.nb.SetPageText(0, name)
-
-    #---------------------------------------------
-    # Menu methods
-    def OnFileExit(self, *event):
-        self.Close()
-
-
-    def OnHelpAbout(self, event):
-        from About import MyAboutBox
-        about = MyAboutBox(self)
-        about.ShowModal()
-        about.Destroy()
-
-
-    #---------------------------------------------
-    def OnCloseWindow(self, event):
-        self.dying = true
-        self.window = None
-        self.mainmenu = None
-        if hasattr(self, "tbicon"):
-            del self.tbicon
-        self.Destroy()
-
-
-    #---------------------------------------------
-    def OnIdle(self, event):
-        if self.otherWin:
-            self.otherWin.Raise()
-            self.window = self.otherWin
-            self.otherWin = None
-
-    #---------------------------------------------
-    def OnDemoMenu(self, event):
-        try:
-            selectedDemo = self.treeMap[self.mainmenu.GetLabel(event.GetId())]
-        except:
-            selectedDemo = None
-        if selectedDemo:
-            self.tree.SelectItem(selectedDemo)
-            self.tree.EnsureVisible(selectedDemo)
-
-
-    #---------------------------------------------
-    def OnTaskBarActivate(self, evt):
-        if self.IsIconized():
-            self.Iconize(false)
-        if not self.IsShown():
-            self.Show(true)
-        self.Raise()
-
-    #---------------------------------------------
-
-    TBMENU_RESTORE = 1000
-    TBMENU_CLOSE   = 1001
-
-    def OnTaskBarMenu(self, evt):
-        menu = wxMenu()
-        menu.Append(self.TBMENU_RESTORE, "Restore wxPython Demo")
-        menu.Append(self.TBMENU_CLOSE,   "Close")
-        self.tbicon.PopupMenu(menu)
-        menu.Destroy()
-
-    #---------------------------------------------
-    def OnTaskBarClose(self, evt):
-        self.Close()
-
-        # because of the way wxTaskBarIcon.PopupMenu is implemented we have to
-        # prod the main idle handler a bit to get the window to actually close
-        wxGetApp().ProcessIdle()
-
-
-    #---------------------------------------------
-    def OnIconfiy(self, evt):
-        wxLogMessage("OnIconfiy")
-        evt.Skip()
-
-    #---------------------------------------------
-    def OnMaximize(self, evt):
-        wxLogMessage("OnMaximize")
-        evt.Skip()
-
-
-
-
-#---------------------------------------------------------------------------
-#---------------------------------------------------------------------------
-
-class MyApp(wxApp):
-    def OnInit(self):
-        wxInitAllImageHandlers()
-
-        self.splash = SplashScreen(None, bitmapfile='bitmaps/splash.gif',
-                              duration=4000, callback=self.AfterSplash)
-        self.splash.Show(true)
-        wxYield()
-        return true
-
-
-    def AfterSplash(self):
-        self.splash.Close(true)
-        frame = wxPythonDemo(None, -1, "wxPython: (A Demonstration)")
-        frame.Show(true)
-        self.SetTopWindow(frame)
-        self.ShowTip(frame)
-
-
-    def ShowTip(self, frame):
-        try:
-            showTipText = open("data/showTips").read()
-            showTip, index = eval(showTipText)
-        except IOError:
-            showTip, index = (1, 0)
-        #print showTip, index
-        if showTip:
-            tp = wxCreateFileTipProvider("data/tips.txt", index)
-            showTip = wxShowTip(frame, tp)
-            index = tp.GetCurrentTip()
-            open("data/showTips", "w").write(str( (showTip, index) ))
-
-
-#---------------------------------------------------------------------------
-
-def main():
-    try:
-        demoPath = os.path.dirname(__file__)
-        os.chdir(demoPath)
-    except:
-        pass
-    app = MyApp(0)
-    app.MainLoop()
-
-
-#---------------------------------------------------------------------------
-
-
-
-overview = """<html><body>
- <h2>Python</h2>
-
- Python is an interpreted, interactive, object-oriented programming
- language often compared to Tcl, Perl, Scheme, or Java.
-
- <p> Python combines remarkable power with very clear syntax. It has
- modules, classes, exceptions, very high level dynamic data types, and
- dynamic typing.  There are interfaces to many system calls and
- libraries, and new built-in modules are easily written in C or
- C++. Python is also usable as an extension language for applications
- that need a programmable interface.  <p>
-
- <h2>wxWindows</h2>
-
- wxWindows is a free C++ framework designed to make cross-platform
- programming child's play. Well, almost. wxWindows 2 supports Windows
- 3.1/95/98/NT, Unix with GTK/Motif/Lesstif, with a Mac version
- underway. Other ports are under consideration.  <p>
-
- wxWindows is a set of libraries that allows C++ applications to
- compile and run on several different types of computers, with minimal
- source code changes.  There is one library per supported GUI (such as
- Motif, or Windows). As well as providing a common API (Application
- Programming Interface) for GUI functionality, it provides
- functionality for accessing some commonly-used operating system
- facilities, such as copying or deleting files. wxWindows is a
- 'framework' in the sense that it provides a lot of built-in
- functionality, which the application can use or replace as required,
- thus saving a great deal of coding effort. Basic data structures such
- as strings, linked lists and hash tables are also supported.
-
- <p>
- <h2>wxPython</h2>
-
- wxPython is a Python extension module that encapsulates the wxWindows
- GUI classes. Currently it is only available for the Win32 and GTK
- ports of wxWindows, but as soon as the other ports are brought up to
- the same level as Win32 and GTK, it should be fairly trivial to
- enable wxPython to be used with the new GUI.
-
- <p>
-
- The wxPython extension module attempts to mirror the class heiarchy
- of wxWindows as closely as possible. This means that there is a
- wxFrame class in wxPython that looks, smells, tastes and acts almost
- the same as the wxFrame class in the C++ version. Unfortunately,
- because of differences in the languages, wxPython doesn't match
- wxWindows exactly, but the differences should be easy to absorb
- because they are natural to Python. For example, some methods that
- return multiple values via argument pointers in C++ will return a
- tuple of values in Python.
-
- <p>
-
- There is still much to be done for wxPython, many classes still need
- to be mirrored. Also, wxWindows is still somewhat of a moving target
- so it is a bit of an effort just keeping wxPython up to date. On the
- other hand, there are enough of the core classes completed that
- useful applications can be written.
-
- <p>
-
- wxPython is close enough to the C++ version that the majority of
- the wxPython documentation is actually just notes attached to the C++
- documents that describe the places where wxPython is different. There
- is also a series of sample programs included, and a series of
- documentation pages that assist the programmer in getting started
- with wxPython.
-
- """
-
-
-#----------------------------------------------------------------------------
-#----------------------------------------------------------------------------
-
-if __name__ == '__main__':
-    main()
-
-#----------------------------------------------------------------------------
-
-
-
-
-
-
-

wxPython/demo/OOR.py

@@ -1,118 +0,0 @@
-
-from wxPython.wx import *
-from wxPython.html import *
-
-#----------------------------------------------------------------------
-
-BTN1 = wxNewId()
-BTN2 = wxNewId()
-
-
-class TestPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-        self.log = log
-
-        sizer = wxBoxSizer(wxVERTICAL)
-        html = wxHtmlWindow(self, -1)
-        html.SetPage(overview)
-        sizer.Add(html, 1, wxEXPAND|wxALL, 5)
-
-        btns = wxBoxSizer(wxHORIZONTAL)
-        btns.Add(50, -1, 1, wxEXPAND)
-        btn1 = wxButton(self, BTN1, "Find My Alter-ego")  # don't save a ref to this one
-        btns.Add(btn1)
-        btns.Add(50, -1, 1, wxEXPAND)
-        self.btn2 = wxButton(self, BTN2, "Find Myself")
-        btns.Add(self.btn2)
-        btns.Add(50, -1, 1, wxEXPAND)
-
-        sizer.Add(btns, 0, wxEXPAND|wxALL, 15)
-
-        self.SetSizer(sizer)
-        self.SetAutoLayout(true)
-
-        EVT_BUTTON(self, BTN1, self.OnFindButton1)
-        EVT_BUTTON(self, BTN2, self.OnFindButton2)
-
-
-    def OnFindButton1(self, evt):
-        win = self.FindWindowById(BTN1)
-        if win is None:
-            self.log.write("***** OOPS! None returned...\n")
-            return
-        className = win.__class__.__name__
-        if className in ["wxButton", "wxButtonPtr"]:
-            self.log.write("The types are the same! <grin>\n")
-        else:
-            self.log.write("Got %s, expected wxButton or wxButtonPtr\n" % className)
-
-
-
-    def OnFindButton2(self, evt):
-        win = self.FindWindowById(BTN2)
-        if win is None:
-            self.log.write("***** OOPS! None returned...\n")
-            return
-        if win is self.btn2:
-            self.log.write("The objects are the same! <grin>\n")
-        else:
-            self.log.write("The objects are NOT the same! <frown>\n")
-
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestPanel(nb, log)
-    return win
-
-#----------------------------------------------------------------------
-
-
-overview = """\
-<html><body>
-<h2>Original Object Return</h2>
-
-<p>Several methods in wxWindows return pointers to base class objects,
-when in fact the actual object pointed to is of a derived type.  Since
-SWIG isn't able to tell the actual type it just creates a new Python
-shadow object of the base type to wrap around the base type pointer
-and returns it.
-
-<p>In wxPython this can cause annoying issues.  For example if you
-call:
-
-<pre>
-
-        myText = someWindow.FindWindowById(txtID)
-</pre>
-
-expecting to get a wxTextCtrl you will actually get a wxWindow object
-instead.  If you then try to call SetValue on that object you'll get
-an exception since there is no such method.  This is the reason for
-the wxPyTypeCast hack that has been in wxPython for so long.
-
-<p>Even with wxPyTypeCast there is the issue that the object returned
-is not the same one that was created in Python originally, but a new
-object of the same type that wraps the same C++ pointer.  If the
-programmer has set additional attributes of that original object they
-will not exist in the new object.
-
-<p>For a long time now I have wanted to do away with wxPyTypeCast and
-also find a way to return the original Python object from methods like
-FindWindowById.  This project naturally divides into two phases:
-
-<p><ol>
-
-<li>Teach the wrapper methods how to return objects of the right type,
-and be able to then turn wxPyTypeCast in to a no-op.
-
-<li>Be able to return the original Python shadow object if it still exists.
-
-</ol>
-
-<p>The first button below shows the first of these phases (<i>working</i>)
-and the second will show #2 (<i>not yet working.</i>)
-
-</body></html>
-"""

wxPython/demo/PrintFramework.py

@@ -1,176 +0,0 @@
-
-from wxPython.wx         import *
-from wxScrolledWindow    import MyCanvas
-
-#----------------------------------------------------------------------
-
-class MyPrintout(wxPrintout):
-    def __init__(self, canvas, log):
-        wxPrintout.__init__(self)
-        self.canvas = canvas
-        self.log = log
-
-    def OnBeginDocument(self, start, end):
-        self.log.WriteText("wxPrintout.OnBeginDocument\n")
-        return self.base_OnBeginDocument(start, end)
-
-    def OnEndDocument(self):
-        self.log.WriteText("wxPrintout.OnEndDocument\n")
-        self.base_OnEndDocument()
-
-    def OnBeginPrinting(self):
-        self.log.WriteText("wxPrintout.OnBeginPrinting\n")
-        self.base_OnBeginPrinting()
-
-    def OnEndPrinting(self):
-        self.log.WriteText("wxPrintout.OnEndPrinting\n")
-        self.base_OnEndPrinting()
-
-    def OnPreparePrinting(self):
-        self.log.WriteText("wxPrintout.OnPreparePrinting\n")
-        self.base_OnPreparePrinting()
-
-    def HasPage(self, page):
-        self.log.WriteText("wxPrintout.HasPage\n")
-        if page == 1:
-            return true
-        else:
-            return false
-
-    def GetPageInfo(self):
-        self.log.WriteText("wxPrintout.GetPageInfo\n")
-        return (1, 1, 1, 1)
-
-    def OnPrintPage(self, page):
-        self.log.WriteText("wxPrintout.OnPrintPage\n")
-        dc = self.GetDC()
-
-        #-------------------------------------------
-        # One possible method of setting scaling factors...
-
-        maxX = self.canvas.getWidth()
-        maxY = self.canvas.getHeight()
-
-        # Let's have at least 50 device units margin
-        marginX = 50
-        marginY = 50
-
-        # Add the margin to the graphic size
-        maxX = maxX + (2 * marginX)
-        maxY = maxY + (2 * marginY)
-
-        # Get the size of the DC in pixels
-        (w, h) = dc.GetSizeTuple()
-
-        # Calculate a suitable scaling factor
-        scaleX = float(w) / maxX
-        scaleY = float(h) / maxY
-
-        # Use x or y scaling factor, whichever fits on the DC
-        actualScale = min(scaleX, scaleY)
-
-        # Calculate the position on the DC for centring the graphic
-        posX = (w - (self.canvas.getWidth() * actualScale)) / 2.0
-        posY = (h - (self.canvas.getHeight() * actualScale)) / 2.0
-
-        # Set the scale and origin
-        dc.SetUserScale(actualScale, actualScale)
-        dc.SetDeviceOrigin(int(posX), int(posY))
-
-        #-------------------------------------------
-
-        self.canvas.DoDrawing(dc)
-        return true
-
-
-#----------------------------------------------------------------------
-
-
-class TestPrintPanel(wxPanel):
-    def __init__(self, parent, frame, log):
-        wxPanel.__init__(self, parent, -1)
-        self.log = log
-        self.frame = frame
-
-
-        self.printData = wxPrintData()
-        self.printData.SetPaperId(wxPAPER_LETTER)
-
-        self.box = wxBoxSizer(wxVERTICAL)
-        self.canvas = MyCanvas(self)
-        self.box.Add(self.canvas, 1, wxGROW)
-
-        subbox = wxBoxSizer(wxHORIZONTAL)
-        btn = wxButton(self, 1201, "Print Setup")
-        EVT_BUTTON(self, 1201, self.OnPrintSetup)
-        subbox.Add(btn, 1, wxGROW | wxALL, 2)
-
-        btn = wxButton(self, 1202, "Print Preview")
-        EVT_BUTTON(self, 1202, self.OnPrintPreview)
-        subbox.Add(btn, 1, wxGROW | wxALL, 2)
-
-        btn = wxButton(self, 1203, "Print")
-        EVT_BUTTON(self, 1203, self.OnDoPrint)
-        subbox.Add(btn, 1, wxGROW | wxALL, 2)
-
-        self.box.Add(subbox, 0, wxGROW)
-
-        self.SetAutoLayout(true)
-        self.SetSizer(self.box)
-
-
-    def OnPrintSetup(self, event):
-        printerDialog = wxPrintDialog(self)
-        printerDialog.GetPrintDialogData().SetPrintData(self.printData)
-        printerDialog.GetPrintDialogData().SetSetupDialog(true)
-        printerDialog.ShowModal();
-        self.printData = printerDialog.GetPrintDialogData().GetPrintData()
-        printerDialog.Destroy()
-
-
-    def OnPrintPreview(self, event):
-        self.log.WriteText("OnPrintPreview\n")
-        printout = MyPrintout(self.canvas, self.log)
-        printout2 = MyPrintout(self.canvas, self.log)
-        self.preview = wxPrintPreview(printout, printout2, self.printData)
-        if not self.preview.Ok():
-            self.log.WriteText("Houston, we have a problem...\n")
-            return
-
-        frame = wxPreviewFrame(self.preview, self.frame, "This is a print preview")
-
-        frame.Initialize()
-        frame.SetPosition(self.frame.GetPosition())
-        frame.SetSize(self.frame.GetSize())
-        frame.Show(true)
-
-
-
-    def OnDoPrint(self, event):
-        pdd = wxPrintDialogData()
-        pdd.SetPrintData(self.printData)
-        printer = wxPrinter(pdd)
-        printout = MyPrintout(self.canvas, self.log)
-        if not printer.Print(self.frame, printout):
-            wxMessageBox("There was a problem printing.\nPerhaps your current printer is not set correctly?", "Printing", wxOK)
-        else:
-            self.printData = printer.GetPrintDialogData().GetPrintData()
-        printout.Destroy()
-
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestPrintPanel(nb, frame, log)
-    return win
-
-
-#----------------------------------------------------------------------
-
-
-
-
-
-overview = """\
-"""
-

wxPython/demo/PyCrust.py

@@ -1,16 +0,0 @@
-
-
-from wxPython.lib.PyCrust import shell, version
-
-
-#----------------------------------------------------------------------
-
-intro = 'Welcome To PyCrust %s - The Flakiest Python Shell' % version.VERSION
-
-def runTest(frame, nb, log):
-    win = shell.Shell(nb, -1, introText=intro)
-    return win
-
-#----------------------------------------------------------------------
-
-overview = shell.__doc__

wxPython/demo/PyCrustWithFilling.py

@@ -1,21 +0,0 @@
-
-from wxPython.wx import *
-from wxPython.lib.PyCrust import shell, version, filling
-
-
-#----------------------------------------------------------------------
-
-intro = 'Welcome To PyCrust %s - The Flakiest Python Shell' % version.VERSION
-
-def runTest(frame, nb, log):
-    win = wxSplitterWindow(nb, -1, size=(640, 480))
-    shellWin = shell.Shell(win, -1, introText=intro)
-    fillingWin = filling.Filling(win, -1, size=(640, 480),
-                                 rootObject=shellWin.interp.locals
-                                 )
-    win.SplitHorizontally(shellWin, fillingWin)
-    return win
-
-#----------------------------------------------------------------------
-
-overview = filling.__doc__

wxPython/demo/PythonEvents.py

@@ -1,85 +0,0 @@
-
-from wxPython.wx import *
-import sys
-
-#----------------------------------------------------------------------
-
-myEVT_BUTTON_CLICKPOS = wxNewEventType()
-
-def EVT_BUTTON_CLICKPOS(win, id, func):
-    win.Connect(id, -1, myEVT_BUTTON_CLICKPOS, func)
-
-
-
-class MyEvent(wxPyCommandEvent):
-    def __init__(self, evtType, id):
-        wxPyCommandEvent.__init__(self, evtType, id)
-        self.myVal = None
-
-    #def __del__(self):
-    #    print '__del__'
-    #    wxPyCommandEvent.__del__(self)
-
-    def SetMyVal(self, val):
-        self.myVal = val
-
-    def GetMyVal(self):
-        return self.myVal
-
-
-
-class MyButton(wxButton):
-    def __init__(self, parent, id, txt, pos):
-        wxButton.__init__(self, parent, id, txt, pos)
-        EVT_LEFT_DOWN(self, self.OnLeftDown)
-
-    def OnLeftDown(self, event):
-        pt = event.GetPosition()
-        evt = MyEvent(myEVT_BUTTON_CLICKPOS, self.GetId())
-        evt.SetMyVal(pt)
-        #print id(evt), sys.getrefcount(evt)
-        self.GetEventHandler().ProcessEvent(evt)
-        #print id(evt), sys.getrefcount(evt)
-        event.Skip()
-
-
-
-class TestPanel(wxPanel):
-    def __init__(self, parent, log):
-        wxPanel.__init__(self, parent, -1)
-        self.log = log
-
-        b = MyButton(self, -1, " Click me ", wxPoint(30,30))
-        EVT_BUTTON(self, b.GetId(), self.OnClick)
-        EVT_BUTTON_CLICKPOS(self, b.GetId(), self.OnMyEvent)
-
-        wxStaticText(self, -1, "Please see the Overview and Demo Code for details...",
-                     wxPoint(30, 80))
-
-
-    def OnClick(self, event):
-        self.log.WriteText("OnClick\n")
-
-    def OnMyEvent(self, event):
-        #print id(event), sys.getrefcount(event)
-        self.log.WriteText("MyEvent: %s\n" % (event.GetMyVal(), ) )
-
-
-#----------------------------------------------------------------------
-
-def runTest(frame, nb, log):
-    win = TestPanel(nb, log)
-    return win
-
-#----------------------------------------------------------------------
-
-
-
-
-overview = """\
-This demo is a contrived example of defining an event class in wxPython and sending it up the containment heirachy for processing.
-"""
-
-
-
-

wxPython/demo/README.txt

@@ -1,7 +0,0 @@
-To run the main demo in this directory, execute demo.py.  In other
-words, one of the following commands should do it:
-
-       demo.py
-       python demo.py
-       pythonw demo.py
-