This commit was manufactured by cvs2svn to create tag

'before_templates'.

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

include/wx/msw/bitmap.h

@@ -0,0 +1,300 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/msw/bitmap.h
+// Purpose:     wxBitmap class
+// Author:      Julian Smart
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_BITMAP_H_
+#define _WX_BITMAP_H_
+
+#ifdef __GNUG__
+    #pragma interface "bitmap.h"
+#endif
+
+#include "wx/msw/gdiimage.h"
+#include "wx/gdicmn.h"
+#include "wx/palette.h"
+
+class WXDLLEXPORT wxBitmap;
+class WXDLLEXPORT wxBitmapHandler;
+class WXDLLEXPORT wxBitmapRefData;
+class WXDLLEXPORT wxControl;
+class WXDLLEXPORT wxCursor;
+class WXDLLEXPORT wxDC;
+class WXDLLEXPORT wxDIB;
+class WXDLLEXPORT wxIcon;
+class WXDLLEXPORT wxImage;
+class WXDLLEXPORT wxMask;
+class WXDLLEXPORT wxPalette;
+class WXDLLEXPORT wxRawBitmapData;
+
+// ----------------------------------------------------------------------------
+// wxBitmap: a mono or colour bitmap
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxBitmap : public wxGDIImage
+{
+public:
+    // default ctor creates an invalid bitmap, you must Create() it later
+    wxBitmap() { Init(); }
+
+    // Copy constructors
+    wxBitmap(const wxBitmap& bitmap) { Init(); Ref(bitmap); }
+
+    // Initialize with raw data
+    wxBitmap(const char bits[], int width, int height, int depth = 1);
+
+    // Initialize with XPM data
+    wxBitmap(const char **data) { CreateFromXpm(data); }
+    wxBitmap(char **data) { CreateFromXpm((const char **)data); }
+
+    // Load a file or resource
+    wxBitmap(const wxString& name, wxBitmapType type = wxBITMAP_TYPE_BMP_RESOURCE);
+
+    // New constructor for generalised creation from data
+    wxBitmap(void *data, long type, int width, int height, int depth = 1);
+
+    // Create a new, uninitialized bitmap of the given size and depth (if it
+    // is omitted, will create a bitmap compatible with the display)
+    //
+    // NB: this ctor will create a DIB for 24 and 32bpp bitmaps, use ctor
+    //     taking a DC argument if you want to force using DDB in this case
+    wxBitmap(int width, int height, int depth = -1);
+
+    // Create a bitmap compatible with the given DC
+    wxBitmap(int width, int height, const wxDC& dc);
+
+#if wxUSE_IMAGE
+    // Convert from wxImage
+    wxBitmap(const wxImage& image, int depth = -1)
+        { (void)CreateFromImage(image, depth); }
+
+    // Create a DDB compatible with the given DC from wxImage
+    wxBitmap(const wxImage& image, const wxDC& dc)
+        { (void)CreateFromImage(image, dc); }
+#endif // wxUSE_IMAGE
+
+    // we must have this, otherwise icons are silently copied into bitmaps using
+    // the copy ctor but the resulting bitmap is invalid!
+    wxBitmap(const wxIcon& icon) { Init(); CopyFromIcon(icon); }
+
+    wxBitmap& operator=(const wxBitmap& bitmap)
+    {
+        if ( m_refData != bitmap.m_refData )
+            Ref(bitmap);
+        return *this;
+    }
+
+    wxBitmap& operator=(const wxIcon& icon)
+    {
+        (void)CopyFromIcon(icon);
+
+        return *this;
+    }
+
+    wxBitmap& operator=(const wxCursor& cursor)
+    {
+        (void)CopyFromCursor(cursor);
+
+        return *this;
+    }
+
+    virtual ~wxBitmap();
+
+#if wxUSE_IMAGE
+    wxImage ConvertToImage() const;
+#endif // wxUSE_IMAGE
+
+    // get the given part of bitmap
+    wxBitmap GetSubBitmap( const wxRect& rect ) const;
+
+    // copies the contents and mask of the given (colour) icon to the bitmap
+    bool CopyFromIcon(const wxIcon& icon);
+
+    // copies the contents and mask of the given cursor to the bitmap
+    bool CopyFromCursor(const wxCursor& cursor);
+
+    // copies from a device independent bitmap
+    bool CopyFromDIB(const wxDIB& dib);
+
+    virtual bool Create(int width, int height, int depth = -1);
+    virtual bool Create(int width, int height, const wxDC& dc);
+    virtual bool Create(void *data, long type, int width, int height, int depth = 1);
+    virtual bool LoadFile(const wxString& name, long type = wxBITMAP_TYPE_BMP_RESOURCE);
+    virtual bool SaveFile(const wxString& name, int type, const wxPalette *cmap = NULL);
+
+    wxBitmapRefData *GetBitmapData() const
+        { return (wxBitmapRefData *)m_refData; }
+
+    // raw bitmap access support functions
+    bool GetRawData(wxRawBitmapData *data);
+    void UngetRawData(wxRawBitmapData *);
+
+#if wxUSE_PALETTE
+    wxPalette* GetPalette() const;
+    void SetPalette(const wxPalette& palette);
+#endif // wxUSE_PALETTE
+
+    wxMask *GetMask() const;
+    void SetMask(wxMask *mask);
+
+    bool operator==(const wxBitmap& bitmap) const { return m_refData == bitmap.m_refData; }
+    bool operator!=(const wxBitmap& bitmap) const { return m_refData != bitmap.m_refData; }
+
+    // these functions are internal and shouldn't be used, they risk to
+    // disappear in the future
+    bool HasAlpha() const;
+    void UseAlpha();
+
+#if WXWIN_COMPATIBILITY_2_4
+    // these functions do nothing and are only there for backwards
+    // compatibility
+    wxDEPRECATED( int GetQuality() const );
+    wxDEPRECATED( void SetQuality(int quality) );
+#endif // WXWIN_COMPATIBILITY_2_4
+
+#if WXWIN_COMPATIBILITY_2
+    void SetOk(bool isOk);
+#endif // WXWIN_COMPATIBILITY_2
+
+#if WXWIN_COMPATIBILITY
+#if wxUSE_PALETTE
+    wxPalette *GetColourMap() const { return GetPalette(); }
+    void SetColourMap(wxPalette *cmap) { SetPalette(*cmap); };
+#endif // wxUSE_PALETTE
+#endif // WXWIN_COMPATIBILITY
+
+    // implementation only from now on
+    // -------------------------------
+
+public:
+    void SetHBITMAP(WXHBITMAP bmp) { SetHandle((WXHANDLE)bmp); }
+    WXHBITMAP GetHBITMAP() const { return (WXHBITMAP)GetHandle(); }
+
+#ifdef __WXDEBUG__
+    void SetSelectedInto(wxDC *dc);
+    wxDC *GetSelectedInto() const;
+#endif // __WXDEBUG__
+
+protected:
+    // common part of all ctors
+    void Init();
+
+    virtual wxGDIImageRefData *CreateData() const;
+
+    // creates the bitmap from XPM data, supposed to be called from ctor
+    bool CreateFromXpm(const char **bits);
+
+    // creates an uninitialized bitmap, called from Create()s above
+    bool DoCreate(int w, int h, int depth, WXHDC hdc);
+
+#if wxUSE_IMAGE
+    // creates the bitmap from wxImage, supposed to be called from ctor
+    bool CreateFromImage(const wxImage& image, int depth);
+
+    // creates a DDB from wxImage, supposed to be called from ctor
+    bool CreateFromImage(const wxImage& image, const wxDC& dc);
+
+    // common part of the 2 methods above (hdc may be 0)
+    bool CreateFromImage(const wxImage& image, int depth, WXHDC hdc);
+#endif // wxUSE_IMAGE
+
+private:
+#ifdef __WIN32__
+    // common part of CopyFromIcon/CopyFromCursor for Win32
+    bool CopyFromIconOrCursor(const wxGDIImage& icon);
+#endif // __WIN32__
+
+    DECLARE_DYNAMIC_CLASS(wxBitmap)
+};
+
+// ----------------------------------------------------------------------------
+// wxMask: a mono bitmap used for drawing bitmaps transparently.
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxMask : public wxObject
+{
+public:
+    wxMask();
+
+    // Construct a mask from a bitmap and a colour indicating the transparent
+    // area
+    wxMask(const wxBitmap& bitmap, const wxColour& colour);
+
+    // Construct a mask from a bitmap and a palette index indicating the
+    // transparent area
+    wxMask(const wxBitmap& bitmap, int paletteIndex);
+
+    // Construct a mask from a mono bitmap (copies the bitmap).
+    wxMask(const wxBitmap& bitmap);
+
+    // construct a mask from the givne bitmap handle
+    wxMask(WXHBITMAP hbmp) { m_maskBitmap = hbmp; }
+
+    virtual ~wxMask();
+
+    bool Create(const wxBitmap& bitmap, const wxColour& colour);
+    bool Create(const wxBitmap& bitmap, int paletteIndex);
+    bool Create(const wxBitmap& bitmap);
+
+    // Implementation
+    WXHBITMAP GetMaskBitmap() const { return m_maskBitmap; }
+    void SetMaskBitmap(WXHBITMAP bmp) { m_maskBitmap = bmp; }
+
+protected:
+    WXHBITMAP m_maskBitmap;
+
+    DECLARE_DYNAMIC_CLASS(wxMask)
+};
+
+// ----------------------------------------------------------------------------
+// wxBitmapHandler is a class which knows how to load/save bitmaps to/from file
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxBitmapHandler : public wxGDIImageHandler
+{
+public:
+    wxBitmapHandler() { m_type = wxBITMAP_TYPE_INVALID; }
+    wxBitmapHandler(const wxString& name, const wxString& ext, long type)
+        : wxGDIImageHandler(name, ext, type)
+    {
+    }
+
+    // keep wxBitmapHandler derived from wxGDIImageHandler compatible with the
+    // old class which worked only with bitmaps
+    virtual bool Create(wxBitmap *bitmap,
+                        void *data,
+                        long flags,
+                        int width, int height, int depth = 1);
+    virtual bool LoadFile(wxBitmap *bitmap,
+                          const wxString& name,
+                          long flags,
+                          int desiredWidth, int desiredHeight);
+    virtual bool SaveFile(wxBitmap *bitmap,
+                          const wxString& name,
+                          int type,
+                          const wxPalette *palette = NULL);
+
+    virtual bool Create(wxGDIImage *image,
+                        void *data,
+                        long flags,
+                        int width, int height, int depth = 1);
+    virtual bool Load(wxGDIImage *image,
+                      const wxString& name,
+                      long flags,
+                      int desiredWidth, int desiredHeight);
+    virtual bool Save(wxGDIImage *image,
+                      const wxString& name,
+                      int type);
+
+private:
+    DECLARE_DYNAMIC_CLASS(wxBitmapHandler)
+};
+
+#endif
+  // _WX_BITMAP_H_

include/wx/rawbmp.h

@@ -0,0 +1,262 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        wx/rawbmp.h
+// Purpose:     macros for fast, raw bitmap data access
+// Author:      Eric Kidd, Vadim Zeitlin
+// Modified by:
+// Created:     10.03.03
+// RCS-ID:      $Id$
+// Copyright:   (c) 2002 Vadim Zeitlin <vadim@wxwindows.org>
+// Licence:     wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_RAWBMP_H_BASE_
+#define _WX_RAWBMP_H_BASE_
+
+// ----------------------------------------------------------------------------
+// Abstract Pixel API
+//
+// We need to access our raw bitmap data (1) portably and (2) efficiently.
+// We do this using a two-dimensional "iteration" interface.  Performance
+// is extremely important here: these functions will be called hundreds
+// of thousands of times in a row, and even small inefficiencies will
+// make applications seem slow.
+//
+// We can't always rely on inline functions, because not all compilers actually
+// bother to inline them unless we crank the optimization levels way up.
+// Therefore, we also provide macros to wring maximum speed out of compiler
+// unconditionally (e.g. even in debug builds). Of course, if the performance
+// isn't absolutely crucial for you you shouldn't be using them but the inline
+// functions instead.
+// ----------------------------------------------------------------------------
+
+/*
+   Usage example:
+
+    wxBitmap bmp;
+    wxRawBitmapData data(bitmap);
+    if ( !data )
+    {
+        ... raw access to bitmap data unavailable, do something else ...
+        return;
+    }
+
+    if ( data.m_width < 20 || data.m_height < 20 )
+    {
+        ... complain: the bitmap it too small ...
+        return;
+    }
+
+    wxRawBitmapIterator p(data);
+
+    // we draw a (10, 10)-(20, 20) rect manually using the given r, g, b
+    p.Offset(10, 10);
+
+    for ( int y = 0; y < 10; ++y )
+    {
+        wxRawBitmapIterator rowStart = p;
+
+        for ( int x = 0; x < 10; ++x, ++p )
+        {
+            p.Red() = r;
+            p.Green() = g;
+            p.Blue() = b;
+        }
+
+        p = rowStart;
+        p.OffsetY(1);
+    }
+ */
+
+// this struct represents a pointer to raw bitmap data
+class wxRawBitmapData
+{
+public:
+    // ctor associates this pointer with a bitmap and locks the bitmap for raw
+    // access, it will be unlocked only by our dtor and so these objects should
+    // normally be only created on the stack, i.e. have limited life-time
+    wxRawBitmapData(wxBitmap bmp) : m_bmp(bmp)
+    {
+        if ( !bmp.GetRawData(this) )
+            m_pixels = NULL;
+    }
+
+    // we evaluate to true only if we could get access to bitmap data
+    // successfully
+    operator bool() const { return m_pixels != NULL; }
+
+    // dtor unlocks the bitmap
+    ~wxRawBitmapData()
+    {
+        m_bmp.UngetRawData(this);
+    }
+
+    // call this to indicate that we should use the alpha channel
+    void UseAlpha() { m_bmp.UseAlpha(); }
+
+    // accessors
+    unsigned char *GetPixels() const { return m_pixels; }
+    int GetWidth() const { return m_width; }
+    int GetHeight() const { return m_height; }
+    int GetByPP() const { return m_bypp; }
+    int GetBPP() const { return 8*GetByPP(); }
+    int GetRowStride() const { return m_stride; }
+
+// private: -- public because accessed by the macros below but still mustn't be
+//             used directly
+
+    // the bitmap we're associated with
+    wxBitmap m_bmp;
+
+    // pointer to the start of the data
+    unsigned char *m_pixels;
+
+    // the size of the image we address, in pixels
+    int m_width,
+        m_height;
+
+    // number of bytes (NOT bits) per pixel, including alpha channel if any
+    int m_bypp;
+
+    // this parameter is the offset of the start of the (N+1)st row from the
+    // Nth one and can be different from m_bypp*width in some cases:
+    //  a) the most usual one is to force 32/64 bit alignment of rows
+    //  b) another one is for bottom-to-top images where it's negative
+    //  c) finally, it could conceivably be 0 for the images with all
+    //     lines being identical
+    int m_stride;
+};
+
+// this is the type for the iterator over raw bitmap data
+class wxRawBitmapIterator
+{
+public:
+    // ctors and such
+    // --------------
+
+    // we must be associated/initialized with some bitmap data object
+    wxRawBitmapIterator(const wxRawBitmapData& data) : m_data(&data)
+    {
+        m_ptr = m_data->GetPixels();
+    }
+
+    // default copy ctor, assignment operator and dtor are ok
+
+
+    // navigation
+    // ----------
+
+    // move x pixels to the right and y down
+    //
+    // note that the rows don't wrap!
+    void Offset(int x, int y)
+    {
+        m_ptr += m_data->GetRowStride()*y + m_data->GetByPP()*x;
+    }
+
+    // move x pixels to the right (again, no row wrapping)
+    void OffsetX(int x)
+    {
+        m_ptr += m_data->GetByPP()*x;
+    }
+
+    // move y rows to the bottom
+    void OffsetY(int y)
+    {
+        m_ptr += m_data->GetRowStride()*y;
+    }
+
+    // go back to (0, 0)
+    void Reset()
+    {
+        m_ptr = m_data->GetPixels();
+    }
+
+    // go to the given position
+    void MoveTo(int x, int y)
+    {
+        Reset();
+        Offset(x, y);
+    }
+
+    // same as OffsetX(1) for convenience
+    wxRawBitmapIterator& operator++()
+    {
+        OffsetX(1);
+        return *this;
+    }
+
+    // postfix (hence less efficient) version
+    wxRawBitmapIterator operator++(int)
+    {
+        wxRawBitmapIterator p(*this);
+        OffsetX(1);
+        return p;
+    }
+
+    // data access
+    // -----------
+
+    // DIBs store data in BGR format, i.e. "little endian" RGB
+    enum
+    {
+#ifdef __WXMSW__
+        BLUE, GREEN, RED,
+#else // !__WXMSW__
+        RED, GREEN, BLUE,
+#endif // __WXMSW__/!__WXMSW__
+        ALPHA
+    };
+
+    // access to invidividual colour components
+    unsigned char& Red() { return m_ptr[RED]; }
+    unsigned char& Green() { return m_ptr[GREEN]; }
+    unsigned char& Blue() { return m_ptr[BLUE]; }
+    unsigned char& Alpha() { return m_ptr[ALPHA]; }
+
+    // address the pixel contents directly
+    //
+    // warning: the format is platform dependent
+    wxUint32& Data() { return *(wxUint32 *)m_ptr; }
+
+// private: -- don't access these fields directly, same as as above
+    unsigned char *m_ptr;
+
+    const wxRawBitmapData *m_data;
+};
+
+
+// these macros are used to change the current location in the bitmap
+// ------------------------------------------------------------------
+
+// move x pixels to the right and y down
+//
+// note that the rows don't wrap!
+#define wxBMP_OFFSET(p, x, y) \
+    p.m_ptr += p.m_data->m_stride * (y) + p.m_data->m_bypp * (x)
+
+// move x pixels to the right (again, no row wrapping)
+#define wxBMP_OFFSET_X(p, x) p.m_ptr += p.m_data->m_bypp * (x)
+
+// move y rows to the bottom
+#define wxBMP_OFFSET_Y(p, y) p.m_ptr += p.m_data->m_stride * (y)
+
+
+
+// these macros are used to work with the pixel values
+//
+// all of them can be used as either lvalues or rvalues.
+// ----------------------------------------------------
+
+#define wxBMP_RED(p)         (p.m_ptr[wxRawBitmapIterator::RED])
+#define wxBMP_GREEN(p)       (p.m_ptr[wxRawBitmapIterator::GREEN])
+#define wxBMP_BLUE(p)        (p.m_ptr[wxRawBitmapIterator::BLUE])
+
+#define wxBMP_ALPHA(p)       (p.m_ptr[wxRawBitmapIterator::ALPHA])
+
+// these macros are most efficient but return the buffer contents in
+// platform-specific format, e.g. RGB on all sane platforms and BGR under Win32
+#define wxBMP_RGB(p)     *(wxUint32 *)(p.m_ptr)
+#define wxBMP_RGBA(p)    *(wxUint32 *)(p.m_ptr)
+
+#endif // _WX_RAWBMP_H_BASE_
+

wxPython/wxPython/py/CHANGES.txt

@@ -1,594 +0,0 @@
-
-0.9.2 (5/3/2003 to //2003)
------------------------------
-
-Changed to the new prefix-less "wx" package::
-
-    import wx
-
-instead of::
-
-    from wxPython import wx
-
-Fixed typo in ``PyWrap.py``::
-
-    if __name__ == '__main__':
-        main(sys.argv)
-
-should have been::
-
-    if __name__ == '__main__':
-        main()
-
-Added pretty-print Display tab to Crust, based on suggestion from
-Jason Whitlark.
-
-Improved ``Can*`` checks in ``EditWindow``, since STC is too lenient,
-particularly when it is set to read-only but returns True for
-CanPaste() (seems like an STC bug to me)::
-
-    def CanCopy(self):
-        """Return True if text is selected and can be copied."""
-        return self.GetSelectionStart() != self.GetSelectionEnd()
-
-    def CanCut(self):
-        """Return True if text is selected and can be cut."""
-        return self.CanCopy() and self.CanEdit()
-
-    def CanEdit(self):
-        """Return True if editing should succeed."""
-        return not self.GetReadOnly()
-
-    def CanPaste(self):
-        """Return True if pasting should succeed."""
-        return stc.StyledTextCtrl.CanPaste(self) and self.CanEdit()
-
-
-0.9.1 (3/21/2003 to 5/2/2003)
------------------------------
-
-PyCrust is dead!  Long live Py!
-
-* Renamed ``PyCrust`` package to ``py``.
-* Moved code to wxPython's CVS repository.
-
-Fixed bug in ``introspect.py`` on introspecting objects occurring
-immediately after a secondary prompt, like this::
-
-    >>> l = [1, 2, 3]
-    >>> for n in range(3):
-    ...     l.  <-- failed to popup autocomplete list
-
-Added documentation files:
-
-* PyManual.txt
-* wxPythonManual.txt
-* wxPythonPackage.txt
-* wxPythonExamples.txt
-
-Added PyAlaMode and PyAlaCarte code editors.
-
-Major refactoring to support ``editor`` and ``shell`` from the same
-base.
-
-Renamed program files:
-
-* ``PyCrustApp.py`` to ``PyCrust.py``
-* ``PyFillingApp.py`` to ``PyFilling.py``
-* ``PyShellApp.py`` to ``PyShell.py``
-* ``wrap.py`` to ``PyWrap.py``
-
-Removed disabling of autocomplete for lists of 2000 items or more.
-The current implementation of wxSTC can now handle lists this big.
-
-Improved handling of ``sys.path`` to mimic the standard Python shell.
-
-
-0.9 (2/27/2003 to 3/20/2003)
-----------------------------
-
-Added fontIncrease, fontDecrease, fontDefault signals, receivers and
-keybindings::
-
-    Ctrl+]            Increase font size.
-    Ctrl+[            Decrease font size.
-    Ctrl+=            Default font size.
-
-Continued enhancement of the decorator capability to provide better
-documentation and docstrings for wxPython classes and functions.
-
-Introduced new tabbed interface:
-
-* Namespace
-* Calltip
-* Session
-* Dispatcher
-* wxPython Docs
-* wxSTC Docs
-
-``Filling.tree`` now expands tuples as well as lists.  (It should have
-done this all along, I just never noticed this omission before.)
-
-Added this True/False test to all modules::
-
-    try:
-        True
-    except NameError:
-        True = 1==1
-        False = 1==0
-
-Added ``wxd`` directory with decoration classes.
-
-
-0.8.2 (1/5/2003 to 2/26/2003)
------------------------------
-
-Wrapped ``sys.ps1``, ``sys.ps2``, and ``sys.ps3`` in ``str()``.
-(Thanks, Kieran Holland.)
-
-Fixed minor things found by PyChecker.
-
-Changed locals to use ``__main__.__dict__`` and added code to clean up
-the namespace, making it as close to the regular Python environment as
-possible.  This solves the problem of pickling and unpickling
-instances of classes defined in the shell.
-
-Made ``shell.PasteAndRun()`` a little more forgiving when it finds a
-ps2 prompt line with no trailing space, such when you copy code from a
-web page.
-
-Improved autocomplete behavior by adding these to shell::
-
-    self.AutoCompSetAutoHide(False)
-    self.AutoCompStops(' .,;:([)]}\'"\\<>%^&+-=*/|`')
-
-Added ``decor`` directory, ``decorator.py``, ``stcDecor.py``, and
-``stcConstants.py``.  These all serve the purpose of adding docstrings
-to existing wxPython classes, in particular the ``wxStyledTextCtrl``.
-
-Added ``wrap.py``, a command line utility for running a wxPython app
-with additional runtime-tools loaded, such as PyCrust (the only tool
-at this point).
-
-Flushed the clipboard Cut/Copy operations so that selections will
-exist in the clipboard even after PyCrust has been closed.
-
-Improved the suppression of docstrings for simple data types appearing
-in the namespace viewer.
-
-Better handling of autocompletion with numeric types; no
-autocompletion when typing a dot after an integer.  If the
-autocompletion is desired, type a space before the dot::
-
-    func = 3 .
-
-More Filling!!! The namespace tree is now dynamically updated.
-
-
-0.8.1 (12/20/2002 to 12/25/2002)
---------------------------------
-
-Improved keyboard handling with Autocomplete active.  You can now use
-Enter as well as Tab to select an item from the list.
-
-Disabled autocomplete for lists of 2000 items or more.  The current
-implementation of wxSTC can't handle lists this big.
-
-Changed ``filling`` to always display docstrings for objects.  This is
-useful for objects whose docstrings have been decorated, rather than
-coming directly from the source code.  (Hmmm.  Sounds like someone is
-doing some decorating.  I wonder where that would be helpful? <wink>)
-
-Fixed handling of icon.  Added ``images.py`` file.
-
-
-0.8 (10/29/2002 to 12/16/2002)
-------------------------------
-
-Added "help" to startup banner info.
-
-Made all ``wx`` and ``stc`` imports explicit.  No more ``import *``.
-
-Replaced use of the ``wx`` module's ``true`` and ``false`` with
-Python's ``True`` and ``False``.
-
-Changed ``introspect.getRoot()`` to use ``tokenize`` module.  This
-does a slightly better job than the previous parsing routine and the
-code is clearer.
-
-Improved handling of whitespace and empty types during introspection.
-
-Fixed cut/copy clipboard problem under Linux.  (Robin Dunn rocks!!!)
-
-Added shell.about() which works like this::
-
-    >>> shell.about()
-    PyCrust Version: 0.8
-    Shell Revision: 1.80
-    Interpreter Revision: 1.15
-    Python Version: 2.2.2
-    wxPython Version: 2.3.3.1
-    Platform: linux2
-
-Added copy plus and paste plus to shell menu.
-
-Moved shell menu from ``shell.py`` to ``shellmenu.py``.
-
-Added ``sys.stdin.readlines()`` support.
-
-Added ``time.sleep()`` in ``readline()`` and ``OnIdle()`` event
-handler to free up the CPU.
-
-
-0.7.2 (2/22/2002 to 8/27/2002)
-------------------------------
-
-Tweaked ``getAttributeNames()`` to pick up a few more attributes::
-
-    '__bases__', '__class__', '__dict__', '__name__', 'func_closure',
-    'func_code', 'func_defaults', 'func_dict', 'func_doc',
-    'func_globals', 'func_name'
-
-Added a tests directory and unit tests.
-
-Improved support for empty types in the shell: ``[]``, ``()`` and
-``{}`` as far as when call tips and autocompletion are available.
-
-Added support for the other triple string - ``''''''``.
-
-Refactored ``introspect.py`` to improve testability.
-
-Improved call tips for unbound methods by leaving the "self"
-parameter, since unbound methods require an instance be passed.
-
-Fixed call tip bug where a tip was displayed when a "(" was typed
-after an object that wasn't callable.
-
-Fixed ``getAllAttributeNames`` when ``str(object)`` fails.
-
-Added brace highlighting.  (Thank you, Kevin Altis.)
-
-Fixed problem displaying unicode objects in ``PyFilling``.
-
-Changed how ``filling.py`` checks for expandable objects.  Lists are
-now expandable objects.
-
-Made the key handling more robust when there is an active text
-selection that includes text prior to the last primary prompt.  Thanks
-to Raul Cota for pointing this out.
-
-Fixed wxSTC problem with brace highlighting and non-us keyboards.
-(Thank you for the patch, Jean-Michel Fauth.)
-
-Added ``busy = wxBusyCursor()`` to key points in ``shell`` and
-``filling``.
-
-Added ``OnCloseWindow`` handler to ``ShellFrame`` and ``CrustFrame``.
-
-Default to ``SetWrapMode(1)`` for shell and namespace viewer.
-
-Added ``shell.wrap()`` and ``shell.zoom()``.
-
-Added autoCompleteKeys hooks for Raul Cota.
-
-Cleaned up various little key handling bugs.
-
-Changed input methods to get values from shell, rather than dialog
-boxes.  Renamed ``readIn`` to ``readline`` and ``readRaw`` to
-``raw_input``.
-
-
-0.7.1 (12/12/2001 to 2/21/2002)
--------------------------------
-
-Fixed ``OnChar()`` issues effecting European keyboards, as reported by
-Jean-Michel Fauth.
-
-Fixed ``introspect.py`` issue with xmlrpc objects reported by Kevin
-Altis.
-
-Fixed some introspect/PyFilling issues with regard to Python 2.2.
-
-Fixed font background color as reported by Keith J. Farmer.  (Thanks)
-
-Fixed problem with call tips and autocompletion inside multiline
-commands as report by Kevin Altis.
-
-Improved ``OnKeyDown`` handling of cut/copy/paste operations based on
-feedback from Syver Enstad.  (Thanks)
-
-Added a ``shell.help()`` method to display some help info.
-
-Changed sort of items in the namespace viewer to case insensitive.
-
-Changed ``attributes.sort(lambda x, y: cmp(x.upper(), y.upper()))`` in
-advance of an upcoming fix to an autocompletion matching bug in wxSTC.
-
-Improved support for ZODB by allowing namespace drilldown into BTrees.
-
-Added ``shell.PasteAndRun()`` to support pasting multiple commands into
-the shell from the clipboard.  Ctrl+Shift+V or v.
-
-Enter now always processes a command (or copies down a previous one.)
-To insert a line break, press Ctrl+Enter.
-
-Escape key clears the current, unexecuted command.
-
-History retrieval changed to replace current command.  Added new keys
-to insert from history - Shift+Up and Shift+Down.
-
-Better call tips on objects with ``__call__`` methods.
-
-Improved call tip positioning calculation.
-
-
-0.7 (10/15/2001 to 12/11/2001)
-------------------------------
-
-Changed how command history retrieval functions work.  Added Alt-P,
-Alt-N as keybindings for Retrieve-Previous, Retrieve-Next.
-
-Added full support for multi-line commands, similar to IDLE.
-
-Changed ``introspect.getAttributeNames()`` to do a case insensitive
-sort.
-
-Changed Cut/Copy/Paste to deal with prompts intelligently.  Cut and
-Copy remove all prompts.  Paste can handle prompted or not-prompted
-text.
-
-Added ``CopyWithPrompts()`` method attached to Ctrl-Shift-C for those
-times when you really do want all the prompts left intact.
-
-Improved handling of the shell's read-only zone.
-
-Changed ``CrustFrame.__init__`` parameter spec to include all
-parameters allowed by a ``wxFrame``.
-
-Changed ``FillingText`` to be read-only.
-
-Renamed ``PyCrust.py`` to ``PyCrustApp.py`` to eliminate
-package/module name conflicts that kept you from doing ``from PyCrust
-import shell`` inside files located in the ``PyCrust`` directory.
-
-Renamed ``PyFilling.py`` to ``PyFillingApp.py`` and ``PyShell.py`` to
-``PyShellApp.py`` to maintain consistency.
-
-Removed the ``__date__`` property from all modules.
-
-Fixed bug in ``introspect.getCallTip()``, reported by Kevin Altis.
-
-
-0.6.1 (9/19/2001 to 10/12/2001)
--------------------------------
-
-Changed ``Shell.run()`` to always position to the end of existing
-text, as suggested by Raul Cota.
-
-Changed ``introspect.getAllAttributeNames()`` to break circular
-references in ``object.__class__``, which occurs in Zope/ZODB
-extension classes.
-
-Changed ``filling.FillingTree.getChildren()`` to introspect extension
-classes.
-
-Fixed minor bugs in ``introspect.getCallTip()`` that were interfering
-with call tips for Zope/ZODB extension class methods.
-
-In preparation for wxPython 2.3.2, added code to fix a font sizing
-problem.  Versions of wxPython prior to 2.3.2 had a sizing bug on Win
-platform where the font was 2 points larger than what was specified.
-
-Added a hack to ``introspect.getAllAttributeNames()`` to "wake up"
-ZODB objects that are asleep - in a "ghost" state.  Otherwise it
-returns incomplete info.
-
-
-0.6 (8/21/2001 to 9/12/2001)
-----------------------------
-
-Added ``PyFilling.py`` and ``filling.py``.
-
-``PyShell.py`` and ``PyFilling.py`` can now be run standalone, as well
-as ``PyCrust.py``.
-
-Added ``crust.py`` and moved some code from ``PyCrust.py`` to it.
-
-Added command history retrieval features submitted by Richie Hindle.
-
-Changed ``shell.write()`` to replace line endings with OS-specific
-endings.  Changed ``shell.py`` and ``interpreter.py`` to use
-``os.linesep`` in strings having hardcoded line endings.
-
-Added ``shell.redirectStdin()``, ``shell.redirectStdout()`` and
-``shell.redirectStderr()`` to allow the surrounding app to toggle
-requests that the specified ``sys.std*`` be redirected to the shell.
-These can also be run from within the shell itself, of course.
-
-The shell now adds the current working directory "." to the search
-path::
-
-    sys.path.insert(0, os.curdir)
-
-Added support for distutils installations.
-
-
-0.5.4 (8/17/2001 to 8/20/2001)
-------------------------------
-
-Changed default font size under Linux to::
-
-    'size'   : 12,
-    'lnsize' : 10,
-
-Changed ``Shell`` to expect a parameter referencing an Interpreter
-class, rather than an intepreter instance, to facilitate subclassing
-of Interpreter, which effectively broke when the Editor class was
-eliminated.
-
-Fixed ``PyCrustAlaCarte.py``, which had been broken by previous
-changes.
-
-Created ``InterpreterAlaCarte`` class as an example for use in the
-demo.
-
-Split ``PyCrust.py`` into ``PyCrust.py`` and ``PyShell.py`` in
-anticipation of ``PyFilling.py``.
-
-
-0.5.3 (8/16/2001)
------------------
-
-Added patch to ``PyCrust.py`` to fix wxPython bug::
-
-    wxID_SELECTALL = NewId() # This *should* be defined by wxPython.
-
-
-0.5.2 (8/14/2001 to 8/15/2001)
-------------------------------
-
-Shortened module names by dropping "PyCrust" as a prefix.
-
-Changed ``version`` to ``VERSION`` in ``version`` module.
-
-Added Options menu to PyCrust application.
-
-Eliminated the Editor class (and editor module) by merging with Shell.
-This means that Shell "is a" wxStyledTextCtrl rather than "has a".
-There just wasn't enough non-gui code to justify the separation.
-Plus, Shell will be much easier for gui toolkits/designers to deal
-with now.
-
-
-0.5.1 (8/10/2001 to 8/14/2001)
-------------------------------
-
-Added ``introspect`` module.
-
-Moved some functionality from ``PyCrustInterp`` to ``introspect``.
-
-Changed ``introspect.getRoot()`` to no longer remove whitespace from
-the command.  This was a remnant of a previous approach that, when
-left as part of the current approach, turned out to be a really bad
-thing.
-
-Changed ``introspect.getRoot()`` to allow commands of ``''``, ``""``,
-``""""""``, ``[]``, ``()``, and ``{}`` to pass through.  This allows
-you to type them, followed by a dot, and get autocomplete options on
-them.
-
-Changed ``introspect.getRoot()`` to identify some situations where
-strings shouldn't be considered roots.  For example::
-
-    >>> import PyCrust  # To illustrate the potential problem.
-    >>> len('PyCrust.py')
-
-Typing the dot at the end of "PyCrust" in the second line above should
-NOT result in an autocompletion list because "PyCrust" is part of a
-string in this context, not a reference to the PyCrust module object.
-Similar reasoning applies to call tips.  For example::
-
-    >>> len('dir(')
-
-Typing the left paren at the end of "dir" should NOT result in a call
-tip.
-
-Both features now behave properly in the examples given.  However,
-there is still the case where whitespace precedes the potential root
-and that is NOT handled properly.  For example::
-
-    >>> len('this is a dir(')
-
-and::
-
-    >>> len('This is PyCrust.py')
-
-More code needs to be written to handle more complex situations.
-
-Added ``locals=None`` parameter to ``Shell.__init__()``.
-
-Added support for magic attribute retrieval.  Users can change this
-with::
-
-    >>> shell.editor.autoCompleteIncludeMagic = 0
-
-Added the ability to set filters on auto completion to exclude
-attributes prefixed with a single or double underscore.  Users can
-exclude one or the other or both with::
-
-    >>> shell.editor.autoCompleteExcludeSingle = 1
-    >>> shell.editor.autoCompleteExcludeDouble = 1
-
-
-0.5 (8/8/2001)
---------------
-
-Mostly just a final version change before creating a release.
-
-
-0.4 (8/4/2001 to 8/7/2001)
---------------------------
-
-Changed version/revision handling.
-
-Fixed bugs.
-
-
-0.3 (8/2/2001 to 8/3/2001)
---------------------------
-
-Removed lots of cruft.
-
-Added lots of docstrings.
-
-Imported to CVS repository at SourceForge.
-
-Added call tips.
-
-
-0.2 (7/30/2001 to 8/2/2001)
----------------------------
-
-Renamed several files.
-
-Added command autocompletion.
-
-Added menus to PyCrust.py: File, Edit and Help.
-
-Added sample applications: ``PyCrustAlaCarte.py``,
-``PyCrustAlaMode.py``, and ``PyCrustMinimus.py``.
-
-
-0.1 (7/1/2001 to 7/19/2001)
----------------------------
-
-Added basic syntax coloring much like Boa.
-
-Added read-only logging much like IDLE.
-
-Can retrieve a previous command by putting the cursor back on that
-line and hitting enter.
-
-Stdin and raw_input operate properly so you can now do ``help()`` and
-``license()`` without hanging.
-
-Redefined "quit", "exit", and "close" to display a better-than-nothing
-response.
-
-Home key honors the prompt.
-
-Created SourceForge account, but nothing was posted.
-
-
-In the beginning, there was pie... (7/1/2001)
----------------------------------------------
-
-Blame it all on IDLE, Boa and PythonWin.  I was using all three, got
-frustrated with their dissimilarities, and began to let everyone know
-how I felt.  At the same time, Scintilla looked like an interesting
-tool to build a shell around.  And while I didn't receive much in the
-way of positive feedback, let alone encouragement, I just couldn't let
-go of the idea of a Scintilla-based Python shell.  Then the PythonCard
-project got to the point where they were talking about including a
-shell in their development environment.  That was all the incentive I
-needed.  PyCrust had to happen...

wxPython/wxPython/py/PyAlaCarte.py

@@ -1,43 +0,0 @@
-"""PyAlaCarte is a simple programmer's editor."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-
-import os
-import sys
-
-import editor
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-class App(wx.App):
-    """PyAlaCarte standalone application."""
-
-    def __init__(self, filename=None):
-        self.filename = filename
-        wx.App.__init__(self, redirect=False)
-
-    def OnInit(self):
-        wx.InitAllImageHandlers()
-        self.frame = editor.EditorFrame(filename=self.filename)
-        self.frame.Show()
-        self.SetTopWindow(self.frame)
-        return True
-
-def main(filename=None):
-    if not filename and len(sys.argv) > 1:
-        filename = sys.argv[1]
-    if filename:
-        filename = os.path.realpath(filename)
-    app = App(filename)
-    app.MainLoop()
-
-if __name__ == '__main__':
-    main()

wxPython/wxPython/py/PyAlaMode.py

@@ -1,43 +0,0 @@
-"""PyAlaMode is a programmer's editor."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-
-import os
-import sys
-
-import editor
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-class App(wx.App):
-    """PyAlaMode standalone application."""
-
-    def __init__(self, filename=None):
-        self.filename = filename
-        wx.App.__init__(self, redirect=False)
-
-    def OnInit(self):
-        wx.InitAllImageHandlers()
-        self.frame = editor.EditorNotebookFrame(filename=self.filename)
-        self.frame.Show()
-        self.SetTopWindow(self.frame)
-        return True
-
-def main(filename=None):
-    if not filename and len(sys.argv) > 1:
-        filename = sys.argv[1]
-    if filename:
-        filename = os.path.realpath(filename)
-    app = App(filename)
-    app.MainLoop()
-
-if __name__ == '__main__':
-    main()

wxPython/wxPython/py/PyAlaModeTest.py

@@ -1,42 +0,0 @@
-"""PyAlaModeTest is a programmer's editor."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-
-import os
-import sys
-
-import editor
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-class App(wx.App):
-    """PyAlaModeTest standalone application."""
-
-    def __init__(self, filename=None):
-        self.filename = filename
-        wx.App.__init__(self, redirect=False)
-
-    def OnInit(self):
-        wx.InitAllImageHandlers()
-        self.frame = editor.EditorShellNotebookFrame(filename=self.filename)
-        self.frame.Show()
-        self.SetTopWindow(self.frame)
-        return True
-
-def main(filename=None):
-    app = App(filename)
-    app.MainLoop()
-
-if __name__ == '__main__':
-    filename = None
-    if len(sys.argv) > 1:
-        filename = os.path.realpath(sys.argv[1])
-    main(filename)

wxPython/wxPython/py/PyCrust.py

@@ -1,78 +0,0 @@
-"""PyCrust is a python shell and namespace browser application."""
-
-# The next two lines, and the other code below that makes use of
-# ``__main__`` and ``original``, serve the purpose of cleaning up the
-# main namespace to look as much as possible like the regular Python
-# shell environment.
-import __main__
-original = __main__.__dict__.keys()
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class App(wx.App):
-    """PyCrust standalone application."""
-
-    def OnInit(self):
-        import wx
-        wx.InitAllImageHandlers()
-        locals = __main__.__dict__
-        from crust import CrustFrame
-        self.frame = CrustFrame(locals=locals)
-        self.frame.SetSize((800, 600))
-        self.frame.Show()
-        self.SetTopWindow(self.frame)
-        return True
-
-'''
-The main() function needs to handle being imported, such as with the
-pycrust script that wxPython installs:
-
-    #!/usr/bin/env python
-
-    from wx.py.PyCrust import main
-    main()
-'''
-
-def main():
-    """The main function for the PyCrust program."""
-    # Cleanup the main namespace, leaving the App class.
-    import __main__
-    md = __main__.__dict__
-    keepers = original
-    keepers.append('App')
-    for key in md.keys():
-        if key not in keepers:
-            del md[key]
-    # Create an application instance.
-    app = App(0)
-    # Mimic the contents of the standard Python shell's sys.path.
-    import sys
-    if sys.path[0]:
-        sys.path[0] = ''
-    # Add the application object to the sys module's namespace.
-    # This allows a shell user to do:
-    # >>> import sys
-    # >>> sys.app.whatever
-    sys.app = app
-    del sys
-    # Cleanup the main namespace some more.
-    if md.has_key('App') and md['App'] is App:
-        del md['App']
-    if md.has_key('__main__') and md['__main__'] is __main__:
-        del md['__main__']
-    # Start the wxPython event loop.
-    app.MainLoop()
-
-if __name__ == '__main__':
-    main()

wxPython/wxPython/py/PyFilling.py

@@ -1,43 +0,0 @@
-"""PyFilling is a python namespace inspection application."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-# We use this object to get more introspection when run standalone.
-app = None
-
-import filling
-
-# These are imported just to have something interesting to inspect.
-import crust
-import interpreter
-import introspect
-import pseudo
-import shell
-import sys
-import wx
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class App(filling.App):
-    def OnInit(self):
-        filling.App.OnInit(self)
-        self.root = self.fillingFrame.filling.tree.root
-        return True
-
-def main():
-    """Create and run the application."""
-    global app
-    app = App(0)
-    app.fillingFrame.filling.tree.Expand(app.root)
-    app.MainLoop()
-
-
-if __name__ == '__main__':
-    main()

wxPython/wxPython/py/PyShell.py

@@ -1,79 +0,0 @@
-"""PyShell is a python shell application."""
-
-# The next two lines, and the other code below that makes use of
-# ``__main__`` and ``original``, serve the purpose of cleaning up the
-# main namespace to look as much as possible like the regular Python
-# shell environment.
-import __main__
-original = __main__.__dict__.keys()
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class App(wx.App):
-    """PyShell standalone application."""
-
-    def OnInit(self):
-        import wx
-        wx.InitAllImageHandlers()
-        locals = __main__.__dict__
-        from shell import ShellFrame
-        self.frame = ShellFrame(locals=locals)
-        self.frame.SetSize((750, 525))
-        self.frame.Show()
-        self.SetTopWindow(self.frame)
-        self.frame.shell.SetFocus()
-        return True
-
-'''
-The main() function needs to handle being imported, such as with the
-pyshell script that wxPython installs:
-
-    #!/usr/bin/env python
-
-    from wx.py.PyShell import main
-    main()
-'''
-
-def main():
-    """The main function for the PyShell program."""
-    # Cleanup the main namespace, leaving the App class.
-    import __main__
-    md = __main__.__dict__
-    keepers = original
-    keepers.append('App')
-    for key in md.keys():
-        if key not in keepers:
-            del md[key]
-    # Create an application instance.
-    app = App(0)
-    # Cleanup the main namespace some more.
-    if md.has_key('App') and md['App'] is App:
-        del md['App']
-    if md.has_key('__main__') and md['__main__'] is __main__:
-        del md['__main__']
-    # Mimic the contents of the standard Python shell's sys.path.
-    import sys
-    if sys.path[0]:
-        sys.path[0] = ''
-    # Add the application object to the sys module's namespace.
-    # This allows a shell user to do:
-    # >>> import sys
-    # >>> sys.app.whatever
-    sys.app = app
-    del sys
-    # Start the wxPython event loop.
-    app.MainLoop()
-
-if __name__ == '__main__':
-    main()

wxPython/wxPython/py/PyWrap.py

@@ -1,56 +0,0 @@
-"""PyWrap is a command line utility that runs a wxPython program with
-additional runtime-tools, such as PyCrust."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import os
-import sys
-import wx
-from crust import CrustFrame as Frame
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-def wrap(app):
-    wx.InitAllImageHandlers()
-    frame = Frame()
-    frame.SetSize((750, 525))
-    frame.Show(True)
-    frame.shell.interp.locals['app'] = app
-    app.MainLoop()
-
-
-def main(modulename=None):
-    sys.path.insert(0, os.curdir)
-    if not modulename:
-        if len(sys.argv) < 2:
-            print "Please specify a module name."
-            raise SystemExit
-        modulename = sys.argv[1]
-        if modulename.endswith('.py'):
-            modulename = modulename[:-3]
-    module = __import__(modulename)
-    # Find the App class.
-    App = None
-    d = module.__dict__
-    for item in d.keys():
-        try:
-            if issubclass(d[item], wx.App):
-                App = d[item]
-        except (NameError, TypeError):
-            pass
-    if App is None:
-        print "No App class found."
-        raise SystemExit
-    app = App()
-    wrap(app)
-
-
-if __name__ == '__main__':
-    main()

wxPython/wxPython/py/README.txt

@@ -1,79 +0,0 @@
-=====================================
- PyCrust - The Flakiest Python Shell
-=====================================
-
-Half-baked by Patrick K. O'Brien (pobrien@orbtech.com)
-
-Orbtech - "Your source for Python programming expertise."
-Sample all our half-baked Python goods at www.orbtech.com.
-
-
-What is PyCrust?
-----------------
-
-PyCrust is an interactive Python environment written in Python.
-PyCrust components can run standalone or be integrated into other
-development environments and/or other Python applications.
-
-PyCrust comes with an interactive Python shell (PyShell), an
-interactive namespace/object tree control (PyFilling) and an
-integrated, split-window combination of the two (PyCrust).
-
-
-What is PyCrust good for?
--------------------------
-
-Have you ever tried to bake a pie without one? Well, you shouldn't
-build a Python program without a PyCrust either.
-
-
-What else do I need to use PyCrust?
------------------------------------
-
-PyCrust requires Python 2.1.3 or later, and wxPython 2.4 or later.
-PyCrust uses wxPython and the Scintilla wrapper (wxStyledTextCtrl).
-Python is available at http://www.python.org/.  wxPython is available
-at http://www.wxpython.org/.
-
-
-Where can I get the latest version of PyCrust?
-----------------------------------------------
-
-The latest production version ships with wxPython.  The latest
-developer version is available in CVS at:
-http://sourceforge.net/cvs/?group_id=31263
-
-
-Where is the PyCrust project hosted?
-------------------------------------
-
-At SourceForge, of course. The SourceForge summary page:
-http://sourceforge.net/projects/pycrust/
-
-
-I found a bug in PyCrust, what do I do with it?
------------------------------------------------
-
-You can send it to me at pobrien@orbtech.com.
-
-
-I want a new feature added to PyCrust. Will you do it?
-------------------------------------------------------
-
-Flattery and money will get you anything. Short of that, you can send
-me a request and I'll see what I can do.
-
-
-Does PyCrust have a mailing list full of wonderful people?
-----------------------------------------------------------
-
-As a matter of fact, we do. Join the PyCrust mailing lists at:
-http://sourceforge.net/mail/?group_id=31263
-
-
-What is the CVS information for this README file?
--------------------------------------------------
-
-$Date$
-$Revision$
-$Id$

wxPython/wxPython/py/__init__.py

@@ -1,20 +0,0 @@
-"""The py package, formerly the PyCrust package."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import buffer
-import crust
-import dispatcher
-import document
-import editor
-import editwindow
-import filling
-import frame
-import images
-import interpreter
-import introspect
-import pseudo
-import shell
-import version

wxPython/wxPython/py/buffer.py

@@ -1,144 +0,0 @@
-"""Buffer class."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from interpreter import Interpreter
-import imp
-import os
-import sys
-
-import document
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class Buffer:
-    """Buffer class."""
-
-    id = 0
-
-    def __init__(self, filename=None):
-        """Create a Buffer instance."""
-        Buffer.id += 1
-        self.id = Buffer.id
-        self.interp = Interpreter(locals={})
-        self.name = ''
-        self.editors = {}
-        self.editor = None
-        self.modules = sys.modules.keys()
-        self.syspath = sys.path[:]
-        while True:
-            try:
-                self.syspath.remove('')
-            except ValueError:
-                break
-        while True:
-            try:
-                self.syspath.remove('.')
-            except ValueError:
-                break
-        self.open(filename)
-
-    def addEditor(self, editor):
-        """Add an editor."""
-        self.editor = editor
-        self.editors[editor.id] = editor
-
-    def hasChanged(self):
-        """Return True if text in editor has changed since last save."""
-        if self.editor:
-            return self.editor.hasChanged()
-        else:
-            return False
-
-    def new(self, filepath):
-        """New empty buffer."""
-        if not filepath:
-            return
-        if os.path.exists(filepath):
-            self.confirmed = self.overwriteConfirm(filepath)
-        else:
-            self.confirmed = True
-
-    def open(self, filename):
-        """Open file into buffer."""
-        self.doc = document.Document(filename)
-        self.name = self.doc.filename or ('Untitled:' + str(self.id))
-        self.modulename = self.doc.filebase
-        # XXX This should really make sure filedir is first item in syspath.
-        # XXX Or maybe this should be moved to the update namespace method.
-        if self.doc.filedir and self.doc.filedir not in self.syspath:
-            # To create the proper context for updateNamespace.
-            self.syspath.insert(0, self.doc.filedir)
-        if self.doc.filepath and os.path.exists(self.doc.filepath):
-            self.confirmed = True
-        if self.editor:
-            text = self.doc.read()
-            self.editor._setBuffer(buffer=self, text=text)
-
-    def overwriteConfirm(filepath):
-        """Confirm overwriting an existing file."""
-        return False
-
-    def save(self):
-        """Save buffer."""
-        filepath = self.doc.filepath
-        if not filepath:
-            return  # XXX Get filename
-        if not os.path.exists(filepath):
-            self.confirmed = True
-        if not self.confirmed:
-            self.confirmed = self.overwriteConfirm(filepath)
-        if self.confirmed:
-            self.doc.write(self.editor.getText())
-            if self.editor:
-                self.editor.setSavePoint()
-
-    def saveAs(self, filename):
-        """Save buffer."""
-        self.doc = document.Document(filename)
-        self.name = self.doc.filename
-        self.modulename = self.doc.filebase
-        self.save()
-
-    def updateNamespace(self):
-        """Update the namespace for autocompletion and calltips.
-
-        Return True if updated, False if there was an error."""
-        if not self.interp or not hasattr(self.editor, 'getText'):
-            return False
-        syspath = sys.path
-        sys.path = self.syspath
-        text = self.editor.getText()
-        text = text.replace('\r\n', '\n')
-        text = text.replace('\r', '\n')
-        name = self.modulename or self.name
-        module = imp.new_module(name)
-        newspace = module.__dict__.copy()
-        try:
-            try:
-                code = compile(text, name, 'exec')
-            except:
-                raise
-#                return False
-            try:
-                exec code in newspace
-            except:
-                raise
-#                return False
-            else:
-                # No problems, so update the namespace.
-                self.interp.locals.clear()
-                self.interp.locals.update(newspace)
-                return True
-        finally:
-            sys.path = syspath
-            for m in sys.modules.keys():
-                if m not in self.modules:
-                    del sys.modules[m]

wxPython/wxPython/py/crust.py

@@ -1,221 +0,0 @@
-"""Crust combines the shell and filling into one control."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-
-import os
-import pprint
-import sys
-
-import dispatcher
-import editwindow
-from filling import Filling
-import frame
-from shell import Shell
-from version import VERSION
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class Crust(wx.SplitterWindow):
-    """Crust based on SplitterWindow."""
-
-    name = 'Crust'
-    revision = __revision__
-
-    def __init__(self, parent, id=-1, pos=wx.DefaultPosition, 
-                 size=wx.DefaultSize, style=wx.SP_3D,
-                 name='Crust Window', rootObject=None, rootLabel=None,
-                 rootIsNamespace=True, intro='', locals=None, 
-                 InterpClass=None, *args, **kwds):
-        """Create Crust instance."""
-        wx.SplitterWindow.__init__(self, parent, id, pos, size, style, name)
-        self.shell = Shell(parent=self, introText=intro, 
-                           locals=locals, InterpClass=InterpClass, 
-                           *args, **kwds)
-        self.editor = self.shell
-        if rootObject is None:
-            rootObject = self.shell.interp.locals
-        self.notebook = wx.Notebook(parent=self, id=-1)
-        self.shell.interp.locals['notebook'] = self.notebook
-        self.filling = Filling(parent=self.notebook, 
-                               rootObject=rootObject, 
-                               rootLabel=rootLabel, 
-                               rootIsNamespace=rootIsNamespace)
-        # Add 'filling' to the interpreter's locals.
-        self.shell.interp.locals['filling'] = self.filling
-        self.notebook.AddPage(page=self.filling, text='Namespace', select=True)
-        self.display = Display(parent=self.notebook)
-        self.notebook.AddPage(page=self.display, text='Display')
-        # Add 'pp' (pretty print) to the interpreter's locals.
-        self.shell.interp.locals['pp'] = self.display.setItem
-        self.calltip = Calltip(parent=self.notebook)
-        self.notebook.AddPage(page=self.calltip, text='Calltip')
-        self.sessionlisting = SessionListing(parent=self.notebook)
-        self.notebook.AddPage(page=self.sessionlisting, text='Session')
-        self.dispatcherlisting = DispatcherListing(parent=self.notebook)
-        self.notebook.AddPage(page=self.dispatcherlisting, text='Dispatcher')
-        from wxd import wx_
-        self.wxdocs = Filling(parent=self.notebook, 
-                              rootObject=wx_,
-                              rootLabel='wx', 
-                              rootIsNamespace=False,
-                              static=True)
-        self.notebook.AddPage(page=self.wxdocs, text='wxPython Docs')
-        from wxd import stc_
-        self.stcdocs = Filling(parent=self.notebook, 
-                               rootObject=stc_.StyledTextCtrl,
-                               rootLabel='StyledTextCtrl', 
-                               rootIsNamespace=False,
-                               static=True)
-        self.notebook.AddPage(page=self.stcdocs, text='StyledTextCtrl Docs')
-        self.SplitHorizontally(self.shell, self.notebook, 300)
-        self.SetMinimumPaneSize(1)
-
-
-class Display(editwindow.EditWindow):
-    """STC used to display an object using Pretty Print."""
-
-    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize,
-                 style=wx.CLIP_CHILDREN | wx.SUNKEN_BORDER,
-                 static=False):
-        """Create Display instance."""
-        editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
-        # Configure various defaults and user preferences.
-        self.SetReadOnly(True)
-        self.SetWrapMode(False)
-        if not static:
-            dispatcher.connect(receiver=self.push, signal='Interpreter.push')
-
-    def push(self, command, more):
-        """Receiver for Interpreter.push signal."""
-        self.Refresh()
-
-    def Refresh(self):
-        if not hasattr(self, "item"):
-            return
-        self.SetReadOnly(False)
-        text = pprint.pformat(self.item)
-        self.SetText(text)
-        self.SetReadOnly(True)
-
-    def setItem(self, item):
-        """Set item to pretty print in the notebook Display tab."""
-        self.item = item
-        self.Refresh()
-
-
-class Calltip(wx.TextCtrl):
-    """Text control containing the most recent shell calltip."""
-
-    def __init__(self, parent=None, id=-1):
-        style = wx.TE_MULTILINE | wx.TE_READONLY | wx.TE_RICH2
-        wx.TextCtrl.__init__(self, parent=parent, id=id, style=style)
-        self.SetBackgroundColour(wx.Colour(255, 255, 232))
-        dispatcher.connect(receiver=self.display, signal='Shell.calltip')
-
-    def display(self, calltip):
-        """Receiver for Shell.calltip signal."""
-        self.SetValue(calltip)
-
-
-class SessionListing(wx.TextCtrl):
-    """Text control containing all commands for session."""
-
-    def __init__(self, parent=None, id=-1):
-        style = wx.TE_MULTILINE | wx.TE_READONLY | \
-                wx.TE_RICH2 | wx.TE_DONTWRAP
-        wx.TextCtrl.__init__(self, parent=parent, id=id, style=style)
-        dispatcher.connect(receiver=self.push, signal='Interpreter.push')
-
-    def push(self, command, more):
-        """Receiver for Interpreter.push signal."""
-        if command and not more:
-            self.SetInsertionPointEnd()
-            start, end = self.GetSelection()
-            if start != end:
-                self.SetSelection(0, 0)
-            self.AppendText(command + '\n')
-
-
-class DispatcherListing(wx.TextCtrl):
-    """Text control containing all dispatches for session."""
-
-    def __init__(self, parent=None, id=-1):
-        style = wx.TE_MULTILINE | wx.TE_READONLY | \
-                wx.TE_RICH2 | wx.TE_DONTWRAP
-        wx.TextCtrl.__init__(self, parent=parent, id=id, style=style)
-        dispatcher.connect(receiver=self.spy)
-
-    def spy(self, signal, sender):
-        """Receiver for Any signal from Any sender."""
-        text = '%r from %s' % (signal, sender)
-        self.SetInsertionPointEnd()
-        start, end = self.GetSelection()
-        if start != end:
-            self.SetSelection(0, 0)
-        self.AppendText(text + '\n')
-
-
-class CrustFrame(frame.Frame):
-    """Frame containing all the PyCrust components."""
-
-    name = 'CrustFrame'
-    revision = __revision__
-
-    def __init__(self, parent=None, id=-1, title='PyCrust',
-                 pos=wx.DefaultPosition, size=wx.DefaultSize,
-                 style=wx.DEFAULT_FRAME_STYLE,
-                 rootObject=None, rootLabel=None, rootIsNamespace=True,
-                 locals=None, InterpClass=None, *args, **kwds):
-        """Create CrustFrame instance."""
-        frame.Frame.__init__(self, parent, id, title, pos, size, style)
-        intro = 'PyCrust %s - The Flakiest Python Shell' % VERSION
-        intro += '\nSponsored by Orbtech - '
-        intro += 'Your source for Python programming expertise.'
-        self.SetStatusText(intro.replace('\n', ', '))
-        self.crust = Crust(parent=self, intro=intro,
-                           rootObject=rootObject,
-                           rootLabel=rootLabel,
-                           rootIsNamespace=rootIsNamespace,
-                           locals=locals,
-                           InterpClass=InterpClass, *args, **kwds)
-        self.shell = self.crust.shell
-        # Override the filling so that status messages go to the status bar.
-        self.crust.filling.tree.setStatusText = self.SetStatusText
-        # Override the shell so that status messages go to the status bar.
-        self.shell.setStatusText = self.SetStatusText
-        # Fix a problem with the sash shrinking to nothing.
-        self.crust.filling.SetSashPosition(200)
-        # Set focus to the shell editor.
-        self.shell.SetFocus()
-
-    def OnClose(self, event):
-        """Event handler for closing."""
-        self.crust.shell.destroy()
-        self.Destroy()
-
-    def OnAbout(self, event):
-        """Display an About window."""
-        title = 'About PyCrust'
-        text = 'PyCrust %s\n\n' % VERSION + \
-               'Yet another Python shell, only flakier.\n\n' + \
-               'Half-baked by Patrick K. O\'Brien,\n' + \
-               'the other half is still in the oven.\n\n' + \
-               'Shell Revision: %s\n' % self.shell.revision + \
-               'Interpreter Revision: %s\n\n' % self.shell.interp.revision + \
-               'Python Version: %s\n' % sys.version.split()[0] + \
-               'wxPython Version: %s\n' % wx.VERSION_STRING + \
-               'Platform: %s\n' % sys.platform
-        dialog = wx.MessageDialog(self, text, title,
-                                  wx.OK | wx.ICON_INFORMATION)
-        dialog.ShowModal()
-        dialog.Destroy()

wxPython/wxPython/py/dispatcher.py

@@ -1,266 +0,0 @@
-"""Provides global signal dispatching services."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import exceptions
-import types
-import weakref
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class DispatcherError(exceptions.Exception):
-    def __init__(self, args=None):
-        self.args = args
-
-
-class Parameter:
-    """Used to represent default parameter values."""
-    def __repr__(self):
-        return self.__class__.__name__
-
-class Any(Parameter): pass
-Any = Any()
-
-class Anonymous(Parameter): pass
-Anonymous = Anonymous()
-
-
-connections = {}
-senders = {}
-_boundMethods = weakref.WeakKeyDictionary()
-
-
-def connect(receiver, signal=Any, sender=Any, weak=True):
-    """Connect receiver to sender for signal.
-    
-    If sender is Any, receiver will receive signal from any sender.
-    If signal is Any, receiver will receive any signal from sender.
-    If sender is None, receiver will receive signal from Anonymous.
-    If signal is Any and sender is None, receiver will receive any 
-        signal from Anonymous.
-    If signal is Any and sender is Any, receiver will receive any 
-        signal from any sender.
-    If weak is true, weak references will be used."""
-    if signal is None:
-        raise DispatcherError, 'signal cannot be None'
-    if weak:
-        receiver = safeRef(receiver)
-    senderkey = id(sender)
-    signals = {}
-    if connections.has_key(senderkey):
-        signals = connections[senderkey]
-    else:
-        connections[senderkey] = signals
-        # Keep track of senders for cleanup.
-        if sender not in (None, Any):
-            def remove(object, senderkey=senderkey):
-                _removeSender(senderkey=senderkey)
-            # Skip objects that can not be weakly referenced, which means
-            # they won't be automatically cleaned up, but that's too bad.
-            try:
-                weakSender = weakref.ref(sender, remove)
-                senders[senderkey] = weakSender
-            except:
-                pass
-    receivers = []
-    if signals.has_key(signal):
-        receivers = signals[signal]
-    else:
-        signals[signal] = receivers
-    try:
-        receivers.remove(receiver)
-    except ValueError:
-        pass
-    receivers.append(receiver)
-
-def disconnect(receiver, signal=Any, sender=Any, weak=True):
-    """Disconnect receiver from sender for signal.
-    
-    Disconnecting is not required. The use of disconnect is the same as for
-    connect, only in reverse. Think of it as undoing a previous connection."""
-    if signal is None:
-        raise DispatcherError, 'signal cannot be None'
-    if weak:
-        receiver = safeRef(receiver)
-    senderkey = id(sender)
-    try:
-        receivers = connections[senderkey][signal]
-    except KeyError:
-        raise DispatcherError, \
-              'No receivers for signal %r from sender %s' % (signal, sender)
-    try:
-        receivers.remove(receiver)
-    except ValueError:
-        raise DispatcherError, \
-              'No connection to receiver %s for signal %r from sender %s' % \
-              (receiver, signal, sender)
-    _cleanupConnections(senderkey, signal)
-
-def send(signal, sender=Anonymous, **kwds):
-    """Send signal from sender to all connected receivers.
-    
-    Return a list of tuple pairs [(receiver, response), ... ].
-    If sender is not specified, signal is sent anonymously."""
-    senderkey = id(sender)
-    anykey = id(Any)
-    # Get receivers that receive *this* signal from *this* sender.
-    receivers = []
-    try:
-        receivers.extend(connections[senderkey][signal])
-    except KeyError:
-        pass
-    # Add receivers that receive *any* signal from *this* sender.
-    anyreceivers = []
-    try:
-        anyreceivers = connections[senderkey][Any]
-    except KeyError:
-        pass
-    for receiver in anyreceivers:
-        if receivers.count(receiver) == 0:
-            receivers.append(receiver)
-    # Add receivers that receive *this* signal from *any* sender.
-    anyreceivers = []
-    try:
-        anyreceivers = connections[anykey][signal]
-    except KeyError:
-        pass
-    for receiver in anyreceivers:
-        if receivers.count(receiver) == 0:
-            receivers.append(receiver)
-    # Add receivers that receive *any* signal from *any* sender.
-    anyreceivers = []
-    try:
-        anyreceivers = connections[anykey][Any]
-    except KeyError:
-        pass
-    for receiver in anyreceivers:
-        if receivers.count(receiver) == 0:
-            receivers.append(receiver)
-    # Call each receiver with whatever arguments it can accept.
-    # Return a list of tuple pairs [(receiver, response), ... ].
-    responses = []
-    for receiver in receivers:
-        if type(receiver) is weakref.ReferenceType \
-        or isinstance(receiver, BoundMethodWeakref):
-            # Dereference the weak reference.
-            receiver = receiver()
-            if receiver is None:
-                # This receiver is dead, so skip it.
-                continue
-        response = _call(receiver, signal=signal, sender=sender, **kwds)
-        responses += [(receiver, response)]
-    return responses
-
-def _call(receiver, **kwds):
-    """Call receiver with only arguments it can accept."""
-##    if type(receiver) is types.InstanceType:
-    if hasattr(receiver, '__call__') and \
-       (hasattr(receiver.__call__, 'im_func') or hasattr(receiver.__call__, 'im_code')):
-        # receiver is a class instance; assume it is callable.
-        # Reassign receiver to the actual method that will be called.
-        receiver = receiver.__call__
-    if hasattr(receiver, 'im_func'):
-        # receiver is a method. Drop the first argument, usually 'self'.
-        fc = receiver.im_func.func_code
-        acceptable = fc.co_varnames[1:fc.co_argcount]
-    elif hasattr(receiver, 'func_code'):
-        # receiver is a function.
-        fc = receiver.func_code
-        acceptable = fc.co_varnames[0:fc.co_argcount]
-    else:
-        raise DispatcherError, 'Unknown receiver %s of type %s' % (receiver, type(receiver))
-    if not (fc.co_flags & 8):
-        # fc does not have a **kwds type parameter, therefore 
-        # remove unacceptable arguments.
-        for arg in kwds.keys():
-            if arg not in acceptable:
-                del kwds[arg]
-    return receiver(**kwds)
-
-
-def safeRef(object):
-    """Return a *safe* weak reference to a callable object."""
-    if hasattr(object, 'im_self'):
-        if object.im_self is not None:
-            # Turn a bound method into a BoundMethodWeakref instance.
-            # Keep track of these instances for lookup by disconnect().
-            selfkey = object.im_self
-            funckey = object.im_func
-            if not _boundMethods.has_key(selfkey):
-                _boundMethods[selfkey] = weakref.WeakKeyDictionary()
-            if not _boundMethods[selfkey].has_key(funckey):
-                _boundMethods[selfkey][funckey] = \
-                BoundMethodWeakref(boundMethod=object)
-            return _boundMethods[selfkey][funckey]
-    return weakref.ref(object, _removeReceiver)
-
-
-class BoundMethodWeakref:
-    """BoundMethodWeakref class."""
-
-    def __init__(self, boundMethod):
-        """Return a weak-reference-like instance for a bound method."""
-        self.isDead = 0
-        def remove(object, self=self):
-            """Set self.isDead to true when method or instance is destroyed."""
-            self.isDead = 1
-            _removeReceiver(receiver=self)
-        self.weakSelf = weakref.ref(boundMethod.im_self, remove)
-        self.weakFunc = weakref.ref(boundMethod.im_func, remove)
-
-    def __repr__(self):
-        """Return the closest representation."""
-        return '<bound method weakref for %s.%s>' % (self.weakSelf, self.weakFunc)
-
-    def __call__(self):
-        """Return a strong reference to the bound method."""
-        if self.isDead:
-            return None
-        else:
-            object = self.weakSelf()
-            method = self.weakFunc().__name__
-            try:  # wxPython hack to handle wxDead objects.
-                return getattr(object, method)
-            except AttributeError:
-##                 _removeReceiver(receiver=self)
-                return None
-
-
-def _removeReceiver(receiver):
-    """Remove receiver from connections."""
-    for senderkey in connections.keys():
-        for signal in connections[senderkey].keys():
-            receivers = connections[senderkey][signal]
-            try:
-                receivers.remove(receiver)
-            except:
-                pass
-            _cleanupConnections(senderkey, signal)
-            
-def _cleanupConnections(senderkey, signal):
-    """Delete any empty signals for senderkey. Delete senderkey if empty."""
-    receivers = connections[senderkey][signal]
-    if not receivers:
-        # No more connected receivers. Therefore, remove the signal.
-        signals = connections[senderkey]
-        del signals[signal]
-        if not signals:
-            # No more signal connections. Therefore, remove the sender.
-            _removeSender(senderkey)
-            
-def _removeSender(senderkey):
-    """Remove senderkey from connections."""
-    del connections[senderkey]
-    # Senderkey will only be in senders dictionary if sender 
-    # could be weakly referenced.
-    try:
-        del senders[senderkey]
-    except:
-        pass

wxPython/wxPython/py/document.py

@@ -1,49 +0,0 @@
-"""Document class."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import os
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class Document:
-    """Document class."""
-
-    def __init__(self, filename=None):
-        """Create a Document instance."""
-        self.filename = filename
-        self.filepath = None
-        self.filedir = None
-        self.filebase = None
-        self.fileext = None
-        if self.filename:
-            self.filepath = os.path.realpath(self.filename)
-            self.filedir, self.filename = os.path.split(self.filepath)
-            self.filebase, self.fileext = os.path.splitext(self.filename)
-
-    def read(self):
-        """Return contents of file."""
-        if self.filepath and os.path.exists(self.filepath):
-            f = file(self.filepath, 'rb')
-            try:
-                return f.read()
-            finally:
-                f.close()
-        else:
-            return ''
-
-    def write(self, text):
-        """Write text to file."""
-        try:
-            f = file(self.filepath, 'wb')
-            f.write(text)
-        finally:
-            if f:
-                f.close()

wxPython/wxPython/py/editor.py

@@ -1,846 +0,0 @@
-"""PyAlaCarte and PyAlaMode editors."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-
-from buffer import Buffer
-import crust
-import dispatcher
-import editwindow
-import frame
-from shell import Shell
-import version
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class EditorFrame(frame.Frame):
-    """Frame containing one editor."""
-
-    def __init__(self, parent=None, id=-1, title='PyAlaCarte',
-                 pos=wx.DefaultPosition, size=(800, 600), 
-                 style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE,
-                 filename=None):
-        """Create EditorFrame instance."""
-        frame.Frame.__init__(self, parent, id, title, pos, size, style)
-        self.buffers = {}
-        self.buffer = None  # Current buffer.
-        self.editor = None
-        self._defaultText = title + ' - the tastiest Python editor.'
-        self._statusText = self._defaultText
-        self.SetStatusText(self._statusText)
-        wx.EVT_IDLE(self, self.OnIdle)
-        self._setup()
-        if filename:
-            self.bufferCreate(filename)
-
-    def _setup(self):
-        """Setup prior to first buffer creation.
-
-        Useful for subclasses."""
-        pass
-
-    def setEditor(self, editor):
-        self.editor = editor
-        self.buffer = self.editor.buffer
-        self.buffers[self.buffer.id] = self.buffer
-
-    def OnAbout(self, event):
-        """Display an About window."""
-        title = 'About PyAlaCarte'
-        text = 'Another fine, flaky program.'
-        dialog = wx.MessageDialog(self, text, title,
-                                  wx.OK | wx.ICON_INFORMATION)
-        dialog.ShowModal()
-        dialog.Destroy()
-
-    def OnClose(self, event):
-        """Event handler for closing."""
-        for buffer in self.buffers.values():
-            self.buffer = buffer
-            if buffer.hasChanged():
-                cancel = self.bufferSuggestSave()
-                if cancel and event.CanVeto():
-                    event.Veto()
-                    return
-        self.Destroy()
-
-    def OnIdle(self, event):
-        """Event handler for idle time."""
-        self._updateStatus()
-        if hasattr(self, 'notebook'):
-            self._updateTabText()
-        self._updateTitle()
-        event.Skip()
-
-    def _updateStatus(self):
-        """Show current status information."""
-        if self.editor and hasattr(self.editor, 'getStatus'):
-            status = self.editor.getStatus()
-            text = 'File: %s  |  Line: %d  |  Column: %d' % status
-        else:
-            text = self._defaultText
-        if text != self._statusText:
-            self.SetStatusText(text)
-            self._statusText = text
-
-    def _updateTabText(self):
-        """Show current buffer information on notebook tab."""
-##         suffix = ' **'
-##         notebook = self.notebook
-##         selection = notebook.GetSelection()
-##         if selection == -1:
-##             return
-##         text = notebook.GetPageText(selection)
-##         window = notebook.GetPage(selection)
-##         if window.editor and window.editor.buffer.hasChanged():
-##             if text.endswith(suffix):
-##                 pass
-##             else:
-##                 notebook.SetPageText(selection, text + suffix)
-##         else:
-##             if text.endswith(suffix):
-##                 notebook.SetPageText(selection, text[:len(suffix)])
-
-    def _updateTitle(self):
-        """Show current title information."""
-        title = self.GetTitle()
-        if self.bufferHasChanged():
-            if title.startswith('* '):
-                pass
-            else:
-                self.SetTitle('* ' + title)
-        else:
-            if title.startswith('* '):
-                self.SetTitle(title[2:])
-        
-    def hasBuffer(self):
-        """Return True if there is a current buffer."""
-        if self.buffer:
-            return True
-        else:
-            return False
-
-    def bufferClose(self):
-        """Close buffer."""
-        if self.bufferHasChanged():
-            cancel = self.bufferSuggestSave()
-            if cancel:
-                return cancel
-        self.bufferDestroy()
-        cancel = False
-        return cancel
-
-    def bufferCreate(self, filename=None):
-        """Create new buffer."""
-        self.bufferDestroy()
-        buffer = Buffer()
-        self.panel = panel = wx.Panel(parent=self, id=-1)
-        wx.EVT_ERASE_BACKGROUND(panel, lambda x: x)        
-        editor = Editor(parent=panel)
-        panel.editor = editor
-        sizer = wx.BoxSizer(wx.VERTICAL)
-        sizer.Add(editor.window, 1, wx.EXPAND)
-        panel.SetSizer(sizer)
-        panel.SetAutoLayout(True)
-        sizer.Layout()
-        buffer.addEditor(editor)
-        buffer.open(filename)
-        self.setEditor(editor)
-        self.editor.setFocus()
-        self.SendSizeEvent()
-        
-
-    def bufferDestroy(self):
-        """Destroy the current buffer."""
-        if self.buffer:
-            for editor in self.buffer.editors.values():
-                editor.destroy()
-            self.editor = None
-            del self.buffers[self.buffer.id]
-            self.buffer = None
-            self.panel.Destroy()
-
-
-    def bufferHasChanged(self):
-        """Return True if buffer has changed since last save."""
-        if self.buffer:
-            return self.buffer.hasChanged()
-        else:
-            return False
-
-    def bufferNew(self):
-        """Create new buffer."""
-        if self.bufferHasChanged():
-            cancel = self.bufferSuggestSave()
-            if cancel:
-                return cancel
-        self.bufferCreate()
-        cancel = False
-        return cancel
-
-    def bufferOpen(self):
-        """Open file in buffer."""
-        if self.bufferHasChanged():
-            cancel = self.bufferSuggestSave()
-            if cancel:
-                return cancel
-        filedir = ''
-        if self.buffer and self.buffer.doc.filedir:
-            filedir = self.buffer.doc.filedir
-        result = openSingle(directory=filedir)
-        if result.path:
-            self.bufferCreate(result.path)
-        cancel = False
-        return cancel
-
-##     def bufferPrint(self):
-##         """Print buffer."""
-##         pass
-
-##     def bufferRevert(self):
-##         """Revert buffer to version of file on disk."""
-##         pass
-
-    def bufferSave(self):
-        """Save buffer to its file."""
-        if self.buffer.doc.filepath:
-            self.buffer.save()
-            cancel = False
-        else:
-            cancel = self.bufferSaveAs()
-        return cancel
-
-    def bufferSaveAs(self):
-        """Save buffer to a new filename."""
-        if self.bufferHasChanged() and self.buffer.doc.filepath:
-            cancel = self.bufferSuggestSave()
-            if cancel:
-                return cancel
-        filedir = ''
-        if self.buffer and self.buffer.doc.filedir:
-            filedir = self.buffer.doc.filedir
-        result = saveSingle(directory=filedir)
-        if result.path:
-            self.buffer.saveAs(result.path)
-            cancel = False
-        else:
-            cancel = True
-        return cancel
-
-    def bufferSuggestSave(self):
-        """Suggest saving changes.  Return True if user selected Cancel."""
-        result = messageDialog(parent=None,
-                               message='%s has changed.\n'
-                                       'Would you like to save it first'
-                                       '?' % self.buffer.name,
-                               title='Save current file?')
-        if result.positive:
-            cancel = self.bufferSave()
-        else:
-            cancel = result.text == 'Cancel'
-        return cancel
-
-    def updateNamespace(self):
-        """Update the buffer namespace for autocompletion and calltips."""
-        if self.buffer.updateNamespace():
-            self.SetStatusText('Namespace updated')
-        else:
-            self.SetStatusText('Error executing, unable to update namespace')
-
-
-class EditorNotebookFrame(EditorFrame):
-    """Frame containing one or more editors in a notebook."""
-
-    def __init__(self, parent=None, id=-1, title='PyAlaMode',
-                 pos=wx.DefaultPosition, size=(800, 600), 
-                 style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE,
-                 filename=None):
-        """Create EditorNotebookFrame instance."""
-        self.notebook = None
-        EditorFrame.__init__(self, parent, id, title, pos,
-                             size, style, filename)
-        if self.notebook:
-            dispatcher.connect(receiver=self._editorChange,
-                               signal='EditorChange', sender=self.notebook)
-
-    def _setup(self):
-        """Setup prior to first buffer creation.
-
-        Called automatically by base class during init."""
-        self.notebook = EditorNotebook(parent=self)
-        intro = 'Py %s' % version.VERSION
-        import imp
-        module = imp.new_module('__main__')
-        import __builtin__
-        module.__dict__['__builtins__'] = __builtin__
-        namespace = module.__dict__.copy()
-        self.crust = crust.Crust(parent=self.notebook, intro=intro, locals=namespace)
-        self.shell = self.crust.shell
-        # Override the filling so that status messages go to the status bar.
-        self.crust.filling.tree.setStatusText = self.SetStatusText
-        # Override the shell so that status messages go to the status bar.
-        self.shell.setStatusText = self.SetStatusText
-        # Fix a problem with the sash shrinking to nothing.
-        self.crust.filling.SetSashPosition(200)
-        self.notebook.AddPage(page=self.crust, text='*Shell*', select=True)
-        self.setEditor(self.crust.editor)
-        self.crust.editor.SetFocus()
-
-    def _editorChange(self, editor):
-        """Editor change signal receiver."""
-        self.setEditor(editor)
-
-    def OnAbout(self, event):
-        """Display an About window."""
-        title = 'About PyAlaMode'
-        text = 'Another fine, flaky program.'
-        dialog = wx.MessageDialog(self, text, title,
-                                  wx.OK | wx.ICON_INFORMATION)
-        dialog.ShowModal()
-        dialog.Destroy()
-
-    def _updateTitle(self):
-        """Show current title information."""
-        pass
-##         title = self.GetTitle()
-##         if self.bufferHasChanged():
-##             if title.startswith('* '):
-##                 pass
-##             else:
-##                 self.SetTitle('* ' + title)
-##         else:
-##             if title.startswith('* '):
-##                 self.SetTitle(title[2:])
-        
-    def bufferCreate(self, filename=None):
-        """Create new buffer."""
-        buffer = Buffer()
-        panel = wx.Panel(parent=self.notebook, id=-1)
-        wx.EVT_ERASE_BACKGROUND(panel, lambda x: x)        
-        editor = Editor(parent=panel)
-        panel.editor = editor
-        sizer = wx.BoxSizer(wx.VERTICAL)
-        sizer.Add(editor.window, 1, wx.EXPAND)
-        panel.SetSizer(sizer)
-        panel.SetAutoLayout(True)
-        sizer.Layout()
-        buffer.addEditor(editor)
-        buffer.open(filename)
-        self.setEditor(editor)
-        self.notebook.AddPage(page=panel, text=self.buffer.name, select=True)
-        self.editor.setFocus()
-
-    def bufferDestroy(self):
-        """Destroy the current buffer."""
-        selection = self.notebook.GetSelection()
-##         print "Destroy Selection:", selection
-        if selection > 0:  # Don't destroy the PyCrust tab.
-            if self.buffer:
-                del self.buffers[self.buffer.id]
-                self.buffer = None  # Do this before DeletePage().
-            self.notebook.DeletePage(selection)
-
-    def bufferNew(self):
-        """Create new buffer."""
-        self.bufferCreate()
-        cancel = False
-        return cancel
-
-    def bufferOpen(self):
-        """Open file in buffer."""
-        filedir = ''
-        if self.buffer and self.buffer.doc.filedir:
-            filedir = self.buffer.doc.filedir
-        result = openMultiple(directory=filedir)
-        for path in result.paths:
-            self.bufferCreate(path)
-        cancel = False
-        return cancel
-
-
-class EditorNotebook(wx.Notebook):
-    """A notebook containing a page for each editor."""
-
-    def __init__(self, parent):
-        """Create EditorNotebook instance."""
-        wx.Notebook.__init__(self, parent, id=-1, style=wx.NO_FULL_REPAINT_ON_RESIZE)
-        wx.EVT_NOTEBOOK_PAGE_CHANGING(self, self.GetId(),
-                                      self.OnPageChanging)
-        wx.EVT_NOTEBOOK_PAGE_CHANGED(self, self.GetId(),
-                                     self.OnPageChanged)
-        wx.EVT_IDLE(self, self.OnIdle)
-
-    def OnIdle(self, event):
-        """Event handler for idle time."""
-        self._updateTabText()
-        event.Skip()
-
-    def _updateTabText(self):
-        """Show current buffer display name on all but first tab."""
-        size = 3
-        changed = ' **'
-        unchanged = ' --'
-        selection = self.GetSelection()
-        if selection < 1:
-            return
-        text = self.GetPageText(selection)
-        window = self.GetPage(selection)
-        if not window.editor:
-            return
-        if text.endswith(changed) or text.endswith(unchanged):
-            name = text[:-size]
-        else:
-            name = text
-        if name != window.editor.buffer.name:
-            text = window.editor.buffer.name
-        if window.editor.buffer.hasChanged():
-            if text.endswith(changed):
-                text = None
-            elif text.endswith(unchanged):
-                text = text[:-size] + changed
-            else:
-                text += changed
-        else:
-            if text.endswith(changed):
-                text = text[:-size] + unchanged
-            elif text.endswith(unchanged):
-                text = None
-            else:
-                text += unchanged
-        if text is not None:
-            self.SetPageText(selection, text)
-            self.Refresh()  # Needed on Win98.
-
-    def OnPageChanging(self, event):
-        """Page changing event handler."""
-        event.Skip()
-
-    def OnPageChanged(self, event):
-        """Page changed event handler."""
-        new = event.GetSelection()
-        window = self.GetPage(new)
-        dispatcher.send(signal='EditorChange', sender=self,
-                        editor=window.editor)
-        window.SetFocus()
-        event.Skip()
-
-
-class EditorShellNotebookFrame(EditorNotebookFrame):
-    """Frame containing a notebook containing EditorShellNotebooks."""
-
-    def __init__(self, parent=None, id=-1, title='PyAlaModeTest',
-                 pos=wx.DefaultPosition, size=(600, 400), 
-                 style=wx.DEFAULT_FRAME_STYLE,
-                 filename=None, singlefile=False):
-        """Create EditorShellNotebookFrame instance."""
-        self._singlefile = singlefile
-        EditorNotebookFrame.__init__(self, parent, id, title, pos,
-                                     size, style, filename)
-
-    def _setup(self):
-        """Setup prior to first buffer creation.
-
-        Called automatically by base class during init."""
-        if not self._singlefile:
-            self.notebook = EditorNotebook(parent=self)
-
-    def OnAbout(self, event):
-        """Display an About window."""
-        title = 'About PyAlaModePlus'
-        text = 'Another fine, flaky program.'
-        dialog = wx.MessageDialog(self, text, title,
-                                  wx.OK | wx.ICON_INFORMATION)
-        dialog.ShowModal()
-        dialog.Destroy()
-
-    def bufferCreate(self, filename=None):
-        """Create new buffer."""
-        if self._singlefile:
-            self.bufferDestroy()
-            notebook = EditorShellNotebook(parent=self,
-                                           filename=filename)
-            self.notebook = notebook
-        else:
-            notebook = EditorShellNotebook(parent=self.notebook,
-                                           filename=filename)
-        self.setEditor(notebook.editor)
-        if not self._singlefile:
-            self.notebook.AddPage(page=notebook, text=self.buffer.name,
-                                  select=True)
-        self.editor.setFocus()
-
-    def bufferDestroy(self):
-        """Destroy the current buffer."""
-        if self.buffer:
-            self.editor = None
-            del self.buffers[self.buffer.id]
-            self.buffer = None  # Do this before DeletePage().
-        if self._singlefile:
-            self.notebook.Destroy()
-            self.notebook = None
-        else:
-            selection = self.notebook.GetSelection()
-##             print "Destroy Selection:", selection
-            self.notebook.DeletePage(selection)
-
-    def bufferNew(self):
-        """Create new buffer."""
-        if self._singlefile and self.bufferHasChanged():
-            cancel = self.bufferSuggestSave()
-            if cancel:
-                return cancel
-        self.bufferCreate()
-        cancel = False
-        return cancel
-
-    def bufferOpen(self):
-        """Open file in buffer."""
-        if self._singlefile and self.bufferHasChanged():
-            cancel = self.bufferSuggestSave()
-            if cancel:
-                return cancel
-        filedir = ''
-        if self.buffer and self.buffer.doc.filedir:
-            filedir = self.buffer.doc.filedir
-        if self._singlefile:
-            result = openSingle(directory=filedir)
-            if result.path:
-                self.bufferCreate(result.path)
-        else:
-            result = openMultiple(directory=filedir)
-            for path in result.paths:
-                self.bufferCreate(path)
-        cancel = False
-        return cancel
-
-
-class EditorShellNotebook(wx.Notebook):
-    """A notebook containing an editor page and a shell page."""
-
-    def __init__(self, parent, filename=None):
-        """Create EditorShellNotebook instance."""
-        wx.Notebook.__init__(self, parent, id=-1)
-        usePanels = True
-        if usePanels:
-            editorparent = editorpanel = wx.Panel(self, -1)
-            shellparent = shellpanel = wx.Panel(self, -1)
-        else:
-            editorparent = self
-            shellparent = self
-        self.buffer = Buffer()
-        self.editor = Editor(parent=editorparent)
-        self.buffer.addEditor(self.editor)
-        self.buffer.open(filename)
-        self.shell = Shell(parent=shellparent, locals=self.buffer.interp.locals,
-                           style=wx.CLIP_CHILDREN | wx.SUNKEN_BORDER)
-        self.buffer.interp.locals.clear()
-        if usePanels:
-            self.AddPage(page=editorpanel, text='Editor', select=True)
-            self.AddPage(page=shellpanel, text='Shell')
-            # Setup sizers
-            editorsizer = wx.BoxSizer(wx.VERTICAL)
-            editorsizer.Add(self.editor.window, 1, wx.EXPAND)
-            editorpanel.SetSizer(editorsizer)
-            editorpanel.SetAutoLayout(True)
-            shellsizer = wx.BoxSizer(wx.VERTICAL)
-            shellsizer.Add(self.shell, 1, wx.EXPAND)
-            shellpanel.SetSizer(shellsizer)
-            shellpanel.SetAutoLayout(True)
-        else:
-            self.AddPage(page=self.editor.window, text='Editor', select=True)
-            self.AddPage(page=self.shell, text='Shell')
-        self.editor.setFocus()
-        wx.EVT_NOTEBOOK_PAGE_CHANGED(self, self.GetId(), self.OnPageChanged)
-
-    def OnPageChanged(self, event):
-        """Page changed event handler."""
-        selection = event.GetSelection()
-        if selection == 0:
-            self.editor.setFocus()
-        else:
-            self.shell.SetFocus()
-        event.Skip()
-
-    def SetFocus(self):
-        wx.Notebook.SetFocus(self)
-        selection = self.GetSelection()
-        if selection == 0:
-            self.editor.setFocus()
-        else:
-            self.shell.SetFocus()
-
-
-class Editor:
-    """Editor having an EditWindow."""
-
-    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize,
-                 style=wx.CLIP_CHILDREN | wx.SUNKEN_BORDER):
-        """Create Editor instance."""
-        self.window = EditWindow(self, parent, id, pos, size, style)
-        self.id = self.window.GetId()
-        self.buffer = None
-        # Assign handlers for keyboard events.
-        wx.EVT_CHAR(self.window, self.OnChar)
-        wx.EVT_KEY_DOWN(self.window, self.OnKeyDown)
-
-    def _setBuffer(self, buffer, text):
-        """Set the editor to a buffer.  Private callback called by buffer."""
-        self.buffer = buffer
-        self.autoCompleteKeys = buffer.interp.getAutoCompleteKeys()
-        self.clearAll()
-        self.setText(text)
-        self.emptyUndoBuffer()
-        self.setSavePoint()
-
-    def destroy(self):
-        """Destroy all editor objects."""
-        self.window.Destroy()
-
-    def clearAll(self):
-        self.window.ClearAll()
-
-    def emptyUndoBuffer(self):
-        self.window.EmptyUndoBuffer()
-
-    def getStatus(self):
-        """Return (filepath, line, column) status tuple."""
-        pos = self.window.GetCurrentPos()
-        line = self.window.LineFromPosition(pos) + 1
-        col = self.window.GetColumn(pos)
-        if self.buffer:
-            name = self.buffer.doc.filepath or self.buffer.name
-        else:
-            name = ''
-        status = (name, line, col)
-        return status
-
-    def getText(self):
-        """Return contents of editor."""
-        return self.window.GetText()
-
-    def hasChanged(self):
-        """Return True if contents have changed."""
-        return self.window.GetModify()
-
-    def setFocus(self):
-        """Set the input focus to the editor window."""
-        self.window.SetFocus()
-
-    def setSavePoint(self):
-        self.window.SetSavePoint()
-
-    def setText(self, text):
-        """Set contents of editor."""
-        self.window.SetText(text)
-
-    def OnChar(self, event):
-        """Keypress event handler.
-        
-        Only receives an event if OnKeyDown calls event.Skip() for the
-        corresponding event."""
-
-        key = event.KeyCode()
-        if key in self.autoCompleteKeys:
-            # Usually the dot (period) key activates auto completion.
-            if self.window.AutoCompActive(): 
-                self.window.AutoCompCancel()
-            self.window.ReplaceSelection('')
-            self.window.AddText(chr(key))
-            text, pos = self.window.GetCurLine()
-            text = text[:pos]
-            if self.window.autoComplete: 
-                self.autoCompleteShow(text)
-        elif key == ord('('):
-            # The left paren activates a call tip and cancels an
-            # active auto completion.
-            if self.window.AutoCompActive(): 
-                self.window.AutoCompCancel()
-            self.window.ReplaceSelection('')
-            self.window.AddText('(')
-            text, pos = self.window.GetCurLine()
-            text = text[:pos]
-            self.autoCallTipShow(text)
-        else:
-            # Allow the normal event handling to take place.
-            event.Skip()
-
-    def OnKeyDown(self, event):
-        """Key down event handler."""
-
-        key = event.KeyCode()
-        # If the auto-complete window is up let it do its thing.
-        if self.window.AutoCompActive():
-            event.Skip()
-            return
-        controlDown = event.ControlDown()
-        altDown = event.AltDown()
-        shiftDown = event.ShiftDown()
-        # Let Ctrl-Alt-* get handled normally.
-        if controlDown and altDown:
-            event.Skip()
-        # Increase font size.
-        elif controlDown and key in (ord(']'),):
-            dispatcher.send(signal='FontIncrease')
-        # Decrease font size.
-        elif controlDown and key in (ord('['),):
-            dispatcher.send(signal='FontDecrease')
-        # Default font size.
-        elif controlDown and key in (ord('='),):
-            dispatcher.send(signal='FontDefault')
-        else:
-            event.Skip()
-
-    def autoCompleteShow(self, command):
-        """Display auto-completion popup list."""
-        list = self.buffer.interp.getAutoCompleteList(command, 
-                    includeMagic=self.window.autoCompleteIncludeMagic, 
-                    includeSingle=self.window.autoCompleteIncludeSingle, 
-                    includeDouble=self.window.autoCompleteIncludeDouble)
-        if list:
-            options = ' '.join(list)
-            offset = 0
-            self.window.AutoCompShow(offset, options)
-
-    def autoCallTipShow(self, command):
-        """Display argument spec and docstring in a popup window."""
-        if self.window.CallTipActive():
-            self.window.CallTipCancel()
-        (name, argspec, tip) = self.buffer.interp.getCallTip(command)
-        if tip:
-            dispatcher.send(signal='Shell.calltip', sender=self, calltip=tip)
-        if not self.window.autoCallTip:
-            return
-        if argspec:
-            startpos = self.window.GetCurrentPos()
-            self.window.AddText(argspec + ')')
-            endpos = self.window.GetCurrentPos()
-            self.window.SetSelection(endpos, startpos)
-        if tip:
-            curpos = self.window.GetCurrentPos()
-            size = len(name)
-            tippos = curpos - (size + 1)
-            fallback = curpos - self.window.GetColumn(curpos)
-            # In case there isn't enough room, only go back to the
-            # fallback.
-            tippos = max(tippos, fallback)
-            self.window.CallTipShow(tippos, tip)
-            self.window.CallTipSetHighlight(0, size)
-
-
-class EditWindow(editwindow.EditWindow):
-    """EditWindow based on StyledTextCtrl."""
-
-    def __init__(self, editor, parent, id=-1, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize,
-                 style=wx.CLIP_CHILDREN | wx.SUNKEN_BORDER):
-        """Create EditWindow instance."""
-        editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
-        self.editor = editor
-
-
-class DialogResults:
-    """DialogResults class."""
-
-    def __init__(self, returned):
-        """Create wrapper for results returned by dialog."""
-        self.returned = returned
-        self.positive = returned in (wx.ID_OK, wx.ID_YES)
-        self.text = self._asString()
-        
-
-    def __repr__(self):
-        return str(self.__dict__)
-
-    def _asString(self):
-        returned = self.returned
-        if returned == wx.ID_OK:
-            return "Ok"
-        elif returned == wx.ID_CANCEL:
-            return "Cancel"
-        elif returned == wx.ID_YES:
-            return "Yes"
-        elif returned == wx.ID_NO:
-            return "No"
-
-
-def fileDialog(parent=None, title='Open', directory='', filename='',
-               wildcard='All Files (*.*)|*.*',
-               style=wx.OPEN | wx.MULTIPLE):
-    """File dialog wrapper function."""
-    dialog = wx.FileDialog(parent, title, directory, filename,
-                           wildcard, style)
-    result = DialogResults(dialog.ShowModal())
-    if result.positive:
-        result.paths = dialog.GetPaths()
-    else:
-        result.paths = []
-    dialog.Destroy()
-    return result
-
-
-def openSingle(parent=None, title='Open', directory='', filename='',
-               wildcard='All Files (*.*)|*.*', style=wx.OPEN):
-    """File dialog wrapper function."""
-    dialog = wx.FileDialog(parent, title, directory, filename,
-                           wildcard, style)
-    result = DialogResults(dialog.ShowModal())
-    if result.positive:
-        result.path = dialog.GetPath()
-    else:
-        result.path = None
-    dialog.Destroy()
-    return result
-
-
-def openMultiple(parent=None, title='Open', directory='', filename='',
-                 wildcard='All Files (*.*)|*.*',
-                 style=wx.OPEN | wx.MULTIPLE):
-    """File dialog wrapper function."""
-    return fileDialog(parent, title, directory, filename, wildcard, style)
-
-
-def saveSingle(parent=None, title='Save', directory='', filename='',
-               wildcard='All Files (*.*)|*.*',
-               style=wx.SAVE | wx.HIDE_READONLY | wx.OVERWRITE_PROMPT):
-    """File dialog wrapper function."""
-    dialog = wx.FileDialog(parent, title, directory, filename,
-                           wildcard, style)
-    result = DialogResults(dialog.ShowModal())
-    if result.positive:
-        result.path = dialog.GetPath()
-    else:
-        result.path = None
-    dialog.Destroy()
-    return result
-
-
-def directory(parent=None, message='Choose a directory', path='', style=0,
-              pos=wx.DefaultPosition, size=wx.DefaultSize):
-    """Dir dialog wrapper function."""
-    dialog = wx.DirDialog(parent, message, path, style, pos, size)
-    result = DialogResults(dialog.ShowModal())
-    if result.positive:
-        result.path = dialog.GetPath()
-    else:
-        result.path = None
-    dialog.Destroy()
-    return result
-
-
-def messageDialog(parent=None, message='', title='Message box',
-                  style=wx.YES_NO | wx.CANCEL | wx.CENTRE | wx.ICON_QUESTION,
-                  pos=wx.DefaultPosition):
-    """Message dialog wrapper function."""
-    dialog = wx.MessageDialog(parent, message, title, style, pos)
-    result = DialogResults(dialog.ShowModal())
-    dialog.Destroy()
-    return result

wxPython/wxPython/py/editwindow.py

@@ -1,199 +0,0 @@
-"""EditWindow class."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-from wx import stc
-
-import keyword
-import os
-import sys
-import time
-
-import dispatcher
-from version import VERSION
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-if wx.Platform == '__WXMSW__':
-    FACES = { 'times'  : 'Times New Roman',
-              'mono'   : 'Courier New',
-              'helv'   : 'Lucida Console',
-              'lucida' : 'Lucida Console',
-              'other'  : 'Comic Sans MS',
-              'size'   : 10,
-              'lnsize' : 9,
-              'backcol': '#FFFFFF',
-            }
-else:  # GTK
-    FACES = { 'times'  : 'Times',
-              'mono'   : 'Courier',
-              'helv'   : 'Helvetica',
-              'other'  : 'new century schoolbook',
-              'size'   : 12,
-              'lnsize' : 10,
-              'backcol': '#FFFFFF',
-            }
-
-
-class EditWindow(stc.StyledTextCtrl):
-    """EditWindow based on StyledTextCtrl."""
-
-    revision = __revision__
-
-    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize, style=wx.CLIP_CHILDREN | wx.SUNKEN_BORDER):
-        """Create EditWindow instance."""
-        stc.StyledTextCtrl.__init__(self, parent, id, pos, size, style)
-        self.__config()
-        stc.EVT_STC_UPDATEUI(self, id, self.OnUpdateUI)
-        dispatcher.connect(receiver=self._fontsizer, signal='FontIncrease')
-        dispatcher.connect(receiver=self._fontsizer, signal='FontDecrease')
-        dispatcher.connect(receiver=self._fontsizer, signal='FontDefault')
-
-    def _fontsizer(self, signal):
-        """Receiver for Font* signals."""
-        size = self.GetZoom()
-        if signal == 'FontIncrease':
-            size += 1
-        elif signal == 'FontDecrease':
-            size -= 1
-        elif signal == 'FontDefault':
-            size = 0
-        self.SetZoom(size)
-
-    def __config(self):
-        """Configure shell based on user preferences."""
-        self.SetMarginType(1, stc.STC_MARGIN_NUMBER)
-        self.SetMarginWidth(1, 40)
-
-        self.SetLexer(stc.STC_LEX_PYTHON)
-        self.SetKeyWords(0, ' '.join(keyword.kwlist))
-
-        self.setStyles(FACES)
-        self.SetViewWhiteSpace(False)
-        self.SetTabWidth(4)
-        self.SetUseTabs(False)
-        # Do we want to automatically pop up command completion options?
-        self.autoComplete = True
-        self.autoCompleteIncludeMagic = True
-        self.autoCompleteIncludeSingle = True
-        self.autoCompleteIncludeDouble = True
-        self.autoCompleteCaseInsensitive = True
-        self.AutoCompSetIgnoreCase(self.autoCompleteCaseInsensitive)
-        self.AutoCompSetAutoHide(False)
-        self.AutoCompStops(' .,;:([)]}\'"\\<>%^&+-=*/|`')
-        # Do we want to automatically pop up command argument help?
-        self.autoCallTip = True
-        self.CallTipSetBackground(wx.Colour(255, 255, 232))
-        self.SetWrapMode(False)
-        try:
-            self.SetEndAtLastLine(False)
-        except AttributeError:
-            pass
-
-    def setStyles(self, faces):
-        """Configure font size, typeface and color for lexer."""
-
-        # Default style
-        self.StyleSetSpec(stc.STC_STYLE_DEFAULT,
-                          "face:%(mono)s,size:%(size)d,back:%(backcol)s" % \
-                          faces)
-
-        self.StyleClearAll()
-
-        # Built in styles
-        self.StyleSetSpec(stc.STC_STYLE_LINENUMBER,
-                          "back:#C0C0C0,face:%(mono)s,size:%(lnsize)d" % faces)
-        self.StyleSetSpec(stc.STC_STYLE_CONTROLCHAR,
-                          "face:%(mono)s" % faces)
-        self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT,
-                          "fore:#0000FF,back:#FFFF88")
-        self.StyleSetSpec(stc.STC_STYLE_BRACEBAD,
-                          "fore:#FF0000,back:#FFFF88")
-
-        # Python styles
-        self.StyleSetSpec(stc.STC_P_DEFAULT,
-                          "face:%(mono)s" % faces)
-        self.StyleSetSpec(stc.STC_P_COMMENTLINE,
-                          "fore:#007F00,face:%(mono)s" % faces)
-        self.StyleSetSpec(stc.STC_P_NUMBER,
-                          "")
-        self.StyleSetSpec(stc.STC_P_STRING,
-                          "fore:#7F007F,face:%(mono)s" % faces)
-        self.StyleSetSpec(stc.STC_P_CHARACTER,
-                          "fore:#7F007F,face:%(mono)s" % faces)
-        self.StyleSetSpec(stc.STC_P_WORD,
-                          "fore:#00007F,bold")
-        self.StyleSetSpec(stc.STC_P_TRIPLE,
-                          "fore:#7F0000")
-        self.StyleSetSpec(stc.STC_P_TRIPLEDOUBLE,
-                          "fore:#000033,back:#FFFFE8")
-        self.StyleSetSpec(stc.STC_P_CLASSNAME,
-                          "fore:#0000FF,bold")
-        self.StyleSetSpec(stc.STC_P_DEFNAME,
-                          "fore:#007F7F,bold")
-        self.StyleSetSpec(stc.STC_P_OPERATOR,
-                          "")
-        self.StyleSetSpec(stc.STC_P_IDENTIFIER,
-                          "")
-        self.StyleSetSpec(stc.STC_P_COMMENTBLOCK,
-                          "fore:#7F7F7F")
-        self.StyleSetSpec(stc.STC_P_STRINGEOL,
-                          "fore:#000000,face:%(mono)s,back:#E0C0E0,eolfilled" % faces)
-
-    def OnUpdateUI(self, event):
-        """Check for matching braces."""
-        # If the auto-complete window is up let it do its thing.
-        if self.AutoCompActive() or self.CallTipActive():
-            return
-        braceAtCaret = -1
-        braceOpposite = -1
-        charBefore = None
-        caretPos = self.GetCurrentPos()
-        if caretPos > 0:
-            charBefore = self.GetCharAt(caretPos - 1)
-            styleBefore = self.GetStyleAt(caretPos - 1)
-
-        # Check before.
-        if charBefore and chr(charBefore) in '[]{}()' \
-        and styleBefore == stc.STC_P_OPERATOR:
-            braceAtCaret = caretPos - 1
-
-        # Check after.
-        if braceAtCaret < 0:
-            charAfter = self.GetCharAt(caretPos)
-            styleAfter = self.GetStyleAt(caretPos)
-            if charAfter and chr(charAfter) in '[]{}()' \
-            and styleAfter == stc.STC_P_OPERATOR:
-                braceAtCaret = caretPos
-
-        if braceAtCaret >= 0:
-            braceOpposite = self.BraceMatch(braceAtCaret)
-
-        if braceAtCaret != -1  and braceOpposite == -1:
-            self.BraceBadLight(braceAtCaret)
-        else:
-            self.BraceHighlight(braceAtCaret, braceOpposite)
-
-    def CanCopy(self):
-        """Return True if text is selected and can be copied."""
-        return self.GetSelectionStart() != self.GetSelectionEnd()
-
-    def CanCut(self):
-        """Return True if text is selected and can be cut."""
-        return self.CanCopy() and self.CanEdit()
-
-    def CanEdit(self):
-        """Return True if editing should succeed."""
-        return not self.GetReadOnly()
-
-    def CanPaste(self):
-        """Return True if pasting should succeed."""
-        return stc.StyledTextCtrl.CanPaste(self) and self.CanEdit()

wxPython/wxPython/py/filling.py

@@ -1,337 +0,0 @@
-"""Filling is the gui tree control through which a user can navigate
-the local namespace or any object."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-
-import dispatcher
-import editwindow
-import inspect
-import introspect
-import keyword
-import sys
-import types
-from version import VERSION
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-COMMONTYPES = [getattr(types, t) for t in dir(types) \
-               if not t.startswith('_') \
-               and t not in ('ClassType', 'InstanceType', 'ModuleType')]
-
-DOCTYPES = ('BuiltinFunctionType', 'BuiltinMethodType', 'ClassType',
-            'FunctionType', 'GeneratorType', 'InstanceType',
-            'LambdaType', 'MethodType', 'ModuleType',
-            'UnboundMethodType', 'method-wrapper')
-
-SIMPLETYPES = [getattr(types, t) for t in dir(types) \
-               if not t.startswith('_') and t not in DOCTYPES]
-
-del t
-
-try:
-    COMMONTYPES.append(type(''.__repr__))  # Method-wrapper in version 2.2.x.
-except AttributeError:
-    pass
-
-
-class FillingTree(wx.TreeCtrl):
-    """FillingTree based on TreeCtrl."""
-    
-    name = 'Filling Tree'
-    revision = __revision__
-
-    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize, style=wx.TR_DEFAULT_STYLE,
-                 rootObject=None, rootLabel=None, rootIsNamespace=False,
-                 static=False):
-        """Create FillingTree instance."""
-        wx.TreeCtrl.__init__(self, parent, id, pos, size, style)
-        self.rootIsNamespace = rootIsNamespace
-        import __main__
-        if rootObject is None:
-            rootObject = __main__.__dict__
-            self.rootIsNamespace = True
-        if rootObject is __main__.__dict__ and rootLabel is None:
-            rootLabel = 'locals()'
-        if not rootLabel:
-            rootLabel = 'Ingredients'
-        rootData = wx.TreeItemData(rootObject)
-        self.item = self.root = self.AddRoot(rootLabel, -1, -1, rootData)
-        self.SetItemHasChildren(self.root, self.objHasChildren(rootObject))
-        wx.EVT_TREE_ITEM_EXPANDING(self, self.GetId(), self.OnItemExpanding)
-        wx.EVT_TREE_ITEM_COLLAPSED(self, self.GetId(), self.OnItemCollapsed)
-        wx.EVT_TREE_SEL_CHANGED(self, self.GetId(), self.OnSelChanged)
-        wx.EVT_TREE_ITEM_ACTIVATED(self, self.GetId(), self.OnItemActivated)
-        if not static:
-            dispatcher.connect(receiver=self.push, signal='Interpreter.push')
-
-    def push(self, command, more):
-        """Receiver for Interpreter.push signal."""
-        self.display()
-
-    def OnItemExpanding(self, event):
-        """Add children to the item."""
-        busy = wx.BusyCursor()
-        item = event.GetItem()
-        if self.IsExpanded(item):
-            return
-        self.addChildren(item)
-#        self.SelectItem(item)
-
-    def OnItemCollapsed(self, event):
-        """Remove all children from the item."""
-        busy = wx.BusyCursor()
-        item = event.GetItem()
-#        self.CollapseAndReset(item)
-#        self.DeleteChildren(item)
-#        self.SelectItem(item)
-
-    def OnSelChanged(self, event):
-        """Display information about the item."""
-        busy = wx.BusyCursor()
-        self.item = event.GetItem()
-        self.display()
-
-    def OnItemActivated(self, event):
-        """Launch a DirFrame."""
-        item = event.GetItem()
-        text = self.getFullName(item)
-        obj = self.GetPyData(item)
-        frame = FillingFrame(parent=self, size=(600, 100), rootObject=obj,
-                             rootLabel=text, rootIsNamespace=False)
-        frame.Show()
-
-    def objHasChildren(self, obj):
-        """Return true if object has children."""
-        if self.objGetChildren(obj):
-            return True
-        else:
-            return False
-
-    def objGetChildren(self, obj):
-        """Return dictionary with attributes or contents of object."""
-        busy = wx.BusyCursor()
-        otype = type(obj)
-        if otype is types.DictType \
-        or str(otype)[17:23] == 'BTrees' and hasattr(obj, 'keys'):
-            return obj
-        d = {}
-        if otype is types.ListType or otype is types.TupleType:
-            for n in range(len(obj)):
-                key = '[' + str(n) + ']'
-                d[key] = obj[n]
-        if otype not in COMMONTYPES:
-            for key in introspect.getAttributeNames(obj):
-                # Believe it or not, some attributes can disappear,
-                # such as the exc_traceback attribute of the sys
-                # module. So this is nested in a try block.
-                try:
-                    d[key] = getattr(obj, key)
-                except:
-                    pass
-        return d
-
-    def addChildren(self, item):
-        self.DeleteChildren(item)
-        obj = self.GetPyData(item)
-        children = self.objGetChildren(obj)
-        if not children:
-            return
-        keys = children.keys()
-        keys.sort(lambda x, y: cmp(str(x).lower(), str(y).lower()))
-        for key in keys:
-            itemtext = str(key)
-            # Show string dictionary items with single quotes, except
-            # for the first level of items, if they represent a
-            # namespace.
-            if type(obj) is types.DictType \
-            and type(key) is types.StringType \
-            and (item != self.root \
-                 or (item == self.root and not self.rootIsNamespace)):
-                itemtext = repr(key)
-            child = children[key]
-            data = wx.TreeItemData(child)
-            branch = self.AppendItem(parent=item, text=itemtext, data=data)
-            self.SetItemHasChildren(branch, self.objHasChildren(child))
-
-    def display(self):
-        item = self.item
-        if self.IsExpanded(item):
-            self.addChildren(item)
-        self.setText('')
-        obj = self.GetPyData(item)
-        if wx.Platform == '__WXMSW__':
-            if obj is None: # Windows bug fix.
-                return
-        self.SetItemHasChildren(item, self.objHasChildren(obj))
-        otype = type(obj)
-        text = ''
-        text += self.getFullName(item)
-        text += '\n\nType: ' + str(otype)
-        try:
-            value = str(obj)
-        except:
-            value = ''
-        if otype is types.StringType or otype is types.UnicodeType:
-            value = repr(obj)
-        text += '\n\nValue: ' + value
-        if otype not in SIMPLETYPES:
-            try:
-                text += '\n\nDocstring:\n\n"""' + \
-                        inspect.getdoc(obj).strip() + '"""'
-            except:
-                pass
-        if otype is types.InstanceType:
-            try:
-                text += '\n\nClass Definition:\n\n' + \
-                        inspect.getsource(obj.__class__)
-            except:
-                pass
-        else:
-            try:
-                text += '\n\nSource Code:\n\n' + \
-                        inspect.getsource(obj)
-            except:
-                pass
-        self.setText(text)
-
-    def getFullName(self, item, partial=''):
-        """Return a syntactically proper name for item."""
-        name = self.GetItemText(item)
-        parent = None
-        obj = None
-        if item != self.root:
-            parent = self.GetItemParent(item)
-            obj = self.GetPyData(parent)
-        # Apply dictionary syntax to dictionary items, except the root
-        # and first level children of a namepace.
-        if (type(obj) is types.DictType \
-            or str(type(obj))[17:23] == 'BTrees' \
-            and hasattr(obj, 'keys')) \
-        and ((item != self.root and parent != self.root) \
-            or (parent == self.root and not self.rootIsNamespace)):
-            name = '[' + name + ']'
-        # Apply dot syntax to multipart names.
-        if partial:
-            if partial[0] == '[':
-                name += partial
-            else:
-                name += '.' + partial
-        # Repeat for everything but the root item
-        # and first level children of a namespace.
-        if (item != self.root and parent != self.root) \
-        or (parent == self.root and not self.rootIsNamespace):
-            name = self.getFullName(parent, partial=name)
-        return name
-
-    def setText(self, text):
-        """Display information about the current selection."""
-
-        # This method will likely be replaced by the enclosing app to
-        # do something more interesting, like write to a text control.
-        print text
-
-    def setStatusText(self, text):
-        """Display status information."""
-
-        # This method will likely be replaced by the enclosing app to
-        # do something more interesting, like write to a status bar.
-        print text
-
-
-class FillingText(editwindow.EditWindow):
-    """FillingText based on StyledTextCtrl."""
-
-    name = 'Filling Text'
-    revision = __revision__
-
-    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize, style=wx.CLIP_CHILDREN,
-                 static=False):
-        """Create FillingText instance."""
-        editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
-        # Configure various defaults and user preferences.
-        self.SetReadOnly(True)
-        self.SetWrapMode(True)
-        self.SetMarginWidth(1, 0)
-        if not static:
-            dispatcher.connect(receiver=self.push, signal='Interpreter.push')
-
-    def push(self, command, more):
-        """Receiver for Interpreter.push signal."""
-        self.Refresh()
-
-    def SetText(self, *args, **kwds):
-        self.SetReadOnly(False)
-        editwindow.EditWindow.SetText(self, *args, **kwds)
-        self.SetReadOnly(True)
-
-
-class Filling(wx.SplitterWindow):
-    """Filling based on wxSplitterWindow."""
-
-    name = 'Filling'
-    revision = __revision__
-
-    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize, style=wx.SP_3D,
-                 name='Filling Window', rootObject=None,
-                 rootLabel=None, rootIsNamespace=False, static=False):
-        """Create a Filling instance."""
-        wx.SplitterWindow.__init__(self, parent, id, pos, size, style, name)
-        self.tree = FillingTree(parent=self, rootObject=rootObject,
-                                rootLabel=rootLabel,
-                                rootIsNamespace=rootIsNamespace,
-                                static=static)
-        self.text = FillingText(parent=self, static=static)
-        self.SplitVertically(self.tree, self.text, 130)
-        self.SetMinimumPaneSize(1)
-        # Override the filling so that descriptions go to FillingText.
-        self.tree.setText = self.text.SetText
-        # Display the root item.
-##        self.tree.SelectItem(self.tree.root)
-        self.tree.display()
-
-
-class FillingFrame(wx.Frame):
-    """Frame containing the namespace tree component."""
-
-    name = 'Filling Frame'
-    revision = __revision__
-
-    def __init__(self, parent=None, id=-1, title='PyFilling',
-                 pos=wx.DefaultPosition, size=(600, 400),
-                 style=wx.DEFAULT_FRAME_STYLE, rootObject=None,
-                 rootLabel=None, rootIsNamespace=False, static=False):
-        """Create FillingFrame instance."""
-        wx.Frame.__init__(self, parent, id, title, pos, size, style)
-        intro = 'PyFilling - The Tastiest Namespace Inspector'
-        self.CreateStatusBar()
-        self.SetStatusText(intro)
-        import images
-        self.SetIcon(images.getPyIcon())
-        self.filling = Filling(parent=self, rootObject=rootObject,
-                               rootLabel=rootLabel,
-                               rootIsNamespace=rootIsNamespace,
-                               static=static)
-        # Override so that status messages go to the status bar.
-        self.filling.tree.setStatusText = self.SetStatusText
-
-
-class App(wx.App):
-    """PyFilling standalone application."""
-
-    def OnInit(self):
-        wx.InitAllImageHandlers()
-        self.fillingFrame = FillingFrame()
-        self.fillingFrame.Show(True)
-        self.SetTopWindow(self.fillingFrame)
-        return True

wxPython/wxPython/py/frame.py

@@ -1,354 +0,0 @@
-"""Base frame with menu."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-from version import VERSION
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-ID_NEW = wx.ID_NEW
-ID_OPEN = wx.ID_OPEN
-ID_REVERT = wx.ID_REVERT
-ID_CLOSE = wx.ID_CLOSE
-ID_SAVE = wx.ID_SAVE
-ID_SAVEAS = wx.ID_SAVEAS
-ID_PRINT = wx.ID_PRINT
-ID_EXIT = wx.ID_EXIT
-ID_UNDO = wx.ID_UNDO
-ID_REDO = wx.ID_REDO
-ID_CUT = wx.ID_CUT
-ID_COPY = wx.ID_COPY
-ID_PASTE = wx.ID_PASTE
-ID_CLEAR = wx.ID_CLEAR
-ID_SELECTALL = wx.ID_SELECTALL
-ID_ABOUT = wx.ID_ABOUT
-ID_AUTOCOMP = wx.NewId()
-ID_AUTOCOMP_SHOW = wx.NewId()
-ID_AUTOCOMP_MAGIC = wx.NewId()
-ID_AUTOCOMP_SINGLE = wx.NewId()
-ID_AUTOCOMP_DOUBLE = wx.NewId()
-ID_CALLTIPS = wx.NewId()
-ID_CALLTIPS_SHOW = wx.NewId()
-ID_COPY_PLUS = wx.NewId()
-ID_NAMESPACE = wx.NewId()
-ID_PASTE_PLUS = wx.NewId()
-ID_WRAP = wx.NewId()
-
-
-class Frame(wx.Frame):
-    """Frame with standard menu items."""
-
-    revision = __revision__
-
-    def __init__(self, parent=None, id=-1, title='Editor',
-                 pos=wx.DefaultPosition, size=wx.DefaultSize, 
-                 style=wx.DEFAULT_FRAME_STYLE):
-        """Create a Frame instance."""
-        wx.Frame.__init__(self, parent, id, title, pos, size, style)
-        self.CreateStatusBar()
-        self.SetStatusText('Frame')
-        import images
-        self.SetIcon(images.getPyIcon())
-        self.__createMenus()
-        wx.EVT_CLOSE(self, self.OnClose)
-
-    def OnClose(self, event):
-        """Event handler for closing."""
-        self.Destroy()
-
-    def __createMenus(self):
-        m = self.fileMenu = wx.Menu()
-        m.Append(ID_NEW, '&New \tCtrl+N',
-                 'New file')
-        m.Append(ID_OPEN, '&Open... \tCtrl+O',
-                 'Open file')
-        m.AppendSeparator()
-        m.Append(ID_REVERT, '&Revert \tCtrl+R',
-                 'Revert to last saved version')
-        m.Append(ID_CLOSE, '&Close \tCtrl+W',
-                 'Close file')
-        m.AppendSeparator()
-        m.Append(ID_SAVE, '&Save... \tCtrl+S',
-                 'Save file')
-        m.Append(ID_SAVEAS, 'Save &As \tShift+Ctrl+S',
-                 'Save file with new name')
-        m.AppendSeparator()
-        m.Append(ID_PRINT, '&Print... \tCtrl+P',
-                 'Print file')
-        m.AppendSeparator()
-        m.Append(ID_NAMESPACE, '&Update Namespace \tShift+Ctrl+N',
-                 'Update namespace for autocompletion and calltips')
-        m.AppendSeparator()
-        m.Append(ID_EXIT, 'E&xit', 'Exit Program')
-
-        m = self.editMenu = wx.Menu()
-        m.Append(ID_UNDO, '&Undo \tCtrl+Z',
-                 'Undo the last action')
-        m.Append(ID_REDO, '&Redo \tCtrl+Y',
-                 'Redo the last undone action')
-        m.AppendSeparator()
-        m.Append(ID_CUT, 'Cu&t \tCtrl+X',
-                 'Cut the selection')
-        m.Append(ID_COPY, '&Copy \tCtrl+C',
-                 'Copy the selection')
-        m.Append(ID_COPY_PLUS, 'Cop&y Plus \tShift+Ctrl+C',
-                 'Copy the selection - retaining prompts')
-        m.Append(ID_PASTE, '&Paste \tCtrl+V', 'Paste from clipboard')
-        m.Append(ID_PASTE_PLUS, 'Past&e Plus \tShift+Ctrl+V',
-                 'Paste and run commands')
-        m.AppendSeparator()
-        m.Append(ID_CLEAR, 'Cle&ar',
-                 'Delete the selection')
-        m.Append(ID_SELECTALL, 'Select A&ll \tCtrl+A',
-                 'Select all text')
-
-        m = self.autocompMenu = wx.Menu()
-        m.Append(ID_AUTOCOMP_SHOW, 'Show Auto Completion',
-                 'Show auto completion list', 1)
-        m.Append(ID_AUTOCOMP_MAGIC, 'Include Magic Attributes',
-                 'Include attributes visible to __getattr__ and __setattr__',
-                 1)
-        m.Append(ID_AUTOCOMP_SINGLE, 'Include Single Underscores',
-                 'Include attibutes prefixed by a single underscore', 1)
-        m.Append(ID_AUTOCOMP_DOUBLE, 'Include Double Underscores',
-                 'Include attibutes prefixed by a double underscore', 1)
-
-        m = self.calltipsMenu = wx.Menu()
-        m.Append(ID_CALLTIPS_SHOW, 'Show Call Tips',
-                 'Show call tips with argument signature and docstring', 1)
-
-        m = self.optionsMenu = wx.Menu()
-        m.AppendMenu(ID_AUTOCOMP, '&Auto Completion', self.autocompMenu,
-                     'Auto Completion Options')
-        m.AppendMenu(ID_CALLTIPS, '&Call Tips', self.calltipsMenu,
-                     'Call Tip Options')
-        m.Append(ID_WRAP, '&Wrap Lines',
-                 'Wrap lines at right edge', 1)
-
-        m = self.helpMenu = wx.Menu()
-        m.AppendSeparator()
-        m.Append(ID_ABOUT, '&About...', 'About this program')
-
-        b = self.menuBar = wx.MenuBar()
-        b.Append(self.fileMenu, '&File')
-        b.Append(self.editMenu, '&Edit')
-        b.Append(self.optionsMenu, '&Options')
-        b.Append(self.helpMenu, '&Help')
-        self.SetMenuBar(b)
-
-        wx.EVT_MENU(self, ID_NEW, self.OnFileNew)
-        wx.EVT_MENU(self, ID_OPEN, self.OnFileOpen)
-        wx.EVT_MENU(self, ID_REVERT, self.OnFileRevert)
-        wx.EVT_MENU(self, ID_CLOSE, self.OnFileClose)
-        wx.EVT_MENU(self, ID_SAVE, self.OnFileSave)
-        wx.EVT_MENU(self, ID_SAVEAS, self.OnFileSaveAs)
-        wx.EVT_MENU(self, ID_NAMESPACE, self.OnFileUpdateNamespace)
-        wx.EVT_MENU(self, ID_PRINT, self.OnFilePrint)
-        wx.EVT_MENU(self, ID_EXIT, self.OnExit)
-        wx.EVT_MENU(self, ID_UNDO, self.OnUndo)
-        wx.EVT_MENU(self, ID_REDO, self.OnRedo)
-        wx.EVT_MENU(self, ID_CUT, self.OnCut)
-        wx.EVT_MENU(self, ID_COPY, self.OnCopy)
-        wx.EVT_MENU(self, ID_COPY_PLUS, self.OnCopyPlus)
-        wx.EVT_MENU(self, ID_PASTE, self.OnPaste)
-        wx.EVT_MENU(self, ID_PASTE_PLUS, self.OnPastePlus)
-        wx.EVT_MENU(self, ID_CLEAR, self.OnClear)
-        wx.EVT_MENU(self, ID_SELECTALL, self.OnSelectAll)
-        wx.EVT_MENU(self, ID_ABOUT, self.OnAbout)
-        wx.EVT_MENU(self, ID_AUTOCOMP_SHOW, self.OnAutoCompleteShow)
-        wx.EVT_MENU(self, ID_AUTOCOMP_MAGIC, self.OnAutoCompleteMagic)
-        wx.EVT_MENU(self, ID_AUTOCOMP_SINGLE, self.OnAutoCompleteSingle)
-        wx.EVT_MENU(self, ID_AUTOCOMP_DOUBLE, self.OnAutoCompleteDouble)
-        wx.EVT_MENU(self, ID_CALLTIPS_SHOW, self.OnCallTipsShow)
-        wx.EVT_MENU(self, ID_WRAP, self.OnWrap)
-
-        wx.EVT_UPDATE_UI(self, ID_NEW, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_OPEN, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_REVERT, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_CLOSE, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_SAVE, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_SAVEAS, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_NAMESPACE, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_PRINT, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_UNDO, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_REDO, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_CUT, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_COPY, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_COPY_PLUS, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_PASTE, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_PASTE_PLUS, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_CLEAR, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_SELECTALL, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_AUTOCOMP_SHOW, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_AUTOCOMP_MAGIC, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_AUTOCOMP_SINGLE, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_AUTOCOMP_DOUBLE, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_CALLTIPS_SHOW, self.OnUpdateMenu)
-        wx.EVT_UPDATE_UI(self, ID_WRAP, self.OnUpdateMenu)
-
-    def OnFileNew(self, event):
-        self.bufferNew()
-
-    def OnFileOpen(self, event):
-        self.bufferOpen()
-
-    def OnFileRevert(self, event):
-        self.bufferRevert()
-
-    def OnFileClose(self, event):
-        self.bufferClose()
-
-    def OnFileSave(self, event):
-        self.bufferSave()
-
-    def OnFileSaveAs(self, event):
-        self.bufferSaveAs()
-
-    def OnFileUpdateNamespace(self, event):
-        self.updateNamespace()
-
-    def OnFilePrint(self, event):
-        self.bufferPrint()
-
-    def OnExit(self, event):
-        self.Close(False)
-
-    def OnUndo(self, event):
-        win = wx.Window_FindFocus()
-        win.Undo()
-
-    def OnRedo(self, event):
-        win = wx.Window_FindFocus()
-        win.Redo()
-
-    def OnCut(self, event):
-        win = wx.Window_FindFocus()
-        win.Cut()
-
-    def OnCopy(self, event):
-        win = wx.Window_FindFocus()
-        win.Copy()
-
-    def OnCopyPlus(self, event):
-        win = wx.Window_FindFocus()
-        win.CopyWithPrompts()
-
-    def OnPaste(self, event):
-        win = wx.Window_FindFocus()
-        win.Paste()
-
-    def OnPastePlus(self, event):
-        win = wx.Window_FindFocus()
-        win.PasteAndRun()
-
-    def OnClear(self, event):
-        win = wx.Window_FindFocus()
-        win.Clear()
-
-    def OnSelectAll(self, event):
-        win = wx.Window_FindFocus()
-        win.SelectAll()
-
-    def OnAbout(self, event):
-        """Display an About window."""
-        title = 'About'
-        text = 'Your message here.'
-        dialog = wx.MessageDialog(self, text, title,
-                                  wx.OK | wx.ICON_INFORMATION)
-        dialog.ShowModal()
-        dialog.Destroy()
-
-    def OnAutoCompleteShow(self, event):
-        win = wx.Window_FindFocus()
-        win.autoComplete = event.IsChecked()
-
-    def OnAutoCompleteMagic(self, event):
-        win = wx.Window_FindFocus()
-        win.autoCompleteIncludeMagic = event.IsChecked()
-
-    def OnAutoCompleteSingle(self, event):
-        win = wx.Window_FindFocus()
-        win.autoCompleteIncludeSingle = event.IsChecked()
-
-    def OnAutoCompleteDouble(self, event):
-        win = wx.Window_FindFocus()
-        win.autoCompleteIncludeDouble = event.IsChecked()
-
-    def OnCallTipsShow(self, event):
-        win = wx.Window_FindFocus()
-        win.autoCallTip = event.IsChecked()
-
-    def OnWrap(self, event):
-        win = wx.Window_FindFocus()
-        win.SetWrapMode(event.IsChecked())
-
-    def OnUpdateMenu(self, event):
-        """Update menu items based on current status and context."""
-        win = wx.Window_FindFocus()
-        id = event.GetId()
-        event.Enable(True)
-        try:
-            if id == ID_NEW:
-                event.Enable(hasattr(self, 'bufferNew'))
-            elif id == ID_OPEN:
-                event.Enable(hasattr(self, 'bufferOpen'))
-            elif id == ID_REVERT:
-                event.Enable(hasattr(self, 'bufferRevert')
-                             and self.hasBuffer())
-            elif id == ID_CLOSE:
-                event.Enable(hasattr(self, 'bufferClose')
-                             and self.hasBuffer())
-            elif id == ID_SAVE:
-                event.Enable(hasattr(self, 'bufferSave')
-                             and self.bufferHasChanged())
-            elif id == ID_SAVEAS:
-                event.Enable(hasattr(self, 'bufferSaveAs')
-                             and self.hasBuffer())
-            elif id == ID_NAMESPACE:
-                event.Enable(hasattr(self, 'updateNamespace')
-                             and self.hasBuffer())
-            elif id == ID_PRINT:
-                event.Enable(hasattr(self, 'bufferPrint')
-                             and self.hasBuffer())
-            elif id == ID_UNDO:
-                event.Enable(win.CanUndo())
-            elif id == ID_REDO:
-                event.Enable(win.CanRedo())
-            elif id == ID_CUT:
-                event.Enable(win.CanCut())
-            elif id == ID_COPY:
-                event.Enable(win.CanCopy())
-            elif id == ID_COPY_PLUS:
-                event.Enable(win.CanCopy() and hasattr(win, 'CopyWithPrompts'))
-            elif id == ID_PASTE:
-                event.Enable(win.CanPaste())
-            elif id == ID_PASTE_PLUS:
-                event.Enable(win.CanPaste() and hasattr(win, 'PasteAndRun'))
-            elif id == ID_CLEAR:
-                event.Enable(win.CanCut())
-            elif id == ID_SELECTALL:
-                event.Enable(hasattr(win, 'SelectAll'))
-            elif id == ID_AUTOCOMP_SHOW:
-                event.Check(win.autoComplete)
-            elif id == ID_AUTOCOMP_MAGIC:
-                event.Check(win.autoCompleteIncludeMagic)
-            elif id == ID_AUTOCOMP_SINGLE:
-                event.Check(win.autoCompleteIncludeSingle)
-            elif id == ID_AUTOCOMP_DOUBLE:
-                event.Check(win.autoCompleteIncludeDouble)
-            elif id == ID_CALLTIPS_SHOW:
-                event.Check(win.autoCallTip)
-            elif id == ID_WRAP:
-                event.Check(win.GetWrapMode())
-            else:
-                event.Enable(False)
-        except AttributeError:
-            # This menu option is not supported in the current context.
-            event.Enable(False)

wxPython/wxPython/py/images.py

@@ -1,72 +0,0 @@
-"""Support for icons."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import wx
-import cStringIO
-
-
-def getPyIcon():
-    icon = wx.EmptyIcon()
-    icon.CopyFromBitmap(getPyBitmap())
-    return icon
-
-def getPyBitmap():
-    return wx.BitmapFromImage(getPyImage())
-
-def getPyImage():
-    stream = cStringIO.StringIO(getPyData())
-    return wx.ImageFromStream(stream)
-
-def getPyData():
-    return \
-'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
-\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x04\
-\x95IDATx\x9c\xed\x97?lSG\x1c\xc7?\x97\x98\xd8Q\xa3\xdeY\xa2j\x06\xa4\xf7"QJ\
-\xbb<3@\x01\xa9\xc2\x0c\xa8!\x1d\x1c6\xcaB\xa8D[uI2\xf4\x8f\xe8\x103\xb4\xa2\
-,5\x0b\x03\x032C\xab\xc0\x92dh:t\xc0)*E\xcd@<Q\x01Rl\t\xd4D\xaa\xe4{R\xd0{&\
-\xa5\xd7\xe1\xfc\xec\xe7\xfciR\x08e\xe9O\xb2\xee|\xfe\xbd\xfb}~\xdf\xdf\xbd\
-\xbb\xb3PJ\xf1"\xad\xe3\x85F\xff\x1f\xe0y\x03h\xad\xcdA\xc7~\xb4\xd6f-\x9f\
-\xc4\xf3\x0c>Y\x1c#\x97\xddCUk\xf4B\x8d3\x9f\x8d\x9a\x9bU%\xe2~b\xab\xdf\x82\
-\x83N+\xd3\xe92\\\x1f\xcf\x93\xdd\x9f\xa1\xaa5\x95\xf9\n\xe7\xf3y\xe2\x10[V\
-\x82H\xe6\xd3G\x1dN\xf7\xc3\xa7\xc7a\xc0\x83\xc3\xc7\xf3\xcc\xcc\xcd\xe3(\
-\x85\xdb\xe7\xf2\xc9\xe8X\x1b\xe43+\x10\xd5\xb6\x94\x87Z\xe8\x90NU\x91I@\x00\
-\x06\xbe\x18\xb7J\x98\xca$`\x98\xb9]&{,\x8fRV\x85\xa7V@k\x9bq)o\x83+\t\xe9T\
-\xd5f\x95\x02\x91\xb4~_\r\xd9\xb6\xbaP\x03\x04n\x9f\xcbDa\xb8\t\xfe\xaf\x17a\
-<\xe3\xc8\x94lo\x9b\xd6\xa8\xf4\x80\x07\xb7o\xcd\xe0\x0c\x0e\xa2R\x8a\xb4\
-\x93n\xbal\x1a`e\xe0U\xc1\xd6\xb0\xb8\n\x99\x91"\x93\xaf\xba\xe4\x0ed\xda|6,\
-\x81\xd6\xda\x9c|\xab]\xea\xcd\x04\x8f\x9b\t\xad\nz\xa1\x02\x80\xdb\xe7R\x1a\
-\xcf\xa3\xb56\xeb\x02D5\x9e\xf8\xdc\xe1T\xff\xd3\x05\x8e\x82\x83U\xe1Z\xb1\
-\x18\x9b\xbf\x06\xacQ\x82H\xea\x01/Z@Ut\x08R\xb4$}\x16\xd3\x81A&%\xde\xee\
-\xbev\x80x\xe0]{\xb2\x1cR\xa5\xe6C*\xb5\xf1\xc4Q\xa6"e\xfbQ\x1b\x8dE\xe6\x87\
->\xaa[Q\xadi\x0b\xb0r\x8f\x9e.\xc3t\xb9\xc4]\xaf5\xf6\xfe\xdb\xddt&\x02\xfa\
-\x9c\xf5\x01\xe2A\xa2\xbeX\x01>]ntR\x12\xe3[\x00\x01\x98\x89\x11[_\xed\xafn\
-\xab\x81U\xa0\xe7I7\x00\x97o\x04\xcd\x89\x06<;\xe9\x80\x07]i\x97\xc17\x1f\
-\xd2\xd3\x91`\xe9\xaf?\x01p^Y\x06Z\n\xfau8?a\xfb]i\x97\xec\xa1\x8c\x05(|\xd8\
-N\xba\xb3\xab\x87\xfb\x8f\x97\xd8\xd9\xd5\x03\xc0\xfd\xc7K\xec\xd8\xd6\xdd\
-\xfc\xfd\xc1r\xd0\xf4\x01\xda~\x03H\xf4\x04\xd4j :\xb75\xc7\xae\xfd\xbcLW\
-\xda\xa5\xf0M\x1e\t\xcc\xcc\xcdq\xa9P@\x8c\xf5fL\xdaHF\x16g\x9a\x19\xad\xcc\
-\xee\xcb\xa3\n\xad\xa1\xda\xf1\x08\xef\xe5\x97x\xf8\xc8f\xf8\xc7\x93:\xdb;\
-\x93M\xc8\x08j\xc7\xb6n\x1e,\x07m`\x97o\x04|;>\xd1T\xc4\x17\x8a\x13\xb9\xc3\
-\x88\x01\x0fs\xa4\x9cc}\xf3A\x190\x82\x1f\xddR{-\x1bV\xfc\xd8f\xba\xbd3\xd9\
-\x06\x15\x07\xbb\xf8\xd3\x12\xdf]-"\x93\xb2\xb1C*\xde\xcd\x1d\xde\xccN(\xc1\
-\xae\x17"\xd0#+<j\x17m{\xcd\x9bj\x00.\xaf\xf0Xb\xb8\xdfA\xa6\x14\x18\x03\x06\
-\xb4o\xcf\x8d\xc4\xbervc\x86M\xdaz\x80\x00\x95T\x19?\xd0 @&%~c\xbc\xe3W\xaf\
-\xb4e\x00\xffh\xc6@\xbd\x11\xbc\xde\x1a\xfe\xef.\xa5\xa2q4\n0\x81\xad\xe9\
-\xae7<\x12\xaf\xf5\xc2hy\xaa\xe97\x9cS\\\x98\xb2\x0e\x03\xb1\xcdhW\xdaC\x1a\
-\xa0\xa2\xa0\x0e"\x14`\xb0Y\x85\x1b\x1f\x12\xaa7\x03)\xd9\x84\xa8\xccW\xb8{\
-\xa7L\xe2\xde\x02\x94\xc6Gp_\xcf\x80\x90\x98\xd0g\xf4\xac\x82Pc\x82\x1a\xd5\
-\x10\x08}&\xa7J\xcc\xde.1]m\x80\xf6+\xee\xfd\xae\x9bo\xc4\xf0;\x80\xef\x90\
-\x0e\x04\x06`Q!\x02\x05\xc2 \xb5\xc2\x95\x15d\xb4C&[\xf7\xd2\x04\x80\xbb\xdb\
-\x9e\xd1\x8e\x02\x90\xd8\xd4$ I\x87\x80\xf1\xf1\xdc!4\xc3\x88\x94}\xd8,TH\
-\xbb.5m\xf0C\x9f3\x1f\r\x01\x96.\x82\x1a9\xe9Q\xb8\xd2\xf8\xf25\x0c\xbe\xe7#\
-\x92\x12\x1d[\x03\t\x00E\xf4\xa6\t\xaaZ7`$\x18\x90\xf8\xf8\x80JK\x94\xa1\x01\
-\x07\xb8\x0e~X\xc3\xed\x16\xf8)\xf8~j\x12B\rI\x89_\xf7!0 \x04\xf9Q\xc0\x18\
-\x0c\xd1i\xea\x13\xb7\x04\xc0\x89\x93C\xabj\xb6\xf7@\x96\xd9_J|0:\x86R\n\xb7\
-\xd7@\xaa%\x9d\xa3$\xba.\x90RA]\xe3\x87\x1a\x89\xdd\xefeR\xc2\x1a\'\xa8\x1f\
-\x82\x0e-@m\xd1\xde\x076\xbc\x15\x97~(\x9a\x89b\x9e\xd9[s\xab!\xf7g\xd6\x1c\
-\x8f\xdb\xbel\x8e\xa1S\xc7\xda\xc6\xe6\xee\xccs\xe9\xdcYnV\x95\xd8\xf2?&q+\
-\x9c\x1b1\xf3\xbf\xcd3{\xfdJ\xdb\xf8\xde\xfd\x19.\\\xad\x08\x80\xbf\x01\xd1\
-\x86\xfa\x8b\xc7\xc0\xc8\xb7\x00\x00\x00\x00IEND\xaeB`\x82' 

wxPython/wxPython/py/interpreter.py

@@ -1,125 +0,0 @@
-"""Interpreter executes Python commands."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import os
-import sys
-from code import InteractiveInterpreter
-import dispatcher
-import introspect
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class Interpreter(InteractiveInterpreter):
-    """Interpreter based on code.InteractiveInterpreter."""
-    
-    revision = __revision__
-    
-    def __init__(self, locals=None, rawin=None, 
-                 stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr):
-        """Create an interactive interpreter object."""
-        InteractiveInterpreter.__init__(self, locals=locals)
-        self.stdin = stdin
-        self.stdout = stdout
-        self.stderr = stderr
-        if rawin:
-            import __builtin__
-            __builtin__.raw_input = rawin
-            del __builtin__
-        copyright = 'Type "help", "copyright", "credits" or "license"'
-        copyright += ' for more information.'
-        self.introText = 'Python %s on %s%s%s' % \
-                         (sys.version, sys.platform, os.linesep, copyright)
-        try:
-            sys.ps1
-        except AttributeError:
-            sys.ps1 = '>>> '
-        try:
-            sys.ps2
-        except AttributeError:
-            sys.ps2 = '... '
-        self.more = 0
-        # List of lists to support recursive push().
-        self.commandBuffer = []
-        self.startupScript = os.environ.get('PYTHONSTARTUP')
-
-    def push(self, command):
-        """Send command to the interpreter to be executed.
-        
-        Because this may be called recursively, we append a new list
-        onto the commandBuffer list and then append commands into
-        that.  If the passed in command is part of a multi-line
-        command we keep appending the pieces to the last list in
-        commandBuffer until we have a complete command. If not, we
-        delete that last list."""
-        command = str(command)  # In case the command is unicode.
-        if not self.more:
-            try: del self.commandBuffer[-1]
-            except IndexError: pass
-        if not self.more: self.commandBuffer.append([])
-        self.commandBuffer[-1].append(command)
-        source = '\n'.join(self.commandBuffer[-1])
-        more = self.more = self.runsource(source)
-        dispatcher.send(signal='Interpreter.push', sender=self,
-                        command=command, more=more, source=source)
-        return more
-        
-    def runsource(self, source):
-        """Compile and run source code in the interpreter."""
-        stdin, stdout, stderr = sys.stdin, sys.stdout, sys.stderr
-        sys.stdin, sys.stdout, sys.stderr = \
-                   self.stdin, self.stdout, self.stderr
-        more = InteractiveInterpreter.runsource(self, source)
-        # If sys.std* is still what we set it to, then restore it.
-        # But, if the executed source changed sys.std*, assume it was
-        # meant to be changed and leave it. Power to the people.
-        if sys.stdin == self.stdin:
-            sys.stdin = stdin
-        if sys.stdout == self.stdout:
-            sys.stdout = stdout
-        if sys.stderr == self.stderr:
-            sys.stderr = stderr
-        return more
-        
-    def getAutoCompleteKeys(self):
-        """Return list of auto-completion keycodes."""
-        return [ord('.')]
-
-    def getAutoCompleteList(self, command='', *args, **kwds):
-        """Return list of auto-completion options for a command.
-        
-        The list of options will be based on the locals namespace."""
-        stdin, stdout, stderr = sys.stdin, sys.stdout, sys.stderr
-        sys.stdin, sys.stdout, sys.stderr = \
-                   self.stdin, self.stdout, self.stderr
-        l = introspect.getAutoCompleteList(command, self.locals,
-                                           *args, **kwds)
-        sys.stdin, sys.stdout, sys.stderr = stdin, stdout, stderr
-        return l
-
-    def getCallTip(self, command='', *args, **kwds):
-        """Return call tip text for a command.
-        
-        Call tip information will be based on the locals namespace."""
-        return introspect.getCallTip(command, self.locals, *args, **kwds)
-
-
-class InterpreterAlaCarte(Interpreter):
-    """Demo Interpreter."""
-    
-    def __init__(self, locals, rawin, stdin, stdout, stderr, 
-                 ps1='main prompt', ps2='continuation prompt'):
-        """Create an interactive interpreter object."""
-        Interpreter.__init__(self, locals=locals, rawin=rawin, 
-                             stdin=stdin, stdout=stdout, stderr=stderr)
-        sys.ps1 = ps1
-        sys.ps2 = ps2
-
-   

wxPython/wxPython/py/introspect.py

@@ -1,363 +0,0 @@
-"""Provides a variety of introspective-type support functions for
-things like call tips and command auto completion."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from __future__ import nested_scopes
-
-import cStringIO
-import inspect
-import sys
-import tokenize
-import types
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-def getAutoCompleteList(command='', locals=None, includeMagic=1, 
-                        includeSingle=1, includeDouble=1):
-    """Return list of auto-completion options for command.
-    
-    The list of options will be based on the locals namespace."""
-    attributes = []
-    # Get the proper chunk of code from the command.
-    root = getRoot(command, terminator='.')
-    try:
-        if locals is not None:
-            object = eval(root, locals)
-        else:
-            object = eval(root)
-    except:
-        pass
-    else:
-        attributes = getAttributeNames(object, includeMagic, 
-                                       includeSingle, includeDouble)
-    return attributes
-    
-def getAttributeNames(object, includeMagic=1, includeSingle=1,
-                      includeDouble=1):
-    """Return list of unique attributes, including inherited, for object."""
-    attributes = []
-    dict = {}
-    if not hasattrAlwaysReturnsTrue(object):
-        # Add some attributes that don't always get picked up.  If
-        # they don't apply, they'll get filtered out at the end.
-        attributes += ['__bases__', '__class__', '__dict__', '__name__', 
-                       'func_closure', 'func_code', 'func_defaults', 
-                       'func_dict', 'func_doc', 'func_globals', 'func_name']
-    if includeMagic:
-        try: attributes += object._getAttributeNames()
-        except: pass
-    # Get all attribute names.
-    attrdict = getAllAttributeNames(object)
-    for attrlist in attrdict.values():
-        attributes += attrlist
-    # Remove duplicates from the attribute list.
-    for item in attributes:
-        dict[item] = None
-    attributes = dict.keys()
-    attributes.sort(lambda x, y: cmp(x.upper(), y.upper()))
-    if not includeSingle:
-        attributes = filter(lambda item: item[0]!='_' \
-                            or item[1]=='_', attributes)
-    if not includeDouble:
-        attributes = filter(lambda item: item[:2]!='__', attributes)
-    # Make sure we haven't picked up any bogus attributes somehow.
-    attributes = [attribute for attribute in attributes \
-                  if hasattr(object, attribute)]
-    return attributes
-
-def hasattrAlwaysReturnsTrue(object):
-    return hasattr(object, 'bogu5_123_aTTri8ute')
-
-def getAllAttributeNames(object):
-    """Return dict of all attributes, including inherited, for an object.
-    
-    Recursively walk through a class and all base classes.
-    """
-    attrdict = {}  # (object, technique, count): [list of attributes]
-    # !!!
-    # Do Not use hasattr() as a test anywhere in this function,
-    # because it is unreliable with remote objects: xmlrpc, soap, etc.
-    # They always return true for hasattr().
-    # !!!
-    try:
-        # Yes, this can fail if object is an instance of a class with
-        # __str__ (or __repr__) having a bug or raising an
-        # exception. :-(
-        key = str(object)
-    except:
-        key = 'anonymous'
-    # Wake up sleepy objects - a hack for ZODB objects in "ghost" state.
-    wakeupcall = dir(object)
-    del wakeupcall
-    # Get attributes available through the normal convention.
-    attributes = dir(object)
-    attrdict[(key, 'dir', len(attributes))] = attributes
-    # Get attributes from the object's dictionary, if it has one.
-    try:
-        attributes = object.__dict__.keys()
-        attributes.sort()
-    except:  # Must catch all because object might have __getattr__.
-        pass
-    else:
-        attrdict[(key, '__dict__', len(attributes))] = attributes
-    # For a class instance, get the attributes for the class.
-    try:
-        klass = object.__class__
-    except:  # Must catch all because object might have __getattr__.
-        pass
-    else:
-        if klass is object:
-            # Break a circular reference. This happens with extension
-            # classes.
-            pass
-        else:
-            attrdict.update(getAllAttributeNames(klass))
-    # Also get attributes from any and all parent classes.
-    try:
-        bases = object.__bases__
-    except:  # Must catch all because object might have __getattr__.
-        pass
-    else:
-        if isinstance(bases, types.TupleType):
-            for base in bases:
-                if type(base) is types.TypeType:
-                    # Break a circular reference. Happens in Python 2.2.
-                    pass
-                else:
-                    attrdict.update(getAllAttributeNames(base))
-    return attrdict
-
-def getCallTip(command='', locals=None):
-    """For a command, return a tuple of object name, argspec, tip text.
-    
-    The call tip information will be based on the locals namespace."""
-    calltip = ('', '', '')  # object name, argspec, tip text.
-    # Get the proper chunk of code from the command.
-    root = getRoot(command, terminator='(')
-    try:
-        if locals is not None:
-            object = eval(root, locals)
-        else:
-            object = eval(root)
-    except:
-        return calltip
-    name = ''
-    object, dropSelf = getBaseObject(object)
-    try:
-        name = object.__name__
-    except AttributeError:
-        pass
-    tip1 = ''
-    argspec = ''
-    if inspect.isbuiltin(object):
-        # Builtin functions don't have an argspec that we can get.
-        pass
-    elif inspect.isfunction(object):
-        # tip1 is a string like: "getCallTip(command='', locals=None)"
-        argspec = apply(inspect.formatargspec, inspect.getargspec(object))
-        if dropSelf:
-            # The first parameter to a method is a reference to an
-            # instance, usually coded as "self", and is usually passed
-            # automatically by Python; therefore we want to drop it.
-            temp = argspec.split(',')
-            if len(temp) == 1:  # No other arguments.
-                argspec = '()'
-            else:  # Drop the first argument.
-                argspec = '(' + ','.join(temp[1:]).lstrip()
-        tip1 = name + argspec
-    doc = ''
-    if callable(object):
-        try:
-            doc = inspect.getdoc(object)
-        except:
-            pass
-    if doc:
-        # tip2 is the first separated line of the docstring, like:
-        # "Return call tip text for a command."
-        # tip3 is the rest of the docstring, like:
-        # "The call tip information will be based on ... <snip>
-        firstline = doc.split('\n')[0].lstrip()
-        if tip1 == firstline:
-            tip1 = ''
-        else:
-            tip1 += '\n\n'
-        docpieces = doc.split('\n\n')
-        tip2 = docpieces[0]
-        tip3 = '\n\n'.join(docpieces[1:])
-        tip = '%s%s\n\n%s' % (tip1, tip2, tip3)
-    else:
-        tip = tip1
-    calltip = (name, argspec[1:-1], tip.strip())
-    return calltip
-
-def getRoot(command, terminator=None):
-    """Return the rightmost root portion of an arbitrary Python command.
-    
-    Return only the root portion that can be eval()'d without side
-    effects.  The command would normally terminate with a '(' or
-    '.'. The terminator and anything after the terminator will be
-    dropped."""
-    command = command.split('\n')[-1]
-    if command.startswith(sys.ps2):
-        command = command[len(sys.ps2):]
-    command = command.lstrip()
-    command = rtrimTerminus(command, terminator)
-    tokens = getTokens(command)
-    if not tokens:
-        return ''
-    if tokens[-1][0] is tokenize.ENDMARKER:
-        # Remove the end marker.
-        del tokens[-1]
-    if not tokens:
-        return ''
-    if terminator == '.' and \
-           (tokens[-1][1] <> '.' or tokens[-1][0] is not tokenize.OP):
-        # Trap decimals in numbers, versus the dot operator.
-        return ''
-    else:
-        # Strip off the terminator.
-        if terminator and command.endswith(terminator):
-            size = 0 - len(terminator)
-            command = command[:size]
-    command = command.rstrip()
-    tokens = getTokens(command)
-    tokens.reverse()
-    line = ''
-    start = None
-    prefix = ''
-    laststring = '.'
-    emptyTypes = ('[]', '()', '{}')
-    for token in tokens:
-        tokentype = token[0]
-        tokenstring = token[1]
-        line = token[4]
-        if tokentype is tokenize.ENDMARKER:
-            continue
-        if tokentype in (tokenize.NAME, tokenize.STRING, tokenize.NUMBER) \
-        and laststring != '.':
-            # We've reached something that's not part of the root.
-            if prefix and line[token[3][1]] != ' ':
-                # If it doesn't have a space after it, remove the prefix.
-                prefix = ''
-            break
-        if tokentype in (tokenize.NAME, tokenize.STRING, tokenize.NUMBER) \
-        or (tokentype is tokenize.OP and tokenstring == '.'):
-            if prefix:
-                # The prefix isn't valid because it comes after a dot.
-                prefix = ''
-                break
-            else:
-                # start represents the last known good point in the line.
-                start = token[2][1]
-        elif len(tokenstring) == 1 and tokenstring in ('[({])}'):
-            # Remember, we're working backwords.
-            # So prefix += tokenstring would be wrong.
-            if prefix in emptyTypes and tokenstring in ('[({'):
-                # We've already got an empty type identified so now we
-                # are in a nested situation and we can break out with
-                # what we've got.
-                break
-            else:
-                prefix = tokenstring + prefix
-        else:
-            # We've reached something that's not part of the root.
-            break
-        laststring = tokenstring
-    if start is None:
-        start = len(line)
-    root = line[start:]
-    if prefix in emptyTypes:
-        # Empty types are safe to be eval()'d and introspected.
-        root = prefix + root
-    return root    
-
-def getTokens(command):
-    """Return list of token tuples for command."""
-    command = str(command)  # In case the command is unicode, which fails.
-    f = cStringIO.StringIO(command)
-    # tokens is a list of token tuples, each looking like: 
-    # (type, string, (srow, scol), (erow, ecol), line)
-    tokens = []
-    # Can't use list comprehension:
-    #   tokens = [token for token in tokenize.generate_tokens(f.readline)]
-    # because of need to append as much as possible before TokenError.
-    try:
-##        This code wasn't backward compatible with Python 2.1.3.
-##
-##        for token in tokenize.generate_tokens(f.readline):
-##            tokens.append(token)
-
-        # This works with Python 2.1.3 (with nested_scopes).
-        def eater(*args):
-            tokens.append(args)
-        tokenize.tokenize_loop(f.readline, eater)
-    except tokenize.TokenError:
-        # This is due to a premature EOF, which we expect since we are
-        # feeding in fragments of Python code.
-        pass
-    return tokens    
-
-def rtrimTerminus(command, terminator=None):
-    """Return command minus anything that follows the final terminator."""
-    if terminator:
-        pieces = command.split(terminator)
-        if len(pieces) > 1:
-            command = terminator.join(pieces[:-1]) + terminator
-    return command
-
-def getBaseObject(object):
-    """Return base object and dropSelf indicator for an object."""
-    if inspect.isbuiltin(object):
-        # Builtin functions don't have an argspec that we can get.
-        dropSelf = 0
-    elif inspect.ismethod(object):
-        # Get the function from the object otherwise
-        # inspect.getargspec() complains that the object isn't a
-        # Python function.
-        try:
-            if object.im_self is None:
-                # This is an unbound method so we do not drop self
-                # from the argspec, since an instance must be passed
-                # as the first arg.
-                dropSelf = 0
-            else:
-                dropSelf = 1
-            object = object.im_func
-        except AttributeError:
-            dropSelf = 0
-    elif inspect.isclass(object):
-        # Get the __init__ method function for the class.
-        constructor = getConstructor(object)
-        if constructor is not None:
-            object = constructor
-            dropSelf = 1
-        else:
-            dropSelf = 0
-    elif callable(object):
-        # Get the __call__ method instead.
-        try:
-            object = object.__call__.im_func
-            dropSelf = 1
-        except AttributeError:
-            dropSelf = 0
-    else:
-        dropSelf = 0
-    return object, dropSelf
-
-def getConstructor(object):
-    """Return constructor for class object, or None if there isn't one."""
-    try:
-        return object.__init__.im_func
-    except AttributeError:
-        for base in object.__bases__:
-            constructor = getConstructor(base)
-            if constructor is not None:
-                return constructor
-    return None

wxPython/wxPython/py/pseudo.py

@@ -1,107 +0,0 @@
-"""Provides a variety of classes to create pseudo keywords and pseudo files."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class PseudoKeyword:
-    """A callable class that calls a method passed as a parameter.
-
-    Good for creating a pseudo keyword in the python runtime
-    environment. The keyword is really an object that has a repr()
-    that calls itself which calls the method that was passed in the
-    init of the object. All this just to avoid having to type in the
-    closing parens on a method. So, for example:
-
-        >>> quit = PseudoKeyword(SomeObject.someMethod)
-        >>> quit
-
-    SomeObject.someMethod gets executed as if it had been called
-    directly and the user didn't have to type the parens, like
-    'quit()'. This technique is most applicable for pseudo keywords
-    like quit, exit and help.
-
-    If SomeObject.someMethod can take parameters, they can still be
-    passed by using the keyword in the traditional way with parens."""
-
-    def __init__(self, method):
-        """Create a callable object that executes method when called."""
-
-        if callable(method):
-            self.method = method
-        else:
-            raise ValueError, 'method must be callable'
-
-    def __call__(self, *args, **kwds):
-        self.method(*args, **kwds)
-
-    def __repr__(self):
-        self()
-        return ''
-
-
-class PseudoFile:
-
-    def __init__(self):
-        """Create a file-like object."""
-        pass
-
-    def readline(self):
-        pass
-
-    def write(self, s):
-        pass
-
-    def writelines(self, l):
-        map(self.write, l)
-
-    def flush(self):
-        pass
-
-    def isatty(self):
-        pass
-
-
-class PseudoFileIn(PseudoFile):
-
-    def __init__(self, readline, readlines=None):
-        if callable(readline):
-            self.readline = readline
-        else:
-            raise ValueError, 'readline must be callable'
-        if callable(readlines):
-            self.readlines = readlines
-
-    def isatty(self):
-        return 1
-        
-        
-class PseudoFileOut(PseudoFile):
-
-    def __init__(self, write):
-        if callable(write):
-            self.write = write
-        else:
-            raise ValueError, 'write must be callable'
-
-    def isatty(self):
-        return 1
-
-
-class PseudoFileErr(PseudoFile):
-
-    def __init__(self, write):
-        if callable(write):
-            self.write = write
-        else:
-            raise ValueError, 'write must be callable'
-
-    def isatty(self):
-        return 1

wxPython/wxPython/py/tests/test_interpreter.py

@@ -1,82 +0,0 @@
-#!/usr/bin/env python
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import unittest
-
-# Import from this module's parent directory.
-import os
-import sys
-sys.path.insert(0, os.pardir)
-import interpreter
-del sys.path[0]
-del sys
-del os
-
-
-"""
-These unittest methods are preferred:
--------------------------------------
-self.assert_(expr, msg=None)
-self.assertEqual(first, second, msg=None)
-self.assertRaises(excClass, callableObj, *args, **kwargs)
-self.fail(msg=None)
-self.failIf(expr, msg=None)
-"""
-
-
-class ModuleTestCase(unittest.TestCase):
-
-    def test_module(self):
-        module = interpreter
-        self.assert_(module.__author__)
-        self.assert_(module.__cvsid__)
-        self.assert_(module.__revision__)
-        self.assert_(module.Interpreter)
-        self.assert_(module.Interpreter.push)
-        self.assert_(module.Interpreter.runsource)
-        self.assert_(module.Interpreter.getAutoCompleteList)
-        self.assert_(module.Interpreter.getCallTip)
-        self.assert_(module.InterpreterAlaCarte)
-
-
-class InterpreterTestCase(unittest.TestCase):
-
-    def setUp(self):
-        self.output = ''
-        self.i = interpreter.Interpreter(stdout=self)
-
-    def write(self, text):
-        """Capture output from self.i.push()."""
-        self.output += text
-
-    def tearDown(self):
-        self.output = ''
-        self.i = None
-        del self.i
-
-    def test_more(self):
-        self.assertEqual(self.i.push('dir()'), 0)
-        self.assertEqual(self.i.push('for n in range(3):'), 1)
-
-    def test_push(self):
-        values = (
-        ('dir', '<built-in function dir>'),
-        ('dir()', "['__builtins__', '__doc__', '__name__']"),
-        ('2 + 2', '4'),
-        ('d = {}', ''),
-        ('d', '{}'),
-        ('del d', ''),
-        ('len([4,5,6])', '3'),
-        )
-        for input, output in values:
-            if output: output += '\n'
-            self.i.push(input)
-            self.assertEqual(self.output, output)
-            self.output = ''
-
-
-if __name__ == '__main__':
-    unittest.main()

wxPython/wxPython/py/tests/test_introspect.py

@@ -1,862 +0,0 @@
-#!/usr/bin/env python
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import unittest
-
-# Import from this module's parent directory.
-import os
-import sys
-sys.path.insert(0, os.pardir)
-import introspect
-del sys.path[0]
-del sys
-del os
-
-
-"""
-These unittest methods are preferred:
--------------------------------------
-self.assert_(expr, msg=None)
-self.assertEqual(first, second, msg=None)
-self.assertRaises(excClass, callableObj, *args, **kwargs)
-self.fail(msg=None)
-self.failIf(expr, msg=None)
-"""
-
-
-class ModuleTestCase(unittest.TestCase):
-
-    def test_module(self):
-        module = introspect
-        self.assert_(module.__author__)
-        self.assert_(module.__cvsid__)
-        self.assert_(module.__revision__)
-        self.assert_(module.getAllAttributeNames)
-        self.assert_(module.getAttributeNames)
-        self.assert_(module.getAutoCompleteList)
-        self.assert_(module.getBaseObject)
-        self.assert_(module.getCallTip)
-        self.assert_(module.getConstructor)
-        self.assert_(module.getRoot)
-        self.assert_(module.rtrimTerminus)
-
-
-class RtrimTerminusTestCase(unittest.TestCase):
-
-    def test_rtrimTerminus(self):
-        values = (
-            ('', '', ''),
-            ('', None, ''),
-            ('', '.', ''),
-            ('', '(', ''),
-            
-            ('.', '', '.'),
-            ('.', None, '.'),
-            ('.', '.', '.'),
-            ('.', '(', '.'),
-            
-            ('(', '', '('),
-            ('(', None, '('),
-            ('(', '.', '('),
-            ('(', '(', '('),
-            
-            ('spam', '', 'spam'),
-            ('spam', None, 'spam'),
-            ('spam', '.', 'spam'),
-            ('spam', '(', 'spam'),
-            
-            ('spam.', '', 'spam.'),
-            ('spam.', None, 'spam.'),
-            ('spam.', '.', 'spam.'),
-            ('spam.', '(', 'spam.'),
-            
-            ('spam(', '', 'spam('),
-            ('spam(', None, 'spam('),
-            ('spam(', '.', 'spam('),
-            ('spam(', '(', 'spam('),
-            
-            ('spam.eggs', '.', 'spam.'),
-            ('spam.eggs.', '.', 'spam.eggs.'),
-            ('spam.eggs(', '(', 'spam.eggs('),
-            ('spam.eggs.', '(', 'spam.eggs.'),
-            ('spam.eggs(', '.', 'spam.'),
-            
-            ('x = spam.', '.', 'x = spam.'),
-            ('x = spam.eggs', '.', 'x = spam.'),
-            ('x = spam.eggs.', '.', 'x = spam.eggs.'),
-            ('x = spam.eggs(', '(', 'x = spam.eggs('),
-        )
-        for input, terminator, output in values:
-            result = introspect.rtrimTerminus(input, terminator)
-            self.assertEqual(result, output,
-                             ':in: %r :t: %r :out: %r :result: %r' %
-                             (input, terminator, output, result))
-
-
-class GetRootTestCase(unittest.TestCase):
-
-    def _checkRoot(self, input, terminator, output):
-        root = introspect.getRoot(command=input, terminator=terminator)
-        self.assertEqual(root, output,
-                         ':in: %r :t: %r :out: %r :root: %r' %
-                         (input, terminator, output, root))
-
-    def test_getRoot(self):
-        values = (
-            ('', '', ''),
-            ('', None, ''),
-            ('', '.', ''),
-            ('', '(', ''),
-            
-            ('.', '', '.'),
-            ('.', None, '.'),
-            ('.', '.', ''),
-            ('.', '(', '.'),
-            
-            ('(', '', ''),
-            ('(', None, ''),
-            ('(', '.', ''),
-            ('(', '(', ''),
-            
-            ('spam', '', 'spam'),
-            ('spam', None, 'spam'),
-            ('spam', '.', ''),
-            ('spam', '(', 'spam'),
-            
-            ('spam.', '', 'spam.'),
-            ('spam.', None, 'spam.'),
-            ('spam.', '.', 'spam'),
-            ('spam.', '(', 'spam.'),
-            
-            ('spam(', '', ''),
-            ('spam(', None, ''),
-            ('spam(', '.', ''),
-            ('spam(', '(', 'spam'),
-            
-            ('spam.eggs', '.', 'spam'),
-            ('spam.eggs.', '.', 'spam.eggs'),
-            ('spam.eggs(', '(', 'spam.eggs'),
-            ('spam.eggs.', '(', 'spam.eggs.'),
-            ('spam.eggs(', '.', 'spam'),
-            
-            ('x = spam.', '.', 'spam'),
-            ('x = spam.eggs', '.', 'spam'),
-            ('x = spam.eggs.', '.', 'spam.eggs'),
-            ('x = spam.eggs(', '(', 'spam.eggs'),
-
-            ('for n in range(3):\n    d.', '.', 'd'),
-            ('for n in range(3):\n...    d.', '.', 'd'),
-        )
-        for input, terminator, output in values:
-            self._checkRoot(input, terminator, output)
-
-    def test_getRoot_Advanced(self):
-        values = (
-            ('spam_', '', 'spam_'),
-            ('spam_', None, 'spam_'),
-            ('spam_', '.', ''),
-            ('spam_', '(', 'spam_'),
-            
-            ('_spam', '', '_spam'),
-            ('_spam', None, '_spam'),
-            ('_spam', '.', ''),
-            ('_spam', '(', '_spam'),
-            
-            ('spam_eggs', '', 'spam_eggs'),
-            ('spam_eggs', None, 'spam_eggs'),
-            ('spam_eggs', '.', ''),
-            ('spam_eggs', '(', 'spam_eggs'),
-            
-            ('spam123', '', 'spam123'),
-            ('spam123', None, 'spam123'),
-            ('spam123', '.', ''),
-            ('spam123', '(', 'spam123'),
-
-            ('spam_123', '', 'spam_123'),
-            ('spam_123', None, 'spam_123'),
-            ('spam_123', '.', ''),
-            ('spam_123', '(', 'spam_123'),
-        )
-        for input, terminator, output in values:
-            self._checkRoot(input, terminator, output)
-
-## The original intent was to detect when we were inside a string.
-## That has proven to be very difficult, for little benefit.
-## The fact that autocomplete or calltips might be triggered inside
-## a string is not a big deal. Sometimes it is even helpful.
-
-##    def test_getRoot_InsideStrings(self):
-##        values = (
-##            ('x = ".', '.', ''),
-##            ("x = '.", '.', ''),
-##            ('x = """.', '.', ''),
-##            ("x = '''.", '.', ''),
-##
-##            ('x = "(', '(', ''),
-##            ("x = '(", '(', ''),
-##            ('x = """(', '(', ''),
-##            ("x = '''(", '(', ''),
-##
-##            ('x = "spam', '.', ''),
-##            ('x = "spam.', '.', ''),
-##            ("x = 'spam.", '.', ''),
-##            ('x = """spam.', '.', ''),
-##            ("x = '''spam.", '.', ''),
-##            
-##            ('x = "spam', '(', ''),
-##            ('x = "spam(', '(', ''),
-##            ("x = 'spam(", '(', ''),
-##            ('x = """spam(', '(', ''),
-##            ("x = '''spam(", '(', ''),
-##            
-##            ('x = "spam.eggs.', '.', ''),
-##            ("x = 'spam.eggs.", '.', ''),
-##            ('x = """spam.eggs.', '.', ''),
-##            ("x = '''spam.eggs.", '.', ''),
-##            
-##            ('x = "spam.eggs(', '(', ''),
-##            ("x = 'spam.eggs(", '(', ''),
-##            ('x = """spam.eggs(', '(', ''),
-##            ("x = '''spam.eggs(", '(', ''),
-##        )
-##        for input, terminator, output in values:
-##            self._checkRoot(input, terminator, output)
-
-    def test_getRoot_EmptyTypes(self):
-        values = (
-            ("''.", '.', "''"),
-            ('"".', '.', '""'),
-            ('"""""".', '.', '""""""'),
-            ("''''''.", '.', "''''''"),
-
-            ('[].', '.', '[]'),
-            ('().', '.', '()'),
-            ('{}.', '.', '{}'),
-            
-            ('[](', '(', '[]'),
-            ('()(', '(', '()'),
-            ('{}(', '(', '{}'),
-            
-            ("x = ''.", '.', "''"),
-            ('x = "".', '.', '""'),
-            ('x = """""".', '.', '""""""'),
-            ("x = ''''''.", '.', "''''''"),
-
-            ('x = [].', '.', '[]'),
-            ('x = ().', '.', '()'),
-            ('x = {}.', '.', '{}'),
-            
-            ('x = [](', '(', '[]'),
-            ('x = ()(', '(', '()'),
-            ('x = {}(', '(', '{}'),
-
-            ('print [].', '.', '[]'),
-            ('print ().', '.', '()'),
-            ('print {}.', '.', '{}'),
-            
-            ('print [](', '(', '[]'),
-            ('print ()(', '(', '()'),
-            ('print {}(', '(', '{}'),
-
-            ("''.attr.", '.', "''.attr"),
-            ('"".attr.', '.', '"".attr'),
-            ('"""""".attr.', '.', '"""""".attr'),
-            ("''''''.attr.", '.', "''''''.attr"),
-
-            ('[].attr.', '.', '[].attr'),
-            ('().attr.', '.', '().attr'),
-            ('{}.attr.', '.', '{}.attr'),
-            
-            ('[].attr(', '(', '[].attr'),
-            ('().attr(', '(', '().attr'),
-            ('{}.attr(', '(', '{}.attr'),
-
-            ('spam().', '.', ''),
-            ('spam_().', '.', ''),
-            ('spam5().', '.', ''),
-            ('spam[]().', '.', ''),
-            ('spam()[].', '.', ''),
-            ('spam[]{}.', '.', ''),
-
-            ("spam(''.", '.', "''"),
-            ('spam("".', '.', '""'),
-            ('spam("""""".', '.', '""""""'),
-            ("spam(''''''.", '.', "''''''"),
-
-            ('spam([].', '.', '[]'),
-            ('spam(().', '.', '()'),
-            ('spam({}.', '.', '{}'),
-            ('spam[[].', '.', '[]'),
-            ('spam[().', '.', '()'),
-            ('spam[{}.', '.', '{}'),
-            ('x = {[].', '.', '[]'),
-            ('x = {().', '.', '()'),
-            ('x = {{}.', '.', '{}'),
-
-            ('spam,[].', '.', '[]'),
-            ('spam+[].', '.', '[]'),
-            ('spam-[].', '.', '[]'),
-            ('spam*[].', '.', '[]'),
-            ('spam/[].', '.', '[]'),
-            ('spam=[].', '.', '[]'),
-            ('spam%[].', '.', '[]'),
-            ('spam<[].', '.', '[]'),
-            ('spam>[].', '.', '[]'),
-            ('spam&[].', '.', '[]'),
-            ('spam|[].', '.', '[]'),
-            ('spam^[].', '.', '[]'),
-            ('spam~[].', '.', '[]'),
-            ('spam:[].', '.', '[]'),
-
-            ('spam,().', '.', '()'),
-            ('spam+().', '.', '()'),
-            ('spam-().', '.', '()'),
-            ('spam*().', '.', '()'),
-            ('spam/().', '.', '()'),
-            ('spam=().', '.', '()'),
-            ('spam%().', '.', '()'),
-            ('spam<().', '.', '()'),
-            ('spam>().', '.', '()'),
-            ('spam&().', '.', '()'),
-            ('spam|().', '.', '()'),
-            ('spam^().', '.', '()'),
-            ('spam~().', '.', '()'),
-            ('spam:().', '.', '()'),
-
-            ('spam,{}.', '.', '{}'),
-            ('spam+{}.', '.', '{}'),
-            ('spam-{}.', '.', '{}'),
-            ('spam*{}.', '.', '{}'),
-            ('spam/{}.', '.', '{}'),
-            ('spam={}.', '.', '{}'),
-            ('spam%{}.', '.', '{}'),
-            ('spam<{}.', '.', '{}'),
-            ('spam>{}.', '.', '{}'),
-            ('spam&{}.', '.', '{}'),
-            ('spam|{}.', '.', '{}'),
-            ('spam^{}.', '.', '{}'),
-            ('spam~{}.', '.', '{}'),
-            ('spam:{}.', '.', '{}'),
-        )
-        for input, terminator, output in values:
-            self._checkRoot(input, terminator, output)
-
-
-# Support for GetBaseObjectTestCase and GetAttributeNamesTestCase.
-
-class Foo:
-    def __init__(self):
-        pass
-
-    def __del__(self):
-        pass
-
-    def _private(self):
-        pass
-
-class Bar:
-    pass
-
-class Spam:
-    def __call__(self):
-        pass
-
-    def foo(self):
-        pass
-
-    def bar(spam):
-        # It shouldn't matter what we call "self".
-        pass
-
-    def eggs(self):
-        pass
-
-def ham(eggs):
-    pass
-
-class GetBaseObjectTestCase(unittest.TestCase):
-
-    def test_getBaseObject(self):
-        spam = Spam()
-        eggs = Spam.eggs
-        listappend = [].append
-        spamda = lambda: None
-        values = (
-            ('spam', 'spam', 0),
-            (123, 123, 0),
-            (12.3, 12.3, 0),
-            ([], [], 0),
-            ((), (), 0),
-            ({}, {}, 0),
-            # Builtin function.
-            (len, len, 0),
-            # Builtin method.
-            (listappend, listappend, 0),
-            # User function.
-            (ham, ham, 0),
-            # Byte-compiled code.
-            (ham.func_code, ham.func_code, 0),
-            # Lambda.
-            (spamda, spamda, 0),
-            # Class with init.
-            (Foo, Foo.__init__.im_func, 1),
-            # Class with no init.
-            (Bar, Bar, 0),
-            # Bound method.
-            (spam.foo, spam.foo.im_func, 1),
-            # Bound method with self named something else (spam).
-            (spam.bar, spam.bar.im_func, 1),
-            # Unbound method. (Do not drop the self argument.)
-            (eggs, eggs.im_func, 0),
-            # Callable instance.
-            (spam, spam.__call__.im_func, 1),
-        )
-        for object, baseObject, dropSelf in values:
-            result = introspect.getBaseObject(object)
-            self.assertEqual(result, (baseObject, dropSelf))
-
-
-class GetAttributeTestCase(unittest.TestCase):
-    """Base class for other test case classes."""
-
-    def setUp(self):
-        self.values = (
-            '__abs__',
-            '__add__',
-            '__and__',
-            '__base__',
-            '__bases__',
-            '__basicsize__',
-            '__builtins__',
-            '__call__',
-            '__class__',
-            '__cmp__',
-            '__coerce__',
-            '__contains__',
-            '__del__',
-            '__delattr__',
-            '__delitem__',
-            '__delslice__',
-            '__dict__',
-            '__dictoffset__',
-            '__div__',
-            '__divmod__',
-            '__doc__',
-            '__eq__',
-            '__file__',
-            '__flags__',
-            '__float__',
-            '__floordiv__',
-            '__ge__',
-            '__get__',
-            '__getattr__',
-            '__getattribute__',
-            '__getitem__',
-            '__getslice__',
-            '__gt__',
-            '__hash__',
-            '__hex__',
-            '__iadd__',
-            '__imul__',
-            '__init__',
-            '__int__',
-            '__invert__',
-            '__itemsize__',
-            '__iter__',
-            '__le__',
-            '__len__',
-            '__long__',
-            '__lshift__',
-            '__lt__',
-            '__mod__',
-            '__module__',
-            '__mro__',
-            '__mul__',
-            '__name__',
-            '__ne__',
-            '__neg__',
-            '__new__',
-            '__nonzero__',
-            '__oct__',
-            '__or__',
-            '__path__',
-            '__pos__',
-            '__pow__',
-            '__radd__',
-            '__rand__',
-            '__rdiv__',
-            '__rdivmod__',
-            '__reduce__',
-            '__repr__',
-            '__rfloordiv__',
-            '__rlshift__',
-            '__rmod__',
-            '__rmul__',
-            '__ror__',
-            '__rpow__',
-            '__rrshift__',
-            '__rshift__',
-            '__rsub__',
-            '__rtruediv__',
-            '__rxor__',
-            '__self__',
-            '__setattr__',
-            '__setitem__',
-            '__setslice__',
-            '__str__',
-            '__sub__',
-            '__subclasses__',
-            '__truediv__',
-            '__warningregistry__',
-            '__weakrefoffset__',
-            '__xor__',
-            'append',
-            'capitalize',
-            'center',
-            'clear',
-            'close',
-            'closed',
-            'co_argcount',
-            'co_cellvars',
-            'co_code',
-            'co_consts',
-            'co_filename',
-            'co_firstlineno',
-            'co_flags',
-            'co_freevars',
-            'co_lnotab',
-            'co_name',
-            'co_names',
-            'co_nlocals',
-            'co_stacksize',
-            'co_varnames',
-            'conjugate',
-            'copy',
-            'count',
-            'decode',
-            'encode',
-            'endswith',
-            'expandtabs',
-            'extend',
-            'fileno',
-            'find',
-            'flush',
-            'func_closure',
-            'func_code',
-            'func_defaults',
-            'func_dict',
-            'func_doc',
-            'func_globals',
-            'func_name',
-            'get',
-            'has_key',
-            'im_class',
-            'im_func',
-            'im_self',
-            'imag',
-            'index',
-            'insert',
-            'isalnum',
-            'isalpha',
-            'isatty',
-            'isdigit',
-            'islower',
-            'isspace',
-            'istitle',
-            'isupper',
-            'items',
-            'iteritems',
-            'iterkeys',
-            'itervalues',
-            'join',
-            'keys',
-            'ljust',
-            'lower',
-            'lstrip',
-            'mode',
-            'mro',
-            'name',
-            'pop',
-            'popitem',
-            'real',
-            'read',
-            'readinto',
-            'readline',
-            'readlines',
-            'remove',
-            'replace',
-            'reverse',
-            'rfind',
-            'rindex',
-            'rjust',
-            'rstrip',
-            'seek',
-            'setdefault',
-            'softspace',
-            'sort',
-            'split',
-            'splitlines',
-            'start',
-            'startswith',
-            'step',
-            'stop',
-            'strip',
-            'swapcase',
-            'tell',
-            'title',
-            'tolist',
-            'translate',
-            'truncate',
-            'update',
-            'upper',
-            'values',
-            'write',
-            'writelines',
-            'xreadlines',
-        )
-
-# Since getAllAttributeNames() calls str(object),
-# we need to test for a broken __str__ method.
-class BrokenStr:
-    def __str__(self):
-        raise Exception
-    
-brokenStr = BrokenStr()
-
-class GetAttributeNamesTestCase(GetAttributeTestCase):
-
-    def setUp(self):
-        GetAttributeTestCase.setUp(self)
-        import PyCrust
-        spam = Spam()
-        self.f = open('test_introspect.py')
-        self.items = (
-            None,
-            int(123),
-            long(123),
-            float(123),
-            complex(123),
-            "",
-            unicode(""),
-            [],
-            (),
-            xrange(0),
-            {},
-            # Builtin function.
-            len,
-            # Builtin method.
-            [].append,
-            # User function.
-            ham,
-            # Byte-compiled code.
-            ham.func_code,
-            # Lambda.
-            lambda: None,
-            # Class with no init.
-            Bar,
-            # Instance with no init.
-            Bar(),
-            # Class with init and del.
-            Foo,
-            # Instance with init and del.
-            Foo(),
-            # Bound method.
-            spam.foo,
-            # Unbound method.
-            Spam.eggs,
-            # Callable instance.
-            spam,
-            # Module.
-            introspect,
-            # Package.
-            PyCrust,
-            # Buffer.
-            buffer(''),
-            # File.
-            self.f,
-            # Slice.
-            slice(0),
-            # Ellipsis.
-            Ellipsis,
-            # BrokenStr class.
-            BrokenStr,
-            # BrokenStr instance.
-            brokenStr,
-        )
-
-    def tearDown(self):
-        self.items = None
-        self.f.close()
-
-    def test_getAttributeNames(self):
-        for item in self.items:
-            self._checkAttributeNames(item)
-        if __builtins__.has_key('object'):
-            self._checkAttributeNames(object)
-
-    def test_getAttributeNames_NoSingle(self):
-        for item in self.items:
-            result = introspect.getAttributeNames(item, includeSingle=0)
-            attributes = [attribute for attribute in result \
-                          if attribute[0] != '_' or attribute[:2] == '__']
-            self.assertEqual(result, attributes, 
-                             ':item: %r' % (item,))
-
-    def test_getAttributeNames_NoDouble(self):
-        for item in self.items:
-            result = introspect.getAttributeNames(item, includeDouble=0)
-            attributes = [attribute for attribute in result \
-                          if attribute[:2] != '__']
-            self.assertEqual(result, attributes, 
-                             ':item: %r' % (item,))
-
-    def test_getAttributeNames_NoSingleOrDouble(self):
-        for item in self.items:
-            result = introspect.getAttributeNames(item, includeSingle=0, 
-                                                  includeDouble=0)
-            attributes = [attribute for attribute in result \
-                          if attribute[0] != '_']
-            self.assertEqual(result, attributes, 
-                             ':item: %r' % (item,))
-
-    def _checkAttributeNames(self, item):
-        result = introspect.getAttributeNames(item)
-        attributes = [attribute for attribute in self.values \
-                      if hasattr(item, attribute)]
-        for attribute in attributes:
-            self.assert_(attribute in result, 
-                         ':item: %r :attribute: %r' % (item, attribute))
-
-
-class GetAutoCompleteListTestCase(GetAttributeTestCase):
-
-    def setUp(self):
-        GetAttributeTestCase.setUp(self)
-        self.items = (
-            'None.',
-            '123 .',
-            '"".',
-            '[].',
-            '().',
-            '{}.',
-            # Builtin function.
-            'len.',
-            # Builtin method.
-            '[].append.',
-        )
-
-    def test_getAutoCompleteList(self):
-        for item in self.items:
-            result = introspect.getAutoCompleteList(item)
-            object = eval(item[:-1])
-            attributes = [attribute for attribute in self.values \
-                          if hasattr(object, attribute)]
-            for attribute in attributes:
-                self.assert_(attribute in result, 
-                             ':item: %r :attribute: %r' % (item, attribute))
-
-    def test_getAutoCompleteList_NoSingle(self):
-        for item in self.items:
-            result = introspect.getAutoCompleteList(item, includeSingle=0)
-            attributes = [attribute for attribute in result \
-                          if attribute[0] != '_' or attribute[:2] == '__']
-            self.assertEqual(result, attributes, 
-                             ':item: %r' % (item,))
-
-    def test_getAutoCompleteList_NoDouble(self):
-        for item in self.items:
-            result = introspect.getAutoCompleteList(item, includeDouble=0)
-            attributes = [attribute for attribute in result \
-                          if attribute[:2] != '__']
-            self.assertEqual(result, attributes, 
-                             ':item: %r' % (item,))
-
-    def test_getAutoCompleteList_NoSingleOrDouble(self):
-        for item in self.items:
-            result = introspect.getAutoCompleteList(item, includeSingle=0, 
-                                                    includeDouble=0)
-            attributes = [attribute for attribute in result \
-                          if attribute[0] != '_']
-            self.assertEqual(result, attributes, 
-                             ':item: %r' % (item,))
-
-
-# Support for GetConstructorTestCase.
-
-class A1:
-    def __init__(self, a):
-        self.a = a
-
-class B1(A1):
-    def __init__(self, b):
-        self.b = b
-
-class C1(A1):
-    pass
-
-class D1(C1, B1):
-    pass
-
-if __builtins__.has_key('object'):
-    class A2(object):
-        def __init__(self, a):
-            self.a = a
-
-    class B2(A2):
-        def __init__(self, b):
-            self.b = b
-
-    class C2(A2):
-        pass
-
-    class D2(C2, B2):
-        pass
-    
-class N:
-    pass
-
-class O:
-    def __init__(self, a, b=2, *args, **kwargs):
-        pass
-
-class P(O):
-    pass
-
-class Q(P):
-    def __init__(self, c, d=4):
-        pass
-
-class GetConstructorTestCase(unittest.TestCase):
-
-    def test_getConstructor(self):
-        args = ('self', 'a', 'b', 'args', 'kwargs')
-        varnames = introspect.getConstructor(O).func_code.co_varnames
-        self.assertEqual(varnames, args)
-        varnames = introspect.getConstructor(P).func_code.co_varnames
-        self.assertEqual(varnames, args)
-        args = ('self', 'c', 'd')
-        varnames = introspect.getConstructor(Q).func_code.co_varnames
-        self.assertEqual(varnames, args)
-
-    def test_getConstructor_None(self):
-        values = (N, 1, 'spam', {}, [], (), dir)
-        for value in values:
-            self.assertEqual(introspect.getConstructor(N), None)
-
-    def test_getConstructor_MultipleInheritance(self):
-        # Test old style inheritance rules.
-        args = ('self', 'a')
-        varnames = introspect.getConstructor(D1).func_code.co_varnames
-        self.assertEqual(varnames, args)
-        if __builtins__.has_key('object'):
-            # Test new style inheritance rules as well.
-            args = ('self', 'b')
-            varnames = introspect.getConstructor(D2).func_code.co_varnames
-            self.assertEqual(varnames, args)
-
-
-if __name__ == '__main__':
-    unittest.main()

wxPython/wxPython/py/tests/test_pseudo.py

@@ -1,81 +0,0 @@
-#!/usr/bin/env python
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import unittest
-
-# Import from this module's parent directory.
-import os
-import sys
-sys.path.insert(0, os.pardir)
-import pseudo
-del sys.path[0]
-del sys
-del os
-
-
-"""
-These unittest methods are preferred:
--------------------------------------
-self.assert_(expr, msg=None)
-self.assertEqual(first, second, msg=None)
-self.assertRaises(excClass, callableObj, *args, **kwargs)
-self.fail(msg=None)
-self.failIf(expr, msg=None)
-"""
-
-
-class ModuleTestCase(unittest.TestCase):
-
-    def test_module(self):
-        module = pseudo
-        self.assert_(module.__author__)
-        self.assert_(module.__cvsid__)
-        self.assert_(module.__revision__)
-        self.assert_(module.PseudoFile)
-        self.assert_(module.PseudoFileErr)
-        self.assert_(module.PseudoFileIn)
-        self.assert_(module.PseudoFileOut)
-        self.assert_(module.PseudoKeyword)
-
-
-class PseudoTestCase(unittest.TestCase):
-
-    def setUp(self):
-        pass
-
-    def tearDown(self):
-        pass
-
-
-class PseudoFileTestCase(unittest.TestCase):
-
-    def setUp(self):
-        pass
-
-    def tearDown(self):
-        pass
-
-
-class PseudoFileOutTestCase(unittest.TestCase):
-
-    def setUp(self):
-        pass
-
-    def tearDown(self):
-        pass
-
-    def _write(self):
-        pass
-
-    def test_PseudoFileOut_goodInit(self):
-        self.assert_(pseudo.PseudoFileOut(write=self._write))
-
-    def test_PseudoFileOut_badInit(self):
-        self.assertRaises(ValueError, pseudo.PseudoFileOut, write='bad')
-
-
-if __name__ == '__main__':
-    unittest.main()

wxPython/wxPython/py/tests/test_version.py

@@ -1,49 +0,0 @@
-#!/usr/bin/env python
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-import unittest
-
-import types
-
-# Import from this module's parent directory.
-import os
-import sys
-sys.path.insert(0, os.pardir)
-import version
-del sys.path[0]
-del sys
-del os
-
-
-"""
-These unittest methods are preferred:
--------------------------------------
-self.assert_(expr, msg=None)
-self.assertEqual(first, second, msg=None)
-self.assertRaises(excClass, callableObj, *args, **kwargs)
-self.fail(msg=None)
-self.failIf(expr, msg=None)
-"""
-
-
-class ModuleTestCase(unittest.TestCase):
-
-    def test_module(self):
-        module = version
-        self.assert_(module.__author__)
-        self.assert_(module.__cvsid__)
-        self.assert_(module.__revision__)
-        self.assert_(module.VERSION)
-
-
-class VersionTestCase(unittest.TestCase):
-
-    def test_VERSION(self):
-        self.assert_(type(version.VERSION) is types.StringType)
-
-
-if __name__ == '__main__':
-    unittest.main()

wxPython/wxPython/py/tests/testall.py

@@ -1,25 +0,0 @@
-#!/usr/bin/env python
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-import unittest
-import glob
-import os
-
-
-def suite():
-    """Return a test suite containing all test cases in all test modules. 
-    Searches the current directory for any modules matching test_*.py."""
-    suite = unittest.TestSuite()
-    for filename in glob.glob('test_*.py'):
-        module = __import__(os.path.splitext(filename)[0])
-        suite.addTest(unittest.defaultTestLoader.loadTestsFromModule(module))
-    return suite
-
-
-if __name__ == '__main__':
-    unittest.main(defaultTest='suite')
-

wxPython/wxPython/py/version.py

@@ -1,9 +0,0 @@
-"""Provides an object representing the current 'version' or 'release'
-of Py as a whole.  Individual classes, such as the shell, filling and
-interpreter, each have a revision property based on the CVS Revision."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-VERSION = '0.9.3'

wxPython/wxPython/py/wxd/Accelerators.py

@@ -1,58 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-
-
-class AcceleratorEntry:
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def GetCommand(self):
-        """"""
-        pass
-
-    def GetFlags(self):
-        """"""
-        pass
-
-    def GetKeyCode(self):
-        """"""
-        pass
-
-    def Set(self):
-        """"""
-        pass
-
-
-class AcceleratorTable(Object):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/App.py

@@ -1,358 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import EvtHandler
-import Parameters as wx
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class PyApp(EvtHandler):
-    """Python Application base class.
-
-    It is used to:
-
-    - set and get application-wide properties;
-
-    - implement the windowing system message or event loop;
-
-    - initiate application processing via App.OnInit;
-
-    - allow default processing of events not handled by other objects
-      in the application."""
-
-    def __init__(self):
-        """Create a PyApp instance."""
-        pass
-
-    def Dispatch(self):
-        """Dispatches the next event in the windowing system event
-        queue.
-
-        This can be used for programming event loops."""
-        pass
-
-    def ExitMainLoop(self):
-        """Call this to explicitly exit the main message (event) loop.
-
-        You should normally exit the main loop (and the application)
-        by deleting the top window, which wxPython does automatically."""
-        pass
-
-    def GetAppName(self):
-        """Return the application name."""
-        pass
-
-    def GetAssertMode(self):
-        """Return the current assertion mode."""
-        pass
-
-    def GetAuto3D(self):
-        """Returns True if 3D control mode is on, False otherwise.
-        Windows only."""
-        pass
-
-    def GetClassName(self):
-        """Return the class name of the application."""
-        pass
-
-    def GetExitOnFrameDelete(self):
-        """Returns True if the application will exit when the
-        top-level window is deleted, False otherwise."""
-        pass
-
-    def GetPrintMode(self):
-        """Deprecated."""
-        pass
-
-    def GetTopWindow(self):
-        """Return the top window.
-
-        If the top window hasn't been set using App.SetTopWindow,
-        this method will find the first top-level window (frame or
-        dialog) and return that."""
-        pass
-
-    def GetUseBestVisual(self):
-        """Return True if the application will use the best visual on
-        systems that support different visuals, False otherwise."""
-        pass
-
-    def GetVendorName(self):
-        """Return the application's vendor name."""
-        pass
-
-    def Initialized(self):
-        """Return True if the application has been initialized
-        (i.e. if App.OnInit has returned successfully). This can be
-        useful for error message routines to determine which method of
-        output is best for the current state of the program (some
-        windowing systems may not like dialogs to pop up before the
-        main loop has been entered)."""
-        pass
-
-    def MainLoop(self):
-        """Called by wxWindows on creation of the application.
-        Override this if you wish to provide your own
-        (environment-dependent) main loop.
-
-        Return 0 under X, and the wParam of the WM_QUIT message under
-        Windows."""
-        pass
-
-    def OnAssert(self, file, line, cond, msg):
-        """Called when an assert failure occurs, i.e. the condition
-        specified in ASSERT macro evaluated to FALSE. It is only
-        called in debug mode (when __WXDEBUG__ is defined) as asserts
-        are not left in the release code at all.
-
-        The base class version show the default assert failure dialog
-        box proposing to the user to stop the program, continue or
-        ignore all subsequent asserts.
-
-        file is the name of the source file where the assert occured
-
-        line is the line number in this file where the assert occured
-
-        cond is the condition of the failed assert in string form
-
-        msg is the message specified as argument to ASSERT_MSG or
-        FAIL_MSG, will be NULL if just ASSERT or FAIL was used"""
-        pass
-
-    def OnExit(self):
-        """Provide this member function for any processing which needs
-        to be done as the application is about to exit.  OnExit is
-        called after destroying all application windows and controls,
-        but before wxWindows cleanup."""
-        pass
-
-    def OnInit(self):
-        """This must be provided by the application, and will usually
-        create the application's main window, optionally calling
-        App.SetTopWindow.
-
-        Return True to continue processing, False to exit the
-        application."""
-        pass
-
-    def OnInitGui(self):
-        """Called just after the platform's GUI has been initialized,
-        but before the App.OnInit() gets called. Rarely needed in
-        practice. Unlike App.OnInit(), does not need to return
-        True/False."""
-        pass
-    
-    def Pending(self):
-        """Return True if unprocessed events are in the window system
-        event queue."""
-        pass
-
-    def ProcessIdle(self):
-        """Sends the EVT_IDLE event and is called inside the MainLoop.
-        
-        You only need this if you implement your own main loop."""
-        pass
-
-    def SetAppName(self, name):
-        """Set the name of the application."""
-        pass
-
-    def SetAssertMode(self, mode):
-        """Lets you control how C++ assertions are processed.
-
-        Valid modes are: PYAPP_ASSERT_SUPPRESS,
-        PYAPP_ASSERT_EXCEPTION, and PYAPP_ASSERT_DIALOG.  Using
-        _SUPPRESS will give you behavior like the old final builds and
-        the assert will be ignored, _EXCEPTION is the new default
-        described above, and _DIALOG is like the default in 2.3.3.1
-        and prior hybrid builds.  You can also combine _EXCEPTION and
-        _DIALOG if you wish, although I don't know why you would."""
-        pass
-
-    def SetAuto3D(self, auto3D):
-        """Switches automatic 3D controls on or off.  Windows only.
-
-        If auto3D is True, all controls will be created with 3D
-        appearances unless overridden for a control or dialog.  The
-        default is True."""
-        pass
-
-    def SetClassName(self, name):
-        """Set the class name of the application."""
-        pass
-
-    def SetExitOnFrameDelete(self, flag):
-        """If flag is True (the default), the application will exit
-        when the top-level frame is deleted.  If False, the
-        application will continue to run."""
-        pass
-
-    def SetPrintMode(self, mode):
-        """Deprecated."""
-        pass
-
-    def SetTopWindow(self, window):
-        """Set the 'top' window.
-
-        You can call this from within App.OnInit to let wxWindows
-        know which is the main window.  You don't have to set the top
-        window; it is only a convenience so that (for example) certain
-        dialogs without parents can use a specific window as the top
-        window.  If no top window is specified by the application,
-        wxWindows just uses the first frame or dialog in its top-level
-        window list, when it needs to use the top window."""
-        pass
-
-    def SetUseBestVisual(self, flag):
-        """Allows the programmer to specify whether the application
-        will use the best visual on systems that support several
-        visual on the same display.  This is typically the case under
-        Solaris and IRIX, where the default visual is only 8-bit
-        whereas certain applications are supposed to run in TrueColour
-        mode.
-
-        Note that this function has to be called in the constructor of
-        the App instance and won't have any effect when called later
-        on.
-
-        This function currently only has effect under GTK."""
-        pass
-
-    def SetVendorName(self, name):
-        """Sets the name of application's vendor.  The name will be
-        used in registry access."""
-        pass
-
-    def Yield(self, onlyIfNeeded=False):
-        """Yields control to pending messages in the windowing system.
-        This can be useful, for example, when a time-consuming process
-        writes to a text window.  Without an occasional yield, the
-        text window will not be updated properly, and on systems with
-        cooperative multitasking, such as Windows 3.1 other processes
-        will not respond.
-
-        Caution should be exercised, however, since yielding may allow
-        the user to perform actions which are not compatible with the
-        current task.  Disabling menu items or whole menus during
-        processing can avoid unwanted reentrance of code: see
-        wx.SafeYield for a better function.
-
-        Calling Yield() recursively is normally an error and an assert
-        failure is raised in debug build if such situation is
-        detected.  However if the the onlyIfNeeded parameter is True,
-        the method will just silently return False instead."""
-        pass
-
-
-from wxPython.wx import wxPlatform
-_redirect = (wxPlatform == '__WXMSW__' or wxPlatform == '__WXMAC__')
-del wxPlatform
-
-
-class App(PyApp):
-    """The main application class.
-
-    Inherit from this class and implement an OnInit method that
-    creates a frame and then calls self.SetTopWindow(frame)."""
-
-    def __init__(self, redirect=_redirect, filename=None, useBestVisual=False):
-        """Create an App instance.
-
-        redirect defaults to True on Windows and Mac. If redirect is
-        True, stdio goes to an output window or a file if filename is
-        not None."""
-        pass
-
-
-del _redirect
-
-
-class PyOnDemandOutputWindow:
-    """Used by App to display stdout and stderr messages if app is
-    created using App(redirect=True).  Mostly useful on Windows or
-    Mac where apps aren't always launched from the command line."""
-    pass
-
-
-class PySimpleApp(App):
-    """Use instead of App for simple apps with a simple frame or
-    dialog, particularly for testing."""
-
-    def __init__(self, flag=0):
-        """Create a PySimpleApp instance.
-
-        flag is the same as App's redirect parameter to redirect stdio."""
-        pass
-
-    def OnInit(self):
-        """Automatically does a wx.InitAllImageHandlers()."""
-        pass
-
-
-class PyWidgetTester(App):
-    """Use instead of App for testing widgets. Provides a frame
-    containing an instance of a widget.
-
-    Create a PyWidgetTester instance with the desired size for the
-    frame, then create the widget and show the frame using SetWidget."""
-
-    def __init__(self, size=(250, 100)):
-        """Create a PyWidgetTester instance, with no stdio redirection.
-
-        size is for the frame to hold the widget."""
-        pass
-
-    def OnInit(self):
-        """Creates a frame that will hold the widget to be tested."""
-        pass
-
-    def SetWidget(self, widgetClass, *args):
-        """Create a widgetClass instance using the supplied args and
-        with a frame as parent, then show the frame."""
-        pass
-
-
-class SingleInstanceChecker:
-    """Allows one to check that only a single instance of a program is
-    running. To do it, you should create an object of this class. As
-    long as this object is alive, calls to IsAnotherRunning() from
-    other processes will return True.
-
-    As the object should have the life span as big as possible, it
-    makes sense to create it either as a global or in App.OnInit()."""
-
-    def __init__(self, name, path=wx.EmptyString):
-        """Create a SingleInstanceChecker instance.
-
-        name should be as unique as possible. It is used as the mutex
-        name under Win32 and the lock file name under Unix.
-        App.GetAppName() and wx.GetUserId() are commonly used.
-
-        path is optional and is ignored under Win32 and used as the
-        directory to create the lock file in under Unix (default is
-        wx.GetHomeDir())."""
-        pass
-
-    def Create(self, name, path=wx.EmptyString):
-        """Create a SingleInstanceChecker instance."""
-        pass
-
-    def IsAnotherRunning(self):
-        """Return True if another copy of this program is already running."""
-        pass

wxPython/wxPython/py/wxd/Base.py

@@ -1,206 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-import Parameters as wx
-
-
-class Object:
-    """Base class for all other wxPython classes."""
-    
-    def __init__(self):
-        """Create a Object instance."""
-        pass
-
-    def Destroy(self):
-        """Destroy the Object instance."""
-        pass
-
-    def GetClassName(self):
-        """Return the name of the class."""
-        pass
-
-
-class EvtHandler(Object):
-    """Base class that can handle events from the windowing system.
-
-    If the handler is part of a chain, the destructor will unlink
-    itself and restore the previous and next handlers so that they
-    point to each other."""
-
-    def __init__(self):
-        """Create a EvtHandler instance."""
-        pass
-
-    def AddPendingEvent(self, event):
-        """Post an event to be processed later.
-
-        event is an Event instance to add to process queue.
-
-        The difference between sending an event (using the
-        ProcessEvent method) and posting it is that in the first case
-        the event is processed before the function returns, while in
-        the second case, the function returns immediately and the
-        event will be processed sometime later (usually during the
-        next event loop iteration).
-
-        A copy of event is made by the function, so the original can
-        be deleted as soon as function returns (it is common that the
-        original is created on the stack).  This requires that the
-        Event::Clone method be implemented by event so that it can
-        be duplicated and stored until it gets processed.
-
-        This is also the method to call for inter-thread
-        communication.  It will post events safely between different
-        threads which means that this method is thread-safe by using
-        critical sections where needed.  In a multi-threaded program,
-        you often need to inform the main GUI thread about the status
-        of other working threads and such notification should be done
-        using this method.
-
-        This method automatically wakes up idle handling if the
-        underlying window system is currently idle and thus would not
-        send any idle events.  (Waking up idle handling is done
-        calling WakeUpIdle.)"""
-        pass
-
-    def Connect(self, id, lastId, eventType, func):
-        """Connects the given function dynamically with the event
-        handler, id and event type.  This is an alternative to the use
-        of static event tables.
-
-        id is the identifier (or first of the identifier range) to be
-        associated with the event handler function.
-
-        lastId is the second part of the identifier range to be
-        associated with the event handler function.
-
-        eventType is the event type to be associated with this event
-        handler.
-
-        function is the event handler function.
-
-        userData is data to be associated with the event table entry."""
-        pass
-
-    def Disconnect(self, id, lastId=-1, eventType=wx.EVT_NULL):
-        """Disconnects the given function dynamically from the event
-        handler, using the specified parameters as search criteria and
-        returning True if a matching function has been found and
-        removed.  This method can only disconnect functions which have
-        been added using the EvtHandler.Connect method. There is no
-        way to disconnect functions connected using the (static) event
-        tables.
-
-        id is the identifier (or first of the identifier range) to be
-        associated with the event handler function.
-
-        lastId is the second part of the identifier range to be
-        associated with the event handler function.
-
-        eventType is the event type to be associated with this event
-        handler.
-
-        function is the event handler function.
-
-        userData is data to be associated with the event table entry."""
-        pass
-
-    def GetEvtHandlerEnabled(self):
-        """Return True if the event handler is enabled, False
-        otherwise."""
-        pass
-
-    def GetNextHandler(self):
-        """Return the next handler in the chain."""
-        pass
-
-    def GetPreviousHandler(self):
-        """Return the previous handler in the chain."""
-        pass
-
-    def ProcessEvent(self, event):
-        """Processes an event, searching event tables and calling zero
-        or more suitable event handler function(s).  Return True if a
-        suitable event handler function was found and executed, and
-        the function did not call Event.Skip().
-
-        event is an Event to process.
-
-        Normally, your application would not call this function: it is
-        called in the wxPython implementation to dispatch incoming
-        user interface events to the framework (and application).
-
-        However, you might need to call it if implementing new
-        functionality (such as a new control) where you define new
-        event types, as opposed to allowing the user to override
-        virtual functions.
-
-        An instance where you might actually override the ProcessEvent
-        function is where you want to direct event processing to event
-        handlers not normally noticed by wxWindows.  For example, in
-        the document/view architecture, documents and views are
-        potential event handlers.  When an event reaches a frame,
-        ProcessEvent will need to be called on the associated document
-        and view in case event handler functions are associated with
-        these objects.  The property classes library (Property) also
-        overrides ProcessEvent for similar reasons.
-
-        The normal order of event table searching is as follows:
-
-        1. If the object is disabled (via a call to
-        EvtHandler.SetEvtHandlerEnabled) the function skips to step
-        (6).
-
-        2. If the object is a Window, ProcessEvent is recursively
-        called on the window's Validator.  If this returns TRUE, the
-        function exits.
-
-        3. SearchEventTable is called for this event handler.  If this
-        fails, the base class table is tried, and so on until no more
-        tables exist or an appropriate function was found, in which
-        case the function exits.
-
-        4. The search is applied down the entire chain of event
-        handlers (usually the chain has a length of one).  If this
-        succeeds, the function exits.
-
-        5. If the object is a Window and the event is a
-        CommandEvent, ProcessEvent is recursively applied to the
-        parent window's event handler.  If this returns TRUE, the
-        function exits.
-
-        6. Finally, ProcessEvent is called on the App object.
-
-        See also:
-
-        EvtHandler::SearchEventTable"""
-        pass
-
-    def SetEvtHandlerEnabled(self, enabled):
-        """Enable or disable the event handler.
-
-        You can use this function to avoid having to remove the event
-        handler from the chain, for example when implementing a dialog
-        editor and changing from edit to test mode."""
-        pass
-
-    def SetNextHandler(self, handler):
-        """Set the pointer to the next handler."""
-        pass
-
-    def SetPreviousHandler(self, handler):
-        """Set the pointer to the previous handler."""
-        pass
-
-

wxPython/wxPython/py/wxd/ClipDragDrop.py

@@ -1,485 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-
-
-class Clipboard(Object):
-    """"""
-
-    def AddData(self):
-        """"""
-        pass
-
-    def Clear(self):
-        """"""
-        pass
-
-    def Close(self):
-        """"""
-        pass
-
-    def Flush(self):
-        """"""
-        pass
-
-    def GetData(self):
-        """"""
-        pass
-
-    def IsOpened(self):
-        """"""
-        pass
-
-    def IsSupported(self):
-        """"""
-        pass
-
-    def Open(self):
-        """"""
-        pass
-
-    def SetData(self):
-        """"""
-        pass
-
-    def UsePrimarySelection(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class DataFormat:
-    """"""
-
-    def GetId(self):
-        """"""
-        pass
-
-    def GetType(self):
-        """"""
-        pass
-
-    def SetId(self):
-        """"""
-        pass
-
-    def SetType(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class DataObject:
-    """"""
-
-    def GetAllFormats(self):
-        """"""
-        pass
-
-    def GetDataHere(self):
-        """"""
-        pass
-
-    def GetDataSize(self):
-        """"""
-        pass
-
-    def GetFormatCount(self):
-        """"""
-        pass
-
-    def GetPreferredFormat(self):
-        """"""
-        pass
-
-    def IsSupportedFormat(self):
-        """"""
-        pass
-
-    def SetData(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class DataObjectComposite(DataObject):
-    """"""
-
-    def Add(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class DataObjectSimple(DataObject):
-    """"""
-
-    def GetFormat(self):
-        """"""
-        pass
-
-    def SetFormat(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PyDataObjectSimple(DataObjectSimple):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class BitmapDataObject(DataObjectSimple):
-    """"""
-
-    def GetBitmap(self):
-        """"""
-        pass
-
-    def SetBitmap(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PyBitmapDataObject(BitmapDataObject):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class CustomDataObject(DataObjectSimple):
-    """"""
-
-    def GetData(self):
-        """"""
-        pass
-
-    def GetSize(self):
-        """"""
-        pass
-
-    def SetData(self):
-        """"""
-        pass
-
-    def TakeData(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class DragImage(Object):
-    """"""
-
-    def BeginDrag(self):
-        """"""
-        pass
-
-    def BeginDrag2(self):
-        """"""
-        pass
-
-    def EndDrag(self):
-        """"""
-        pass
-
-    def GetImageRect(self):
-        """"""
-        pass
-
-    def Hide(self):
-        """"""
-        pass
-
-    def Move(self):
-        """"""
-        pass
-
-    def RedrawImage(self):
-        """"""
-        pass
-
-    def SetBackingBitmap(self):
-        """"""
-        pass
-
-    def Show(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class DropSource:
-    """"""
-
-    def DoDragDrop(self):
-        """"""
-        pass
-
-    def GetDataObject(self):
-        """"""
-        pass
-
-    def SetCursor(self):
-        """"""
-        pass
-
-    def SetData(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-    def base_GiveFeedback(self):
-        """"""
-        pass
-
-
-class DropTarget:
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PyDropTarget(DropTarget):
-    """"""
-
-    def GetData(self):
-        """"""
-        pass
-
-    def GetDataObject(self):
-        """"""
-        pass
-
-    def SetDataObject(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-    def base_OnDragOver(self):
-        """"""
-        pass
-
-    def base_OnDrop(self):
-        """"""
-        pass
-
-    def base_OnEnter(self):
-        """"""
-        pass
-
-    def base_OnLeave(self):
-        """"""
-        pass
-
-
-class FileDataObject(DataObjectSimple):
-    """"""
-
-    def GetFilenames(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FileDropTarget(PyDropTarget):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-    def base_OnData(self):
-        """"""
-        pass
-
-    def base_OnDragOver(self):
-        """"""
-        pass
-
-    def base_OnDrop(self):
-        """"""
-        pass
-
-    def base_OnEnter(self):
-        """"""
-        pass
-
-    def base_OnLeave(self):
-        """"""
-        pass
-
-
-class TextDataObject(DataObjectSimple):
-    """"""
-
-    def GetText(self):
-        """"""
-        pass
-
-    def GetTextLength(self):
-        """"""
-        pass
-
-    def SetText(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PyTextDataObject(TextDataObject):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class TextDropTarget(PyDropTarget):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-    def base_OnData(self):
-        """"""
-        pass
-
-    def base_OnDragOver(self):
-        """"""
-        pass
-
-    def base_OnDrop(self):
-        """"""
-        pass
-
-    def base_OnEnter(self):
-        """"""
-        pass
-
-    def base_OnLeave(self):
-        """"""
-        pass
-
-
-class URLDataObject(DataObjectComposite):
-    """"""
-
-    def GetURL(self):
-        """"""
-        pass
-
-    def SetURL(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-

wxPython/wxPython/py/wxd/Config.py

@@ -1,199 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-import Parameters as wx
-
-
-class ConfigBase:
-    """"""
-
-    def DeleteAll(self):
-        """"""
-        pass
-
-    def DeleteEntry(self):
-        """"""
-        pass
-
-    def DeleteGroup(self):
-        """"""
-        pass
-
-    def Exists(self):
-        """"""
-        pass
-
-    def ExpandEnvVars(self):
-        """"""
-        pass
-
-    def Flush(self):
-        """"""
-        pass
-
-    def GetAppName(self):
-        """"""
-        pass
-
-    def GetEntryType(self):
-        """"""
-        pass
-
-    def GetFirstEntry(self):
-        """"""
-        pass
-
-    def GetFirstGroup(self):
-        """"""
-        pass
-
-    def GetNextEntry(self):
-        """"""
-        pass
-
-    def GetNextGroup(self):
-        """"""
-        pass
-
-    def GetNumberOfEntries(self):
-        """"""
-        pass
-
-    def GetNumberOfGroups(self):
-        """"""
-        pass
-
-    def GetPath(self):
-        """"""
-        pass
-
-    def GetStyle(self):
-        """"""
-        pass
-
-    def GetVendorName(self):
-        """"""
-        pass
-
-    def HasEntry(self):
-        """"""
-        pass
-
-    def HasGroup(self):
-        """"""
-        pass
-
-    def IsExpandingEnvVars(self):
-        """"""
-        pass
-
-    def IsRecordingDefaults(self):
-        """"""
-        pass
-
-    def Read(self):
-        """"""
-        pass
-
-    def ReadBool(self):
-        """"""
-        pass
-
-    def ReadFloat(self):
-        """"""
-        pass
-
-    def ReadInt(self):
-        """"""
-        pass
-
-    def RenameEntry(self):
-        """"""
-        pass
-
-    def RenameGroup(self):
-        """"""
-        pass
-
-    def SetAppName(self):
-        """"""
-        pass
-
-    def SetExpandEnvVars(self):
-        """"""
-        pass
-
-    def SetPath(self):
-        """"""
-        pass
-
-    def SetRecordDefaults(self):
-        """"""
-        pass
-
-    def SetStyle(self):
-        """"""
-        pass
-
-    def SetVendorName(self):
-        """"""
-        pass
-
-    def Write(self):
-        """"""
-        pass
-
-    def WriteBool(self):
-        """"""
-        pass
-
-    def WriteFloat(self):
-        """"""
-        pass
-
-    def WriteInt(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class Config(ConfigBase):
-    """"""
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FileConfig(ConfigBase):
-    """"""
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass

wxPython/wxPython/py/wxd/DataStructures.py

@@ -1,485 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-import Parameters as wx
-
-
-class Point:
-    """"""
-
-    def Set(self):
-        """"""
-        pass
-
-    def __add__(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __eq__(self):
-        """"""
-        pass
-
-    def __getattr__(self):
-        """"""
-        pass
-
-    def __getitem__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __len__(self):
-        """"""
-        pass
-
-    def __ne__(self):
-        """"""
-        pass
-
-    def __nonzero__(self):
-        """"""
-        pass
-
-    def __setattr__(self):
-        """"""
-        pass
-
-    def __setitem__(self):
-        """"""
-        pass
-
-    def __str__(self):
-        """"""
-        pass
-
-    def __sub__(self):
-        """"""
-        pass
-
-    def asTuple(self):
-        """"""
-        pass
-
-
-class Point2DDouble:
-    """"""
-
-    def GetCrossProduct(self):
-        """"""
-        pass
-
-    def GetDistance(self):
-        """"""
-        pass
-
-    def GetDistanceSquare(self):
-        """"""
-        pass
-
-    def GetDotProduct(self):
-        """"""
-        pass
-
-    def GetFloor(self):
-        """"""
-        pass
-
-    def GetRounded(self):
-        """"""
-        pass
-
-    def GetVectorAngle(self):
-        """"""
-        pass
-
-    def GetVectorLength(self):
-        """"""
-        pass
-
-    def Normalize(self):
-        """"""
-        pass
-
-    def SetPolarCoordinates(self):
-        """"""
-        pass
-
-    def SetVectorAngle(self):
-        """"""
-        pass
-
-    def SetVectorLength(self):
-        """"""
-        pass
-
-    def __eq__(self):
-        """"""
-        pass
-
-    def __getattr__(self):
-        """"""
-        pass
-
-    def __getitem__(self):
-        """"""
-        pass
-
-    def __iadd__(self):
-        """"""
-        pass
-
-    def __idiv__(self):
-        """"""
-        pass
-
-    def __imul__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __isub__(self):
-        """"""
-        pass
-
-    def __len__(self):
-        """"""
-        pass
-
-    def __ne__(self):
-        """"""
-        pass
-
-    def __neg__(self):
-        """"""
-        pass
-
-    def __nonzero__(self):
-        """"""
-        pass
-
-    def __setattr__(self):
-        """"""
-        pass
-
-    def __setitem__(self):
-        """"""
-        pass
-
-    def __str__(self):
-        """"""
-        pass
-
-    def asTuple(self):
-        """"""
-        pass
-
-
-class RealPoint:
-    """"""
-
-    def Set(self):
-        """"""
-        pass
-
-    def __add__(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __eq__(self):
-        """"""
-        pass
-
-    def __getattr__(self):
-        """"""
-        pass
-
-    def __getitem__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __len__(self):
-        """"""
-        pass
-
-    def __ne__(self):
-        """"""
-        pass
-
-    def __nonzero__(self):
-        """"""
-        pass
-
-    def __setattr__(self):
-        """"""
-        pass
-
-    def __setitem__(self):
-        """"""
-        pass
-
-    def __str__(self):
-        """"""
-        pass
-
-    def __sub__(self):
-        """"""
-        pass
-
-    def asTuple(self):
-        """"""
-        pass
-
-
-class Rect:
-    """"""
-
-    def GetBottom(self):
-        """"""
-        pass
-
-    def GetHeight(self):
-        """"""
-        pass
-
-    def GetLeft(self):
-        """"""
-        pass
-
-    def GetPosition(self):
-        """"""
-        pass
-
-    def GetRight(self):
-        """"""
-        pass
-
-    def GetSize(self):
-        """"""
-        pass
-
-    def GetTop(self):
-        """"""
-        pass
-
-    def GetWidth(self):
-        """"""
-        pass
-
-    def GetX(self):
-        """"""
-        pass
-
-    def GetY(self):
-        """"""
-        pass
-
-    def Inflate(self):
-        """"""
-        pass
-
-    def Inside(self):
-        """"""
-        pass
-
-    def SetBottom(self):
-        """"""
-        pass
-
-    def SetHeight(self):
-        """"""
-        pass
-
-    def SetLeft(self):
-        """"""
-        pass
-
-    def SetPosition(self):
-        """"""
-        pass
-
-    def SetRight(self):
-        """"""
-        pass
-
-    def SetSize(self):
-        """"""
-        pass
-
-    def SetTop(self):
-        """"""
-        pass
-
-    def SetWidth(self):
-        """"""
-        pass
-
-    def SetX(self):
-        """"""
-        pass
-
-    def SetY(self):
-        """"""
-        pass
-
-    def __add__(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __eq__(self):
-        """"""
-        pass
-
-    def __getattr__(self):
-        """"""
-        pass
-
-    def __getitem__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __len__(self):
-        """"""
-        pass
-
-    def __ne__(self):
-        """"""
-        pass
-
-    def __nonzero__(self):
-        """"""
-        pass
-
-    def __setattr__(self):
-        """"""
-        pass
-
-    def __setitem__(self):
-        """"""
-        pass
-
-    def __str__(self):
-        """"""
-        pass
-
-    def asTuple(self):
-        """"""
-        pass
-
-
-class Size:
-    """"""
-
-    def GetHeight(self):
-        """"""
-        pass
-
-    def GetWidth(self):
-        """"""
-        pass
-
-    def GetX(self):
-        """"""
-        pass
-
-    def GetY(self):
-        """"""
-        pass
-
-    def Set(self):
-        """"""
-        pass
-
-    def SetHeight(self):
-        """"""
-        pass
-
-    def SetWidth(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __eq__(self):
-        """"""
-        pass
-
-    def __getattr__(self):
-        """"""
-        pass
-
-    def __getitem__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __len__(self):
-        """"""
-        pass
-
-    def __ne__(self):
-        """"""
-        pass
-
-    def __nonzero__(self):
-        """"""
-        pass
-
-    def __setattr__(self):
-        """"""
-        pass
-
-    def __setitem__(self):
-        """"""
-        pass
-
-    def __str__(self):
-        """"""
-        pass
-
-    def asTuple(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/DateTime.py

@@ -1,553 +0,0 @@
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-import Parameters as wx
-
-
-class DateSpan:
-    """"""
-
-    def Add(self):
-        """"""
-        pass
-
-    def GetDays(self):
-        """"""
-        pass
-
-    def GetMonths(self):
-        """"""
-        pass
-
-    def GetTotalDays(self):
-        """"""
-        pass
-
-    def GetWeeks(self):
-        """"""
-        pass
-
-    def GetYears(self):
-        """"""
-        pass
-
-    def Multiply(self):
-        """"""
-        pass
-
-    def Neg(self):
-        """"""
-        pass
-
-    def SetDays(self):
-        """"""
-        pass
-
-    def SetMonths(self):
-        """"""
-        pass
-
-    def SetWeeks(self):
-        """"""
-        pass
-
-    def SetYears(self):
-        """"""
-        pass
-
-    def Subtract(self):
-        """"""
-        pass
-
-    def __add__(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __mul__(self):
-        """"""
-        pass
-
-    def __neg__(self):
-        """"""
-        pass
-
-    def __rmul__(self):
-        """"""
-        pass
-
-    def __sub__(self):
-        """"""
-        pass
-
-
-class DateTime:
-    """"""
-
-    def AddDS(self):
-        """"""
-        pass
-
-    def AddTS(self):
-        """"""
-        pass
-
-    def Format(self):
-        """"""
-        pass
-
-    def FormatDate(self):
-        """"""
-        pass
-
-    def FormatISODate(self):
-        """"""
-        pass
-
-    def FormatISOTime(self):
-        """"""
-        pass
-
-    def FormatTime(self):
-        """"""
-        pass
-
-    def GetDay(self):
-        """"""
-        pass
-
-    def GetDayOfYear(self):
-        """"""
-        pass
-
-    def GetHour(self):
-        """"""
-        pass
-
-    def GetJDN(self):
-        """"""
-        pass
-
-    def GetJulianDayNumber(self):
-        """"""
-        pass
-
-    def GetLastMonthDay(self):
-        """"""
-        pass
-
-    def GetLastWeekDay(self):
-        """"""
-        pass
-
-    def GetMJD(self):
-        """"""
-        pass
-
-    def GetMillisecond(self):
-        """"""
-        pass
-
-    def GetMinute(self):
-        """"""
-        pass
-
-    def GetModifiedJulianDayNumber(self):
-        """"""
-        pass
-
-    def GetMonth(self):
-        """"""
-        pass
-
-    def GetNextWeekDay(self):
-        """"""
-        pass
-
-    def GetPrevWeekDay(self):
-        """"""
-        pass
-
-    def GetRataDie(self):
-        """"""
-        pass
-
-    def GetSecond(self):
-        """"""
-        pass
-
-    def GetTicks(self):
-        """"""
-        pass
-
-    def GetWeek(self):
-        """"""
-        pass
-
-    def GetWeekDay(self):
-        """"""
-        pass
-
-    def GetWeekDayInSameWeek(self):
-        """"""
-        pass
-
-    def GetWeekOfMonth(self):
-        """"""
-        pass
-
-    def GetWeekOfYear(self):
-        """"""
-        pass
-
-    def GetYear(self):
-        """"""
-        pass
-
-    def GetYearDay(self):
-        """"""
-        pass
-
-    def IsBetween(self):
-        """"""
-        pass
-
-    def IsDST(self):
-        """"""
-        pass
-
-    def IsEarlierThan(self):
-        """"""
-        pass
-
-    def IsEqualTo(self):
-        """"""
-        pass
-
-    def IsEqualUpTo(self):
-        """"""
-        pass
-
-    def IsLaterThan(self):
-        """"""
-        pass
-
-    def IsSameDate(self):
-        """"""
-        pass
-
-    def IsSameTime(self):
-        """"""
-        pass
-
-    def IsStrictlyBetween(self):
-        """"""
-        pass
-
-    def IsValid(self):
-        """"""
-        pass
-
-    def IsWorkDay(self):
-        """"""
-        pass
-
-    def MakeGMT(self):
-        """"""
-        pass
-
-    def MakeTimezone(self):
-        """"""
-        pass
-
-    def ParseDate(self):
-        """"""
-        pass
-
-    def ParseDateTime(self):
-        """"""
-        pass
-
-    def ParseFormat(self):
-        """"""
-        pass
-
-    def ParseRfc822Date(self):
-        """"""
-        pass
-
-    def ParseTime(self):
-        """"""
-        pass
-
-    def ResetTime(self):
-        """"""
-        pass
-
-    def Set(self):
-        """"""
-        pass
-
-    def SetDay(self):
-        """"""
-        pass
-
-    def SetHMS(self):
-        """"""
-        pass
-
-    def SetHour(self):
-        """"""
-        pass
-
-    def SetJDN(self):
-        """"""
-        pass
-
-    def SetMillisecond(self):
-        """"""
-        pass
-
-    def SetMinute(self):
-        """"""
-        pass
-
-    def SetMonth(self):
-        """"""
-        pass
-
-    def SetSecond(self):
-        """"""
-        pass
-
-    def SetTimeT(self):
-        """"""
-        pass
-
-    def SetToCurrent(self):
-        """"""
-        pass
-
-    def SetToLastMonthDay(self):
-        """"""
-        pass
-
-    def SetToLastWeekDay(self):
-        """"""
-        pass
-
-    def SetToNextWeekDay(self):
-        """"""
-        pass
-
-    def SetToPrevWeekDay(self):
-        """"""
-        pass
-
-    def SetToTheWeek(self):
-        """"""
-        pass
-
-    def SetToWeekDay(self):
-        """"""
-        pass
-
-    def SetToWeekDayInSameWeek(self):
-        """"""
-        pass
-
-    def SetToYearDay(self):
-        """"""
-        pass
-
-    def SetYear(self):
-        """"""
-        pass
-
-    def Subtract(self):
-        """"""
-        pass
-
-    def SubtractDS(self):
-        """"""
-        pass
-
-    def SubtractTS(self):
-        """"""
-        pass
-
-    def ToGMT(self):
-        """"""
-        pass
-
-    def ToTimezone(self):
-        """"""
-        pass
-
-    def __add__(self):
-        """"""
-        pass
-
-    def __cmp__(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __str__(self):
-        """"""
-        pass
-
-    def __sub__(self):
-        """"""
-        pass
-
-    def _wxDateTimePtr__add__DS(self):
-        """"""
-        pass
-
-    def _wxDateTimePtr__add__TS(self):
-        """"""
-        pass
-
-    def _wxDateTimePtr__sub__DS(self):
-        """"""
-        pass
-
-    def _wxDateTimePtr__sub__DT(self):
-        """"""
-        pass
-
-    def _wxDateTimePtr__sub__TS(self):
-        """"""
-        pass
-
-
-class TimeSpan:
-    """"""
-
-    def Abs(self):
-        """"""
-        pass
-
-    def Add(self):
-        """"""
-        pass
-
-    def Format(self):
-        """"""
-        pass
-
-    def GetDays(self):
-        """"""
-        pass
-
-    def GetHours(self):
-        """"""
-        pass
-
-    def GetMilliseconds(self):
-        """"""
-        pass
-
-    def GetMinutes(self):
-        """"""
-        pass
-
-    def GetSeconds(self):
-        """"""
-        pass
-
-    def GetWeeks(self):
-        """"""
-        pass
-
-    def IsEqualTo(self):
-        """"""
-        pass
-
-    def IsLongerThan(self):
-        """"""
-        pass
-
-    def IsNegative(self):
-        """"""
-        pass
-
-    def IsNull(self):
-        """"""
-        pass
-
-    def IsPositive(self):
-        """"""
-        pass
-
-    def IsShorterThan(self):
-        """"""
-        pass
-
-    def Multiply(self):
-        """"""
-        pass
-
-    def Neg(self):
-        """"""
-        pass
-
-    def Subtract(self):
-        """"""
-        pass
-
-    def __add__(self):
-        """"""
-        pass
-
-    def __cmp__(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __mul__(self):
-        """"""
-        pass
-
-    def __neg__(self):
-        """"""
-        pass
-
-    def __rmul__(self):
-        """"""
-        pass
-
-    def __sub__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/Dialogs.py

@@ -1,471 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-from Frames import Frame
-import Parameters as wx
-from Window import TopLevelWindow
-
-
-class Dialog(TopLevelWindow):
-    """"""
-
-    def Centre(self):
-        """"""
-        pass
-
-    def Create(self):
-        """"""
-        pass
-
-    def CreateButtonSizer(self):
-        """"""
-        pass
-
-    def CreateTextSizer(self):
-        """"""
-        pass
-
-    def EndModal(self):
-        """"""
-        pass
-
-    def GetReturnCode(self):
-        """"""
-        pass
-
-    def IsModal(self):
-        """"""
-        pass
-
-    def SetModal(self):
-        """"""
-        pass
-
-    def SetReturnCode(self):
-        """"""
-        pass
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ColourDialog(Dialog):
-    """"""
-
-    def GetColourData(self):
-        """"""
-        pass
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ColourData(Object):
-    """"""
-
-    def GetChooseFull(self):
-        """"""
-        pass
-
-    def GetColour(self):
-        """"""
-        pass
-
-    def GetCustomColour(self):
-        """"""
-        pass
-
-    def SetChooseFull(self):
-        """"""
-        pass
-
-    def SetColour(self):
-        """"""
-        pass
-
-    def SetCustomColour(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ColourDatabase(Object):
-    """"""
-
-    def Append(self):
-        """"""
-        pass
-
-    def FindColour(self):
-        """"""
-        pass
-
-    def FindName(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class DirDialog(Dialog):
-    """"""
-
-    def GetMessage(self):
-        """"""
-        pass
-
-    def GetPath(self):
-        """"""
-        pass
-
-    def GetStyle(self):
-        """"""
-        pass
-
-    def SetMessage(self):
-        """"""
-        pass
-
-    def SetPath(self):
-        """"""
-        pass
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FileDialog(Dialog):
-    """"""
-
-    def GetDirectory(self):
-        """"""
-        pass
-
-    def GetFilename(self):
-        """"""
-        pass
-
-    def GetFilenames(self):
-        """"""
-        pass
-
-    def GetFilterIndex(self):
-        """"""
-        pass
-
-    def GetMessage(self):
-        """"""
-        pass
-
-    def GetPath(self):
-        """"""
-        pass
-
-    def GetPaths(self):
-        """"""
-        pass
-
-    def GetStyle(self):
-        """"""
-        pass
-
-    def GetWildcard(self):
-        """"""
-        pass
-
-    def SetDirectory(self):
-        """"""
-        pass
-
-    def SetFilename(self):
-        """"""
-        pass
-
-    def SetFilterIndex(self):
-        """"""
-        pass
-
-    def SetMessage(self):
-        """"""
-        pass
-
-    def SetPath(self):
-        """"""
-        pass
-
-    def SetStyle(self):
-        """"""
-        pass
-
-    def SetWildcard(self):
-        """"""
-        pass
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FindReplaceDialog(Dialog):
-    """"""
-
-    def Create(self):
-        """"""
-        pass
-
-    def GetData(self):
-        """"""
-        pass
-
-    def SetData(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FindReplaceData(Object):
-    """"""
-
-    def GetFindString(self):
-        """"""
-        pass
-
-    def GetFlags(self):
-        """"""
-        pass
-
-    def GetReplaceString(self):
-        """"""
-        pass
-
-    def SetFindString(self):
-        """"""
-        pass
-
-    def SetFlags(self):
-        """"""
-        pass
-
-    def SetReplaceString(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FontDialog(Dialog):
-    """"""
-
-    def GetFontData(self):
-        """"""
-        pass
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FontData(Object):
-    """"""
-
-    def EnableEffects(self):
-        """"""
-        pass
-
-    def GetAllowSymbols(self):
-        """"""
-        pass
-
-    def GetChosenFont(self):
-        """"""
-        pass
-
-    def GetColour(self):
-        """"""
-        pass
-
-    def GetEnableEffects(self):
-        """"""
-        pass
-
-    def GetInitialFont(self):
-        """"""
-        pass
-
-    def GetShowHelp(self):
-        """"""
-        pass
-
-    def SetAllowSymbols(self):
-        """"""
-        pass
-
-    def SetChosenFont(self):
-        """"""
-        pass
-
-    def SetColour(self):
-        """"""
-        pass
-
-    def SetInitialFont(self):
-        """"""
-        pass
-
-    def SetRange(self):
-        """"""
-        pass
-
-    def SetShowHelp(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class MessageDialog(Dialog):
-    """"""
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-
-class MultiChoiceDialog(Dialog):
-    """"""
-
-    def GetSelections(self):
-        """"""
-        pass
-
-    def SetSelections(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ProgressDialog(Frame):
-    """"""
-
-    def Resume(self):
-        """"""
-        pass
-
-    def Update(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class SingleChoiceDialog(Dialog):
-    """"""
-
-    def GetSelection(self):
-        """"""
-        pass
-
-    def GetStringSelection(self):
-        """"""
-        pass
-
-    def SetSelection(self):
-        """"""
-        pass
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class TextEntryDialog(Dialog):
-    """"""
-
-    def GetValue(self):
-        """"""
-        pass
-
-    def SetValue(self):
-        """"""
-        pass
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass

wxPython/wxPython/py/wxd/Errors.py

@@ -1,25 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-class PyAssertionError(AssertionError):
-    """"""
-    pass
-
-
-class PyDeadObjectError(AttributeError):
-    """Instances of wx objects that are OOR capable will have their
-    __class__ attribute changed to a _wxPyDeadObject class when the
-    C++ object is deleted.  Subsequent attempts to access object
-    attributes will raise this error, rather than segfault."""
-    pass

wxPython/wxPython/py/wxd/EventFunctions.py

@@ -1,801 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-def EVT_ACTIVATE(win, func):
-    """"""
-    pass
-
-def EVT_ACTIVATE_APP(win, func):
-    """"""
-    pass
-
-def EVT_BUTTON(win, id, func):
-    """"""
-    pass
-
-def EVT_CALCULATE_LAYOUT():
-    """"""
-    pass
-
-def EVT_CHAR(win, func):
-    """"""
-    pass
-
-def EVT_CHAR_HOOK(win, func):
-    """"""
-    pass
-
-def EVT_CHECKBOX(win, id, func):
-    """"""
-    pass
-
-def EVT_CHECKLISTBOX(win, id, func):
-    """"""
-    pass
-
-def EVT_CHILD_FOCUS(win, func):
-    """"""
-    pass
-
-def EVT_CHOICE(win, id, func):
-    """"""
-    pass
-
-def EVT_CLOSE(win, func):
-    """"""
-    pass
-
-def EVT_COMBOBOX(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND(win, id, cmd, func):
-    """"""
-    pass
-
-def EVT_COMMAND_ENTER(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_FIND():
-    """"""
-    pass
-
-def EVT_COMMAND_FIND_CLOSE():
-    """"""
-    pass
-
-def EVT_COMMAND_FIND_NEXT():
-    """"""
-    pass
-
-def EVT_COMMAND_FIND_REPLACE():
-    """"""
-    pass
-
-def EVT_COMMAND_FIND_REPLACE_ALL():
-    """"""
-    pass
-
-def EVT_COMMAND_KILL_FOCUS(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_LEFT_CLICK(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_LEFT_DCLICK(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_RANGE(win, id1, id2, cmd, func):
-    """"""
-    pass
-
-def EVT_COMMAND_RIGHT_CLICK(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_RIGHT_DCLICK(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLLWIN(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLLWIN_BOTTOM(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLLWIN_LINEDOWN(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLLWIN_LINEUP(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLLWIN_PAGEDOWN(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLLWIN_PAGEUP(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLLWIN_THUMBRELEASE(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLLWIN_THUMBTRACK(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLLWIN_TOP(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL_BOTTOM(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL_ENDSCROLL(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL_LINEDOWN(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL_LINEUP(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL_PAGEDOWN(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL_PAGEUP(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL_THUMBRELEASE(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL_THUMBTRACK(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SCROLL_TOP(win, id, func):
-    """"""
-    pass
-
-def EVT_COMMAND_SET_FOCUS(win, id, func):
-    """"""
-    pass
-
-def EVT_CONTEXT_MENU(win, func):
-    """"""
-    pass
-
-def EVT_DISPLAY_CHANGED(win, func):
-    """"""
-    pass
-
-def EVT_DROP_FILES(win, func):
-    """"""
-    pass
-
-def EVT_END_PROCESS(eh, id, func):
-    """"""
-    pass
-
-def EVT_END_SESSION(win, func):
-    """"""
-    pass
-
-def EVT_ENTER_WINDOW(win, func):
-    """"""
-    pass
-
-def EVT_ERASE_BACKGROUND(win, func):
-    """"""
-    pass
-
-def EVT_ICONIZE(win, func):
-    """"""
-    pass
-
-def EVT_IDLE(win, func):
-    """"""
-    pass
-
-def EVT_INIT_DIALOG(win, func):
-    """"""
-    pass
-
-def EVT_JOYSTICK_EVENTS(win, func):
-    """"""
-    pass
-
-def EVT_JOY_DOWN(win, func):
-    """"""
-    pass
-
-def EVT_JOY_MOVE(win, func):
-    """"""
-    pass
-
-def EVT_JOY_UP(win, func):
-    """"""
-    pass
-
-def EVT_JOY_ZMOVE(win, func):
-    """"""
-    pass
-
-def EVT_KEY_DOWN(win, func):
-    """"""
-    pass
-
-def EVT_KEY_UP(win, func):
-    """"""
-    pass
-
-def EVT_KILL_FOCUS(win, func):
-    """"""
-    pass
-
-def EVT_LEAVE_WINDOW(win, func):
-    """"""
-    pass
-
-def EVT_LEFT_DCLICK(win, func):
-    """"""
-    pass
-
-def EVT_LEFT_DOWN(win, func):
-    """"""
-    pass
-
-def EVT_LEFT_UP(win, func):
-    """"""
-    pass
-
-def EVT_LISTBOX(win, id, func):
-    """"""
-    pass
-
-def EVT_LISTBOX_DCLICK(win, id, func):
-    """"""
-    pass
-
-def EVT_LIST_BEGIN_DRAG():
-    """"""
-    pass
-
-def EVT_LIST_BEGIN_LABEL_EDIT():
-    """"""
-    pass
-
-def EVT_LIST_BEGIN_RDRAG():
-    """"""
-    pass
-
-def EVT_LIST_CACHE_HINT():
-    """"""
-    pass
-
-def EVT_LIST_COL_BEGIN_DRAG():
-    """"""
-    pass
-
-def EVT_LIST_COL_CLICK():
-    """"""
-    pass
-
-def EVT_LIST_COL_DRAGGING():
-    """"""
-    pass
-
-def EVT_LIST_COL_END_DRAG():
-    """"""
-    pass
-
-def EVT_LIST_COL_RIGHT_CLICK():
-    """"""
-    pass
-
-def EVT_LIST_DELETE_ALL_ITEMS():
-    """"""
-    pass
-
-def EVT_LIST_DELETE_ITEM():
-    """"""
-    pass
-
-def EVT_LIST_END_LABEL_EDIT():
-    """"""
-    pass
-
-def EVT_LIST_GET_INFO():
-    """"""
-    pass
-
-def EVT_LIST_INSERT_ITEM():
-    """"""
-    pass
-
-def EVT_LIST_ITEM_ACTIVATED():
-    """"""
-    pass
-
-def EVT_LIST_ITEM_DESELECTED():
-    """"""
-    pass
-
-def EVT_LIST_ITEM_FOCUSED():
-    """"""
-    pass
-
-def EVT_LIST_ITEM_MIDDLE_CLICK():
-    """"""
-    pass
-
-def EVT_LIST_ITEM_RIGHT_CLICK():
-    """"""
-    pass
-
-def EVT_LIST_ITEM_SELECTED():
-    """"""
-    pass
-
-def EVT_LIST_KEY_DOWN():
-    """"""
-    pass
-
-def EVT_LIST_SET_INFO():
-    """"""
-    pass
-
-def EVT_MAXIMIZE(win, func):
-    """"""
-    pass
-
-def EVT_MENU(win, id, func):
-    """"""
-    pass
-
-def EVT_MENU_CLOSE(win, func):
-    """"""
-    pass
-
-def EVT_MENU_HIGHLIGHT(win, id, func):
-    """"""
-    pass
-
-def EVT_MENU_HIGHLIGHT_ALL(win, func):
-    """"""
-    pass
-
-def EVT_MENU_OPEN(win, func):
-    """"""
-    pass
-
-def EVT_MENU_RANGE(win, id1, id2, func):
-    """"""
-    pass
-
-def EVT_MIDDLE_DCLICK(win, func):
-    """"""
-    pass
-
-def EVT_MIDDLE_DOWN(win, func):
-    """"""
-    pass
-
-def EVT_MIDDLE_UP(win, func):
-    """"""
-    pass
-
-def EVT_MOTION(win, func):
-    """"""
-    pass
-
-def EVT_MOUSEWHEEL(win, func):
-    """"""
-    pass
-
-def EVT_MOUSE_CAPTURE_CHANGED(win, func):
-    """"""
-    pass
-
-def EVT_MOUSE_EVENTS(win, func):
-    """"""
-    pass
-
-def EVT_MOVE(win, func):
-    """"""
-    pass
-
-def EVT_NAVIGATION_KEY(win, func):
-    """"""
-    pass
-
-def EVT_NOTEBOOK_PAGE_CHANGED(win, id, func):
-    """"""
-    pass
-
-def EVT_NOTEBOOK_PAGE_CHANGING(win, id, func):
-    """"""
-    pass
-
-def EVT_PAINT(win, func):
-    """"""
-    pass
-
-def EVT_PALETTE_CHANGED(win, func):
-    """"""
-    pass
-
-def EVT_QUERY_END_SESSION(win, func):
-    """"""
-    pass
-
-def EVT_QUERY_LAYOUT_INFO():
-    """"""
-    pass
-
-def EVT_QUERY_NEW_PALETTE(win, func):
-    """"""
-    pass
-
-def EVT_RADIOBOX(win, id, func):
-    """"""
-    pass
-
-def EVT_RADIOBUTTON(win, id, func):
-    """"""
-    pass
-
-def EVT_RIGHT_DCLICK(win, func):
-    """"""
-    pass
-
-def EVT_RIGHT_DOWN(win, func):
-    """"""
-    pass
-
-def EVT_RIGHT_UP(win, func):
-    """"""
-    pass
-
-def EVT_SASH_DRAGGED(win, id, func):
-    """"""
-    pass
-
-def EVT_SASH_DRAGGED_RANGE(win, id1, id2, func):
-    """"""
-    pass
-
-def EVT_SCROLL(win, func):
-    """"""
-    pass
-
-def EVT_SCROLLWIN(win, func):
-    """"""
-    pass
-
-def EVT_SCROLLWIN_BOTTOM(win, func):
-    """"""
-    pass
-
-def EVT_SCROLLWIN_LINEDOWN(win, func):
-    """"""
-    pass
-
-def EVT_SCROLLWIN_LINEUP(win, func):
-    """"""
-    pass
-
-def EVT_SCROLLWIN_PAGEDOWN(win, func):
-    """"""
-    pass
-
-def EVT_SCROLLWIN_PAGEUP(win, func):
-    """"""
-    pass
-
-def EVT_SCROLLWIN_THUMBRELEASE(win, func):
-    """"""
-    pass
-
-def EVT_SCROLLWIN_THUMBTRACK(win, func):
-    """"""
-    pass
-
-def EVT_SCROLLWIN_TOP(win, func):
-    """"""
-    pass
-
-def EVT_SCROLL_BOTTOM(win, func):
-    """"""
-    pass
-
-def EVT_SCROLL_ENDSCROLL(win, func):
-    """"""
-    pass
-
-def EVT_SCROLL_LINEDOWN(win, func):
-    """"""
-    pass
-
-def EVT_SCROLL_LINEUP(win, func):
-    """"""
-    pass
-
-def EVT_SCROLL_PAGEDOWN(win, func):
-    """"""
-    pass
-
-def EVT_SCROLL_PAGEUP(win, func):
-    """"""
-    pass
-
-def EVT_SCROLL_THUMBRELEASE(win, func):
-    """"""
-    pass
-
-def EVT_SCROLL_THUMBTRACK(win, func):
-    """"""
-    pass
-
-def EVT_SCROLL_TOP(win, func):
-    """"""
-    pass
-
-def EVT_SET_CURSOR(win, func):
-    """"""
-    pass
-
-def EVT_SET_FOCUS(win, func):
-    """"""
-    pass
-
-def EVT_SHOW(win, func):
-    """"""
-    pass
-
-def EVT_SIZE():
-    """"""
-    pass
-
-def EVT_SLIDER(win, id, func):
-    """"""
-    pass
-
-def EVT_SPIN(win, id, func):
-    """"""
-    pass
-
-def EVT_SPINCTRL(win, id, func):
-    """"""
-    pass
-
-def EVT_SPIN_DOWN(win, id, func):
-    """"""
-    pass
-
-def EVT_SPIN_UP(win, id, func):
-    """"""
-    pass
-
-def EVT_SPLITTER_DOUBLECLICKED(win, id, func):
-    """"""
-    pass
-
-def EVT_SPLITTER_SASH_POS_CHANGED(win, id, func):
-    """"""
-    pass
-
-def EVT_SPLITTER_SASH_POS_CHANGING(win, id, func):
-    """"""
-    pass
-
-def EVT_SPLITTER_UNSPLIT(win, id, func):
-    """"""
-    pass
-
-def EVT_SYS_COLOUR_CHANGED(win, func):
-    """"""
-    pass
-
-def EVT_TASKBAR_LEFT_DCLICK(win, func):
-    """"""
-    pass
-
-def EVT_TASKBAR_LEFT_DOWN(win, func):
-    """"""
-    pass
-
-def EVT_TASKBAR_LEFT_UP(win, func):
-    """"""
-    pass
-
-def EVT_TASKBAR_MOVE(win, func):
-    """"""
-    pass
-
-def EVT_TASKBAR_RIGHT_DCLICK(win, func):
-    """"""
-    pass
-
-def EVT_TASKBAR_RIGHT_DOWN(win, func):
-    """"""
-    pass
-
-def EVT_TASKBAR_RIGHT_UP(win, func):
-    """"""
-    pass
-
-def EVT_TEXT(win, id, func):
-    """"""
-    pass
-
-def EVT_TEXT_ENTER(win, id, func):
-    """"""
-    pass
-
-def EVT_TEXT_MAXLEN(win, id, func):
-    """"""
-    pass
-
-def EVT_TEXT_URL(win, id, func):
-    """"""
-    pass
-
-def EVT_TIMER(win, id, func):
-    """"""
-    pass
-
-def EVT_TOGGLEBUTTON(win, id, func):
-    """"""
-    pass
-
-def EVT_TOOL(win, id, func):
-    """"""
-    pass
-
-def EVT_TOOL_ENTER(win, id, func):
-    """"""
-    pass
-
-def EVT_TOOL_RANGE(win, id, id2, func):
-    """"""
-    pass
-
-def EVT_TOOL_RCLICKED(win, id, func):
-    """"""
-    pass
-
-def EVT_TOOL_RCLICKED_RANGE(win, id, id2, func):
-    """"""
-    pass
-
-def EVT_TREE_BEGIN_DRAG():
-    """"""
-    pass
-
-def EVT_TREE_BEGIN_LABEL_EDIT():
-    """"""
-    pass
-
-def EVT_TREE_BEGIN_RDRAG():
-    """"""
-    pass
-
-def EVT_TREE_DELETE_ITEM():
-    """"""
-    pass
-
-def EVT_TREE_END_DRAG():
-    """"""
-    pass
-
-def EVT_TREE_END_LABEL_EDIT():
-    """"""
-    pass
-
-def EVT_TREE_GET_INFO():
-    """"""
-    pass
-
-def EVT_TREE_ITEM_ACTIVATED():
-    """"""
-    pass
-
-def EVT_TREE_ITEM_COLLAPSED():
-    """"""
-    pass
-
-def EVT_TREE_ITEM_COLLAPSING():
-    """"""
-    pass
-
-def EVT_TREE_ITEM_EXPANDED():
-    """"""
-    pass
-
-def EVT_TREE_ITEM_EXPANDING():
-    """"""
-    pass
-
-def EVT_TREE_ITEM_MIDDLE_CLICK():
-    """"""
-    pass
-
-def EVT_TREE_ITEM_RIGHT_CLICK():
-    """"""
-    pass
-
-def EVT_TREE_KEY_DOWN():
-    """"""
-    pass
-
-def EVT_TREE_SEL_CHANGED():
-    """"""
-    pass
-
-def EVT_TREE_SEL_CHANGING():
-    """"""
-    pass
-
-def EVT_TREE_SET_INFO():
-    """"""
-    pass
-
-def EVT_UPDATE_UI(win, id, func):
-    """"""
-    pass
-
-def EVT_UPDATE_UI_RANGE(win, id, id2, func):
-    """"""
-    pass
-
-def EVT_VLBOX(win, id, func):
-    """"""
-    pass
-
-def EVT_WINDOW_CREATE(win, func):
-    """"""
-    pass
-
-def EVT_WINDOW_CREATE_ID(win, id, func):
-    """"""
-    pass
-
-def EVT_WINDOW_DESTROY(win, func):
-    """"""
-    pass
-
-def EVT_WINDOW_DESTROY_ID(win, id, func):
-    """"""
-    pass

wxPython/wxPython/py/wxd/FileSystem.py

@@ -1,193 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-
-
-class FSFile(Object):
-    """"""
-
-    def GetAnchor(self):
-        """"""
-        pass
-
-    def GetLocation(self):
-        """"""
-        pass
-
-    def GetMimeType(self):
-        """"""
-        pass
-
-    def GetModificationTime(self):
-        """"""
-        pass
-
-    def GetStream(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FileSystem(Object):
-    """"""
-
-    def ChangePathTo(self):
-        """"""
-        pass
-
-    def FindFirst(self):
-        """"""
-        pass
-
-    def FindNext(self):
-        """"""
-        pass
-
-    def GetPath(self):
-        """"""
-        pass
-
-    def OpenFile(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class CPPFileSystemHandler(Object):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FileSystemHandler(CPPFileSystemHandler):
-    """"""
-
-    def CanOpen(self):
-        """"""
-        pass
-
-    def FindFirst(self):
-        """"""
-        pass
-
-    def FindNext(self):
-        """"""
-        pass
-
-    def GetAnchor(self):
-        """"""
-        pass
-
-    def GetLeftLocation(self):
-        """"""
-        pass
-
-    def GetMimeTypeFromExt(self):
-        """"""
-        pass
-
-    def GetProtocol(self):
-        """"""
-        pass
-
-    def GetRightLocation(self):
-        """"""
-        pass
-
-    def OpenFile(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class InternetFSHandler(CPPFileSystemHandler):
-    """"""
-
-    def CanOpen(self):
-        """"""
-        pass
-
-    def OpenFile(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class MemoryFSHandler(CPPFileSystemHandler):
-    """"""
-
-    def CanOpen(self):
-        """"""
-        pass
-
-    def FindFirst(self):
-        """"""
-        pass
-
-    def FindNext(self):
-        """"""
-        pass
-
-    def OpenFile(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ZipFSHandler(CPPFileSystemHandler):
-    """"""
-
-    def CanOpen(self):
-        """"""
-        pass
-
-    def FindFirst(self):
-        """"""
-        pass
-
-    def FindNext(self):
-        """"""
-        pass
-
-    def OpenFile(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-

wxPython/wxPython/py/wxd/Frames.py

@@ -1,519 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-from Window import TopLevelWindow, Window
-
-
-class Frame(TopLevelWindow):
-    """A frame is a window whose size and position can (usually) be
-    changed by the user. It usually has thick borders and a title bar,
-    and can optionally contain a menu bar, toolbar and status bar. A
-    frame can contain any window that is not a frame or dialog.
-
-    A frame that has a status bar and toolbar created via the
-    CreateStatusBar/CreateToolBar functions manages these windows, and
-    adjusts the value returned by GetClientSize to reflect the
-    remaining size available to application windows.
-
-    An application should normally define a CloseEvent handler for the
-    frame to respond to system close events, for example so that
-    related data and subwindows can be cleaned up."""
-
-    def __init__(self, parent, id, title, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE,
-                 name=wx.PyFrameNameStr):
-        """Create a Frame instance.
-
-        parent - The window parent.  This may be None.  If it is not
-        None, the frame will always be displayed on top of the parent
-        window on Windows.
-
-        id - The window identifier. It may take a value of -1 to
-        indicate a default value.
-
-        title - The caption to be displayed on the frame's title bar.
-
-        pos - The window position. A value of (-1, -1) indicates a
-        default position, chosen by either the windowing system or
-        wxWindows, depending on platform.
-
-        size - The window size. A value of (-1, -1) indicates a
-        default size, chosen by either the windowing system or
-        wxWindows, depending on platform.
-
-        style - The window style.
-
-        name - The name of the window. This parameter is used to
-        associate a name with the item, allowing the application user
-        to set Motif resource values for individual windows."""
-        pass
-
-    def Create(self, parent, id, title, pos=wx.DefaultPosition,
-               size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE,
-               name=wx.PyFrameNameStr):
-        """Create a Frame instance."""
-        pass
-
-    def Command(self, id):
-        """Simulate a menu command; id is a menu item identifier."""
-        pass
-
-    def CreateStatusBar(self, number=1, style=wx.ST_SIZEGRIP, id=-1,
-                        name=wx.PyStatusLineNameStr):
-        """Create a status bar at the bottom of frame.
-
-        number - The number of fields to create. Specify a value
-        greater than 1 to create a multi-field status bar.
-
-        style - The status bar style. See wx.StatusBar for a list of
-        valid styles.
-
-        id - The status bar window identifier. If -1, an identifier
-        will be chosen by wxWindows.
-
-        name - The status bar window name.
-
-        The width of the status bar is the whole width of the frame
-        (adjusted automatically when resizing), and the height and
-        text size are chosen by the host windowing system.
-
-        By default, the status bar is an instance of wx.StatusBar."""
-        pass
-
-    def CreateToolBar(self, style=wx.NO_BORDER | wx.TB_HORIZONTAL,
-                      id=-1, name=wx.PyToolBarNameStr):
-        """Create a toolbar at the top or left of frame.
-
-        style - The toolbar style. See wxToolBar for a list of valid
-        styles.
-
-        id - The toolbar window identifier. If -1, an identifier will
-        be chosen by wxWindows.
-
-        name - The toolbar window name.
-
-        By default, the toolbar is an instance of wx.ToolBar (which is
-        defined to be a suitable toolbar class on each platform, such
-        as wx.ToolBar95).
-
-        When a toolbar has been created with this function, or made
-        known to the frame with wx.Frame.SetToolBar, the frame will
-        manage the toolbar position and adjust the return value from
-        wx.Window.GetClientSize to reflect the available space for
-        application windows."""
-        pass
-
-    def DoGiveHelp(self, text, show):
-        """Show help text (typically in the statusbar).
-
-        show is False if you are hiding the help, True otherwise.
-
-        Meant to be overridden if a derived frame wants to do
-        something else with help text from menus and etc.  The default
-        implementation simply calls Frame.SetStatusText."""
-        pass
-
-    def GetClientAreaOrigin(self):
-        """Return origin of frame client area (in client coordinates).
-
-        It may be different from (0, 0) if the frame has a toolbar."""
-        pass
-
-    def GetMenuBar(self):
-        """Return menubar currently associated with frame (if any)."""
-        pass
-
-    def GetStatusBar(self):
-        """Return status bar currently associated with frame (if any)."""
-        pass
-
-    def GetStatusBarPane(self):
-        """Return status bar pane used to display menu/toolbar help."""
-        pass
-
-    def GetToolBar(self):
-        """Return toolbar currently associated with frame (if any)."""
-        pass
-
-    def PopStatusText(self, number=0):
-        """Redraw status bar with previous status text.
-
-        number - The status field (starting from zero)."""
-        pass
-
-    def ProcessCommand(self, id):
-        """Process menu command; return True if processed.
-
-        id is the menu command identifier."""
-        pass
-
-    def PushStatusText(self, text, number=0):
-        """Set status bar text and redraw status bar, remembering
-        previous text.
-
-        text - The text for the status field.
-
-        number - The status field (starting from zero).
-
-        Use an empty string to clear the status bar."""
-        pass
-
-    def SendSizeEvent(self):
-        """Send a dummy size event to the frame forcing it to
-        reevaluate its children positions. It is sometimes useful to
-        call this function after adding or deleting a children after
-        the frame creation or if a child size changes.
-
-        Note that if the frame is using either sizers or constraints
-        for the children layout, it is enough to call Frame.Layout()
-        directly and this function should not be used in this case."""
-        pass
-
-    def SetMenuBar(self, menubar):
-        """Show the menu bar in the frame.
-
-        menuBar - The menu bar to associate with the frame.
-
-        If the frame is destroyed, the menu bar and its menus will be
-        destroyed also, so do not delete the menu bar explicitly
-        (except by resetting the frame's menu bar to another frame or
-        NULL).
-
-        Under Windows, a call to Frame.OnSize is generated, so be sure
-        to initialize data members properly before calling SetMenuBar.
-
-        Note that it is not possible to call this function twice for
-        the same frame object."""
-        pass
-
-    def SetStatusBar(self, statBar):
-        """Associate a status bar with the frame."""
-        pass
-
-    def SetStatusBarPane(self, n):
-        """Set the status bar pane used to display menu and toolbar
-        help.  Using -1 disables help display."""
-        pass
-
-    def SetStatusText(self, text, number=0):
-        """Set status bar text and redraw status bar.
-
-        text - The text for the status field.
-
-        number - The status field (starting from zero).
-
-        Use an empty string to clear the status bar."""
-        pass
-
-    def SetStatusWidths(self, choices):
-        """Sets the widths of the fields in the status bar.
-
-        choices - a Python list of integers, each of which is a status
-        field width in pixels. A value of -1 indicates that the field
-        is variable width; at least one field must be -1.
-
-        The widths of the variable fields are calculated from the
-        total width of all fields, minus the sum of widths of the
-        non-variable fields, divided by the number of variable fields."""
-        pass
-
-    def SetToolBar(self, toolbar):
-        """Associate a toolbar with the frame."""
-        pass
-
-
-class LayoutAlgorithm(Object):
-    """LayoutAlgorithm implements layout of subwindows in MDI or SDI
-    frames.  It sends a wx.CalculateLayoutEvent event to children of
-    the frame, asking them for information about their size.  For MDI
-    parent frames, the algorithm allocates the remaining space to the
-    MDI client window (which contains the MDI child frames).  For SDI
-    (normal) frames, a 'main' window is specified as taking up the
-    remaining space.
-
-    Because the event system is used, this technique can be applied to
-    any windows, which are not necessarily 'aware' of the layout
-    classes.  However, you may wish to use wx.SashLayoutWindow for
-    your subwindows since this class provides handlers for the
-    required events, and accessors to specify the desired size of the
-    window.  The sash behaviour in the base class can be used,
-    optionally, to make the windows user-resizable.
-
-    LayoutAlgorithm is typically used in IDE (integrated development
-    environment) applications, where there are several resizable
-    windows in addition to the MDI client window, or other primary
-    editing window.  Resizable windows might include toolbars, a
-    project window, and a window for displaying error and warning
-    messages.
-
-    When a window receives an OnCalculateLayout event, it should call
-    SetRect in the given event object, to be the old supplied
-    rectangle minus whatever space the window takes up.  It should
-    also set its own size accordingly.
-    SashLayoutWindow.OnCalculateLayout generates an OnQueryLayoutInfo
-    event which it sends to itself to determine the orientation,
-    alignment and size of the window, which it gets from internal
-    member variables set by the application.
-
-    The algorithm works by starting off with a rectangle equal to the
-    whole frame client area.  It iterates through the frame children,
-    generating OnCalculateLayout events which subtract the window size
-    and return the remaining rectangle for the next window to process.
-    It is assumed (by SashLayoutWindow.OnCalculateLayout) that a
-    window stretches the full dimension of the frame client, according
-    to the orientation it specifies.  For example, a horizontal window
-    will stretch the full width of the remaining portion of the frame
-    client area.  In the other orientation, the window will be fixed
-    to whatever size was specified by OnQueryLayoutInfo.  An alignment
-    setting will make the window 'stick' to the left, top, right or
-    bottom of the remaining client area.  This scheme implies that
-    order of window creation is important.  Say you wish to have an
-    extra toolbar at the top of the frame, a project window to the
-    left of the MDI client window, and an output window above the
-    status bar.  You should therefore create the windows in this
-    order: toolbar, output window, project window.  This ensures that
-    the toolbar and output window take up space at the top and bottom,
-    and then the remaining height in-between is used for the project
-    window.
-
-    LayoutAlgorithm is quite independent of the way in which
-    OnCalculateLayout chooses to interpret a window's size and
-    alignment.  Therefore you could implement a different window class
-    with a new OnCalculateLayout event handler, that has a more
-    sophisticated way of laying out the windows.  It might allow
-    specification of whether stretching occurs in the specified
-    orientation, for example, rather than always assuming
-    stretching. (This could, and probably should, be added to the
-    existing implementation).
-
-    The algorithm object does not respond to events, but itself
-    generates the following events in order to calculate window sizes:
-    EVT_QUERY_LAYOUT_INFO(func), EVT_CALCULATE_LAYOUT(func)."""
-
-    def __init__(self):
-        """Create a LayoutAlgorithm instance."""
-        pass
-
-    def LayoutFrame(self, frame, mainWindow=wx.NULL):
-        """Lay out the children of a normal frame.
-
-        mainWindow is set to occupy the remaining space.  This
-        function simply calls LayoutWindow()."""
-        pass
-
-    def LayoutMDIFrame(self, frame, rect=wx.NULL):
-        """Lay out the children of an MDI parent frame.
-
-        If rect is non-NULL, the given rectangle will be used as a
-        starting point instead of the frame's client area.
-
-        The MDI client window is set to occupy the remaining space."""
-        pass
-
-    def LayoutWindow(self, parent, mainWindow=wx.NULL):
-        """Lay out the children of a normal frame or other window.
-
-        mainWindow is set to occupy the remaining space.  If this is
-        not specified, then the last window that responds to a
-        calculate layout event in query mode will get the remaining
-        space (that is, a non-query OnCalculateLayout event will not
-        be sent to this window and the window will be set to the
-        remaining size)."""
-        pass
-
-
-class MDIChildFrame(Frame):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def Create(self):
-        """"""
-        pass
-
-    def Activate(self):
-        """"""
-        pass
-
-    def Maximize(self):
-        """"""
-        pass
-
-    def Restore(self):
-        """"""
-        pass
-
-
-class MDIClientWindow(Window):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def Create(self):
-        """"""
-        pass
-
-
-class MDIParentFrame(Frame):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def Create(self):
-        """"""
-        pass
-
-    def ActivateNext(self):
-        """"""
-        pass
-
-    def ActivatePrevious(self):
-        """"""
-        pass
-
-    def ArrangeIcons(self):
-        """"""
-        pass
-
-    def Cascade(self):
-        """"""
-        pass
-
-    def GetActiveChild(self):
-        """"""
-        pass
-
-    def GetClientWindow(self):
-        """"""
-        pass
-
-    def GetToolBar(self):
-        """"""
-        pass
-
-    def Tile(self):
-        """"""
-        pass
-
-
-class MiniFrame(Frame):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def Create(self):
-        """"""
-        pass
-
-
-class SplashScreen(Frame):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def GetSplashStyle(self):
-        """"""
-        pass
-
-    def GetSplashWindow(self):
-        """"""
-        pass
-
-    def GetTimeout(self):
-        """"""
-        pass
-
-
-class SplashScreenWindow(Window):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def GetBitmap(self):
-        """"""
-        pass
-
-    def SetBitmap(self):
-        """"""
-        pass
-
-
-class StatusBar(Window):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def Create(self):
-        """"""
-        pass
-
-    def GetBorderX(self):
-        """"""
-        pass
-
-    def GetBorderY(self):
-        """"""
-        pass
-
-    def GetFieldRect(self):
-        """"""
-        pass
-
-    def GetFieldsCount(self):
-        """"""
-        pass
-
-    def GetStatusText(self):
-        """"""
-        pass
-
-    def PopStatusText(self):
-        """"""
-        pass
-
-    def PushStatusText(self):
-        """"""
-        pass
-
-    def SetFieldsCount(self):
-        """"""
-        pass
-
-    def SetMinHeight(self):
-        """"""
-        pass
-
-    def SetStatusText(self):
-        """"""
-        pass
-
-    def SetStatusWidths(self):
-        """"""
-        pass

wxPython/wxPython/py/wxd/Help.py

@@ -1,127 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-from Window import Window
-
-
-class PopupWindow(Window):
-    """"""
-
-    def Create(self):
-        """"""
-        pass
-
-    def Position(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PopupTransientWindow(PopupWindow):
-    """"""
-
-    def Dismiss(self):
-        """"""
-        pass
-
-    def Popup(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class TipProvider:
-    """"""
-
-    def GetCurrentTip(self):
-        """"""
-        pass
-
-    def GetTip(self):
-        """"""
-        pass
-
-    def PreprocessTip(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PyTipProvider(TipProvider):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class TipWindow(PopupTransientWindow):
-    """"""
-
-    def Close(self):
-        """"""
-        pass
-
-    def SetBoundingRect(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ToolTip(Object):
-    """"""
-
-    def GetTip(self):
-        """"""
-        pass
-
-    def GetWindow(self):
-        """"""
-        pass
-
-    def SetTip(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/ImageHandlers.py

@@ -1,142 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-
-
-class ImageHandler(Object):
-    """"""
-
-    def CanRead(self):
-        """"""
-        pass
-
-    def GetExtension(self):
-        """"""
-        pass
-
-    def GetMimeType(self):
-        """"""
-        pass
-
-    def GetName(self):
-        """"""
-        pass
-
-    def GetType(self):
-        """"""
-        pass
-
-    def SetExtension(self):
-        """"""
-        pass
-
-    def SetMimeType(self):
-        """"""
-        pass
-
-    def SetName(self):
-        """"""
-        pass
-
-    def SetType(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class BMPHandler(ImageHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class GIFHandler(ImageHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ICOHandler(BMPHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class CURHandler(ICOHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ANIHandler(CURHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class JPEGHandler(ImageHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PCXHandler(ImageHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PNGHandler(ImageHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PNMHandler(ImageHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class TIFFHandler(ImageHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/Joystick.py

@@ -1,197 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-
-
-class Joystick(Object):
-    """"""
-
-    def GetButtonState(self):
-        """"""
-        pass
-
-    def GetManufacturerId(self):
-        """"""
-        pass
-
-    def GetMaxAxes(self):
-        """"""
-        pass
-
-    def GetMaxButtons(self):
-        """"""
-        pass
-
-    def GetMovementThreshold(self):
-        """"""
-        pass
-
-    def GetNumberAxes(self):
-        """"""
-        pass
-
-    def GetNumberButtons(self):
-        """"""
-        pass
-
-    def GetNumberJoysticks(self):
-        """"""
-        pass
-
-    def GetPOVCTSPosition(self):
-        """"""
-        pass
-
-    def GetPOVPosition(self):
-        """"""
-        pass
-
-    def GetPollingMax(self):
-        """"""
-        pass
-
-    def GetPollingMin(self):
-        """"""
-        pass
-
-    def GetPosition(self):
-        """"""
-        pass
-
-    def GetProductId(self):
-        """"""
-        pass
-
-    def GetProductName(self):
-        """"""
-        pass
-
-    def GetRudderMax(self):
-        """"""
-        pass
-
-    def GetRudderMin(self):
-        """"""
-        pass
-
-    def GetRudderPosition(self):
-        """"""
-        pass
-
-    def GetUMax(self):
-        """"""
-        pass
-
-    def GetUMin(self):
-        """"""
-        pass
-
-    def GetUPosition(self):
-        """"""
-        pass
-
-    def GetVMax(self):
-        """"""
-        pass
-
-    def GetVMin(self):
-        """"""
-        pass
-
-    def GetVPosition(self):
-        """"""
-        pass
-
-    def GetXMax(self):
-        """"""
-        pass
-
-    def GetXMin(self):
-        """"""
-        pass
-
-    def GetYMax(self):
-        """"""
-        pass
-
-    def GetYMin(self):
-        """"""
-        pass
-
-    def GetZMax(self):
-        """"""
-        pass
-
-    def GetZMin(self):
-        """"""
-        pass
-
-    def GetZPosition(self):
-        """"""
-        pass
-
-    def HasPOV(self):
-        """"""
-        pass
-
-    def HasPOV4Dir(self):
-        """"""
-        pass
-
-    def HasPOVCTS(self):
-        """"""
-        pass
-
-    def HasRudder(self):
-        """"""
-        pass
-
-    def HasU(self):
-        """"""
-        pass
-
-    def HasV(self):
-        """"""
-        pass
-
-    def HasZ(self):
-        """"""
-        pass
-
-    def IsOk(self):
-        """"""
-        pass
-
-    def ReleaseCapture(self):
-        """"""
-        pass
-
-    def SetCapture(self):
-        """"""
-        pass
-
-    def SetMovementThreshold(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-

wxPython/wxPython/py/wxd/LayoutConstraints.py

@@ -1,80 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-
-
-class IndividualLayoutConstraint(Object):
-    """"""
-
-    def Above(self):
-        """"""
-        pass
-
-    def Absolute(self):
-        """"""
-        pass
-
-    def AsIs(self):
-        """"""
-        pass
-
-    def Below(self):
-        """"""
-        pass
-
-    def LeftOf(self):
-        """"""
-        pass
-
-    def PercentOf(self):
-        """"""
-        pass
-
-    def RightOf(self):
-        """"""
-        pass
-
-    def SameAs(self):
-        """"""
-        pass
-
-    def Set(self):
-        """"""
-        pass
-
-    def Unconstrained(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class LayoutConstraints(Object):
-    """"""
-
-    def __getattr__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __setattr__(self):
-        """"""
-        pass

wxPython/wxPython/py/wxd/Logging.py

@@ -1,145 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-import Parameters as wx
-
-
-class Log:
-    """"""
-
-    def Flush(self):
-        """"""
-        pass
-
-    def GetVerbose(self):
-        """"""
-        pass
-
-    def HasPendingMessages(self):
-        """"""
-        pass
-
-    def TimeStamp(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PyLog(Log):
-    """"""
-
-    def Destroy(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class LogChain(Log):
-    """"""
-
-    def GetOldLog(self):
-        """"""
-        pass
-
-    def IsPassingMessages(self):
-        """"""
-        pass
-
-    def PassMessages(self):
-        """"""
-        pass
-
-    def SetLog(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class LogGui(Log):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class LogNull:
-    """"""
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class LogStderr(Log):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class LogTextCtrl(Log):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class LogWindow(Log):
-    """"""
-
-    def GetFrame(self):
-        """"""
-        pass
-
-    def GetOldLog(self):
-        """"""
-        pass
-
-    def IsPassingMessages(self):
-        """"""
-        pass
-
-    def PassMessages(self):
-        """"""
-        pass
-
-    def Show(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/Menus.py

@@ -1,477 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object, EvtHandler
-import Parameters as wx
-from Window import Window
-
-
-class FileHistory(Object):
-    """"""
-
-    def AddFileToHistory(self):
-        """"""
-        pass
-
-    def AddFilesToMenu(self):
-        """"""
-        pass
-
-    def AddFilesToThisMenu(self):
-        """"""
-        pass
-
-    def GetCount(self):
-        """"""
-        pass
-
-    def GetHistoryFile(self):
-        """"""
-        pass
-
-    def GetMaxFiles(self):
-        """"""
-        pass
-
-    def GetNoHistoryFiles(self):
-        """"""
-        pass
-
-    def Load(self):
-        """"""
-        pass
-
-    def RemoveFileFromHistory(self):
-        """"""
-        pass
-
-    def RemoveMenu(self):
-        """"""
-        pass
-
-    def Save(self):
-        """"""
-        pass
-
-    def UseMenu(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class Menu(EvtHandler):
-    """"""
-
-    def Append(self):
-        """"""
-        pass
-
-    def AppendCheckItem(self):
-        """"""
-        pass
-
-    def AppendItem(self):
-        """"""
-        pass
-
-    def AppendMenu(self):
-        """"""
-        pass
-
-    def AppendRadioItem(self):
-        """"""
-        pass
-
-    def AppendSeparator(self):
-        """"""
-        pass
-
-    def Break(self):
-        """"""
-        pass
-
-    def Check(self):
-        """"""
-        pass
-
-    def Delete(self):
-        """"""
-        pass
-
-    def DeleteItem(self):
-        """"""
-        pass
-
-    def Destroy(self):
-        """"""
-        pass
-
-    def DestroyId(self):
-        """"""
-        pass
-
-    def DestroyItem(self):
-        """"""
-        pass
-
-    def Enable(self):
-        """"""
-        pass
-
-    def FindItem(self):
-        """"""
-        pass
-
-    def FindItemById(self):
-        """"""
-        pass
-
-    def GetEventHandler(self):
-        """"""
-        pass
-
-    def GetHelpString(self):
-        """"""
-        pass
-
-    def GetInvokingWindow(self):
-        """"""
-        pass
-
-    def GetLabel(self):
-        """"""
-        pass
-
-    def GetMenuItemCount(self):
-        """"""
-        pass
-
-    def GetMenuItems(self):
-        """"""
-        pass
-
-    def GetParent(self):
-        """"""
-        pass
-
-    def GetStyle(self):
-        """"""
-        pass
-
-    def GetTitle(self):
-        """"""
-        pass
-
-    def Insert(self):
-        """"""
-        pass
-
-    def InsertCheckItem(self):
-        """"""
-        pass
-
-    def InsertItem(self):
-        """"""
-        pass
-
-    def InsertMenu(self):
-        """"""
-        pass
-
-    def InsertRadioItem(self):
-        """"""
-        pass
-
-    def InsertSeparator(self):
-        """"""
-        pass
-
-    def IsAttached(self):
-        """"""
-        pass
-
-    def IsChecked(self):
-        """"""
-        pass
-
-    def IsEnabled(self):
-        """"""
-        pass
-
-    def Prepend(self):
-        """"""
-        pass
-
-    def PrependCheckItem(self):
-        """"""
-        pass
-
-    def PrependItem(self):
-        """"""
-        pass
-
-    def PrependMenu(self):
-        """"""
-        pass
-
-    def PrependRadioItem(self):
-        """"""
-        pass
-
-    def PrependSeparator(self):
-        """"""
-        pass
-
-    def Remove(self):
-        """"""
-        pass
-
-    def RemoveItem(self):
-        """"""
-        pass
-
-    def SetEventHandler(self):
-        """"""
-        pass
-
-    def SetHelpString(self):
-        """"""
-        pass
-
-    def SetInvokingWindow(self):
-        """"""
-        pass
-
-    def SetLabel(self):
-        """"""
-        pass
-
-    def SetParent(self):
-        """"""
-        pass
-
-    def SetTitle(self):
-        """"""
-        pass
-
-    def UpdateUI(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class MenuBar(Window):
-    """"""
-
-    def Append(self):
-        """"""
-        pass
-
-    def Check(self):
-        """"""
-        pass
-
-    def Enable(self):
-        """"""
-        pass
-
-    def EnableTop(self):
-        """"""
-        pass
-
-    def FindItemById(self):
-        """"""
-        pass
-
-    def FindMenu(self):
-        """"""
-        pass
-
-    def FindMenuItem(self):
-        """"""
-        pass
-
-    def GetHelpString(self):
-        """"""
-        pass
-
-    def GetLabel(self):
-        """"""
-        pass
-
-    def GetLabelTop(self):
-        """"""
-        pass
-
-    def GetMenu(self):
-        """"""
-        pass
-
-    def GetMenuCount(self):
-        """"""
-        pass
-
-    def Insert(self):
-        """"""
-        pass
-
-    def IsChecked(self):
-        """"""
-        pass
-
-    def IsEnabled(self):
-        """"""
-        pass
-
-    def IsEnabledTop(self):
-        """"""
-        pass
-
-    def Remove(self):
-        """"""
-        pass
-
-    def Replace(self):
-        """"""
-        pass
-
-    def SetHelpString(self):
-        """"""
-        pass
-
-    def SetLabel(self):
-        """"""
-        pass
-
-    def SetLabelTop(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-class MenuItem(Object):
-    """"""
-
-    def Check(self):
-        """"""
-        pass
-
-    def Enable(self):
-        """"""
-        pass
-
-    def GetAccel(self):
-        """"""
-        pass
-
-    def GetBitmap(self):
-        """"""
-        pass
-
-    def GetHelp(self):
-        """"""
-        pass
-
-    def GetId(self):
-        """"""
-        pass
-
-    def GetKind(self):
-        """"""
-        pass
-
-    def GetLabel(self):
-        """"""
-        pass
-
-    def GetMenu(self):
-        """"""
-        pass
-
-    def GetSubMenu(self):
-        """"""
-        pass
-
-    def GetText(self):
-        """"""
-        pass
-
-    def IsCheckable(self):
-        """"""
-        pass
-
-    def IsChecked(self):
-        """"""
-        pass
-
-    def IsEnabled(self):
-        """"""
-        pass
-
-    def IsSeparator(self):
-        """"""
-        pass
-
-    def IsSubMenu(self):
-        """"""
-        pass
-
-    def SetAccel(self):
-        """"""
-        pass
-
-    def SetBitmap(self):
-        """"""
-        pass
-
-    def SetCheckable(self):
-        """"""
-        pass
-
-    def SetHelp(self):
-        """"""
-        pass
-
-    def SetId(self):
-        """"""
-        pass
-
-    def SetSubMenu(self):
-        """"""
-        pass
-
-    def SetText(self):
-        """"""
-        pass
-
-    def Toggle(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-

wxPython/wxPython/py/wxd/MimeTypes.py

@@ -1,185 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-import Parameters as wx
-
-
-class FileType:
-    """"""
-
-    def GetAllCommands(self):
-        """"""
-        pass
-
-    def GetDescription(self):
-        """"""
-        pass
-
-    def GetExtensions(self):
-        """"""
-        pass
-
-    def GetIcon(self):
-        """"""
-        pass
-
-    def GetIconInfo(self):
-        """"""
-        pass
-
-    def GetMimeType(self):
-        """"""
-        pass
-
-    def GetMimeTypes(self):
-        """"""
-        pass
-
-    def GetOpenCommand(self):
-        """"""
-        pass
-
-    def GetPrintCommand(self):
-        """"""
-        pass
-
-    def SetCommand(self):
-        """"""
-        pass
-
-    def SetDefaultIcon(self):
-        """"""
-        pass
-
-    def Unassociate(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FileTypeInfo:
-    """"""
-
-    def GetDescription(self):
-        """"""
-        pass
-
-    def GetExtensions(self):
-        """"""
-        pass
-
-    def GetExtensionsCount(self):
-        """"""
-        pass
-
-    def GetIconFile(self):
-        """"""
-        pass
-
-    def GetIconIndex(self):
-        """"""
-        pass
-
-    def GetMimeType(self):
-        """"""
-        pass
-
-    def GetOpenCommand(self):
-        """"""
-        pass
-
-    def GetPrintCommand(self):
-        """"""
-        pass
-
-    def GetShortDesc(self):
-        """"""
-        pass
-
-    def IsValid(self):
-        """"""
-        pass
-
-    def SetIcon(self):
-        """"""
-        pass
-
-    def SetShortDesc(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class MimeTypesManager:
-    """"""
-
-    def AddFallback(self):
-        """"""
-        pass
-
-    def Associate(self):
-        """"""
-        pass
-
-    def ClearData(self):
-        """"""
-        pass
-
-    def EnumAllFileTypes(self):
-        """"""
-        pass
-
-    def GetFileTypeFromExtension(self):
-        """"""
-        pass
-
-    def GetFileTypeFromMimeType(self):
-        """"""
-        pass
-
-    def Initialize(self):
-        """"""
-        pass
-
-    def ReadMailcap(self):
-        """"""
-        pass
-
-    def ReadMimeTypes(self):
-        """"""
-        pass
-
-    def Unassociate(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/Misc.py

@@ -1,558 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-
-
-class ArtProvider(Object):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class BusyCursor:
-    """"""
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class BusyInfo(Object):
-    """"""
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class Caret:
-    """"""
-
-    def GetPosition(self):
-        """"""
-        pass
-
-    def GetPositionTuple(self):
-        """"""
-        pass
-
-    def GetSize(self):
-        """"""
-        pass
-
-    def GetSizeTuple(self):
-        """"""
-        pass
-
-    def GetWindow(self):
-        """"""
-        pass
-
-    def Hide(self):
-        """"""
-        pass
-
-    def IsOk(self):
-        """"""
-        pass
-
-    def IsVisible(self):
-        """"""
-        pass
-
-    def Move(self):
-        """"""
-        pass
-
-    def MoveXY(self):
-        """"""
-        pass
-
-    def SetSize(self):
-        """"""
-        pass
-
-    def SetSizeWH(self):
-        """"""
-        pass
-
-    def Show(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class EncodingConverter(Object):
-    """"""
-
-    def Convert(self):
-        """"""
-        pass
-
-    def Init(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class DirItemData(Object):
-    """"""
-
-    def SetNewDirName(self):
-        """"""
-        pass
-
-    def __getattr__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __setattr__(self):
-        """"""
-        pass
-
-
-class Effects(Object):
-    """"""
-
-    def DrawSunkenEdge(self):
-        """"""
-        pass
-
-    def GetDarkShadow(self):
-        """"""
-        pass
-
-    def GetFaceColour(self):
-        """"""
-        pass
-
-    def GetHighlightColour(self):
-        """"""
-        pass
-
-    def GetLightShadow(self):
-        """"""
-        pass
-
-    def GetMediumShadow(self):
-        """"""
-        pass
-
-    def Set(self):
-        """"""
-        pass
-
-    def SetDarkShadow(self):
-        """"""
-        pass
-
-    def SetFaceColour(self):
-        """"""
-        pass
-
-    def SetHighlightColour(self):
-        """"""
-        pass
-
-    def SetLightShadow(self):
-        """"""
-        pass
-
-    def SetMediumShadow(self):
-        """"""
-        pass
-
-    def TileBitmap(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class FontEnumerator:
-    """"""
-
-    def EnumerateEncodings(self):
-        """"""
-        pass
-
-    def EnumerateFacenames(self):
-        """"""
-        pass
-
-    def GetEncodings(self):
-        """"""
-        pass
-
-    def GetFacenames(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class FontMapper:
-    """"""
-
-    def CharsetToEncoding(self):
-        """"""
-        pass
-
-    def GetAltForEncoding(self):
-        """"""
-        pass
-
-    def IsEncodingAvailable(self):
-        """"""
-        pass
-
-    def SetConfig(self):
-        """"""
-        pass
-
-    def SetConfigPath(self):
-        """"""
-        pass
-
-    def SetDialogParent(self):
-        """"""
-        pass
-
-    def SetDialogTitle(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class LanguageInfo:
-    """"""
-
-    def __getattr__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __setattr__(self):
-        """"""
-        pass
-
-
-class Locale:
-    """"""
-
-    def AddCatalog(self):
-        """"""
-        pass
-
-    def GetCanonicalName(self):
-        """"""
-        pass
-
-    def GetLanguage(self):
-        """"""
-        pass
-
-    def GetLocale(self):
-        """"""
-        pass
-
-    def GetName(self):
-        """"""
-        pass
-
-    def GetString(self):
-        """"""
-        pass
-
-    def GetSysName(self):
-        """"""
-        pass
-
-    def Init(self):
-        """"""
-        pass
-
-    def IsLoaded(self):
-        """"""
-        pass
-
-    def IsOk(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class NativeFontInfo:
-    """"""
-
-    def FromString(self):
-        """"""
-        pass
-
-    def FromUserString(self):
-        """"""
-        pass
-
-    def GetEncoding(self):
-        """"""
-        pass
-
-    def GetFaceName(self):
-        """"""
-        pass
-
-    def GetFamily(self):
-        """"""
-        pass
-
-    def GetPointSize(self):
-        """"""
-        pass
-
-    def GetStyle(self):
-        """"""
-        pass
-
-    def GetUnderlined(self):
-        """"""
-        pass
-
-    def GetWeight(self):
-        """"""
-        pass
-
-    def Init(self):
-        """"""
-        pass
-
-    def SetEncoding(self):
-        """"""
-        pass
-
-    def SetFaceName(self):
-        """"""
-        pass
-
-    def SetFamily(self):
-        """"""
-        pass
-
-    def SetPointSize(self):
-        """"""
-        pass
-
-    def SetStyle(self):
-        """"""
-        pass
-
-    def SetUnderlined(self):
-        """"""
-        pass
-
-    def SetWeight(self):
-        """"""
-        pass
-
-    def ToString(self):
-        """"""
-        pass
-
-    def ToUserString(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def __str__(self):
-        """"""
-        pass
-
-
-class PyTimer(Object):
-    """"""
-
-    def GetInterval(self):
-        """"""
-        pass
-
-    def IsOneShot(self):
-        """"""
-        pass
-
-    def IsRunning(self):
-        """"""
-        pass
-
-    def SetOwner(self):
-        """"""
-        pass
-
-    def Start(self):
-        """"""
-        pass
-
-    def Stop(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class StopWatch:
-    """"""
-
-    def Pause(self):
-        """"""
-        pass
-
-    def Resume(self):
-        """"""
-        pass
-
-    def Start(self):
-        """"""
-        pass
-
-    def Time(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class SystemSettings:
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class Timer(PyTimer):
-    """"""
-
-    def __init__(self, evtHandler=None, id=-1):
-        """Create a Timer instance."""
-        pass
-
-
-class Wave(Object):
-    """"""
-
-    def IsOk(self):
-        """"""
-        pass
-
-    def Play(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class WindowDisabler:
-    """"""
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/Panel.py

@@ -1,240 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-import Parameters as wx
-from Window import Window
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class Panel(Window):
-    """"""
-
-    def __init__(self, parent, id, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize, style=wx.TAB_TRAVERSAL,
-                 name=wx.PyPanelNameStr):
-        """"""
-        pass
-
-    def Create(self, parent, id, pos=wx.DefaultPosition,
-               size=wx.DefaultSize, style=wx.TAB_TRAVERSAL,
-               name=wx.PyPanelNameStr):
-        """"""
-        pass
-
-    def InitDialog(self):
-        """"""
-        pass
-
-
-class PyPanel(Panel):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-    def base_AcceptsFocus(self):
-        """"""
-        pass
-
-    def base_AcceptsFocusFromKeyboard(self):
-        """"""
-        pass
-
-    def base_AddChild(self):
-        """"""
-        pass
-
-    def base_DoGetBestSize(self):
-        """"""
-        pass
-
-    def base_DoGetClientSize(self):
-        """"""
-        pass
-
-    def base_DoGetPosition(self):
-        """"""
-        pass
-
-    def base_DoGetSize(self):
-        """"""
-        pass
-
-    def base_DoGetVirtualSize(self):
-        """"""
-        pass
-
-    def base_DoMoveWindow(self):
-        """"""
-        pass
-
-    def base_DoSetClientSize(self):
-        """"""
-        pass
-
-    def base_DoSetSize(self):
-        """"""
-        pass
-
-    def base_DoSetVirtualSize(self):
-        """"""
-        pass
-
-    def base_GetMaxSize(self):
-        """"""
-        pass
-
-    def base_InitDialog(self):
-        """"""
-        pass
-
-    def base_RemoveChild(self):
-        """"""
-        pass
-
-    def base_TransferDataFromWindow(self):
-        """"""
-        pass
-
-    def base_TransferDataToWindow(self):
-        """"""
-        pass
-
-    def base_Validate(self):
-        """"""
-        pass
-
-
-class ScrolledWindow(Panel):
-    """"""
-
-    def __init__(self, parent, id=-1, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize, style=wx.HSCROLL|wx.VSCROLL,
-                 name=wx.PyPanelNameStr):
-        """"""
-        pass
-
-    def Create(self, parent, id=-1, pos=wx.DefaultPosition,
-               size=wx.DefaultSize, style=wx.HSCROLL|wx.VSCROLL,
-               name=wx.PyPanelNameStr):
-        """"""
-        pass
-
-    def AdjustScrollbars(self):
-        """"""
-        pass
-
-    def CalcScrolledPosition(self, *args):
-        """*args can be a point or (x, y) tuple"""
-        pass
-
-    def CalcScrolledPosition1(self, pt):
-        """"""
-        pass
-
-    def CalcScrolledPosition2(self, x, y):
-        """"""
-        pass
-
-    def CalcUnscrolledPosition(self, *args):
-        """*args can be a point or (x, y) tuple"""
-        pass
-
-    def CalcUnscrolledPosition1(self, pt):
-        """"""
-        pass
-
-    def CalcUnscrolledPosition2(self, x, y):
-        """"""
-        pass
-
-    def EnableScrolling(self, xScrolling, yScrolling):
-        """"""
-        pass
-
-    def GetScaleX(self):
-        """"""
-        pass
-
-    def GetScaleY(self):
-        """"""
-        pass
-
-    def GetScrollPageSize(self, orient):
-        """"""
-        pass
-
-    def GetScrollPixelsPerUnit(self):
-        """"""
-        pass
-
-    def GetTargetWindow(self):
-        """"""
-        pass
-
-    def GetViewStart(self):
-        """"""
-        pass
-
-    def IsRetained(self):
-        """"""
-        pass
-
-    def Layout(self):
-        """"""
-        pass
-
-    def PrepareDC(self, dc):
-        """"""
-        pass
-
-    def Scroll(self, x, y):
-        """"""
-        pass
-
-    def SetScale(self, xs, ys):
-        """"""
-        pass
-
-    def SetScrollPageSize(self, orient, pageSize):
-        """"""
-        pass
-
-    def SetScrollRate(self, xstep, ystep):
-        """Set the x, y scrolling increments."""
-        pass
-
-    def SetScrollbars(self, pixelsPerUnitX, pixelsPerUnitY,
-                      noUnitsX, noUnitsY, xPos=0, yPos=0, noRefresh=False):
-        """"""
-        pass
-
-    def SetTargetWindow(self, window):
-        """"""
-        pass
-
-    def ViewStart(self):
-        """"""
-        pass
-

wxPython/wxPython/py/wxd/Parameters.py

@@ -1,69 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-class _Param:
-    """Used by this module to represent default wxPython parameter values,
-    including parameter representations like style=wx.HSCROLL|wx.VSCROLL."""
-
-    def __init__(self, value=None):
-        if value is None:
-            value = 'wx.' + self.__class__.__name__
-        self.value = value
-
-    def __repr__(self):
-        return self.value
-
-    def __or__(self, other):
-        value = '%s|%s' % (self, other)
-        return self.__class__(value)
-
-_params = (
-    'BOTH',
-    'DEFAULT_FRAME_STYLE',
-    'DefaultPosition',
-    'DefaultSize',
-    'DefaultValidator',
-    'EmptyString',
-    'EVT_NULL',
-    'HORIZONTAL',
-    'HSCROLL',
-    'NO_BORDER',
-    'NULL',
-    'NullColour',
-    'PyFrameNameStr',
-    'PyNOTEBOOK_NAME',
-    'PyPanelNameStr',
-    'PyStatusLineNameStr',
-    'PySTCNameStr',
-    'PyToolBarNameStr',
-    'SIZE_AUTO',
-    'SIZE_USE_EXISTING',
-    'ST_SIZEGRIP',
-    'TAB_TRAVERSAL',
-    'TB_HORIZONTAL',
-    'VSCROLL',
-    )
-
-## Create classes, then instances, like this:
-
-## class BOTH(Param): pass
-## BOTH = BOTH()
-
-for _param in _params:
-    exec 'class %s(_Param): pass' % _param
-    exec '%s = %s()' % (_param, _param)
-
-del _param
-del _params
-del _Param

wxPython/wxPython/py/wxd/Printing.py

@@ -1,651 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-from Dialogs import Dialog
-from Frames import Frame
-import Parameters as wx
-
-
-class PageSetupDialog(Dialog):
-    """"""
-
-    def GetPageSetupData(self):
-        """"""
-        pass
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PageSetupDialogData(Object):
-    """"""
-
-    def EnableHelp(self):
-        """"""
-        pass
-
-    def EnableMargins(self):
-        """"""
-        pass
-
-    def EnableOrientation(self):
-        """"""
-        pass
-
-    def EnablePaper(self):
-        """"""
-        pass
-
-    def EnablePrinter(self):
-        """"""
-        pass
-
-    def GetDefaultInfo(self):
-        """"""
-        pass
-
-    def GetDefaultMinMargins(self):
-        """"""
-        pass
-
-    def GetEnableHelp(self):
-        """"""
-        pass
-
-    def GetEnableMargins(self):
-        """"""
-        pass
-
-    def GetEnableOrientation(self):
-        """"""
-        pass
-
-    def GetEnablePaper(self):
-        """"""
-        pass
-
-    def GetEnablePrinter(self):
-        """"""
-        pass
-
-    def GetMarginBottomRight(self):
-        """"""
-        pass
-
-    def GetMarginTopLeft(self):
-        """"""
-        pass
-
-    def GetMinMarginBottomRight(self):
-        """"""
-        pass
-
-    def GetMinMarginTopLeft(self):
-        """"""
-        pass
-
-    def GetPaperId(self):
-        """"""
-        pass
-
-    def GetPaperSize(self):
-        """"""
-        pass
-
-    def GetPrintData(self):
-        """"""
-        pass
-
-    def Ok(self):
-        """"""
-        pass
-
-    def SetDefaultInfo(self):
-        """"""
-        pass
-
-    def SetDefaultMinMargins(self):
-        """"""
-        pass
-
-    def SetMarginBottomRight(self):
-        """"""
-        pass
-
-    def SetMarginTopLeft(self):
-        """"""
-        pass
-
-    def SetMinMarginBottomRight(self):
-        """"""
-        pass
-
-    def SetMinMarginTopLeft(self):
-        """"""
-        pass
-
-    def SetPaperId(self):
-        """"""
-        pass
-
-    def SetPaperSize(self):
-        """"""
-        pass
-
-    def SetPrintData(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PrintDialog(Dialog):
-    """"""
-
-    def GetPrintDC(self):
-        """"""
-        pass
-
-    def GetPrintDialogData(self):
-        """"""
-        pass
-
-    def ShowModal(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PrintDialogData(Object):
-    """"""
-
-    def EnableHelp(self):
-        """"""
-        pass
-
-    def EnablePageNumbers(self):
-        """"""
-        pass
-
-    def EnablePrintToFile(self):
-        """"""
-        pass
-
-    def EnableSelection(self):
-        """"""
-        pass
-
-    def GetAllPages(self):
-        """"""
-        pass
-
-    def GetCollate(self):
-        """"""
-        pass
-
-    def GetFromPage(self):
-        """"""
-        pass
-
-    def GetMaxPage(self):
-        """"""
-        pass
-
-    def GetMinPage(self):
-        """"""
-        pass
-
-    def GetNoCopies(self):
-        """"""
-        pass
-
-    def GetPrintData(self):
-        """"""
-        pass
-
-    def GetPrintToFile(self):
-        """"""
-        pass
-
-    def GetToPage(self):
-        """"""
-        pass
-
-    def Ok(self):
-        """"""
-        pass
-
-    def SetCollate(self):
-        """"""
-        pass
-
-    def SetFromPage(self):
-        """"""
-        pass
-
-    def SetMaxPage(self):
-        """"""
-        pass
-
-    def SetMinPage(self):
-        """"""
-        pass
-
-    def SetNoCopies(self):
-        """"""
-        pass
-
-    def SetPrintData(self):
-        """"""
-        pass
-
-    def SetPrintToFile(self):
-        """"""
-        pass
-
-    def SetSetupDialog(self):
-        """"""
-        pass
-
-    def SetToPage(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PreviewFrame(Frame):
-    """"""
-
-    def Initialize(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PrintData(Object):
-    """"""
-
-    def GetCollate(self):
-        """"""
-        pass
-
-    def GetColour(self):
-        """"""
-        pass
-
-    def GetDuplex(self):
-        """"""
-        pass
-
-    def GetFilename(self):
-        """"""
-        pass
-
-    def GetFontMetricPath(self):
-        """"""
-        pass
-
-    def GetNoCopies(self):
-        """"""
-        pass
-
-    def GetOrientation(self):
-        """"""
-        pass
-
-    def GetPaperId(self):
-        """"""
-        pass
-
-    def GetPaperSize(self):
-        """"""
-        pass
-
-    def GetPreviewCommand(self):
-        """"""
-        pass
-
-    def GetPrintMode(self):
-        """"""
-        pass
-
-    def GetPrinterCommand(self):
-        """"""
-        pass
-
-    def GetPrinterName(self):
-        """"""
-        pass
-
-    def GetPrinterOptions(self):
-        """"""
-        pass
-
-    def GetPrinterScaleX(self):
-        """"""
-        pass
-
-    def GetPrinterScaleY(self):
-        """"""
-        pass
-
-    def GetPrinterTranslateX(self):
-        """"""
-        pass
-
-    def GetPrinterTranslateY(self):
-        """"""
-        pass
-
-    def GetQuality(self):
-        """"""
-        pass
-
-    def Ok(self):
-        """"""
-        pass
-
-    def SetCollate(self):
-        """"""
-        pass
-
-    def SetColour(self):
-        """"""
-        pass
-
-    def SetDuplex(self):
-        """"""
-        pass
-
-    def SetFilename(self):
-        """"""
-        pass
-
-    def SetFontMetricPath(self):
-        """"""
-        pass
-
-    def SetNoCopies(self):
-        """"""
-        pass
-
-    def SetOrientation(self):
-        """"""
-        pass
-
-    def SetPaperId(self):
-        """"""
-        pass
-
-    def SetPaperSize(self):
-        """"""
-        pass
-
-    def SetPreviewCommand(self):
-        """"""
-        pass
-
-    def SetPrintMode(self):
-        """"""
-        pass
-
-    def SetPrinterCommand(self):
-        """"""
-        pass
-
-    def SetPrinterName(self):
-        """"""
-        pass
-
-    def SetPrinterOptions(self):
-        """"""
-        pass
-
-    def SetPrinterScaleX(self):
-        """"""
-        pass
-
-    def SetPrinterScaleY(self):
-        """"""
-        pass
-
-    def SetPrinterScaling(self):
-        """"""
-        pass
-
-    def SetPrinterTranslateX(self):
-        """"""
-        pass
-
-    def SetPrinterTranslateY(self):
-        """"""
-        pass
-
-    def SetPrinterTranslation(self):
-        """"""
-        pass
-
-    def SetQuality(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class PrintPreview(Object):
-    """"""
-
-    def GetCanvas(self):
-        """"""
-        pass
-
-    def GetCurrentPage(self):
-        """"""
-        pass
-
-    def GetFrame(self):
-        """"""
-        pass
-
-    def GetMaxPage(self):
-        """"""
-        pass
-
-    def GetMinPage(self):
-        """"""
-        pass
-
-    def GetPrintDialogData(self):
-        """"""
-        pass
-
-    def GetPrintout(self):
-        """"""
-        pass
-
-    def GetPrintoutForPrinting(self):
-        """"""
-        pass
-
-    def GetZoom(self):
-        """"""
-        pass
-
-    def Ok(self):
-        """"""
-        pass
-
-    def Print(self):
-        """"""
-        pass
-
-    def SetCanvas(self):
-        """"""
-        pass
-
-    def SetCurrentPage(self):
-        """"""
-        pass
-
-    def SetFrame(self):
-        """"""
-        pass
-
-    def SetPrintout(self):
-        """"""
-        pass
-
-    def SetZoom(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class Printer(Object):
-    """"""
-
-    def CreateAbortWindow(self):
-        """"""
-        pass
-
-    def GetPrintDialogData(self):
-        """"""
-        pass
-
-    def Print(self):
-        """"""
-        pass
-
-    def PrintDialog(self):
-        """"""
-        pass
-
-    def ReportError(self):
-        """"""
-        pass
-
-    def Setup(self):
-        """"""
-        pass
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class Printout(Object):
-    """"""
-
-    def Destroy(self):
-        """"""
-        pass
-
-    def GetDC(self):
-        """"""
-        pass
-
-    def GetPPIPrinter(self):
-        """"""
-        pass
-
-    def GetPPIScreen(self):
-        """"""
-        pass
-
-    def GetPageSizeMM(self):
-        """"""
-        pass
-
-    def GetPageSizePixels(self):
-        """"""
-        pass
-
-    def IsPreview(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-    def base_GetPageInfo(self):
-        """"""
-        pass
-
-    def base_HasPage(self):
-        """"""
-        pass
-
-    def base_OnBeginDocument(self):
-        """"""
-        pass
-
-    def base_OnBeginPrinting(self):
-        """"""
-        pass
-
-    def base_OnEndDocument(self):
-        """"""
-        pass
-
-    def base_OnEndPrinting(self):
-        """"""
-        pass
-
-    def base_OnPreparePrinting(self):
-        """"""
-        pass
-

wxPython/wxPython/py/wxd/Process.py

@@ -1,77 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import EvtHandler
-
-
-class Process(EvtHandler):
-    """"""
-
-    def CloseOutput(self):
-        """"""
-        pass
-
-    def Destroy(self):
-        """"""
-        pass
-
-    def Detach(self):
-        """"""
-        pass
-
-    def GetErrorStream(self):
-        """"""
-        pass
-
-    def GetInputStream(self):
-        """"""
-        pass
-
-    def GetOutputStream(self):
-        """"""
-        pass
-
-    def IsErrorAvailable(self):
-        """"""
-        pass
-
-    def IsInputAvailable(self):
-        """"""
-        pass
-
-    def IsInputOpened(self):
-        """"""
-        pass
-
-    def IsRedirected(self):
-        """"""
-        pass
-
-    def Redirect(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-    def base_OnTerminate(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/SashSplitter.py

@@ -1,226 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-import Parameters as wx
-from Window import Window
-
-
-class SashWindow(Window):
-    """"""
-
-    def Create(self):
-        """"""
-        pass
-
-    def GetDefaultBorderSize(self):
-        """"""
-        pass
-
-    def GetEdgeMargin(self):
-        """"""
-        pass
-
-    def GetExtraBorderSize(self):
-        """"""
-        pass
-
-    def GetMaximumSizeX(self):
-        """"""
-        pass
-
-    def GetMaximumSizeY(self):
-        """"""
-        pass
-
-    def GetMinimumSizeX(self):
-        """"""
-        pass
-
-    def GetMinimumSizeY(self):
-        """"""
-        pass
-
-    def GetSashVisible(self):
-        """"""
-        pass
-
-    def HasBorder(self):
-        """"""
-        pass
-
-    def SetDefaultBorderSize(self):
-        """"""
-        pass
-
-    def SetExtraBorderSize(self):
-        """"""
-        pass
-
-    def SetMaximumSizeX(self):
-        """"""
-        pass
-
-    def SetMaximumSizeY(self):
-        """"""
-        pass
-
-    def SetMinimumSizeX(self):
-        """"""
-        pass
-
-    def SetMinimumSizeY(self):
-        """"""
-        pass
-
-    def SetSashBorder(self):
-        """"""
-        pass
-
-    def SetSashVisible(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class SashLayoutWindow(SashWindow):
-    """"""
-
-    def Create(self):
-        """"""
-        pass
-
-    def GetAlignment(self):
-        """"""
-        pass
-
-    def GetOrientation(self):
-        """"""
-        pass
-
-    def SetAlignment(self):
-        """"""
-        pass
-
-    def SetDefaultSize(self):
-        """"""
-        pass
-
-    def SetOrientation(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class SplitterWindow(Window):
-    """"""
-
-    def Create(self):
-        """"""
-        pass
-
-    def GetBorderSize(self):
-        """"""
-        pass
-
-    def GetMinimumPaneSize(self):
-        """"""
-        pass
-
-    def GetNeedUpdating(self):
-        """"""
-        pass
-
-    def GetSashPosition(self):
-        """"""
-        pass
-
-    def GetSashSize(self):
-        """"""
-        pass
-
-    def GetSplitMode(self):
-        """"""
-        pass
-
-    def GetWindow1(self):
-        """"""
-        pass
-
-    def GetWindow2(self):
-        """"""
-        pass
-
-    def Initialize(self):
-        """"""
-        pass
-
-    def IsSplit(self):
-        """"""
-        pass
-
-    def ReplaceWindow(self):
-        """"""
-        pass
-
-    def SetBorderSize(self):
-        """"""
-        pass
-
-    def SetMinimumPaneSize(self):
-        """"""
-        pass
-
-    def SetNeedUpdating(self):
-        """"""
-        pass
-
-    def SetSashPosition(self):
-        """"""
-        pass
-
-    def SetSashSize(self):
-        """"""
-        pass
-
-    def SetSplitMode(self):
-        """"""
-        pass
-
-    def SizeWindows(self):
-        """"""
-        pass
-
-    def SplitHorizontally(self):
-        """"""
-        pass
-
-    def SplitVertically(self):
-        """"""
-        pass
-
-    def Unsplit(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/Sizers.py

@@ -1,605 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-
-Sizer is the abstract base class used for laying out subwindows in a
-window.  You cannot use Sizer directly; instead, you will have to use
-one of the sizer classes derived from it.  Currently there are
-BoxSizer, StaticBoxSizer, NotebookSizer, GridSizer, and FlexGridSizer.
-
-The layout algorithm used by sizers in wxPython is closely related to
-layout in other GUI toolkits, such as Java's AWT, the GTK toolkit or
-the Qt toolkit.  It is based upon the idea of the individual
-subwindows reporting their minimal required size and their ability to
-get stretched if the size of the parent window has changed.  This will
-most often mean, that the programmer does not set the original size of
-a dialog in the beginning, rather the dialog will assigned a sizer and
-this sizer will be queried about the recommended size.  The sizer in
-turn will query its children, which can be normal windows, empty space
-or other sizers, so that a hierarchy of sizers can be constructed.
-Note that wxSizer does not derive from wxWindow and thus do not
-interfere with tab ordering and requires very little resources
-compared to a real window on screen.
-
-What makes sizers so well fitted for use in wxPython is the fact that
-every control reports its own minimal size and the algorithm can
-handle differences in font sizes or different window (dialog item)
-sizes on different platforms without problems.  If e.g. the standard
-font as well as the overall design of Motif widgets requires more
-space than on Windows, the initial dialog size will automatically be
-bigger on Motif than on Windows.
-
-If you wish to create a sizer class in wxPython you should derive the
-class from PySizer in order to get Python-aware capabilities for the
-various virtual methods.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class Sizer(Object):
-    """Sizer is the abstract base class used for laying out subwindows
-    in a window. You shouldn't use Sizer directly; instead, you should
-    use one of the sizer classes derived from it.
-
-    If you wish to create a sizer class in wxPython you should derive
-    the class from PySizer in order to get Python-aware capabilities
-    for the various virtual methods.
-
-    Placing a child sizer in a sizer allows you to create hierarchies
-    of sizers (typically a vertical box as the top sizer and several
-    horizontal boxes on the level beneath).
-
-    When you place a window in a sizer the window's initial size
-    (either set explicitly by the user or calculated internally when
-    using wxDefaultSize) is interpreted as the minimal and in many
-    cases also the initial size.  This is particularly useful in
-    connection with SetSizeHints.
-
-    Adding spacers to sizers gives more flexibility in the design of
-    dialogs.  Imagine for example a horizontal box with two buttons at
-    the bottom of a dialog: you might want to insert a space between
-    the two buttons and make that space stretchable using the
-    proportion flag and the result will be that the left button will
-    be aligned with the left side of the dialog and the right button
-    with the right side - the space in between will shrink and grow
-    with the dialog.
-
-    Several methods (Add, Insert, Prepend) take the following
-    parameters:
-
-    proportion - Used only by BoxSizer to indicate if a child of a
-    sizer can change its size in the main orientation of the BoxSizer,
-    where 0 stands for not changeable and a value of more than zero is
-    interpreted relative to the value of other children of the same
-    BoxSizer.  For example, you might have a horizontal BoxSizer with
-    three children, two of which are supposed to change their size
-    with the sizer.  Then the two stretchable windows would each get a
-    value of 1 to make them grow and shrink equally with the sizer's
-    horizontal dimension.
-
-    flag - This parameter can be used to set a number of flags which
-    can be combined using the binary OR operator |.  Two main
-    behaviours are defined using these flags.  One is the border
-    around a window: the border parameter determines the border width
-    whereas the flags given here determine where the border may be
-    (wx.TOP, wx.BOTTOM, wx.LEFT, wx.RIGHT or wx.ALL).  The other flags
-    determine the child window's behaviour if the size of the sizer
-    changes.  However this is not - in contrast to the proportion flag
-    - in the main orientation, but in the respectively other
-    orientation.  So if you created a BoxSizer with the wx.VERTICAL
-    option, these flags will be relevant if the sizer changes its
-    horizontal size.  A child may get resized to completely fill out
-    the new size (using either wx.GROW or wx.EXPAND), it may get
-    proportionally resized (wx.SHAPED), it may get centered
-    (wx.ALIGN_CENTER or wx.ALIGN_CENTRE) or it may get aligned to
-    either side (wx.ALIGN_LEFT and wx.ALIGN_TOP are set to 0 and thus
-    represent the default, wx.ALIGN_RIGHT and wx.ALIGN_BOTTOM have
-    their obvious meaning).  With proportional resize, a child may
-    also be centered in the main orientation using
-    wx.ALIGN_CENTER_VERTICAL (same as wx.ALIGN_CENTRE_VERTICAL) and
-    wx.ALIGN_CENTER_HORIZONTAL (same as wx.ALIGN_CENTRE_HORIZONTAL)
-    flags.  Finally, you can also specify wx.ADJUST_MINSIZE flag to
-    make the minimal size of the control dynamically adjust to the
-    value returned by its GetAdjustedBestSize() method - this allows,
-    for example, for correct relayouting of a static text control even
-    if its text is changed during run-time.
-
-    border - Determines the border width, if the flag parameter is set
-    to any border.  A border is not a visible element, but rather a
-    margin of empty space surrounding the item.
-
-    userData - Allows an extra object to be attached to the sizer
-    item, for use in derived classes when sizing information is more
-    complex than the option and flag parameters will allow."""
-
-    def __init__(self):
-        """Must be defined by subclasses."""
-        pass
-
-    def Add(self, item, proportion=0, flag=0, border=0,
-            userData=wx.NULL):
-        """Add item to sizer.
-
-        item - window, sizer, or spacer.  Spacer is specified with a
-        (width, height) tuple or wx.Size representing the spacer size.
-
-        Call Layout() to update the layout on-screen after adding."""
-        pass
-
-    def Clear(self, delete_windows=False):
-        """Remove all items from this sizer.
-
-        If delete_windows is True, destroy any window items."""
-        pass
-
-    def DeleteWindows(self):
-        """Destroy windows associated with this sizer."""
-        pass
-
-    def Destroy(self):
-        """Destroy the sizer."""
-        pass
-
-    def Fit(self, window):
-        """Resize window to match sizer's minimal size; return size.
-
-        This is commonly done in the constructor of the window itself."""
-        pass
-
-    def FitInside(self, window):
-        """Resize window virtual size to match sizer's minimal size.
-
-        This will not alter the on screen size of the window, but may
-        cause the addition/removal/alteration of scrollbars required
-        to view the virtual area in windows which manage it."""
-        pass
-
-    def GetChildren(self):
-        """Return list of SizerItem instances."""
-        pass
-
-    def GetMinSize(self):
-        """Return the minimal size of the sizer.
-
-        This is either the combined minimal size of all the children
-        and their borders or the minimal size set by SetMinSize,
-        whichever is larger."""
-        pass
-
-    def GetMinSizeTuple(self):
-        """Return the minimal size of the sizer as a tuple.
-
-        This is either the combined minimal size of all the children
-        and their borders or the minimal size set by SetMinSize,
-        whichever is larger."""
-        pass
-
-    def GetPosition(self):
-        """Return the current position of the sizer."""
-        pass
-
-    def GetPositionTuple(self):
-        """Return the current position of the sizer as a tuple."""
-        pass
-
-    def GetSize(self):
-        """Return the current size of the sizer."""
-        pass
-
-    def GetSizeTuple(self):
-        """Return the current size of the sizer as a tuple."""
-        pass
-
-    def Hide(self, item):
-        """Hide item (sizer or window).  To make a sizer item
-        disappear on-screen, use Hide() followed by Layout()."""
-        pass
-
-    def Insert(self, before, item, proportion=0, flag=0, border=0,
-               userData=wx.NULL):
-        """Same as Add, but inserts item into list of items (windows,
-        subsizers or spacers) owned by this sizer.
-
-        Call Layout() to update the layout on-screen after inserting."""
-        pass
-
-    def IsShown(self, item):
-        """Return True if item (sizer or window) is shown."""
-        pass
-
-    def Layout(self):
-        """Force layout of children anew.
-
-        Use after adding or removing a child (window, other sizer, or
-        spacer) from the sizer while keeping the current dimension."""
-        pass
-
-    def Prepend(self, item, proportion=0, flag=0, border=0,
-                userData=wx.NULL):
-        """Same as Add, but prepends item to beginning of list of
-        items (windows, subsizers or spacers) owned by this sizer.
-
-        Call Layout() to update the layout on-screen after prepending."""
-        pass
-
-    def Remove(self, item):
-        """Remove item from the sizer.
-
-        item - sizer, window, or index of item in the sizer, typically
-        0 for the first item.
-
-        Does not cause any layout or resizing to take place, and does
-        not delete the child itself.  Call Layout() to update the
-        layout on-screen after removing child.
-
-        Return True if child found and removed, False otherwise."""
-        pass
-
-    def SetDimension(self, x, y, width, height):
-        """Force sizer to take the given dimension and thus force
-        items owned by sizer to resize themselves according to the
-        rules defined by the parameter in the Add and Prepend methods."""
-        pass
-
-    def SetItemMinSize(self, item, width, height):
-        """Set minimal size of item.
-
-        item - sizer, window, or index of item in the sizer, typically
-        0 for the first item.
-
-        The item will be found recursively in the sizer's descendants.
-        Enables application to set size of item after initialization."""
-        pass
-
-    def SetMinSize(self, size):
-        """Set minimal size.
-
-        Normally, sizer will calculate minimal size based on how much
-        space its children need.  After calling this method,
-        GetMinSize will return the minimal size as requested by its
-        children or the minimal size set here, whichever is larger."""
-        pass
-
-    def SetSizeHints(self, window):
-        """Set (and Fit) minimal size of window to match sizer's
-        minimal size.  Commonly called in the window's init."""
-        pass
-
-    def SetVirtualSizeHints(self, window):
-        """Set minimal size of window virtual area to match sizer's
-        minimal size.  For windows with managed scrollbars this will
-        set them appropriately."""
-        pass
-
-    def Show(self, item, show=True):
-        """Show or hide item (sizer or window).  To make item
-        disappear or reappear on-screen, use Show() followed by
-        Layout()."""
-        pass
-
-    def ShowItems(self, show):
-        """Recursively call Show() on all sizer items."""
-        pass
-
-
-class PySizer(Sizer):
-    """If you wish to create a custom sizer class you should derive
-    the class from PySizer in order to get Python-aware capabilities
-    for the various virtual methods."""
-
-    def __init__(self):
-        """Create a PySizer instance.  Override in subclass."""
-        pass
-
-
-class BoxSizer(Sizer):
-    """A box sizer is used to lay out a rather simple geometry,
-    typically a row or column or several hierarchies of either."""
-
-    def __init__(self, orient=wx.HORIZONTAL):
-        """Create BoxSizer instance.
-
-        orient is either wx.VERTICAL or wx.HORIZONTAL"""
-        pass
-
-    def CalcMin(self):
-        """Calculate minimum size.  Do not call directly."""
-        pass
-
-    def GetOrientation(self):
-        """Return orientation: wx.VERTICAL or wx.HORIZONTAL."""
-        pass
-
-    def RecalcSizes(self):
-        """Recalculate sizes, then set the size of its children
-        (calling SetSize if child is a window).  Do not call directly."""
-        pass
-
-    def SetOrientation(self, orient):
-        """Set orientation to either wx.VERTICAL or wx.HORIZONTAL."""
-        pass
-
-
-class StaticBoxSizer(BoxSizer):
-    """Like BoxSizer, but adds a static box around the sizer.  Note
-    that the static box has to be created separately."""
-
-    def __init__(self, box, orient=wx.HORIZONTAL):
-        """Create StaticBoxSizer instance.
-
-        box - instance of wx.StaticBox
-
-        orient - either wx.VERTICAL or wx.HORIZONTAL"""
-        pass
-
-    def CalcMin(self):
-        """Calculate minimum size.  Do not call directly."""
-        pass
-
-    def GetStaticBox(self):
-        """Return the static box associated with the sizer."""
-        pass
-
-    def RecalcSizes(self):
-        """Recalculate sizes, then set the size of its children
-        (calling SetSize if child is a window).  Do not call directly."""
-        pass
-
-
-class GridSizer(Sizer):
-    """A grid sizer lays out its children in a two-dimensional table
-    where all cells have the same size: the width of each cell is the
-    width of the widest child, the height of each cell is the height
-    of the tallest child.  See also the FlexGridSizer."""
-
-    def __init__(self, rows=1, cols=0, vgap=0, hgap=0):
-        """Create a GridSizer instance.
-
-        rows and cols - the number of rows and columns in the grid; if
-        either is zero, it will be calculated as the number of
-        children in the sizer, allowing the sizer grow dynamically.
-
-        vgap and hgap - extra space between all cells, in pixels."""
-        pass
-
-    def CalcMin(self):
-        """Calculate minimum size.  Do not call directly."""
-        pass
-
-    def GetCols(self):
-        """Return the number of columns in the grid."""
-        pass
-
-    def GetHGap(self):
-        """Return the horizontal gap (in pixels) between cells."""
-        pass
-
-    def GetRows(self):
-        """Return the number of rows in the grid."""
-        pass
-
-    def GetVGap(self):
-        """Return the vertical gap (in pixels) between cells."""
-        pass
-
-    def RecalcSizes(self):
-        """Recalculate sizes, then set the size of its children
-        (calling SetSize if child is a window).  Do not call directly."""
-        pass
-
-    def SetCols(self, cols):
-        """Set the number of columns in the grid."""
-        pass
-
-    def SetHGap(self, gap):
-        """Set the horizontal gap (in pixels) between cells."""
-        pass
-
-    def SetRows(self, rows):
-        """Sets the number of rows in the grid."""
-        pass
-
-    def SetVGap(self, gap):
-        """Set the vertical gap (in pixels) between cells."""
-        pass
-
-
-class FlexGridSizer(GridSizer):
-    """A flex grid sizer lays out its children in a two-dimensional
-    table where all cells in one row have the same height and all
-    cells in one column have the same width, but all cells are not
-    necessarily the same height and width, as in the GridSizer."""
-
-    def __init__(self, rows=1, cols=0, vgap=0, hgap=0):
-        """Create a GridSizer instance.
-
-        rows and cols - the number of rows and columns in the grid; if
-        either is zero, it will be calculated as the number of
-        children in the sizer, allowing the sizer grow dynamically.
-
-        vgap and hgap - extra space between all cells, in pixels."""
-        pass
-
-    def AddGrowableCol(self, idx):
-        """Specify that column idx (starting from zero) should expand
-        if there is extra space available to the sizer."""
-        pass
-
-    def AddGrowableRow(self, idx):
-        """Specify that row idx (starting from zero) should expand if
-        there is extra space available to the sizer."""
-        pass
-
-    def CalcMin(self):
-        """Calculate minimum size.  Do not call directly."""
-        pass
-
-    def RecalcSizes(self):
-        """Recalculate sizes, then set the size of its children
-        (calling SetSize if child is a window).  Do not call directly."""
-        pass
-
-    def RemoveGrowableCol(self, idx):
-        """Specify that column idx is no longer growable."""
-        pass
-
-    def RemoveGrowableRow(self, idx):
-        """Specify that row idx is no longer growable."""
-        pass
-
-
-class NotebookSizer(Sizer):
-    """NotebookSizer works with a notebook to determine the size of
-    the biggest page and report an adjusted minimal size to a more
-    toplevel sizer.  Do not add children to a NotebookSizer."""
-
-    def __init__(self, nb):
-        """Create a NotebookSizer instance for notebook."""
-        pass
-
-    def CalcMin(self):
-        """Calculate minimum size.  Do not call directly."""
-        pass
-
-    def GetNotebook(self):
-        """Return the notebook associated with the sizer."""
-        pass
-
-    def RecalcSizes(self):
-        """Recalculate size.  Do not call directly."""
-        pass
-
-
-class SizerItem(Object):
-    """SizerItem class.  Wrapper for items managed by a sizer."""
-
-    def __init__(self, this):
-        """Create a SizerItem instance.  You don't normally create one
-        directly."""
-        pass
-
-    def CalcMin(self):
-        """Calculate minimum size.  Do not call directly."""
-        pass
-
-    def DeleteWindows(self):
-        """Recursively destroy windows associated with this SizerItem."""
-        pass
-
-    def GetBorder(self):
-        """Return border width."""
-        pass
-
-    def GetFlag(self):
-        """Return flag value."""
-        pass
-
-    def GetOption(self):
-        """Return option value."""
-        pass
-
-    def GetPosition(self):
-        """Return wx.Point instance representing position relative to
-        the client area."""
-        pass
-
-    def GetRatio(self):
-        """Return a floating point aspect ratio (width/height).  If
-        wx.SHAPED flag is used item will maintain ratio when resized."""
-        pass
-
-    def GetSize(self):
-        """Return wx.Size instance with size."""
-        pass
-
-    def GetSizer(self):
-        """If IsSizer() return the sizer; otherwise return None."""
-        pass
-
-    def GetUserData(self):
-        """Return a wx.PyUserData object."""
-        pass
-
-    def GetWindow(self):
-        """If IsWindow() return the window; otherwise return None."""
-        pass
-
-    def IsShown(self):
-        """Return True if item is shown."""
-        pass
-
-    def IsSizer(self):
-        """Return True if SizerItem represents a sizer."""
-        pass
-
-    def IsSpacer(self):
-        """Return True if SizerItem represents a spacer."""
-        pass
-
-    def IsWindow(self):
-        """Return True if SizerItem represents a window."""
-        pass
-
-    def SetBorder(self, border):
-        """Set border width for item."""
-        pass
-
-    def SetDimension(self, pos, size):
-        """Set position and size for item."""
-        pass
-
-    def SetFlag(self, flag):
-        """Set flag for item."""
-        pass
-
-    def SetInitSize(self, x, y):
-        """Set initial size of item."""
-        pass
-
-    def SetOption(self, option):
-        """Set option for item."""
-        pass
-
-    def SetRatio(self, ratio):
-        """Set a floating point aspect ratio (width/height).  If
-        wx.SHAPED flag is used item will maintain ratio when resized."""
-        pass
-
-    def SetRatioSize(self, size):
-        """Set a floating point aspect ratio (width/height).  If
-        wx.SHAPED flag is used item will maintain ratio when resized."""
-        pass
-
-    def SetRatioWH(self, width, height):
-        """Set a floating point aspect ratio (width/height).  If
-        wx.SHAPED flag is used item will maintain ratio when resized."""
-        pass
-
-    def SetSizer(self, sizer):
-        """Set sizer associated with SizerItem."""
-        pass
-
-    def SetWindow(self, window):
-        """Set window associated with SizerItem."""
-        pass
-
-    def Show(self, show):
-        """Is show is True, show item, otherwise hide item."""
-        pass

wxPython/wxPython/py/wxd/Streams.py

@@ -1,96 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-class InputStream:
-    """"""
-
-    def CanRead(self):
-        """"""
-        pass
-
-    def Eof(self):
-        """"""
-        pass
-
-    def GetC(self):
-        """"""
-        pass
-
-    def LastRead(self):
-        """"""
-        pass
-
-    def Peek(self):
-        """"""
-        pass
-
-    def SeekI(self):
-        """"""
-        pass
-
-    def TellI(self):
-        """"""
-        pass
-
-    def Ungetch(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def close(self):
-        """"""
-        pass
-
-    def eof(self):
-        """"""
-        pass
-
-    def flush(self):
-        """"""
-        pass
-
-    def read(self):
-        """"""
-        pass
-
-    def readline(self):
-        """"""
-        pass
-
-    def readlines(self):
-        """"""
-        pass
-
-    def seek(self):
-        """"""
-        pass
-
-    def tell(self):
-        """"""
-        pass
-
-
-class OutputStream:
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def write(self):
-        """"""
-        pass

wxPython/wxPython/py/wxd/StyledTextConstants.py

@@ -1,643 +0,0 @@
-"""wxStyledTextControl constants for documentation.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-from wxPython import wx
-from wxPython import stc
-
-
-"""
->>> from wxPython import stc_c
->>> def gen_constants():
-...     print '# Begin generated constants.'
-...     for item in dir(stc_c):  # dir returns a sorted list.
-...         if not callable(stc_c.__dict__[item]) \
-...         and not item.startswith('__'):
-...             print item, '=', 'stc.' + item, ' #', \
-...                   repr(stc_c.__dict__[item])
-...     print '# End generated constants.'
-
-"""
-
-# Begin generated constants.
-STC_USE_DND = stc.STC_USE_DND  # 1
-wxEVT_STC_CHANGE = stc.wxEVT_STC_CHANGE  # 10206
-wxEVT_STC_CHARADDED = stc.wxEVT_STC_CHARADDED  # 10208
-wxEVT_STC_DOUBLECLICK = stc.wxEVT_STC_DOUBLECLICK  # 10213
-wxEVT_STC_DO_DROP = stc.wxEVT_STC_DO_DROP  # 10227
-wxEVT_STC_DRAG_OVER = stc.wxEVT_STC_DRAG_OVER  # 10226
-wxEVT_STC_DWELLEND = stc.wxEVT_STC_DWELLEND  # 10224
-wxEVT_STC_DWELLSTART = stc.wxEVT_STC_DWELLSTART  # 10223
-wxEVT_STC_KEY = stc.wxEVT_STC_KEY  # 10212
-wxEVT_STC_MACRORECORD = stc.wxEVT_STC_MACRORECORD  # 10216
-wxEVT_STC_MARGINCLICK = stc.wxEVT_STC_MARGINCLICK  # 10217
-wxEVT_STC_MODIFIED = stc.wxEVT_STC_MODIFIED  # 10215
-wxEVT_STC_NEEDSHOWN = stc.wxEVT_STC_NEEDSHOWN  # 10218
-wxEVT_STC_PAINTED = stc.wxEVT_STC_PAINTED  # 10220
-wxEVT_STC_POSCHANGED = stc.wxEVT_STC_POSCHANGED  # 10219
-wxEVT_STC_ROMODIFYATTEMPT = stc.wxEVT_STC_ROMODIFYATTEMPT  # 10211
-wxEVT_STC_SAVEPOINTLEFT = stc.wxEVT_STC_SAVEPOINTLEFT  # 10210
-wxEVT_STC_SAVEPOINTREACHED = stc.wxEVT_STC_SAVEPOINTREACHED  # 10209
-wxEVT_STC_START_DRAG = stc.wxEVT_STC_START_DRAG  # 10225
-wxEVT_STC_STYLENEEDED = stc.wxEVT_STC_STYLENEEDED  # 10207
-wxEVT_STC_UPDATEUI = stc.wxEVT_STC_UPDATEUI  # 10214
-wxEVT_STC_URIDROPPED = stc.wxEVT_STC_URIDROPPED  # 10222
-wxEVT_STC_USERLISTSELECTION = stc.wxEVT_STC_USERLISTSELECTION  # 10221
-wxEVT_STC_ZOOM = stc.wxEVT_STC_ZOOM  # 10228
-wxSTC_ADA_CHARACTER = stc.wxSTC_ADA_CHARACTER  # 5
-wxSTC_ADA_COMMENT = stc.wxSTC_ADA_COMMENT  # 1
-wxSTC_ADA_DEFAULT = stc.wxSTC_ADA_DEFAULT  # 0
-wxSTC_ADA_IDENTIFIER = stc.wxSTC_ADA_IDENTIFIER  # 7
-wxSTC_ADA_NUMBER = stc.wxSTC_ADA_NUMBER  # 2
-wxSTC_ADA_OPERATOR = stc.wxSTC_ADA_OPERATOR  # 6
-wxSTC_ADA_STRING = stc.wxSTC_ADA_STRING  # 4
-wxSTC_ADA_STRINGEOL = stc.wxSTC_ADA_STRINGEOL  # 8
-wxSTC_ADA_WORD = stc.wxSTC_ADA_WORD  # 3
-wxSTC_AVE_COMMENT = stc.wxSTC_AVE_COMMENT  # 1
-wxSTC_AVE_DEFAULT = stc.wxSTC_AVE_DEFAULT  # 0
-wxSTC_AVE_ENUM = stc.wxSTC_AVE_ENUM  # 7
-wxSTC_AVE_IDENTIFIER = stc.wxSTC_AVE_IDENTIFIER  # 9
-wxSTC_AVE_KEYWORD = stc.wxSTC_AVE_KEYWORD  # 4
-wxSTC_AVE_NUMBER = stc.wxSTC_AVE_NUMBER  # 2
-wxSTC_AVE_OPERATOR = stc.wxSTC_AVE_OPERATOR  # 10
-wxSTC_AVE_STATEMENT = stc.wxSTC_AVE_STATEMENT  # 5
-wxSTC_AVE_STRING = stc.wxSTC_AVE_STRING  # 6
-wxSTC_AVE_STRINGEOL = stc.wxSTC_AVE_STRINGEOL  # 8
-wxSTC_AVE_WORD = stc.wxSTC_AVE_WORD  # 3
-wxSTC_BAAN_COMMENT = stc.wxSTC_BAAN_COMMENT  # 1
-wxSTC_BAAN_COMMENTDOC = stc.wxSTC_BAAN_COMMENTDOC  # 2
-wxSTC_BAAN_DEFAULT = stc.wxSTC_BAAN_DEFAULT  # 0
-wxSTC_BAAN_IDENTIFIER = stc.wxSTC_BAAN_IDENTIFIER  # 8
-wxSTC_BAAN_NUMBER = stc.wxSTC_BAAN_NUMBER  # 3
-wxSTC_BAAN_OPERATOR = stc.wxSTC_BAAN_OPERATOR  # 7
-wxSTC_BAAN_PREPROCESSOR = stc.wxSTC_BAAN_PREPROCESSOR  # 6
-wxSTC_BAAN_STRING = stc.wxSTC_BAAN_STRING  # 5
-wxSTC_BAAN_STRINGEOL = stc.wxSTC_BAAN_STRINGEOL  # 9
-wxSTC_BAAN_WORD = stc.wxSTC_BAAN_WORD  # 4
-wxSTC_BAAN_WORD2 = stc.wxSTC_BAAN_WORD2  # 10
-wxSTC_BAT_COMMAND = stc.wxSTC_BAT_COMMAND  # 5
-wxSTC_BAT_COMMENT = stc.wxSTC_BAT_COMMENT  # 1
-wxSTC_BAT_DEFAULT = stc.wxSTC_BAT_DEFAULT  # 0
-wxSTC_BAT_HIDE = stc.wxSTC_BAT_HIDE  # 4
-wxSTC_BAT_IDENTIFIER = stc.wxSTC_BAT_IDENTIFIER  # 6
-wxSTC_BAT_LABEL = stc.wxSTC_BAT_LABEL  # 3
-wxSTC_BAT_OPERATOR = stc.wxSTC_BAT_OPERATOR  # 7
-wxSTC_BAT_WORD = stc.wxSTC_BAT_WORD  # 2
-wxSTC_B_COMMENT = stc.wxSTC_B_COMMENT  # 1
-wxSTC_B_DATE = stc.wxSTC_B_DATE  # 8
-wxSTC_B_DEFAULT = stc.wxSTC_B_DEFAULT  # 0
-wxSTC_B_IDENTIFIER = stc.wxSTC_B_IDENTIFIER  # 7
-wxSTC_B_KEYWORD = stc.wxSTC_B_KEYWORD  # 3
-wxSTC_B_NUMBER = stc.wxSTC_B_NUMBER  # 2
-wxSTC_B_OPERATOR = stc.wxSTC_B_OPERATOR  # 6
-wxSTC_B_PREPROCESSOR = stc.wxSTC_B_PREPROCESSOR  # 5
-wxSTC_B_STRING = stc.wxSTC_B_STRING  # 4
-wxSTC_CACHE_CARET = stc.wxSTC_CACHE_CARET  # 1
-wxSTC_CACHE_DOCUMENT = stc.wxSTC_CACHE_DOCUMENT  # 3
-wxSTC_CACHE_NONE = stc.wxSTC_CACHE_NONE  # 0
-wxSTC_CACHE_PAGE = stc.wxSTC_CACHE_PAGE  # 2
-wxSTC_CARET_EVEN = stc.wxSTC_CARET_EVEN  # 8
-wxSTC_CARET_JUMPS = stc.wxSTC_CARET_JUMPS  # 16
-wxSTC_CARET_SLOP = stc.wxSTC_CARET_SLOP  # 1
-wxSTC_CARET_STRICT = stc.wxSTC_CARET_STRICT  # 4
-wxSTC_CASE_LOWER = stc.wxSTC_CASE_LOWER  # 2
-wxSTC_CASE_MIXED = stc.wxSTC_CASE_MIXED  # 0
-wxSTC_CASE_UPPER = stc.wxSTC_CASE_UPPER  # 1
-wxSTC_CHARSET_ANSI = stc.wxSTC_CHARSET_ANSI  # 0
-wxSTC_CHARSET_ARABIC = stc.wxSTC_CHARSET_ARABIC  # 178
-wxSTC_CHARSET_BALTIC = stc.wxSTC_CHARSET_BALTIC  # 186
-wxSTC_CHARSET_CHINESEBIG5 = stc.wxSTC_CHARSET_CHINESEBIG5  # 136
-wxSTC_CHARSET_DEFAULT = stc.wxSTC_CHARSET_DEFAULT  # 1
-wxSTC_CHARSET_EASTEUROPE = stc.wxSTC_CHARSET_EASTEUROPE  # 238
-wxSTC_CHARSET_GB2312 = stc.wxSTC_CHARSET_GB2312  # 134
-wxSTC_CHARSET_GREEK = stc.wxSTC_CHARSET_GREEK  # 161
-wxSTC_CHARSET_HANGUL = stc.wxSTC_CHARSET_HANGUL  # 129
-wxSTC_CHARSET_HEBREW = stc.wxSTC_CHARSET_HEBREW  # 177
-wxSTC_CHARSET_JOHAB = stc.wxSTC_CHARSET_JOHAB  # 130
-wxSTC_CHARSET_MAC = stc.wxSTC_CHARSET_MAC  # 77
-wxSTC_CHARSET_OEM = stc.wxSTC_CHARSET_OEM  # 255
-wxSTC_CHARSET_RUSSIAN = stc.wxSTC_CHARSET_RUSSIAN  # 204
-wxSTC_CHARSET_SHIFTJIS = stc.wxSTC_CHARSET_SHIFTJIS  # 128
-wxSTC_CHARSET_SYMBOL = stc.wxSTC_CHARSET_SYMBOL  # 2
-wxSTC_CHARSET_THAI = stc.wxSTC_CHARSET_THAI  # 222
-wxSTC_CHARSET_TURKISH = stc.wxSTC_CHARSET_TURKISH  # 162
-wxSTC_CHARSET_VIETNAMESE = stc.wxSTC_CHARSET_VIETNAMESE  # 163
-wxSTC_CMD_BACKTAB = stc.wxSTC_CMD_BACKTAB  # 2328
-wxSTC_CMD_CANCEL = stc.wxSTC_CMD_CANCEL  # 2325
-wxSTC_CMD_CHARLEFT = stc.wxSTC_CMD_CHARLEFT  # 2304
-wxSTC_CMD_CHARLEFTEXTEND = stc.wxSTC_CMD_CHARLEFTEXTEND  # 2305
-wxSTC_CMD_CHARRIGHT = stc.wxSTC_CMD_CHARRIGHT  # 2306
-wxSTC_CMD_CHARRIGHTEXTEND = stc.wxSTC_CMD_CHARRIGHTEXTEND  # 2307
-wxSTC_CMD_CLEAR = stc.wxSTC_CMD_CLEAR  # 2180
-wxSTC_CMD_COPY = stc.wxSTC_CMD_COPY  # 2178
-wxSTC_CMD_CUT = stc.wxSTC_CMD_CUT  # 2177
-wxSTC_CMD_DELETEBACK = stc.wxSTC_CMD_DELETEBACK  # 2326
-wxSTC_CMD_DELETEBACKNOTLINE = stc.wxSTC_CMD_DELETEBACKNOTLINE  # 2344
-wxSTC_CMD_DELLINELEFT = stc.wxSTC_CMD_DELLINELEFT  # 2395
-wxSTC_CMD_DELLINERIGHT = stc.wxSTC_CMD_DELLINERIGHT  # 2396
-wxSTC_CMD_DELWORDLEFT = stc.wxSTC_CMD_DELWORDLEFT  # 2335
-wxSTC_CMD_DELWORDRIGHT = stc.wxSTC_CMD_DELWORDRIGHT  # 2336
-wxSTC_CMD_DOCUMENTEND = stc.wxSTC_CMD_DOCUMENTEND  # 2318
-wxSTC_CMD_DOCUMENTENDEXTEND = stc.wxSTC_CMD_DOCUMENTENDEXTEND  # 2319
-wxSTC_CMD_DOCUMENTSTART = stc.wxSTC_CMD_DOCUMENTSTART  # 2316
-wxSTC_CMD_DOCUMENTSTARTEXTEND = stc.wxSTC_CMD_DOCUMENTSTARTEXTEND  # 2317
-wxSTC_CMD_EDITTOGGLEOVERTYPE = stc.wxSTC_CMD_EDITTOGGLEOVERTYPE  # 2324
-wxSTC_CMD_FORMFEED = stc.wxSTC_CMD_FORMFEED  # 2330
-wxSTC_CMD_HOME = stc.wxSTC_CMD_HOME  # 2312
-wxSTC_CMD_HOMEDISPLAY = stc.wxSTC_CMD_HOMEDISPLAY  # 2345
-wxSTC_CMD_HOMEDISPLAYEXTEND = stc.wxSTC_CMD_HOMEDISPLAYEXTEND  # 2346
-wxSTC_CMD_HOMEEXTEND = stc.wxSTC_CMD_HOMEEXTEND  # 2313
-wxSTC_CMD_LINECUT = stc.wxSTC_CMD_LINECUT  # 2337
-wxSTC_CMD_LINEDELETE = stc.wxSTC_CMD_LINEDELETE  # 2338
-wxSTC_CMD_LINEDOWN = stc.wxSTC_CMD_LINEDOWN  # 2300
-wxSTC_CMD_LINEDOWNEXTEND = stc.wxSTC_CMD_LINEDOWNEXTEND  # 2301
-wxSTC_CMD_LINEEND = stc.wxSTC_CMD_LINEEND  # 2314
-wxSTC_CMD_LINEENDDISPLAY = stc.wxSTC_CMD_LINEENDDISPLAY  # 2347
-wxSTC_CMD_LINEENDDISPLAYEXTEND = stc.wxSTC_CMD_LINEENDDISPLAYEXTEND  # 2348
-wxSTC_CMD_LINEENDEXTEND = stc.wxSTC_CMD_LINEENDEXTEND  # 2315
-wxSTC_CMD_LINESCROLLDOWN = stc.wxSTC_CMD_LINESCROLLDOWN  # 2342
-wxSTC_CMD_LINESCROLLUP = stc.wxSTC_CMD_LINESCROLLUP  # 2343
-wxSTC_CMD_LINETRANSPOSE = stc.wxSTC_CMD_LINETRANSPOSE  # 2339
-wxSTC_CMD_LINEUP = stc.wxSTC_CMD_LINEUP  # 2302
-wxSTC_CMD_LINEUPEXTEND = stc.wxSTC_CMD_LINEUPEXTEND  # 2303
-wxSTC_CMD_LOWERCASE = stc.wxSTC_CMD_LOWERCASE  # 2340
-wxSTC_CMD_NEWLINE = stc.wxSTC_CMD_NEWLINE  # 2329
-wxSTC_CMD_PAGEDOWN = stc.wxSTC_CMD_PAGEDOWN  # 2322
-wxSTC_CMD_PAGEDOWNEXTEND = stc.wxSTC_CMD_PAGEDOWNEXTEND  # 2323
-wxSTC_CMD_PAGEUP = stc.wxSTC_CMD_PAGEUP  # 2320
-wxSTC_CMD_PAGEUPEXTEND = stc.wxSTC_CMD_PAGEUPEXTEND  # 2321
-wxSTC_CMD_PASTE = stc.wxSTC_CMD_PASTE  # 2179
-wxSTC_CMD_REDO = stc.wxSTC_CMD_REDO  # 2011
-wxSTC_CMD_SELECTALL = stc.wxSTC_CMD_SELECTALL  # 2013
-wxSTC_CMD_TAB = stc.wxSTC_CMD_TAB  # 2327
-wxSTC_CMD_UNDO = stc.wxSTC_CMD_UNDO  # 2176
-wxSTC_CMD_UPPERCASE = stc.wxSTC_CMD_UPPERCASE  # 2341
-wxSTC_CMD_VCHOME = stc.wxSTC_CMD_VCHOME  # 2331
-wxSTC_CMD_VCHOMEEXTEND = stc.wxSTC_CMD_VCHOMEEXTEND  # 2332
-wxSTC_CMD_WORDLEFT = stc.wxSTC_CMD_WORDLEFT  # 2308
-wxSTC_CMD_WORDLEFTEXTEND = stc.wxSTC_CMD_WORDLEFTEXTEND  # 2309
-wxSTC_CMD_WORDPARTLEFT = stc.wxSTC_CMD_WORDPARTLEFT  # 2390
-wxSTC_CMD_WORDPARTLEFTEXTEND = stc.wxSTC_CMD_WORDPARTLEFTEXTEND  # 2391
-wxSTC_CMD_WORDPARTRIGHT = stc.wxSTC_CMD_WORDPARTRIGHT  # 2392
-wxSTC_CMD_WORDPARTRIGHTEXTEND = stc.wxSTC_CMD_WORDPARTRIGHTEXTEND  # 2393
-wxSTC_CMD_WORDRIGHT = stc.wxSTC_CMD_WORDRIGHT  # 2310
-wxSTC_CMD_WORDRIGHTEXTEND = stc.wxSTC_CMD_WORDRIGHTEXTEND  # 2311
-wxSTC_CMD_ZOOMIN = stc.wxSTC_CMD_ZOOMIN  # 2333
-wxSTC_CMD_ZOOMOUT = stc.wxSTC_CMD_ZOOMOUT  # 2334
-wxSTC_CONF_COMMENT = stc.wxSTC_CONF_COMMENT  # 1
-wxSTC_CONF_DEFAULT = stc.wxSTC_CONF_DEFAULT  # 0
-wxSTC_CONF_DIRECTIVE = stc.wxSTC_CONF_DIRECTIVE  # 9
-wxSTC_CONF_EXTENSION = stc.wxSTC_CONF_EXTENSION  # 4
-wxSTC_CONF_IDENTIFIER = stc.wxSTC_CONF_IDENTIFIER  # 3
-wxSTC_CONF_IP = stc.wxSTC_CONF_IP  # 8
-wxSTC_CONF_NUMBER = stc.wxSTC_CONF_NUMBER  # 2
-wxSTC_CONF_OPERATOR = stc.wxSTC_CONF_OPERATOR  # 7
-wxSTC_CONF_PARAMETER = stc.wxSTC_CONF_PARAMETER  # 5
-wxSTC_CONF_STRING = stc.wxSTC_CONF_STRING  # 6
-wxSTC_CP_UTF8 = stc.wxSTC_CP_UTF8  # 65001
-wxSTC_CURSORNORMAL = stc.wxSTC_CURSORNORMAL  # -1
-wxSTC_CURSORWAIT = stc.wxSTC_CURSORWAIT  # 3
-wxSTC_C_CHARACTER = stc.wxSTC_C_CHARACTER  # 7
-wxSTC_C_COMMENT = stc.wxSTC_C_COMMENT  # 1
-wxSTC_C_COMMENTDOC = stc.wxSTC_C_COMMENTDOC  # 3
-wxSTC_C_COMMENTDOCKEYWORD = stc.wxSTC_C_COMMENTDOCKEYWORD  # 17
-wxSTC_C_COMMENTDOCKEYWORDERROR = stc.wxSTC_C_COMMENTDOCKEYWORDERROR  # 18
-wxSTC_C_COMMENTLINE = stc.wxSTC_C_COMMENTLINE  # 2
-wxSTC_C_COMMENTLINEDOC = stc.wxSTC_C_COMMENTLINEDOC  # 15
-wxSTC_C_DEFAULT = stc.wxSTC_C_DEFAULT  # 0
-wxSTC_C_IDENTIFIER = stc.wxSTC_C_IDENTIFIER  # 11
-wxSTC_C_NUMBER = stc.wxSTC_C_NUMBER  # 4
-wxSTC_C_OPERATOR = stc.wxSTC_C_OPERATOR  # 10
-wxSTC_C_PREPROCESSOR = stc.wxSTC_C_PREPROCESSOR  # 9
-wxSTC_C_REGEX = stc.wxSTC_C_REGEX  # 14
-wxSTC_C_STRING = stc.wxSTC_C_STRING  # 6
-wxSTC_C_STRINGEOL = stc.wxSTC_C_STRINGEOL  # 12
-wxSTC_C_UUID = stc.wxSTC_C_UUID  # 8
-wxSTC_C_VERBATIM = stc.wxSTC_C_VERBATIM  # 13
-wxSTC_C_WORD = stc.wxSTC_C_WORD  # 5
-wxSTC_C_WORD2 = stc.wxSTC_C_WORD2  # 16
-wxSTC_DIFF_ADDED = stc.wxSTC_DIFF_ADDED  # 6
-wxSTC_DIFF_COMMAND = stc.wxSTC_DIFF_COMMAND  # 2
-wxSTC_DIFF_COMMENT = stc.wxSTC_DIFF_COMMENT  # 1
-wxSTC_DIFF_DEFAULT = stc.wxSTC_DIFF_DEFAULT  # 0
-wxSTC_DIFF_DELETED = stc.wxSTC_DIFF_DELETED  # 5
-wxSTC_DIFF_HEADER = stc.wxSTC_DIFF_HEADER  # 3
-wxSTC_DIFF_POSITION = stc.wxSTC_DIFF_POSITION  # 4
-wxSTC_EDGE_BACKGROUND = stc.wxSTC_EDGE_BACKGROUND  # 2
-wxSTC_EDGE_LINE = stc.wxSTC_EDGE_LINE  # 1
-wxSTC_EDGE_NONE = stc.wxSTC_EDGE_NONE  # 0
-wxSTC_EIFFEL_CHARACTER = stc.wxSTC_EIFFEL_CHARACTER  # 5
-wxSTC_EIFFEL_COMMENTLINE = stc.wxSTC_EIFFEL_COMMENTLINE  # 1
-wxSTC_EIFFEL_DEFAULT = stc.wxSTC_EIFFEL_DEFAULT  # 0
-wxSTC_EIFFEL_IDENTIFIER = stc.wxSTC_EIFFEL_IDENTIFIER  # 7
-wxSTC_EIFFEL_NUMBER = stc.wxSTC_EIFFEL_NUMBER  # 2
-wxSTC_EIFFEL_OPERATOR = stc.wxSTC_EIFFEL_OPERATOR  # 6
-wxSTC_EIFFEL_STRING = stc.wxSTC_EIFFEL_STRING  # 4
-wxSTC_EIFFEL_STRINGEOL = stc.wxSTC_EIFFEL_STRINGEOL  # 8
-wxSTC_EIFFEL_WORD = stc.wxSTC_EIFFEL_WORD  # 3
-wxSTC_EOL_CR = stc.wxSTC_EOL_CR  # 1
-wxSTC_EOL_CRLF = stc.wxSTC_EOL_CRLF  # 0
-wxSTC_EOL_LF = stc.wxSTC_EOL_LF  # 2
-wxSTC_ERR_BORLAND = stc.wxSTC_ERR_BORLAND  # 5
-wxSTC_ERR_CMD = stc.wxSTC_ERR_CMD  # 4
-wxSTC_ERR_CTAG = stc.wxSTC_ERR_CTAG  # 9
-wxSTC_ERR_DEFAULT = stc.wxSTC_ERR_DEFAULT  # 0
-wxSTC_ERR_DIFF_ADDITION = stc.wxSTC_ERR_DIFF_ADDITION  # 11
-wxSTC_ERR_DIFF_CHANGED = stc.wxSTC_ERR_DIFF_CHANGED  # 10
-wxSTC_ERR_DIFF_DELETION = stc.wxSTC_ERR_DIFF_DELETION  # 12
-wxSTC_ERR_DIFF_MESSAGE = stc.wxSTC_ERR_DIFF_MESSAGE  # 13
-wxSTC_ERR_GCC = stc.wxSTC_ERR_GCC  # 2
-wxSTC_ERR_LUA = stc.wxSTC_ERR_LUA  # 8
-wxSTC_ERR_MS = stc.wxSTC_ERR_MS  # 3
-wxSTC_ERR_NET = stc.wxSTC_ERR_NET  # 7
-wxSTC_ERR_PERL = stc.wxSTC_ERR_PERL  # 6
-wxSTC_ERR_PYTHON = stc.wxSTC_ERR_PYTHON  # 1
-wxSTC_FIND_MATCHCASE = stc.wxSTC_FIND_MATCHCASE  # 4
-wxSTC_FIND_REGEXP = stc.wxSTC_FIND_REGEXP  # 2097152
-wxSTC_FIND_WHOLEWORD = stc.wxSTC_FIND_WHOLEWORD  # 2
-wxSTC_FIND_WORDSTART = stc.wxSTC_FIND_WORDSTART  # 1048576
-wxSTC_FOLDLEVELBASE = stc.wxSTC_FOLDLEVELBASE  # 1024
-wxSTC_FOLDLEVELHEADERFLAG = stc.wxSTC_FOLDLEVELHEADERFLAG  # 8192
-wxSTC_FOLDLEVELNUMBERMASK = stc.wxSTC_FOLDLEVELNUMBERMASK  # 4095
-wxSTC_FOLDLEVELWHITEFLAG = stc.wxSTC_FOLDLEVELWHITEFLAG  # 4096
-wxSTC_HBA_COMMENTLINE = stc.wxSTC_HBA_COMMENTLINE  # 82
-wxSTC_HBA_DEFAULT = stc.wxSTC_HBA_DEFAULT  # 81
-wxSTC_HBA_IDENTIFIER = stc.wxSTC_HBA_IDENTIFIER  # 86
-wxSTC_HBA_NUMBER = stc.wxSTC_HBA_NUMBER  # 83
-wxSTC_HBA_START = stc.wxSTC_HBA_START  # 80
-wxSTC_HBA_STRING = stc.wxSTC_HBA_STRING  # 85
-wxSTC_HBA_STRINGEOL = stc.wxSTC_HBA_STRINGEOL  # 87
-wxSTC_HBA_WORD = stc.wxSTC_HBA_WORD  # 84
-wxSTC_HB_COMMENTLINE = stc.wxSTC_HB_COMMENTLINE  # 72
-wxSTC_HB_DEFAULT = stc.wxSTC_HB_DEFAULT  # 71
-wxSTC_HB_IDENTIFIER = stc.wxSTC_HB_IDENTIFIER  # 76
-wxSTC_HB_NUMBER = stc.wxSTC_HB_NUMBER  # 73
-wxSTC_HB_START = stc.wxSTC_HB_START  # 70
-wxSTC_HB_STRING = stc.wxSTC_HB_STRING  # 75
-wxSTC_HB_STRINGEOL = stc.wxSTC_HB_STRINGEOL  # 77
-wxSTC_HB_WORD = stc.wxSTC_HB_WORD  # 74
-wxSTC_HJA_COMMENT = stc.wxSTC_HJA_COMMENT  # 57
-wxSTC_HJA_COMMENTDOC = stc.wxSTC_HJA_COMMENTDOC  # 59
-wxSTC_HJA_COMMENTLINE = stc.wxSTC_HJA_COMMENTLINE  # 58
-wxSTC_HJA_DEFAULT = stc.wxSTC_HJA_DEFAULT  # 56
-wxSTC_HJA_DOUBLESTRING = stc.wxSTC_HJA_DOUBLESTRING  # 63
-wxSTC_HJA_KEYWORD = stc.wxSTC_HJA_KEYWORD  # 62
-wxSTC_HJA_NUMBER = stc.wxSTC_HJA_NUMBER  # 60
-wxSTC_HJA_REGEX = stc.wxSTC_HJA_REGEX  # 67
-wxSTC_HJA_SINGLESTRING = stc.wxSTC_HJA_SINGLESTRING  # 64
-wxSTC_HJA_START = stc.wxSTC_HJA_START  # 55
-wxSTC_HJA_STRINGEOL = stc.wxSTC_HJA_STRINGEOL  # 66
-wxSTC_HJA_SYMBOLS = stc.wxSTC_HJA_SYMBOLS  # 65
-wxSTC_HJA_WORD = stc.wxSTC_HJA_WORD  # 61
-wxSTC_HJ_COMMENT = stc.wxSTC_HJ_COMMENT  # 42
-wxSTC_HJ_COMMENTDOC = stc.wxSTC_HJ_COMMENTDOC  # 44
-wxSTC_HJ_COMMENTLINE = stc.wxSTC_HJ_COMMENTLINE  # 43
-wxSTC_HJ_DEFAULT = stc.wxSTC_HJ_DEFAULT  # 41
-wxSTC_HJ_DOUBLESTRING = stc.wxSTC_HJ_DOUBLESTRING  # 48
-wxSTC_HJ_KEYWORD = stc.wxSTC_HJ_KEYWORD  # 47
-wxSTC_HJ_NUMBER = stc.wxSTC_HJ_NUMBER  # 45
-wxSTC_HJ_REGEX = stc.wxSTC_HJ_REGEX  # 52
-wxSTC_HJ_SINGLESTRING = stc.wxSTC_HJ_SINGLESTRING  # 49
-wxSTC_HJ_START = stc.wxSTC_HJ_START  # 40
-wxSTC_HJ_STRINGEOL = stc.wxSTC_HJ_STRINGEOL  # 51
-wxSTC_HJ_SYMBOLS = stc.wxSTC_HJ_SYMBOLS  # 50
-wxSTC_HJ_WORD = stc.wxSTC_HJ_WORD  # 46
-wxSTC_HPA_CHARACTER = stc.wxSTC_HPA_CHARACTER  # 110
-wxSTC_HPA_CLASSNAME = stc.wxSTC_HPA_CLASSNAME  # 114
-wxSTC_HPA_COMMENTLINE = stc.wxSTC_HPA_COMMENTLINE  # 107
-wxSTC_HPA_DEFAULT = stc.wxSTC_HPA_DEFAULT  # 106
-wxSTC_HPA_DEFNAME = stc.wxSTC_HPA_DEFNAME  # 115
-wxSTC_HPA_IDENTIFIER = stc.wxSTC_HPA_IDENTIFIER  # 117
-wxSTC_HPA_NUMBER = stc.wxSTC_HPA_NUMBER  # 108
-wxSTC_HPA_OPERATOR = stc.wxSTC_HPA_OPERATOR  # 116
-wxSTC_HPA_START = stc.wxSTC_HPA_START  # 105
-wxSTC_HPA_STRING = stc.wxSTC_HPA_STRING  # 109
-wxSTC_HPA_TRIPLE = stc.wxSTC_HPA_TRIPLE  # 112
-wxSTC_HPA_TRIPLEDOUBLE = stc.wxSTC_HPA_TRIPLEDOUBLE  # 113
-wxSTC_HPA_WORD = stc.wxSTC_HPA_WORD  # 111
-wxSTC_HPHP_COMMENT = stc.wxSTC_HPHP_COMMENT  # 124
-wxSTC_HPHP_COMMENTLINE = stc.wxSTC_HPHP_COMMENTLINE  # 125
-wxSTC_HPHP_DEFAULT = stc.wxSTC_HPHP_DEFAULT  # 118
-wxSTC_HPHP_HSTRING = stc.wxSTC_HPHP_HSTRING  # 119
-wxSTC_HPHP_HSTRING_VARIABLE = stc.wxSTC_HPHP_HSTRING_VARIABLE  # 126
-wxSTC_HPHP_NUMBER = stc.wxSTC_HPHP_NUMBER  # 122
-wxSTC_HPHP_OPERATOR = stc.wxSTC_HPHP_OPERATOR  # 127
-wxSTC_HPHP_SIMPLESTRING = stc.wxSTC_HPHP_SIMPLESTRING  # 120
-wxSTC_HPHP_VARIABLE = stc.wxSTC_HPHP_VARIABLE  # 123
-wxSTC_HPHP_WORD = stc.wxSTC_HPHP_WORD  # 121
-wxSTC_HP_CHARACTER = stc.wxSTC_HP_CHARACTER  # 95
-wxSTC_HP_CLASSNAME = stc.wxSTC_HP_CLASSNAME  # 99
-wxSTC_HP_COMMENTLINE = stc.wxSTC_HP_COMMENTLINE  # 92
-wxSTC_HP_DEFAULT = stc.wxSTC_HP_DEFAULT  # 91
-wxSTC_HP_DEFNAME = stc.wxSTC_HP_DEFNAME  # 100
-wxSTC_HP_IDENTIFIER = stc.wxSTC_HP_IDENTIFIER  # 102
-wxSTC_HP_NUMBER = stc.wxSTC_HP_NUMBER  # 93
-wxSTC_HP_OPERATOR = stc.wxSTC_HP_OPERATOR  # 101
-wxSTC_HP_START = stc.wxSTC_HP_START  # 90
-wxSTC_HP_STRING = stc.wxSTC_HP_STRING  # 94
-wxSTC_HP_TRIPLE = stc.wxSTC_HP_TRIPLE  # 97
-wxSTC_HP_TRIPLEDOUBLE = stc.wxSTC_HP_TRIPLEDOUBLE  # 98
-wxSTC_HP_WORD = stc.wxSTC_HP_WORD  # 96
-wxSTC_H_ASP = stc.wxSTC_H_ASP  # 15
-wxSTC_H_ASPAT = stc.wxSTC_H_ASPAT  # 16
-wxSTC_H_ATTRIBUTE = stc.wxSTC_H_ATTRIBUTE  # 3
-wxSTC_H_ATTRIBUTEUNKNOWN = stc.wxSTC_H_ATTRIBUTEUNKNOWN  # 4
-wxSTC_H_CDATA = stc.wxSTC_H_CDATA  # 17
-wxSTC_H_COMMENT = stc.wxSTC_H_COMMENT  # 9
-wxSTC_H_DEFAULT = stc.wxSTC_H_DEFAULT  # 0
-wxSTC_H_DOUBLESTRING = stc.wxSTC_H_DOUBLESTRING  # 6
-wxSTC_H_ENTITY = stc.wxSTC_H_ENTITY  # 10
-wxSTC_H_NUMBER = stc.wxSTC_H_NUMBER  # 5
-wxSTC_H_OTHER = stc.wxSTC_H_OTHER  # 8
-wxSTC_H_QUESTION = stc.wxSTC_H_QUESTION  # 18
-wxSTC_H_SCRIPT = stc.wxSTC_H_SCRIPT  # 14
-wxSTC_H_SGML_1ST_PARAM = stc.wxSTC_H_SGML_1ST_PARAM  # 23
-wxSTC_H_SGML_1ST_PARAM_COMMENT = stc.wxSTC_H_SGML_1ST_PARAM_COMMENT  # 30
-wxSTC_H_SGML_BLOCK_DEFAULT = stc.wxSTC_H_SGML_BLOCK_DEFAULT  # 31
-wxSTC_H_SGML_COMMAND = stc.wxSTC_H_SGML_COMMAND  # 22
-wxSTC_H_SGML_COMMENT = stc.wxSTC_H_SGML_COMMENT  # 29
-wxSTC_H_SGML_DEFAULT = stc.wxSTC_H_SGML_DEFAULT  # 21
-wxSTC_H_SGML_DOUBLESTRING = stc.wxSTC_H_SGML_DOUBLESTRING  # 24
-wxSTC_H_SGML_ENTITY = stc.wxSTC_H_SGML_ENTITY  # 28
-wxSTC_H_SGML_ERROR = stc.wxSTC_H_SGML_ERROR  # 26
-wxSTC_H_SGML_SIMPLESTRING = stc.wxSTC_H_SGML_SIMPLESTRING  # 25
-wxSTC_H_SGML_SPECIAL = stc.wxSTC_H_SGML_SPECIAL  # 27
-wxSTC_H_SINGLESTRING = stc.wxSTC_H_SINGLESTRING  # 7
-wxSTC_H_TAG = stc.wxSTC_H_TAG  # 1
-wxSTC_H_TAGEND = stc.wxSTC_H_TAGEND  # 11
-wxSTC_H_TAGUNKNOWN = stc.wxSTC_H_TAGUNKNOWN  # 2
-wxSTC_H_VALUE = stc.wxSTC_H_VALUE  # 19
-wxSTC_H_XCCOMMENT = stc.wxSTC_H_XCCOMMENT  # 20
-wxSTC_H_XMLEND = stc.wxSTC_H_XMLEND  # 13
-wxSTC_H_XMLSTART = stc.wxSTC_H_XMLSTART  # 12
-wxSTC_INDIC0_MASK = stc.wxSTC_INDIC0_MASK  # 32
-wxSTC_INDIC1_MASK = stc.wxSTC_INDIC1_MASK  # 64
-wxSTC_INDIC2_MASK = stc.wxSTC_INDIC2_MASK  # 128
-wxSTC_INDICS_MASK = stc.wxSTC_INDICS_MASK  # 224
-wxSTC_INDIC_DIAGONAL = stc.wxSTC_INDIC_DIAGONAL  # 3
-wxSTC_INDIC_MAX = stc.wxSTC_INDIC_MAX  # 7
-wxSTC_INDIC_PLAIN = stc.wxSTC_INDIC_PLAIN  # 0
-wxSTC_INDIC_SQUIGGLE = stc.wxSTC_INDIC_SQUIGGLE  # 1
-wxSTC_INDIC_STRIKE = stc.wxSTC_INDIC_STRIKE  # 4
-wxSTC_INDIC_TT = stc.wxSTC_INDIC_TT  # 2
-wxSTC_INVALID_POSITION = stc.wxSTC_INVALID_POSITION  # -1
-wxSTC_KEY_ADD = stc.wxSTC_KEY_ADD  # 310
-wxSTC_KEY_BACK = stc.wxSTC_KEY_BACK  # 8
-wxSTC_KEY_DELETE = stc.wxSTC_KEY_DELETE  # 308
-wxSTC_KEY_DIVIDE = stc.wxSTC_KEY_DIVIDE  # 312
-wxSTC_KEY_DOWN = stc.wxSTC_KEY_DOWN  # 300
-wxSTC_KEY_END = stc.wxSTC_KEY_END  # 305
-wxSTC_KEY_ESCAPE = stc.wxSTC_KEY_ESCAPE  # 7
-wxSTC_KEY_HOME = stc.wxSTC_KEY_HOME  # 304
-wxSTC_KEY_INSERT = stc.wxSTC_KEY_INSERT  # 309
-wxSTC_KEY_LEFT = stc.wxSTC_KEY_LEFT  # 302
-wxSTC_KEY_NEXT = stc.wxSTC_KEY_NEXT  # 307
-wxSTC_KEY_PRIOR = stc.wxSTC_KEY_PRIOR  # 306
-wxSTC_KEY_RETURN = stc.wxSTC_KEY_RETURN  # 13
-wxSTC_KEY_RIGHT = stc.wxSTC_KEY_RIGHT  # 303
-wxSTC_KEY_SUBTRACT = stc.wxSTC_KEY_SUBTRACT  # 311
-wxSTC_KEY_TAB = stc.wxSTC_KEY_TAB  # 9
-wxSTC_KEY_UP = stc.wxSTC_KEY_UP  # 301
-wxSTC_LASTSTEPINUNDOREDO = stc.wxSTC_LASTSTEPINUNDOREDO  # 256
-wxSTC_LEXER_START = stc.wxSTC_LEXER_START  # 4000
-wxSTC_LEX_ADA = stc.wxSTC_LEX_ADA  # 20
-wxSTC_LEX_ASP = stc.wxSTC_LEX_ASP  # 29
-wxSTC_LEX_AUTOMATIC = stc.wxSTC_LEX_AUTOMATIC  # 1000
-wxSTC_LEX_AVE = stc.wxSTC_LEX_AVE  # 19
-wxSTC_LEX_BAAN = stc.wxSTC_LEX_BAAN  # 31
-wxSTC_LEX_BATCH = stc.wxSTC_LEX_BATCH  # 12
-wxSTC_LEX_BULLANT = stc.wxSTC_LEX_BULLANT  # 27
-wxSTC_LEX_CONF = stc.wxSTC_LEX_CONF  # 17
-wxSTC_LEX_CONTAINER = stc.wxSTC_LEX_CONTAINER  # 0
-wxSTC_LEX_CPP = stc.wxSTC_LEX_CPP  # 3
-wxSTC_LEX_DIFF = stc.wxSTC_LEX_DIFF  # 16
-wxSTC_LEX_EIFFEL = stc.wxSTC_LEX_EIFFEL  # 23
-wxSTC_LEX_EIFFELKW = stc.wxSTC_LEX_EIFFELKW  # 24
-wxSTC_LEX_ERRORLIST = stc.wxSTC_LEX_ERRORLIST  # 10
-wxSTC_LEX_HTML = stc.wxSTC_LEX_HTML  # 4
-wxSTC_LEX_LATEX = stc.wxSTC_LEX_LATEX  # 14
-wxSTC_LEX_LISP = stc.wxSTC_LEX_LISP  # 21
-wxSTC_LEX_LUA = stc.wxSTC_LEX_LUA  # 15
-wxSTC_LEX_MAKEFILE = stc.wxSTC_LEX_MAKEFILE  # 11
-wxSTC_LEX_MATLAB = stc.wxSTC_LEX_MATLAB  # 32
-wxSTC_LEX_NNCRONTAB = stc.wxSTC_LEX_NNCRONTAB  # 26
-wxSTC_LEX_NULL = stc.wxSTC_LEX_NULL  # 1
-wxSTC_LEX_PASCAL = stc.wxSTC_LEX_PASCAL  # 18
-wxSTC_LEX_PERL = stc.wxSTC_LEX_PERL  # 6
-wxSTC_LEX_PHP = stc.wxSTC_LEX_PHP  # 30
-wxSTC_LEX_PROPERTIES = stc.wxSTC_LEX_PROPERTIES  # 9
-wxSTC_LEX_PYTHON = stc.wxSTC_LEX_PYTHON  # 2
-wxSTC_LEX_RUBY = stc.wxSTC_LEX_RUBY  # 22
-wxSTC_LEX_SCRIPTOL = stc.wxSTC_LEX_SCRIPTOL  # 33
-wxSTC_LEX_SQL = stc.wxSTC_LEX_SQL  # 7
-wxSTC_LEX_TCL = stc.wxSTC_LEX_TCL  # 25
-wxSTC_LEX_VB = stc.wxSTC_LEX_VB  # 8
-wxSTC_LEX_VBSCRIPT = stc.wxSTC_LEX_VBSCRIPT  # 28
-wxSTC_LEX_XCODE = stc.wxSTC_LEX_XCODE  # 13
-wxSTC_LEX_XML = stc.wxSTC_LEX_XML  # 5
-wxSTC_LISP_COMMENT = stc.wxSTC_LISP_COMMENT  # 1
-wxSTC_LISP_DEFAULT = stc.wxSTC_LISP_DEFAULT  # 0
-wxSTC_LISP_IDENTIFIER = stc.wxSTC_LISP_IDENTIFIER  # 9
-wxSTC_LISP_KEYWORD = stc.wxSTC_LISP_KEYWORD  # 3
-wxSTC_LISP_NUMBER = stc.wxSTC_LISP_NUMBER  # 2
-wxSTC_LISP_OPERATOR = stc.wxSTC_LISP_OPERATOR  # 10
-wxSTC_LISP_STRING = stc.wxSTC_LISP_STRING  # 6
-wxSTC_LISP_STRINGEOL = stc.wxSTC_LISP_STRINGEOL  # 8
-wxSTC_LUA_CHARACTER = stc.wxSTC_LUA_CHARACTER  # 7
-wxSTC_LUA_COMMENT = stc.wxSTC_LUA_COMMENT  # 1
-wxSTC_LUA_COMMENTDOC = stc.wxSTC_LUA_COMMENTDOC  # 3
-wxSTC_LUA_COMMENTLINE = stc.wxSTC_LUA_COMMENTLINE  # 2
-wxSTC_LUA_DEFAULT = stc.wxSTC_LUA_DEFAULT  # 0
-wxSTC_LUA_IDENTIFIER = stc.wxSTC_LUA_IDENTIFIER  # 11
-wxSTC_LUA_LITERALSTRING = stc.wxSTC_LUA_LITERALSTRING  # 8
-wxSTC_LUA_NUMBER = stc.wxSTC_LUA_NUMBER  # 4
-wxSTC_LUA_OPERATOR = stc.wxSTC_LUA_OPERATOR  # 10
-wxSTC_LUA_PREPROCESSOR = stc.wxSTC_LUA_PREPROCESSOR  # 9
-wxSTC_LUA_STRING = stc.wxSTC_LUA_STRING  # 6
-wxSTC_LUA_STRINGEOL = stc.wxSTC_LUA_STRINGEOL  # 12
-wxSTC_LUA_WORD = stc.wxSTC_LUA_WORD  # 5
-wxSTC_LUA_WORD2 = stc.wxSTC_LUA_WORD2  # 13
-wxSTC_LUA_WORD3 = stc.wxSTC_LUA_WORD3  # 14
-wxSTC_LUA_WORD4 = stc.wxSTC_LUA_WORD4  # 15
-wxSTC_LUA_WORD5 = stc.wxSTC_LUA_WORD5  # 16
-wxSTC_LUA_WORD6 = stc.wxSTC_LUA_WORD6  # 17
-wxSTC_L_COMMAND = stc.wxSTC_L_COMMAND  # 1
-wxSTC_L_COMMENT = stc.wxSTC_L_COMMENT  # 4
-wxSTC_L_DEFAULT = stc.wxSTC_L_DEFAULT  # 0
-wxSTC_L_MATH = stc.wxSTC_L_MATH  # 3
-wxSTC_L_TAG = stc.wxSTC_L_TAG  # 2
-wxSTC_MAKE_COMMENT = stc.wxSTC_MAKE_COMMENT  # 1
-wxSTC_MAKE_DEFAULT = stc.wxSTC_MAKE_DEFAULT  # 0
-wxSTC_MAKE_IDENTIFIER = stc.wxSTC_MAKE_IDENTIFIER  # 3
-wxSTC_MAKE_IDEOL = stc.wxSTC_MAKE_IDEOL  # 9
-wxSTC_MAKE_OPERATOR = stc.wxSTC_MAKE_OPERATOR  # 4
-wxSTC_MAKE_PREPROCESSOR = stc.wxSTC_MAKE_PREPROCESSOR  # 2
-wxSTC_MAKE_TARGET = stc.wxSTC_MAKE_TARGET  # 5
-wxSTC_MARGIN_NUMBER = stc.wxSTC_MARGIN_NUMBER  # 1
-wxSTC_MARGIN_SYMBOL = stc.wxSTC_MARGIN_SYMBOL  # 0
-wxSTC_MARKER_MAX = stc.wxSTC_MARKER_MAX  # 31
-wxSTC_MARKNUM_FOLDER = stc.wxSTC_MARKNUM_FOLDER  # 30
-wxSTC_MARKNUM_FOLDEREND = stc.wxSTC_MARKNUM_FOLDEREND  # 25
-wxSTC_MARKNUM_FOLDERMIDTAIL = stc.wxSTC_MARKNUM_FOLDERMIDTAIL  # 27
-wxSTC_MARKNUM_FOLDEROPEN = stc.wxSTC_MARKNUM_FOLDEROPEN  # 31
-wxSTC_MARKNUM_FOLDEROPENMID = stc.wxSTC_MARKNUM_FOLDEROPENMID  # 26
-wxSTC_MARKNUM_FOLDERSUB = stc.wxSTC_MARKNUM_FOLDERSUB  # 29
-wxSTC_MARKNUM_FOLDERTAIL = stc.wxSTC_MARKNUM_FOLDERTAIL  # 28
-wxSTC_MARK_ARROW = stc.wxSTC_MARK_ARROW  # 2
-wxSTC_MARK_ARROWDOWN = stc.wxSTC_MARK_ARROWDOWN  # 6
-wxSTC_MARK_ARROWS = stc.wxSTC_MARK_ARROWS  # 24
-wxSTC_MARK_BACKGROUND = stc.wxSTC_MARK_BACKGROUND  # 22
-wxSTC_MARK_BOXMINUS = stc.wxSTC_MARK_BOXMINUS  # 14
-wxSTC_MARK_BOXMINUSCONNECTED = stc.wxSTC_MARK_BOXMINUSCONNECTED  # 15
-wxSTC_MARK_BOXPLUS = stc.wxSTC_MARK_BOXPLUS  # 12
-wxSTC_MARK_BOXPLUSCONNECTED = stc.wxSTC_MARK_BOXPLUSCONNECTED  # 13
-wxSTC_MARK_CHARACTER = stc.wxSTC_MARK_CHARACTER  # 10000
-wxSTC_MARK_CIRCLE = stc.wxSTC_MARK_CIRCLE  # 0
-wxSTC_MARK_CIRCLEMINUS = stc.wxSTC_MARK_CIRCLEMINUS  # 20
-wxSTC_MARK_CIRCLEMINUSCONNECTED = stc.wxSTC_MARK_CIRCLEMINUSCONNECTED  # 21
-wxSTC_MARK_CIRCLEPLUS = stc.wxSTC_MARK_CIRCLEPLUS  # 18
-wxSTC_MARK_CIRCLEPLUSCONNECTED = stc.wxSTC_MARK_CIRCLEPLUSCONNECTED  # 19
-wxSTC_MARK_DOTDOTDOT = stc.wxSTC_MARK_DOTDOTDOT  # 23
-wxSTC_MARK_EMPTY = stc.wxSTC_MARK_EMPTY  # 5
-wxSTC_MARK_LCORNER = stc.wxSTC_MARK_LCORNER  # 10
-wxSTC_MARK_LCORNERCURVE = stc.wxSTC_MARK_LCORNERCURVE  # 16
-wxSTC_MARK_MINUS = stc.wxSTC_MARK_MINUS  # 7
-wxSTC_MARK_PLUS = stc.wxSTC_MARK_PLUS  # 8
-wxSTC_MARK_ROUNDRECT = stc.wxSTC_MARK_ROUNDRECT  # 1
-wxSTC_MARK_SHORTARROW = stc.wxSTC_MARK_SHORTARROW  # 4
-wxSTC_MARK_SMALLRECT = stc.wxSTC_MARK_SMALLRECT  # 3
-wxSTC_MARK_TCORNER = stc.wxSTC_MARK_TCORNER  # 11
-wxSTC_MARK_TCORNERCURVE = stc.wxSTC_MARK_TCORNERCURVE  # 17
-wxSTC_MARK_VLINE = stc.wxSTC_MARK_VLINE  # 9
-wxSTC_MASK_FOLDERS = stc.wxSTC_MASK_FOLDERS  # -33554432
-wxSTC_MATLAB_COMMAND = stc.wxSTC_MATLAB_COMMAND  # 2
-wxSTC_MATLAB_COMMENT = stc.wxSTC_MATLAB_COMMENT  # 1
-wxSTC_MATLAB_DEFAULT = stc.wxSTC_MATLAB_DEFAULT  # 0
-wxSTC_MATLAB_IDENTIFIER = stc.wxSTC_MATLAB_IDENTIFIER  # 7
-wxSTC_MATLAB_KEYWORD = stc.wxSTC_MATLAB_KEYWORD  # 4
-wxSTC_MATLAB_NUMBER = stc.wxSTC_MATLAB_NUMBER  # 3
-wxSTC_MATLAB_OPERATOR = stc.wxSTC_MATLAB_OPERATOR  # 6
-wxSTC_MATLAB_STRING = stc.wxSTC_MATLAB_STRING  # 5
-wxSTC_MODEVENTMASKALL = stc.wxSTC_MODEVENTMASKALL  # 3959
-wxSTC_MOD_BEFOREDELETE = stc.wxSTC_MOD_BEFOREDELETE  # 2048
-wxSTC_MOD_BEFOREINSERT = stc.wxSTC_MOD_BEFOREINSERT  # 1024
-wxSTC_MOD_CHANGEFOLD = stc.wxSTC_MOD_CHANGEFOLD  # 8
-wxSTC_MOD_CHANGEMARKER = stc.wxSTC_MOD_CHANGEMARKER  # 512
-wxSTC_MOD_CHANGESTYLE = stc.wxSTC_MOD_CHANGESTYLE  # 4
-wxSTC_MOD_DELETETEXT = stc.wxSTC_MOD_DELETETEXT  # 2
-wxSTC_MOD_INSERTTEXT = stc.wxSTC_MOD_INSERTTEXT  # 1
-wxSTC_NNCRONTAB_ASTERISK = stc.wxSTC_NNCRONTAB_ASTERISK  # 6
-wxSTC_NNCRONTAB_COMMENT = stc.wxSTC_NNCRONTAB_COMMENT  # 1
-wxSTC_NNCRONTAB_DEFAULT = stc.wxSTC_NNCRONTAB_DEFAULT  # 0
-wxSTC_NNCRONTAB_ENVIRONMENT = stc.wxSTC_NNCRONTAB_ENVIRONMENT  # 9
-wxSTC_NNCRONTAB_IDENTIFIER = stc.wxSTC_NNCRONTAB_IDENTIFIER  # 10
-wxSTC_NNCRONTAB_KEYWORD = stc.wxSTC_NNCRONTAB_KEYWORD  # 4
-wxSTC_NNCRONTAB_MODIFIER = stc.wxSTC_NNCRONTAB_MODIFIER  # 5
-wxSTC_NNCRONTAB_NUMBER = stc.wxSTC_NNCRONTAB_NUMBER  # 7
-wxSTC_NNCRONTAB_SECTION = stc.wxSTC_NNCRONTAB_SECTION  # 3
-wxSTC_NNCRONTAB_STRING = stc.wxSTC_NNCRONTAB_STRING  # 8
-wxSTC_NNCRONTAB_TASK = stc.wxSTC_NNCRONTAB_TASK  # 2
-wxSTC_OPTIONAL_START = stc.wxSTC_OPTIONAL_START  # 3000
-wxSTC_PERFORMED_REDO = stc.wxSTC_PERFORMED_REDO  # 64
-wxSTC_PERFORMED_UNDO = stc.wxSTC_PERFORMED_UNDO  # 32
-wxSTC_PERFORMED_USER = stc.wxSTC_PERFORMED_USER  # 16
-wxSTC_PL_ARRAY = stc.wxSTC_PL_ARRAY  # 13
-wxSTC_PL_BACKTICKS = stc.wxSTC_PL_BACKTICKS  # 20
-wxSTC_PL_CHARACTER = stc.wxSTC_PL_CHARACTER  # 7
-wxSTC_PL_COMMENTLINE = stc.wxSTC_PL_COMMENTLINE  # 2
-wxSTC_PL_DATASECTION = stc.wxSTC_PL_DATASECTION  # 21
-wxSTC_PL_DEFAULT = stc.wxSTC_PL_DEFAULT  # 0
-wxSTC_PL_ERROR = stc.wxSTC_PL_ERROR  # 1
-wxSTC_PL_HASH = stc.wxSTC_PL_HASH  # 14
-wxSTC_PL_HERE_DELIM = stc.wxSTC_PL_HERE_DELIM  # 22
-wxSTC_PL_HERE_Q = stc.wxSTC_PL_HERE_Q  # 23
-wxSTC_PL_HERE_QQ = stc.wxSTC_PL_HERE_QQ  # 24
-wxSTC_PL_HERE_QX = stc.wxSTC_PL_HERE_QX  # 25
-wxSTC_PL_IDENTIFIER = stc.wxSTC_PL_IDENTIFIER  # 11
-wxSTC_PL_LONGQUOTE = stc.wxSTC_PL_LONGQUOTE  # 19
-wxSTC_PL_NUMBER = stc.wxSTC_PL_NUMBER  # 4
-wxSTC_PL_OPERATOR = stc.wxSTC_PL_OPERATOR  # 10
-wxSTC_PL_POD = stc.wxSTC_PL_POD  # 3
-wxSTC_PL_PREPROCESSOR = stc.wxSTC_PL_PREPROCESSOR  # 9
-wxSTC_PL_PUNCTUATION = stc.wxSTC_PL_PUNCTUATION  # 8
-wxSTC_PL_REGEX = stc.wxSTC_PL_REGEX  # 17
-wxSTC_PL_REGSUBST = stc.wxSTC_PL_REGSUBST  # 18
-wxSTC_PL_SCALAR = stc.wxSTC_PL_SCALAR  # 12
-wxSTC_PL_STRING = stc.wxSTC_PL_STRING  # 6
-wxSTC_PL_STRING_Q = stc.wxSTC_PL_STRING_Q  # 26
-wxSTC_PL_STRING_QQ = stc.wxSTC_PL_STRING_QQ  # 27
-wxSTC_PL_STRING_QR = stc.wxSTC_PL_STRING_QR  # 29
-wxSTC_PL_STRING_QW = stc.wxSTC_PL_STRING_QW  # 30
-wxSTC_PL_STRING_QX = stc.wxSTC_PL_STRING_QX  # 28
-wxSTC_PL_SYMBOLTABLE = stc.wxSTC_PL_SYMBOLTABLE  # 15
-wxSTC_PL_WORD = stc.wxSTC_PL_WORD  # 5
-wxSTC_PRINT_BLACKONWHITE = stc.wxSTC_PRINT_BLACKONWHITE  # 2
-wxSTC_PRINT_COLOURONWHITE = stc.wxSTC_PRINT_COLOURONWHITE  # 3
-wxSTC_PRINT_COLOURONWHITEDEFAULTBG = stc.wxSTC_PRINT_COLOURONWHITEDEFAULTBG  # 4
-wxSTC_PRINT_INVERTLIGHT = stc.wxSTC_PRINT_INVERTLIGHT  # 1
-wxSTC_PRINT_NORMAL = stc.wxSTC_PRINT_NORMAL  # 0
-wxSTC_PROPS_ASSIGNMENT = stc.wxSTC_PROPS_ASSIGNMENT  # 3
-wxSTC_PROPS_COMMENT = stc.wxSTC_PROPS_COMMENT  # 1
-wxSTC_PROPS_DEFAULT = stc.wxSTC_PROPS_DEFAULT  # 0
-wxSTC_PROPS_DEFVAL = stc.wxSTC_PROPS_DEFVAL  # 4
-wxSTC_PROPS_SECTION = stc.wxSTC_PROPS_SECTION  # 2
-wxSTC_P_CHARACTER = stc.wxSTC_P_CHARACTER  # 4
-wxSTC_P_CLASSNAME = stc.wxSTC_P_CLASSNAME  # 8
-wxSTC_P_COMMENTBLOCK = stc.wxSTC_P_COMMENTBLOCK  # 12
-wxSTC_P_COMMENTLINE = stc.wxSTC_P_COMMENTLINE  # 1
-wxSTC_P_DEFAULT = stc.wxSTC_P_DEFAULT  # 0
-wxSTC_P_DEFNAME = stc.wxSTC_P_DEFNAME  # 9
-wxSTC_P_IDENTIFIER = stc.wxSTC_P_IDENTIFIER  # 11
-wxSTC_P_NUMBER = stc.wxSTC_P_NUMBER  # 2
-wxSTC_P_OPERATOR = stc.wxSTC_P_OPERATOR  # 10
-wxSTC_P_STRING = stc.wxSTC_P_STRING  # 3
-wxSTC_P_STRINGEOL = stc.wxSTC_P_STRINGEOL  # 13
-wxSTC_P_TRIPLE = stc.wxSTC_P_TRIPLE  # 6
-wxSTC_P_TRIPLEDOUBLE = stc.wxSTC_P_TRIPLEDOUBLE  # 7
-wxSTC_P_WORD = stc.wxSTC_P_WORD  # 5
-wxSTC_SCMOD_ALT = stc.wxSTC_SCMOD_ALT  # 4
-wxSTC_SCMOD_CTRL = stc.wxSTC_SCMOD_CTRL  # 2
-wxSTC_SCMOD_SHIFT = stc.wxSTC_SCMOD_SHIFT  # 1
-wxSTC_SCRIPTOL_CHARACTER = stc.wxSTC_SCRIPTOL_CHARACTER  # 7
-wxSTC_SCRIPTOL_COMMENT = stc.wxSTC_SCRIPTOL_COMMENT  # 1
-wxSTC_SCRIPTOL_COMMENTBASIC = stc.wxSTC_SCRIPTOL_COMMENTBASIC  # 19
-wxSTC_SCRIPTOL_COMMENTDOC = stc.wxSTC_SCRIPTOL_COMMENTDOC  # 3
-wxSTC_SCRIPTOL_COMMENTDOCKEYWORD = stc.wxSTC_SCRIPTOL_COMMENTDOCKEYWORD  # 17
-wxSTC_SCRIPTOL_COMMENTDOCKEYWORDERROR = stc.wxSTC_SCRIPTOL_COMMENTDOCKEYWORDERROR  # 18
-wxSTC_SCRIPTOL_COMMENTLINE = stc.wxSTC_SCRIPTOL_COMMENTLINE  # 2
-wxSTC_SCRIPTOL_COMMENTLINEDOC = stc.wxSTC_SCRIPTOL_COMMENTLINEDOC  # 15
-wxSTC_SCRIPTOL_DEFAULT = stc.wxSTC_SCRIPTOL_DEFAULT  # 0
-wxSTC_SCRIPTOL_IDENTIFIER = stc.wxSTC_SCRIPTOL_IDENTIFIER  # 11
-wxSTC_SCRIPTOL_NUMBER = stc.wxSTC_SCRIPTOL_NUMBER  # 4
-wxSTC_SCRIPTOL_OPERATOR = stc.wxSTC_SCRIPTOL_OPERATOR  # 10
-wxSTC_SCRIPTOL_PREPROCESSOR = stc.wxSTC_SCRIPTOL_PREPROCESSOR  # 9
-wxSTC_SCRIPTOL_REGEX = stc.wxSTC_SCRIPTOL_REGEX  # 14
-wxSTC_SCRIPTOL_STRING = stc.wxSTC_SCRIPTOL_STRING  # 6
-wxSTC_SCRIPTOL_STRINGEOL = stc.wxSTC_SCRIPTOL_STRINGEOL  # 12
-wxSTC_SCRIPTOL_UUID = stc.wxSTC_SCRIPTOL_UUID  # 8
-wxSTC_SCRIPTOL_VERBATIM = stc.wxSTC_SCRIPTOL_VERBATIM  # 13
-wxSTC_SCRIPTOL_WORD = stc.wxSTC_SCRIPTOL_WORD  # 5
-wxSTC_SCRIPTOL_WORD2 = stc.wxSTC_SCRIPTOL_WORD2  # 16
-wxSTC_START = stc.wxSTC_START  # 2000
-wxSTC_STYLE_BRACEBAD = stc.wxSTC_STYLE_BRACEBAD  # 35
-wxSTC_STYLE_BRACELIGHT = stc.wxSTC_STYLE_BRACELIGHT  # 34
-wxSTC_STYLE_CONTROLCHAR = stc.wxSTC_STYLE_CONTROLCHAR  # 36
-wxSTC_STYLE_DEFAULT = stc.wxSTC_STYLE_DEFAULT  # 32
-wxSTC_STYLE_INDENTGUIDE = stc.wxSTC_STYLE_INDENTGUIDE  # 37
-wxSTC_STYLE_LASTPREDEFINED = stc.wxSTC_STYLE_LASTPREDEFINED  # 39
-wxSTC_STYLE_LINENUMBER = stc.wxSTC_STYLE_LINENUMBER  # 33
-wxSTC_STYLE_MAX = stc.wxSTC_STYLE_MAX  # 127
-wxSTC_TIME_FOREVER = stc.wxSTC_TIME_FOREVER  # 10000000
-wxSTC_USE_POPUP = stc.wxSTC_USE_POPUP  # 1
-wxSTC_VISIBLE_SLOP = stc.wxSTC_VISIBLE_SLOP  # 1
-wxSTC_VISIBLE_STRICT = stc.wxSTC_VISIBLE_STRICT  # 4
-wxSTC_WRAP_NONE = stc.wxSTC_WRAP_NONE  # 0
-wxSTC_WRAP_WORD = stc.wxSTC_WRAP_WORD  # 1
-wxSTC_WS_INVISIBLE = stc.wxSTC_WS_INVISIBLE  # 0
-wxSTC_WS_VISIBLEAFTERINDENT = stc.wxSTC_WS_VISIBLEAFTERINDENT  # 2
-wxSTC_WS_VISIBLEALWAYS = stc.wxSTC_WS_VISIBLEALWAYS  # 1
-# End generated constants.

wxPython/wxPython/py/wxd/Threading.py

@@ -1,26 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-class MutexGuiLocker:
-    """"""
-
-    def __del__(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/ToolBar.py

@@ -1,403 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-from Controls import Control
-import Parameters as wx
-
-
-class ToolBarBase(Control):
-    """"""
-
-    def AddCheckLabelTool(self):
-        """"""
-        pass
-
-    def AddCheckTool(self):
-        """"""
-        pass
-
-    def AddControl(self):
-        """"""
-        pass
-
-    def AddLabelTool(self):
-        """"""
-        pass
-
-    def AddRadioLabelTool(self):
-        """"""
-        pass
-
-    def AddRadioTool(self):
-        """"""
-        pass
-
-    def AddSeparator(self):
-        """"""
-        pass
-
-    def AddSimpleTool(self):
-        """"""
-        pass
-
-    def AddTool(self):
-        """"""
-        pass
-
-    def ClearTools(self):
-        """"""
-        pass
-
-    def DeleteTool(self):
-        """"""
-        pass
-
-    def DeleteToolByPos(self):
-        """"""
-        pass
-
-    def DoAddTool(self):
-        """"""
-        pass
-
-    def DoInsertTool(self):
-        """"""
-        pass
-
-    def EnableTool(self):
-        """"""
-        pass
-
-    def FindControl(self):
-        """"""
-        pass
-
-    def FindToolForPosition(self):
-        """"""
-        pass
-
-    def GetMargins(self):
-        """"""
-        pass
-
-    def GetMaxCols(self):
-        """"""
-        pass
-
-    def GetMaxRows(self):
-        """"""
-        pass
-
-    def GetToolBitmapSize(self):
-        """"""
-        pass
-
-    def GetToolClientData(self):
-        """"""
-        pass
-
-    def GetToolEnabled(self):
-        """"""
-        pass
-
-    def GetToolLongHelp(self):
-        """"""
-        pass
-
-    def GetToolMargins(self):
-        """"""
-        pass
-
-    def GetToolPacking(self):
-        """"""
-        pass
-
-    def GetToolSeparation(self):
-        """"""
-        pass
-
-    def GetToolShortHelp(self):
-        """"""
-        pass
-
-    def GetToolSize(self):
-        """"""
-        pass
-
-    def GetToolState(self):
-        """"""
-        pass
-
-    def InsertControl(self):
-        """"""
-        pass
-
-    def InsertLabelTool(self):
-        """"""
-        pass
-
-    def InsertSeparator(self):
-        """"""
-        pass
-
-    def InsertSimpleTool(self):
-        """"""
-        pass
-
-    def InsertTool(self):
-        """"""
-        pass
-
-    def IsVertical(self):
-        """"""
-        pass
-
-    def Realize(self):
-        """"""
-        pass
-
-    def RemoveTool(self):
-        """"""
-        pass
-
-    def SetMargins(self):
-        """"""
-        pass
-
-    def SetMarginsXY(self):
-        """"""
-        pass
-
-    def SetMaxRowsCols(self):
-        """"""
-        pass
-
-    def SetRows(self):
-        """"""
-        pass
-
-    def SetToggle(self):
-        """"""
-        pass
-
-    def SetToolBitmapSize(self):
-        """"""
-        pass
-
-    def SetToolClientData(self):
-        """"""
-        pass
-
-    def SetToolLongHelp(self):
-        """"""
-        pass
-
-    def SetToolPacking(self):
-        """"""
-        pass
-
-    def SetToolSeparation(self):
-        """"""
-        pass
-
-    def SetToolShortHelp(self):
-        """"""
-        pass
-
-    def ToggleTool(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ToolBar(ToolBarBase):
-    """"""
-
-    def Create(self):
-        """"""
-        pass
-
-    def FindToolForPosition(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ToolBarSimple(ToolBarBase):
-    """"""
-
-    def Create(self):
-        """"""
-        pass
-
-    def FindToolForPosition(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class ToolBarToolBase(Object):
-    """"""
-
-    def Attach(self):
-        """"""
-        pass
-
-    def CanBeToggled(self):
-        """"""
-        pass
-
-    def Destroy(self):
-        """"""
-        pass
-
-    def Detach(self):
-        """"""
-        pass
-
-    def Enable(self):
-        """"""
-        pass
-
-    def GetBitmap(self):
-        """"""
-        pass
-
-    def GetBitmap1(self):
-        """"""
-        pass
-
-    def GetBitmap2(self):
-        """"""
-        pass
-
-    def GetClientData(self):
-        """"""
-        pass
-
-    def GetControl(self):
-        """"""
-        pass
-
-    def GetDisabledBitmap(self):
-        """"""
-        pass
-
-    def GetId(self):
-        """"""
-        pass
-
-    def GetKind(self):
-        """"""
-        pass
-
-    def GetLabel(self):
-        """"""
-        pass
-
-    def GetLongHelp(self):
-        """"""
-        pass
-
-    def GetNormalBitmap(self):
-        """"""
-        pass
-
-    def GetShortHelp(self):
-        """"""
-        pass
-
-    def GetStyle(self):
-        """"""
-        pass
-
-    def GetToolBar(self):
-        """"""
-        pass
-
-    def IsButton(self):
-        """"""
-        pass
-
-    def IsControl(self):
-        """"""
-        pass
-
-    def IsEnabled(self):
-        """"""
-        pass
-
-    def IsSeparator(self):
-        """"""
-        pass
-
-    def IsToggled(self):
-        """"""
-        pass
-
-    def SetBitmap1(self):
-        """"""
-        pass
-
-    def SetBitmap2(self):
-        """"""
-        pass
-
-    def SetClientData(self):
-        """"""
-        pass
-
-    def SetDisabledBitmap(self):
-        """"""
-        pass
-
-    def SetLabel(self):
-        """"""
-        pass
-
-    def SetLongHelp(self):
-        """"""
-        pass
-
-    def SetNormalBitmap(self):
-        """"""
-        pass
-
-    def SetShortHelp(self):
-        """"""
-        pass
-
-    def SetToggle(self):
-        """"""
-        pass
-
-    def Toggle(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/Tree.py

@@ -1,403 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-from Controls import Control
-import Parameters as wx
-
-
-class TreeCtrl(Control):
-    """A tree control presents information as a hierarchy, with items
-    that may be expanded to show further items. Items in a tree
-    control are referenced by wx.TreeItemId handles, which may be
-    tested for validity by calling TreeItemId.IsOk()."""
-
-    def AddRoot(self):
-        """"""
-        pass
-
-    def AppendItem(self):
-        """"""
-        pass
-
-    def AssignImageList(self):
-        """"""
-        pass
-
-    def AssignStateImageList(self):
-        """"""
-        pass
-
-    def Collapse(self):
-        """"""
-        pass
-
-    def CollapseAndReset(self):
-        """"""
-        pass
-
-    def Create(self):
-        """"""
-        pass
-
-    def Delete(self):
-        """"""
-        pass
-
-    def DeleteAllItems(self):
-        """"""
-        pass
-
-    def DeleteChildren(self):
-        """"""
-        pass
-
-    def EditLabel(self):
-        """"""
-        pass
-
-    def EnsureVisible(self):
-        """"""
-        pass
-
-    def Expand(self):
-        """"""
-        pass
-
-    def GetBoundingRect(self):
-        """"""
-        pass
-
-    def GetChildrenCount(self):
-        """"""
-        pass
-
-    def GetCount(self):
-        """"""
-        pass
-
-    def GetEditControl(self):
-        """"""
-        pass
-
-    def GetFirstChild(self):
-        """"""
-        pass
-
-    def GetFirstVisibleItem(self):
-        """"""
-        pass
-
-    def GetImageList(self):
-        """"""
-        pass
-
-    def GetIndent(self):
-        """"""
-        pass
-
-    def GetItemBackgroundColour(self):
-        """"""
-        pass
-
-    def GetItemData(self):
-        """"""
-        pass
-
-    def GetItemFont(self):
-        """"""
-        pass
-
-    def GetItemImage(self):
-        """"""
-        pass
-
-    def GetItemParent(self):
-        """"""
-        pass
-
-    def GetItemSelectedImage(self):
-        """"""
-        pass
-
-    def GetItemText(self):
-        """"""
-        pass
-
-    def GetItemTextColour(self):
-        """"""
-        pass
-
-    def GetLastChild(self):
-        """"""
-        pass
-
-    def GetNextChild(self):
-        """"""
-        pass
-
-    def GetNextSibling(self):
-        """"""
-        pass
-
-    def GetNextVisible(self):
-        """"""
-        pass
-
-    def GetPrevSibling(self):
-        """"""
-        pass
-
-    def GetPrevVisible(self):
-        """"""
-        pass
-
-    def GetPyData(self):
-        """"""
-        pass
-
-    def GetRootItem(self):
-        """"""
-        pass
-
-    def GetSelection(self):
-        """"""
-        pass
-
-    def GetSelections(self):
-        """"""
-        pass
-
-    def GetSpacing(self):
-        """"""
-        pass
-
-    def GetStateImageList(self):
-        """"""
-        pass
-
-    def HitTest(self):
-        """"""
-        pass
-
-    def InsertItem(self):
-        """"""
-        pass
-
-    def InsertItemBefore(self):
-        """"""
-        pass
-
-    def IsBold(self):
-        """"""
-        pass
-
-    def IsExpanded(self):
-        """"""
-        pass
-
-    def IsSelected(self):
-        """"""
-        pass
-
-    def IsVisible(self):
-        """"""
-        pass
-
-    def ItemHasChildren(self):
-        """"""
-        pass
-
-    def PrependItem(self):
-        """"""
-        pass
-
-    def ScrollTo(self):
-        """"""
-        pass
-
-    def SelectItem(self):
-        """"""
-        pass
-
-    def SetImageList(self):
-        """"""
-        pass
-
-    def SetIndent(self):
-        """"""
-        pass
-
-    def SetItemBackgroundColour(self):
-        """"""
-        pass
-
-    def SetItemBold(self):
-        """"""
-        pass
-
-    def SetItemData(self):
-        """"""
-        pass
-
-    def SetItemFont(self):
-        """"""
-        pass
-
-    def SetItemHasChildren(self):
-        """"""
-        pass
-
-    def SetItemImage(self):
-        """"""
-        pass
-
-    def SetItemSelectedImage(self):
-        """"""
-        pass
-
-    def SetItemText(self):
-        """"""
-        pass
-
-    def SetItemTextColour(self):
-        """"""
-        pass
-
-    def SetPyData(self):
-        """"""
-        pass
-
-    def SetSpacing(self):
-        """"""
-        pass
-
-    def SetStateImageList(self):
-        """"""
-        pass
-
-    def SortChildren(self):
-        """"""
-        pass
-
-    def Toggle(self):
-        """"""
-        pass
-
-    def Unselect(self):
-        """"""
-        pass
-
-    def UnselectAll(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-
-class TreeItemAttr:
-    """"""
-
-    def GetBackgroundColour(self):
-        """"""
-        pass
-
-    def GetFont(self):
-        """"""
-        pass
-
-    def GetTextColour(self):
-        """"""
-        pass
-
-    def HasBackgroundColour(self):
-        """"""
-        pass
-
-    def HasFont(self):
-        """"""
-        pass
-
-    def HasTextColour(self):
-        """"""
-        pass
-
-    def SetBackgroundColour(self):
-        """"""
-        pass
-
-    def SetFont(self):
-        """"""
-        pass
-
-    def SetTextColour(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-
-class TreeItemData(Object):
-    """TreeItemData is some (arbitrary) user class associated with
-    some item. The main advantage of having this class is that
-    TreeItemData objects are destroyed automatically by the tree and
-    the memory and any other resources associated with a tree item
-    will be automatically freed when it is deleted."""
-
-    def __init__(self, obj=wx.NULL):
-        """Associate any Python object with tree item using
-        wxTreeItemData as container."""
-        pass
-
-    def GetData(self):
-        """Return the Python object."""
-        pass
-
-    def GetId(self):
-        """Return the item associated with this node."""
-        pass
-
-    def SetData(self, obj):
-        """Associate Python object with tree item."""
-        pass
-
-    def SetId(self, id):
-        """Set the item associated with this node."""
-        pass
-
-
-class TreeItemId:
-    """Item in a TreeCtrl."""
-
-## You wouldn't create these directly.
-
-##     def __init__(self):
-##         """"""
-##         pass
-
-    def IsOk(self):
-        """Return True if item is valid."""
-        pass
-
-    def Ok(self):
-        """Synonym for IsOk."""
-        pass

wxPython/wxPython/py/wxd/Validators.py

@@ -1,56 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import EvtHandler
-import Parameters as wx
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class Validator(EvtHandler):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def Clone(self):
-        """"""
-        pass
-
-    def GetWindow(self):
-        """"""
-        pass
-
-    def SetWindow(self, window):
-        """"""
-        pass
-
-
-class PyValidator(Validator):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self, _class, incref=True):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/Window.py

@@ -1,850 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import EvtHandler
-import Parameters as wx
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-
-class Window(EvtHandler):
-    """"""
-
-    def __init__(self, parent, id, pos=wx.DefaultPosition,
-                 size=wx.DefaultSize, style=0, name=wx.PyPanelNameStr):
-        """"""
-        pass
-
-    def AcceptsFocus(self):
-        """"""
-        pass
-
-    def AddChild(self, child):
-        """"""
-        pass
-
-    def CaptureMouse(self):
-        """"""
-        pass
-
-    def Center(self, direction=wx.BOTH):
-        """"""
-        pass
-
-    def CenterOnParent(self, direction=wx.BOTH):
-        """"""
-        pass
-
-    def CenterOnScreen(self, direction=wx.BOTH):
-        """"""
-        pass
-
-    def Centre(self, direction=wx.BOTH):
-        """"""
-        pass
-
-    def CentreOnParent(self, direction=wx.BOTH):
-        """"""
-        pass
-
-    def CentreOnScreen(self, direction=wx.BOTH):
-        """"""
-        pass
-
-    def Clear(self):
-        """"""
-        pass
-
-    def ClientToScreen(self, pt):
-        """"""
-        pass
-
-    def ClientToScreenXY(self, x, y):
-        """"""
-        pass
-
-    def Close(self, force=False):
-        """"""
-        pass
-
-    def ConvertDialogPointToPixels(self, pt):
-        """"""
-        pass
-
-    def ConvertDialogSizeToPixels(self, sz):
-        """"""
-        pass
-
-    def ConvertPixelPointToDialog(self, pt):
-        """"""
-        pass
-
-    def ConvertPixelSizeToDialog(self, sz):
-        """"""
-        pass
-
-    def Create(self, parent, id, pos=wx.DefaultPosition,
-               size=wx.DefaultSize, style=0, name=wx.PyPanelNameStr):
-        """"""
-        pass
-
-    def DLG_PNT(self, win, point_or_x, y=None):
-        """"""
-        pass
-
-    def DLG_SZE(self, win, size_width, height=None):
-        """"""
-        pass
-
-    def Destroy(self):
-        """"""
-        pass
-
-    def DestroyChildren(self):
-        """"""
-        pass
-
-    def DragAcceptFiles(self, accept):
-        """Windows only."""
-        pass
-
-    def Enable(self, enable):
-        """"""
-        pass
-
-    def FindWindowById(self, id):
-        """"""
-        pass
-
-    def FindWindowByName(self, name):
-        """"""
-        pass
-
-    def Fit(self):
-        """"""
-        pass
-
-    def FitInside(self):
-        """"""
-        pass
-
-    def Freeze(self):
-        """"""
-        pass
-
-    def GetAcceleratorTable(self):
-        """"""
-        pass
-
-    def GetAdjustedBestSize(self):
-        """"""
-        pass
-
-    def GetAutoLayout(self):
-        """"""
-        pass
-
-    def GetBackgroundColour(self):
-        """"""
-        pass
-
-    def GetBestSize(self):
-        """"""
-        pass
-
-    def GetBestVirtualSize(self):
-        """"""
-        pass
-
-    def GetBorder(self):
-        """"""
-        pass
-
-    def GetCaret(self):
-        """"""
-        pass
-
-    def GetCharHeight(self):
-        """"""
-        pass
-
-    def GetCharWidth(self):
-        """"""
-        pass
-
-    def GetChildren(self):
-        """"""
-        pass
-
-    def GetClientAreaOrigin(self):
-        """"""
-        pass
-
-    def GetClientRect(self):
-        """"""
-        pass
-
-    def GetClientSize(self):
-        """"""
-        pass
-
-    def GetClientSizeTuple(self):
-        """"""
-        pass
-
-    def GetConstraints(self):
-        """"""
-        pass
-
-    def GetContainingSizer(self):
-        """"""
-        pass
-
-    def GetCursor(self):
-        """"""
-        pass
-
-    def GetDefaultItem(self):
-        """"""
-        pass
-
-    def GetDropTarget(self):
-        """"""
-        pass
-
-    def GetEventHandler(self):
-        """"""
-        pass
-
-    def GetFont(self):
-        """"""
-        pass
-
-    def GetForegroundColour(self):
-        """"""
-        pass
-
-    def GetFullTextExtent(self):
-        """"""
-        pass
-
-    def GetGrandParent(self):
-        """"""
-        pass
-
-    def GetHandle(self):
-        """"""
-        pass
-
-    def GetHelpText(self):
-        """"""
-        pass
-
-    def GetId(self):
-        """"""
-        pass
-
-    def GetLabel(self):
-        """"""
-        pass
-
-    def GetMaxSize(self):
-        """"""
-        pass
-
-    def GetName(self):
-        """"""
-        pass
-
-    def GetParent(self):
-        """"""
-        pass
-
-    def GetPosition(self):
-        """"""
-        pass
-
-    def GetPositionTuple(self):
-        """"""
-        pass
-
-    def GetRect(self):
-        """"""
-        pass
-
-    def GetScrollPos(self, orientation):
-        """"""
-        pass
-
-    def GetScrollRange(self, orientation):
-        """"""
-        pass
-
-    def GetScrollThumb(self, orientation):
-        """"""
-        pass
-
-    def GetSize(self):
-        """"""
-        pass
-
-    def GetSizeTuple(self):
-        """"""
-        pass
-
-    def GetSizer(self):
-        """"""
-        pass
-
-    def GetTextExtent(self, string):
-        """"""
-        pass
-
-    def GetTitle(self):
-        """"""
-        pass
-
-    def GetToolTip(self):
-        """"""
-        pass
-
-    def GetUpdateRegion(self):
-        """"""
-        pass
-
-    def GetValidator(self):
-        """"""
-        pass
-
-    def GetVirtualSize(self):
-        """"""
-        pass
-
-    def GetVirtualSizeTuple(self):
-        """"""
-        pass
-
-    def GetWindowStyleFlag(self):
-        """"""
-        pass
-
-    def HasCapture(self):
-        """"""
-        pass
-
-    def HasScrollbar(self, orient):
-        """"""
-        pass
-
-    def Hide(self):
-        """"""
-        pass
-
-    def HitTest(self, pt):
-        """"""
-        pass
-
-    def InitDialog(self):
-        """"""
-        pass
-
-    def IsBeingDeleted(self):
-        """"""
-        pass
-
-    def IsEnabled(self):
-        """"""
-        pass
-
-    def IsExposed(self, x, y, w=0, h=0):
-        """"""
-        pass
-
-    def IsExposedPoint(self, pt):
-        """"""
-        pass
-
-    def IsExposedRect(self, rect):
-        """"""
-        pass
-
-    def IsRetained(self):
-        """"""
-        pass
-
-    def IsShown(self):
-        """"""
-        pass
-
-    def IsTopLevel(self):
-        """"""
-        pass
-
-    def Layout(self):
-        """"""
-        pass
-
-    def LineDown(self):
-        """"""
-        pass
-
-    def LineUp(self):
-        """"""
-        pass
-
-    def LoadFromResource(self, parent, resourceName, resourceTable=wx.NULL):
-        """Only if USE_WX_RESOURCES."""
-        pass
-
-    def Lower(self):
-        """"""
-        pass
-
-    def MakeModal(self, flag=True):
-        """"""
-        pass
-
-    def Move(self, point, flags=wx.SIZE_USE_EXISTING):
-        """"""
-        pass
-
-    def MoveXY(self, x, y, flags=wx.SIZE_USE_EXISTING):
-        """"""
-        pass
-
-    def OnPaint(self, event):
-        """Windows only."""
-        pass
-
-    def PageDown(self):
-        """"""
-        pass
-
-    def PageUp(self):
-        """"""
-        pass
-
-    def PopEventHandler(self, deleteHandler=False):
-        """"""
-        pass
-
-    def PopupMenu(self, menu, pos):
-        """"""
-        pass
-
-    def PopupMenuXY(self, menu, x, y):
-        """"""
-        pass
-
-    def PushEventHandler(self, handler):
-        """"""
-        pass
-
-    def Raise(self):
-        """"""
-        pass
-
-    def Refresh(self, eraseBackground=True, rect=wx.NULL):
-        """"""
-        pass
-
-    def RefreshRect(self, rect):
-        """"""
-        pass
-
-    def ReleaseMouse(self):
-        """"""
-        pass
-
-    def RemoveChild(self, child):
-        """"""
-        pass
-
-    def RemoveEventHandler(self, handler):
-        """"""
-        pass
-
-    def Reparent(self, newParent):
-        """"""
-        pass
-
-    def ScreenToClient(self, pt):
-        """"""
-        pass
-
-    def ScreenToClientXY(self, x, y):
-        """"""
-        pass
-
-    def ScrollLines(self, lines):
-        """"""
-        pass
-
-    def ScrollPages(self, pages):
-        """"""
-        pass
-
-    def ScrollWindow(self, dx, dy, rect=wx.NULL):
-        """"""
-        pass
-
-    def SetAcceleratorTable(self, accel):
-        """"""
-        pass
-
-    def SetAutoLayout(self, autoLayout):
-        """"""
-        pass
-
-    def SetBackgroundColour(self, colour):
-        """"""
-        pass
-
-    def SetCaret(self, caret):
-        """"""
-        pass
-
-    def SetClientSize(self, size):
-        """"""
-        pass
-
-    def SetClientSizeWH(self, width, height):
-        """"""
-        pass
-
-    def SetConstraints(self, constraints):
-        """"""
-        pass
-
-    def SetContainingSizer(self, sizer):
-        """"""
-        pass
-
-    def SetCursor(self, cursor):
-        """"""
-        pass
-
-    def SetDefaultItem(self, btn):
-        """"""
-        pass
-
-    def SetDimensions(self):
-        """"""
-        pass
-
-    def SetDropTarget(self, target):
-        """"""
-        pass
-
-    def SetEventHandler(self, handler):
-        """"""
-        pass
-
-    def SetExtraStyle(self, exStyle):
-        """"""
-        pass
-
-    def SetFocus(self):
-        """"""
-        pass
-
-    def SetFocusFromKbd(self):
-        """"""
-        pass
-
-    def SetFont(self, font):
-        """"""
-        pass
-
-    def SetForegroundColour(self, colour):
-        """"""
-        pass
-
-    def SetHelpText(self, helpText):
-        """"""
-        pass
-
-    def SetHelpTextForId(self, text):
-        """"""
-        pass
-
-    def SetId(self, id):
-        """"""
-        pass
-
-    def SetLabel(self, label):
-        """"""
-        pass
-
-    def SetName(self, name):
-        """"""
-        pass
-
-    def SetPosition(self, pos, flags=wx.SIZE_USE_EXISTING):
-        """"""
-        pass
-
-    def SetRect(self, rect, sizeFlags=wx.SIZE_AUTO):
-        """"""
-        pass
-
-    def SetScrollPos(self, orientation, pos, refresh=True):
-        """"""
-        pass
-
-    def SetScrollbar(self, orientation, pos, thumbSize, range, refresh=True):
-        """"""
-        pass
-
-    def SetSize(self, x, y, width, height, sizeFlags=wx.SIZE_AUTO):
-        """"""
-        pass
-
-    def SetSizeHints(self, minW, minH, maxW=-1, maxH=-1, incW=-1, incH=-1):
-        """"""
-        pass
-
-    def SetSizer(self, sizer, deleteOld=True):
-        """"""
-        pass
-
-    def SetSizerAndFit(self, sizer, deleteOld=True):
-        """"""
-        pass
-
-    def SetTitle(self, title):
-        """"""
-        pass
-
-    def SetTmpDefaultItem(self, win):
-        """"""
-        pass
-
-    def SetToolTip(self, tooltip):
-        """"""
-        pass
-
-    def SetToolTipString(self, tip):
-        """"""
-        pass
-
-    def SetValidator(self, validator):
-        """"""
-        pass
-
-    def SetVirtualSize(self, size):
-        """"""
-        pass
-
-    def SetVirtualSizeHints(self, minW, minH, maxW=-1, maxH=-1):
-        """"""
-        pass
-
-    def SetVirtualSizeWH(self, x, y):
-        """"""
-        pass
-
-    def SetWindowStyle(self, style):
-        """"""
-        pass
-
-    def SetWindowStyleFlag(self, style):
-        """"""
-        pass
-
-    def Show(self, show=True):
-        """"""
-        pass
-
-    def Thaw(self):
-        """"""
-        pass
-
-    def TransferDataFromWindow(self):
-        """"""
-        pass
-
-    def TransferDataToWindow(self):
-        """"""
-        pass
-
-    def UnsetConstraints(self, constraints):
-        """"""
-        pass
-
-    def Update(self):
-        """"""
-        pass
-
-    def UpdateWindowUI(self):
-        """"""
-        pass
-
-    def Validate(self):
-        """"""
-        pass
-
-    def WarpPointer(self, x, y):
-        """"""
-        pass
-
-
-class PyWindow(Window):
-    """"""
-
-    def __init__(self):
-        """"""
-        pass
-
-    def _setCallbackInfo(self):
-        """"""
-        pass
-
-    def base_AcceptsFocus(self):
-        """"""
-        pass
-
-    def base_AcceptsFocusFromKeyboard(self):
-        """"""
-        pass
-
-    def base_AddChild(self):
-        """"""
-        pass
-
-    def base_DoGetBestSize(self):
-        """"""
-        pass
-
-    def base_DoGetClientSize(self):
-        """"""
-        pass
-
-    def base_DoGetPosition(self):
-        """"""
-        pass
-
-    def base_DoGetSize(self):
-        """"""
-        pass
-
-    def base_DoGetVirtualSize(self):
-        """"""
-        pass
-
-    def base_DoMoveWindow(self):
-        """"""
-        pass
-
-    def base_DoSetClientSize(self):
-        """"""
-        pass
-
-    def base_DoSetSize(self):
-        """"""
-        pass
-
-    def base_DoSetVirtualSize(self):
-        """"""
-        pass
-
-    def base_GetMaxSize(self):
-        """"""
-        pass
-
-    def base_InitDialog(self):
-        """"""
-        pass
-
-    def base_RemoveChild(self):
-        """"""
-        pass
-
-    def base_TransferDataFromWindow(self):
-        """"""
-        pass
-
-    def base_TransferDataToWindow(self):
-        """"""
-        pass
-
-    def base_Validate(self):
-        """"""
-        pass
-
-
-class TopLevelWindow(Window):
-    """"""
-
-    def Create(self):
-        """"""
-        pass
-
-    def GetIcon(self):
-        """"""
-        pass
-
-    def GetTitle(self):
-        """"""
-        pass
-
-    def Iconize(self):
-        """"""
-        pass
-
-    def IsFullScreen(self):
-        """"""
-        pass
-
-    def IsIconized(self):
-        """"""
-        pass
-
-    def IsMaximized(self):
-        """"""
-        pass
-
-    def Maximize(self):
-        """"""
-        pass
-
-    def Restore(self):
-        """"""
-        pass
-
-    def SetIcon(self):
-        """"""
-        pass
-
-    def SetIcons(self):
-        """"""
-        pass
-
-    def SetTitle(self):
-        """"""
-        pass
-
-    def ShowFullScreen(self):
-        """"""
-        pass
-
-    def __init__(self):
-        """"""
-        pass
-
-

wxPython/wxPython/py/wxd/__init__.py

@@ -1 +0,0 @@
-# Orbtech python package.

wxPython/wxPython/py/wxd/d_stc.py

@@ -1,17 +0,0 @@
-"""Decorator utility for documentation and shell scripting.
-
-When you import stc from this module, all of the classes get decorated
-with docstrings from our decoration class definitions.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from wxPython import stc
-
-import stc_
-
-import decorator
-
-decorator.decorate(real=stc, decoration=stc_)

wxPython/wxPython/py/wxd/d_wx.py

@@ -1,17 +0,0 @@
-"""Decorator utility for documentation and shell scripting.
-
-When you import wx from this module, all of the classes get decorated
-with docstrings from our decoration class definitions.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-from wxPython import wx
-
-import wx_
-
-import decorator
-
-decorator.decorate(real=wx, decoration=wx_)

wxPython/wxPython/py/wxd/decorator.py

@@ -1,93 +0,0 @@
-"""Decorator utility for documentation and shell scripting."""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-import inspect
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-
-def decorate(real, decoration):
-    """Decorate real module with docstrings from decoration module."""
-    realdict = real.__dict__
-    for item in decoration.__dict__.values():
-        if inspect.isclass(item):
-            decorateClass(item, realdict)
-        elif inspect.isfunction(item):
-            decorateFunction(item, realdict)
-
-def decorateClass(item, realdict):
-    classname = item.__name__
-    if not classname.startswith('wx'):
-        classname = 'wx' + classname
-    try:
-        wxclass = realdict[classname]
-    except:
-        # print classname
-        pass
-    else:
-        if item.__doc__:
-            wxclass.__doc__ = item.__doc__
-        # Get attributes from only the item's local dictionary!
-        for attrname, attr in item.__dict__.items():
-            # If the attribute has a docstring, and the wx class has a
-            # matching attribute.
-            if hasattr(attr, '__doc__') and hasattr(wxclass, attrname):
-                if inspect.isfunction(attr):
-                    # Class methods are functions.
-                    doc = getdoc(attr, drop=True)
-                    # Is getattr() okay, or do we want to only look in
-                    # the wxclass.__dict__ and wxclassPtr.__dict__?
-                    wxattr = getattr(wxclass, attrname)
-                    # Our class code may be defined incorrectly, and
-                    # the wxattr may not actually be a class method,
-                    # but that's okay because the following attempt
-                    # will simply fail.
-                    try:
-                        func = wxattr.im_func
-                        func.__doc__ = doc
-                    except:
-                        pass
-
-def decorateFunction(item, realdict):
-    funcname = item.__name__
-    if funcname in realdict.keys():
-        func = realdict[funcname]
-        doc = getdoc(item, drop=False)
-        try:
-            # Built-in functions have a read-only docstring. :-(
-            func.__doc__ = doc
-        except:
-            # print funcname
-            pass
-
-def getdoc(attr, drop=False):
-    """Return a docstring for attr, which should be a method."""
-    doc = ''
-    if attr.__doc__:
-        doc = inspect.getdoc(attr).strip()
-    name = attr.__name__
-    # tip is a string with name(argspec), like: "SetLabel(label)"
-    tip = ''
-    argspec = apply(inspect.formatargspec, inspect.getargspec(attr))
-    # The first parameter to a method is a reference to an instance,
-    # usually coded as "self", and is usually passed automatically by
-    # Python and therefore we want to drop it.
-    temp = argspec.split(',')
-    if len(temp) == 1:  # No other arguments.
-        argspec = '()'
-    elif drop:  # Drop the first argument.
-        argspec = '(' + ','.join(temp[1:]).lstrip()
-    else:
-        argspec = ','.join(temp).lstrip()
-    tip = name + argspec
-    firstline = doc.split('\n')[0].lstrip()
-    if tip != firstline:
-        doc = '%s\n\n%s' % (tip, doc)
-    return doc

wxPython/wxPython/py/wxd/gen.py

@@ -1,71 +0,0 @@
-
-import inspect
-from wxPython import wx
-
-
-def scan():
-    d = wx.__dict__
-    newd = {}
-    keys = d.keys()
-    keys.sort()
-    for key in keys:
-        if key.endswith('Ptr'):
-            # Skip
-            pass
-        elif key+'Ptr' in keys:
-            # Rename
-            newd[key] = d[key+'Ptr']
-        else:
-            # Include as is
-            newd[key] = d[key]
-    d = newd
-    keys = d.keys()
-    keys.sort()
-    for key in keys:
-        value = d[key]
-        if inspect.isclass(value):
-            # genClass(value)
-            pass
-        elif callable(value):
-            genFunction(value)
-            pass
-        else:
-            # print type(value), value            
-            pass
-
-
-def genClass(cls):
-    sp4 = ' ' * 4
-    name = cls.__name__
-    if name.endswith('Ptr'):
-        name = name[:-3]
-##     if name != 'wxNotebook':
-##         return
-    parent = ''
-    if cls.__bases__:
-        parent = cls.__bases__[0].__name__
-        if parent.endswith('Ptr'):
-            parent = parent[:-3]
-        parent = '(%s)' % parent
-    items = cls.__dict__.keys()
-    items.sort()
-    print
-    print 'class %s%s:' % (name, parent)
-    print sp4 + '""""""'
-    print
-    for item in items:
-        attr = cls.__dict__[item]
-        if inspect.isfunction(attr):
-            print sp4 + 'def ' + item + '(self):'
-            print sp4 + sp4 + '""""""'
-            print sp4 + sp4 + 'pass'
-            print
-
-
-def genFunction(func):
-    sp4 = ' ' * 4
-    name = func.__name__
-    print 'def %s():' % name
-    print sp4 + '""""""'
-    print sp4 + 'pass'
-    print

wxPython/wxPython/py/wxd/genapi.py

@@ -1,133 +0,0 @@
-"""API generator for decorator classes.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-import inspect
-import os
-import sys
-import types
-
-
-header = '''\
-"""wxPython decorator classes.
-
-This file is automatically generated, and these are not the real
-wxPython classes.  These are Python versions for API documentation
-purposes only.
-
-Please send corrections, questions, and suggestions to:
-
-Patrick K. O'Brien <pobrien@orbtech.com>
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-
-from wxd import Parameters as wx
-
-try:
-    True
-except NameError:
-    True = 1==1
-    False = 1==0
-'''
-
-modlist = [
-    'Base',
-    'Window',
-    'Frames',
-    'Accelerators',
-    'App',
-    'ClipDragDrop',
-    'Config',
-    'Controls',
-    'DataStructures',
-    'DateTime',
-    'Dialogs',
-    'Drawing',
-    'Errors',
-    'EventFunctions',
-    'Events',
-    'FileSystem',
-    'Functions',
-    'Help',
-    'ImageHandlers',
-    'Joystick',
-    'LayoutConstraints',
-    'Logging',
-    'Menus',
-    'MimeTypes',
-    'Misc',
-    'Panel',
-    'Printing',
-    'Process',
-    'SashSplitter',
-    'Sizers',
-    'Streams',
-    'Threading',
-    'ToolBar',
-    'Tree',
-    'Validators',
-    ]
-
-dir = os.path.realpath('api/wx/')
-filename = os.path.join(dir, '__init__.py')
-
-def main():
-    modules = {}
-    f = file(filename, 'w')
-    f.write(header)
-    for modname in modlist:
-        modules[modname] = __import__(modname, globals())
-    for modname in modlist:
-        module = modules[modname]
-        try:
-            source = inspect.getsource(module)
-        except IOError:
-            print 'No source for', module
-        else:
-            # Remove everything up to the first class or function definition.
-            splitter = '\n\nclass '
-            parts = source.split(splitter, 1)
-            if len(parts) == 2:
-                source = splitter + parts[1]
-            else:
-                splitter = '\n\ndef '
-                parts = source.split(splitter, 1)
-                if len(parts) == 2:
-                    source = splitter + parts[1]
-            source = '\n\n\n' + source.strip()
-            f.write(source)
-            print 'Writing', modname
-    f.write('\n')
-    f.close()
-
-    # Add constants and any other missing stuff.
-    f = file(filename, 'a')
-    f.write('\n\n## Other Stuff:\n\n')
-    import wx as old
-    old = old.__dict__
-    sys.path.insert(0, dir) # Munge the sys.path so that we can
-    import __init__         # import the file we just created.
-    new = __init__.__dict__
-    l = [(k, v) for (k, v) in old.items() if (not k.startswith('_')
-                                              and not k.endswith('Ptr')
-                                              and not (k == 'cvar'))]
-    l.sort()
-    from wxPython import wx
-    for key, value in l:
-        if key not in new:
-            if (inspect.isclass(value)
-                or inspect.isroutine(value)
-                or type(value) is types.InstanceType):
-                value = repr(value)
-            text = '%s = %r' % (key, value)
-            f.write(text + '\n')
-            print 'Writing', text
-    f.close()
-
-if __name__ == '__main__':
-    main()

wxPython/wxPython/py/wxd/wx_.py

@@ -1,66 +0,0 @@
-"""Decorator classes for documentation and shell scripting.
-
-Information contained in this module, and all modules imported by this
-module, is covered by the wxWindows Free Documentation Licence.  See
-the LICENSE.txt file for details.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-_topics = {
-    'Accelerators': None,
-    'App': None,
-    'Base': None,
-    'ClipDragDrop': None,
-    'Config': None,
-    'Controls': None,
-    'DataStructures': None,
-    'DateTime': None,
-    'Dialogs': None,
-    'Drawing': None,
-    'Errors': None,
-    'EventFunctions': None,
-    'Events': None,
-    'FileSystem': None,
-    'Frames': None,
-    'Functions': None,
-    'Help': None,
-    'ImageHandlers': None,
-    'Joystick': None,
-    'LayoutConstraints': None,
-    'Logging': None,
-    'Menus': None,
-    'MimeTypes': None,
-    'Misc': None,
-    'Panel': None,
-    'Printing': None,
-    'Process': None,
-    'SashSplitter': None,
-    'Sizers': None,
-    'Streams': None,
-    'Threading': None,
-    'ToolBar': None,
-    'Tree': None,
-    'Validators': None,
-    'Window': None,
-    }
-
-for topic in _topics.keys():
-    _topics[topic] = __import__(topic, globals())
-    exec 'from %s import *' % topic
-
-del topic  # Cleanup the namespace.
-
-try:
-    del wx  # Cleanup any module that imports Parameters as wx.
-except:
-    pass