Corrected a return type

[wxWidgets.git] / wxPython / src / gdi.i

diff --git a/wxPython/src/gdi.i b/wxPython/src/gdi.i
index 5d0cdaf57e6edf1247cf438ab04a4532665acf36..d3fe92e1ae9784e35709dba8721f66ec2da9568d 100644 (file)
--- a/wxPython/src/gdi.i
+++ b/wxPython/src/gdi.i
@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        gdi.i
 /////////////////////////////////////////////////////////////////////////////
 // Name:        gdi.i

-// Purpose:     SWIG interface file for wxDC, wxBrush, wxPen, wxFont, etc.
+// Purpose:     SWIG interface file for wxDC, wxBrush, wxPen, etc.

 //
 // Author:      Robin Dunn
 //
 //
 // Author:      Robin Dunn
 //


@@ -20,6 +20,9 @@
 #include <wx/fontenc.h>
 #include <wx/fontmap.h>
 #include <wx/fontutil.h>
 #include <wx/fontenc.h>
 #include <wx/fontmap.h>
 #include <wx/fontutil.h>

+#include <wx/dcbuffer.h>
+#include <wx/dcmirror.h>
+#include <wx/iconbndl.h>

 %}
 
 //----------------------------------------------------------------------
 %}
 
 //----------------------------------------------------------------------


@@ -30,11 +33,15 @@
 // Import some definitions of other classes, etc.
 %import _defs.i
 %import misc.i
 // Import some definitions of other classes, etc.
 %import _defs.i
 %import misc.i

+%import fonts.i

 
 

+%pragma(python) code = "import wx"
+
+//---------------------------------------------------------------------------

 %{
 %{

-    static wxString wxPyEmptyStr("");
+    // Put some wx default wxChar* values into wxStrings.
+    static const wxString wxPyEmptyString(wxT(""));

 %}
 %}

-

 //---------------------------------------------------------------------------
 
 class wxGDIObject : public wxObject {
 //---------------------------------------------------------------------------
 
 class wxGDIObject : public wxObject {


@@ -51,17 +58,26 @@ public:
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

+
+// TODO:  When the API stabalizes and is available on other platforms, add
+// wrappers for the new wxBitmap, wxRawBitmap, wxDIB stuff...
+

 class wxBitmap : public wxGDIObject
 {
 public:
 class wxBitmap : public wxGDIObject
 {
 public:

-    wxBitmap(const wxString& name, wxBitmapType type=wxBITMAP_TYPE_BMP);
+    wxBitmap(const wxString& name, wxBitmapType type=wxBITMAP_TYPE_ANY);

     ~wxBitmap();
 
     wxPalette* GetPalette();
     wxMask* GetMask();
     ~wxBitmap();
 
     wxPalette* GetPalette();
     wxMask* GetMask();

-    bool LoadFile(const wxString& name, wxBitmapType type=wxBITMAP_TYPE_BMP);
+    bool LoadFile(const wxString& name, wxBitmapType type=wxBITMAP_TYPE_ANY);

     bool SaveFile(const wxString& name, wxBitmapType type, wxPalette* palette = NULL);
     void SetMask(wxMask* mask);
     bool SaveFile(const wxString& name, wxBitmapType type, wxPalette* palette = NULL);
     void SetMask(wxMask* mask);

+    %pragma(python) addtoclass = "
+    def SetMaskColour(self, colour):
+        mask = wxMaskColour(self, colour)
+        self.SetMask(mask)
+    "

 #ifdef __WXMSW__
     void SetPalette(wxPalette& palette);
 #endif
 #ifdef __WXMSW__
     void SetPalette(wxPalette& palette);
 #endif


@@ -90,14 +106,7 @@ public:
     void SetQuality(int q);
 #endif
 
     void SetQuality(int q);
 #endif
 

-    %pragma(python) addtoclass = "
-    def __del__(self,gdic=gdic):
-        try:
-            if self.thisown == 1 :
-                gdic.delete_wxBitmap(self)
-        except:
-            pass
-"
+    %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"

 };
 
 
 };
 
 


@@ -105,7 +114,7 @@ public:
 %new wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1);
 %new wxBitmap* wxBitmapFromXPMData(PyObject* listOfStrings);
 %new wxBitmap* wxBitmapFromIcon(const wxIcon& icon);
 %new wxBitmap* wxEmptyBitmap(int width, int height, int depth=-1);
 %new wxBitmap* wxBitmapFromXPMData(PyObject* listOfStrings);
 %new wxBitmap* wxBitmapFromIcon(const wxIcon& icon);

-%new wxBitmap* wxBitmapFromBits(char* bits, int width, int height, int depth = 1 );
+%new wxBitmap* wxBitmapFromBits(PyObject* bits, int width, int height, int depth = 1 );

 
 //  #ifdef __WXMSW__
 //  %new wxBitmap* wxBitmapFromData(PyObject* data, long type,
 
 //  #ifdef __WXMSW__
 //  %new wxBitmap* wxBitmapFromData(PyObject* data, long type,


@@ -157,8 +166,11 @@ public:
     }
 
 
     }
 
 

-    wxBitmap* wxBitmapFromBits(char* bits, int width, int height, int depth = 1 ) {
-        return new wxBitmap(bits, width, height, depth);
+    wxBitmap* wxBitmapFromBits(PyObject* bits, int width, int height, int depth = 1 ) {
+        char* buf;
+        int   length;
+        PyString_AsStringAndSize(bits, &buf, &length);
+        return new wxBitmap(buf, width, height, depth);

     }
 
 
     }
 
 


@@ -202,7 +214,9 @@ public:
            int desiredWidth = -1, int desiredHeight = -1);
     ~wxIcon();
 
            int desiredWidth = -1, int desiredHeight = -1);
     ~wxIcon();
 

+#ifndef __WXMAC__

     bool LoadFile(const wxString& name, long flags);
     bool LoadFile(const wxString& name, long flags);

+#endif

 
     // wxGDIImage methods
 #ifdef __WXMSW__
 
     // wxGDIImage methods
 #ifdef __WXMSW__


@@ -221,20 +235,15 @@ public:
 #endif
     void CopyFromBitmap(const wxBitmap& bmp);
 
 #endif
     void CopyFromBitmap(const wxBitmap& bmp);
 

-    %pragma(python) addtoclass = "
-    def __del__(self,gdic=gdic):
-        try:
-            if self.thisown == 1 :
-                gdic.delete_wxIcon(self)
-        except:
-            pass
-"
+    %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"

 };
 
 
 // Declarations of some alternate "constructors"
 %new wxIcon* wxEmptyIcon();
 %new wxIcon* wxIconFromXPMData(PyObject* listOfStrings);
 };
 
 
 // Declarations of some alternate "constructors"
 %new wxIcon* wxEmptyIcon();
 %new wxIcon* wxIconFromXPMData(PyObject* listOfStrings);

+%new wxIcon* wxIconFromBitmap(const wxBitmap& bmp);
+%new wxIcon* wxIconFromLocation(const wxIconLocation& loc);

 
 %{ // Implementations of some alternate "constructors"
     wxIcon* wxEmptyIcon() {
 
 %{ // Implementations of some alternate "constructors"
     wxIcon* wxEmptyIcon() {


@@ -252,301 +261,162 @@ public:
         delete [] cArray;
         return icon;
     }
         delete [] cArray;
         return icon;
     }

-%}
-
-//---------------------------------------------------------------------------

 
 

-class wxCursor : public wxGDIObject
-{
-public:
-#ifdef __WXMSW__
-    wxCursor(const wxString& cursorName, long flags, int hotSpotX=0, int hotSpotY=0);
-#endif
-    ~wxCursor();
-
-    // wxGDIImage methods
-#ifdef __WXMSW__
-    long GetHandle();
-    void SetHandle(long handle);
-#endif
-    bool Ok();
-#ifdef __WXMSW__
-    int GetWidth();
-    int GetHeight();
-    int GetDepth();
-    void SetWidth(int w);
-    void SetHeight(int h);
-    void SetDepth(int d);
-    void SetSize(const wxSize& size);
-#endif
-};
+    wxIcon* wxIconFromBitmap(const wxBitmap& bmp) {
+        wxIcon* icon = new wxIcon();
+        icon->CopyFromBitmap(bmp);
+        return icon;
+    }

 
 

-%name(wxStockCursor) %new wxCursor* wxPyStockCursor(int id);
-%{                              // Alternate 'constructor'
-    wxCursor* wxPyStockCursor(int id) {
-        return new wxCursor(id);
+    wxIcon* wxIconFromLocation(const wxIconLocation& loc) {
+        wxIcon* icon = new wxIcon(loc);
+        return icon;

     }
 %}
 
     }
 %}
 

-//----------------------------------------------------------------------
-
-
-enum wxFontFamily
-{
-    wxFONTFAMILY_DEFAULT = wxDEFAULT,
-    wxFONTFAMILY_DECORATIVE = wxDECORATIVE,
-    wxFONTFAMILY_ROMAN = wxROMAN,
-    wxFONTFAMILY_SCRIPT = wxSCRIPT,
-    wxFONTFAMILY_SWISS = wxSWISS,
-    wxFONTFAMILY_MODERN = wxMODERN,
-    wxFONTFAMILY_TELETYPE = wxTELETYPE,
-    wxFONTFAMILY_MAX
-};
-
-// font styles
-enum wxFontStyle
-{
-    wxFONTSTYLE_NORMAL = wxNORMAL,
-    wxFONTSTYLE_ITALIC = wxITALIC,
-    wxFONTSTYLE_SLANT = wxSLANT,
-    wxFONTSTYLE_MAX
-};
-
-// font weights
-enum wxFontWeight
-{
-    wxFONTWEIGHT_NORMAL = wxNORMAL,
-    wxFONTWEIGHT_LIGHT = wxLIGHT,
-    wxFONTWEIGHT_BOLD = wxBOLD,
-    wxFONTWEIGHT_MAX
-};
-
-
-// font encodings
-enum wxFontEncoding
-{
-    wxFONTENCODING_SYSTEM = -1,     // system default
-    wxFONTENCODING_DEFAULT,         // current default encoding
-
-    // ISO8859 standard defines a number of single-byte charsets
-    wxFONTENCODING_ISO8859_1,       // West European (Latin1)
-    wxFONTENCODING_ISO8859_2,       // Central and East European (Latin2)
-    wxFONTENCODING_ISO8859_3,       // Esperanto (Latin3)
-    wxFONTENCODING_ISO8859_4,       // Baltic (old) (Latin4)
-    wxFONTENCODING_ISO8859_5,       // Cyrillic
-    wxFONTENCODING_ISO8859_6,       // Arabic
-    wxFONTENCODING_ISO8859_7,       // Greek
-    wxFONTENCODING_ISO8859_8,       // Hebrew
-    wxFONTENCODING_ISO8859_9,       // Turkish (Latin5)
-    wxFONTENCODING_ISO8859_10,      // Variation of Latin4 (Latin6)
-    wxFONTENCODING_ISO8859_11,      // Thai
-    wxFONTENCODING_ISO8859_12,      // doesn't exist currently, but put it
-                                    // here anyhow to make all ISO8859
-                                    // consecutive numbers
-    wxFONTENCODING_ISO8859_13,      // Baltic (Latin7)
-    wxFONTENCODING_ISO8859_14,      // Latin8
-    wxFONTENCODING_ISO8859_15,      // Latin9 (a.k.a. Latin0, includes euro)
-    wxFONTENCODING_ISO8859_MAX,
-
-    // Cyrillic charset soup (see http://czyborra.com/charsets/cyrillic.html)
-    wxFONTENCODING_KOI8,            // we don't support any of KOI8 variants
-    wxFONTENCODING_ALTERNATIVE,     // same as MS-DOS CP866
-    wxFONTENCODING_BULGARIAN,       // used under Linux in Bulgaria
-
-    // what would we do without Microsoft? They have their own encodings
-        // for DOS
-    wxFONTENCODING_CP437,           // original MS-DOS codepage
-    wxFONTENCODING_CP850,           // CP437 merged with Latin1
-    wxFONTENCODING_CP852,           // CP437 merged with Latin2
-    wxFONTENCODING_CP855,           // another cyrillic encoding
-    wxFONTENCODING_CP866,           // and another one
-        // and for Windows
-    wxFONTENCODING_CP874,           // WinThai
-    wxFONTENCODING_CP932,           // Japanese (shift-JIS)
-    wxFONTENCODING_CP936,           // Chiniese simplified (GB)
-    wxFONTENCODING_CP949,           // Korean (Hangul charset)
-    wxFONTENCODING_CP950,           // Chinese (traditional - Big5)
-    wxFONTENCODING_CP1250,          // WinLatin2
-    wxFONTENCODING_CP1251,          // WinCyrillic
-    wxFONTENCODING_CP1252,          // WinLatin1
-    wxFONTENCODING_CP1253,          // WinGreek (8859-7)
-    wxFONTENCODING_CP1254,          // WinTurkish
-    wxFONTENCODING_CP1255,          // WinHebrew
-    wxFONTENCODING_CP1256,          // WinArabic
-    wxFONTENCODING_CP1257,          // WinBaltic (same as Latin 7)
-    wxFONTENCODING_CP12_MAX,
-
-    wxFONTENCODING_UTF7,            // UTF-7 Unicode encoding
-    wxFONTENCODING_UTF8,            // UTF-8 Unicode encoding
-
-    wxFONTENCODING_UNICODE,         // Unicode - currently used only by
-                                    // wxEncodingConverter class
-
-    wxFONTENCODING_MAX
-};
-

 
 

+//---------------------------------------------------------------------------

 
 

-// wxNativeFontInfo is platform-specific font representation: this struct
-// should be considered as opaque font description only used by the native
-// functions, the user code can only get the objects of this type from
-// somewhere and pass it somewhere else (possibly save them somewhere using
-// ToString() and restore them using FromString())
-struct wxNativeFontInfo
+class wxIconLocation

 {
 {

-    // it is important to be able to serialize wxNativeFontInfo objects to be
-    // able to store them (in config file, for example)
-    bool FromString(const wxString& s);
-    wxString ToString() const;
-
+public:
+    // ctor takes the name of the file where the icon is

     %addmethods {
     %addmethods {

-        wxString __str__() {
-            return self->ToString();
+        wxIconLocation(const wxString* filename = &wxPyEmptyString, int num = 0) {
+#ifdef __WXMSW__
+            return new wxIconLocation(*filename, num);
+#else
+            return new wxIconLocation(*filename);
+#endif

         }
     }
         }
     }

-};

 
 

+    ~wxIconLocation();

 
 

-// wxFontMapper manages user-definable correspondence between logical font
-// names and the fonts present on the machine.
-//
-// The default implementations of all functions will ask the user if they are
-// not capable of finding the answer themselves and store the answer in a
-// config file (configurable via SetConfigXXX functions). This behaviour may
-// be disabled by giving the value of FALSE to "interactive" parameter.
-// However, the functions will always consult the config file to allow the
-// user-defined values override the default logic and there is no way to
-// disable this - which shouldn't be ever needed because if "interactive" was
-// never TRUE, the config file is never created anyhow.
-class  wxFontMapper
-{
-public:
-    wxFontMapper();
-    ~wxFontMapper();

 
 

+    // returns true if this object is valid/initialized
+    bool IsOk() const;

 
 

-    // find an alternative for the given encoding (which is supposed to not be
-    // available on this system). If successful, return TRUE and rwxFontEcoding
-    // that can be used it wxFont ctor otherwise return FALSE
-    //bool GetAltForEncoding(wxFontEncoding encoding,
-    //                       wxFontEncoding *alt_encoding,
-    //                       const wxString& facename = wxEmptyString,
-    //                       bool interactive = TRUE);
+    // set/get the icon file name
+    void SetFileName(const wxString& filename);
+    const wxString& GetFileName() const;

 
 

-
-    // Find an alternative for the given encoding (which is supposed to not be
-    // available on this system). If successful, returns the encoding otherwise
-    // returns None.

     %addmethods {
     %addmethods {

-        PyObject* GetAltForEncoding(wxFontEncoding encoding,
-                                    const wxString& facename = wxEmptyString,
-                                    bool interactive = TRUE) {
-            wxFontEncoding alt_enc;
-            if (self->GetAltForEncoding(encoding, &alt_enc, facename, interactive))
-                return PyInt_FromLong(alt_enc);
-            else {
-                Py_INCREF(Py_None);
-                return Py_None;
-            }
+        void SetIndex(int num) {
+#ifdef __WXMSW__
+            self->SetIndex(num);
+#else
+            // do nothing
+#endif

         }
         }

-    }

 
 

+        int GetIndex() {
+#ifdef __WXMSW__
+            return self->GetIndex();
+#else
+            return -1;
+#endif
+        }
+    }
+};

 
 

-    // checks whether given encoding is available in given face or not.
-    // If no facename is given,
-    bool IsEncodingAvailable(wxFontEncoding encoding,
-                             const wxString& facename = wxEmptyString);
-
-    // returns the encoding for the given charset (in the form of RFC 2046) or
-    // wxFONTENCODING_SYSTEM if couldn't decode it
-    wxFontEncoding CharsetToEncoding(const wxString& charset,
-                                     bool interactive = TRUE);

 
 

-    // return internal string identifier for the encoding (see also
-    // GetEncodingDescription())
-    static wxString GetEncodingName(wxFontEncoding encoding);

 
 

-    // return user-readable string describing the given encoding
-    //
-    // NB: hard-coded now, but might change later (read it from config?)
-    static wxString GetEncodingDescription(wxFontEncoding encoding);
+//---------------------------------------------------------------------------

 
 

-    // the parent window for modal dialogs
-    void SetDialogParent(wxWindow *parent);
+class wxIconBundle
+{
+public:
+    // default constructor
+    wxIconBundle();

 
 

-    // the title for the dialogs (note that default is quite reasonable)
-    void SetDialogTitle(const wxString& title);
+    // initializes the bundle with the icon(s) found in the file
+    %name(wxIconBundleFromFile) wxIconBundle( const wxString& file, long type );

 
 

-    // functions which allow to configure the config object used: by default,
-    // the global one (from wxConfigBase::Get() will be used) and the default
-    // root path for the config settings is the string returned by
-    // GetDefaultConfigPath()
+    // initializes the bundle with a single icon
+    %name(wxIconBundleFromIcon)wxIconBundle( const wxIcon& icon );

 
 

+    ~wxIconBundle();

 
 

-    // set the config object to use (may be NULL to use default)
-    void SetConfig(wxConfigBase *config);
+    // adds the icon to the collection, if the collection already
+    // contains an icon with the same width and height, it is
+    // replaced
+    void AddIcon( const wxIcon& icon );

 
 

-    // set the root config path to use (should be an absolute path)
-    void SetConfigPath(const wxString& prefix);
+    // adds all the icons contained in the file to the collection,
+    // if the collection already contains icons with the same
+    // width and height, they are replaced
+    %name(AddIconFromFile)void AddIcon( const wxString& file, long type );

 
 

-    // return default config path
-    static const wxChar *GetDefaultConfigPath();
+    // returns the icon with the given size; if no such icon exists,
+    // returns the icon with size wxSYS_ICON_[XY]; if no such icon exists,
+    // returns the first icon in the bundle
+    const wxIcon& GetIcon( const wxSize& size ) const;

 };
 
 };
 

+//---------------------------------------------------------------------------

 
 

-
-
-class wxFont : public wxGDIObject {
+class wxCursor : public wxGDIObject
+{

 public:
 public:

-    wxFont( int pointSize, int family, int style, int weight,
-            int underline=FALSE, char* faceName = "",
-            wxFontEncoding encoding=wxFONTENCODING_DEFAULT);
-
-    %name(wxFontFromNativeInfo)wxFont(const wxNativeFontInfo& info);
-
-    ~wxFont();
-
-    bool Ok() const;
-    int GetPointSize() const;
-    int GetFamily() const;
-    int GetStyle() const;
-    int GetWeight() const;
-    bool GetUnderlined() const;
-    wxString GetFaceName() const;
-    wxFontEncoding GetEncoding() const;
-    wxNativeFontInfo* GetNativeFontInfo() const;
-
-    void SetPointSize(int pointSize);
-    void SetFamily(int family);
-    void SetStyle(int style);
-    void SetWeight(int weight);
-    void SetFaceName(const wxString& faceName);
-    void SetUnderlined(bool underlined);
-    void SetEncoding(wxFontEncoding encoding);
-    void SetNativeFontInfo(const wxNativeFontInfo& info);
-
-    wxString GetFamilyString() const;
-    wxString GetStyleString() const;
-    wxString GetWeightString() const;
+    %addmethods {
+        wxCursor(const wxString* cursorName, long flags, int hotSpotX=0, int hotSpotY=0) {
+#ifdef __WXGTK__
+            wxCHECK_MSG(FALSE, NULL,
+                        wxT("wxCursor constructor not implemented for wxGTK, use wxStockCursor, wxCursorFromImage, or wxCursorFromBits instead."));
+#else
+            return new wxCursor(*cursorName, flags, hotSpotX, hotSpotY);
+#endif
+        }
+    }

 
 

-    static wxFontEncoding GetDefaultEncoding();
-    static void SetDefaultEncoding(wxFontEncoding encoding);
+    ~wxCursor();

 
 

+    // wxGDIImage methods
+#ifdef __WXMSW__
+    long GetHandle();
+    void SetHandle(long handle);
+#endif
+    bool Ok();
+#ifdef __WXMSW__
+    int GetWidth();
+    int GetHeight();
+    int GetDepth();
+    void SetWidth(int w);
+    void SetHeight(int h);
+    void SetDepth(int d);
+    void SetSize(const wxSize& size);
+#endif
+    %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"

 };
 
 };
 

+%name(wxStockCursor) %new wxCursor* wxPyStockCursor(int id);
+%new wxCursor* wxCursorFromImage(const wxImage& image);
+%new wxCursor* wxCursorFromBits(PyObject* bits, int width, int  height,
+                                int hotSpotX=-1, int hotSpotY=-1,
+                                PyObject* maskBits=0);

 
 

-class wxFontList : public wxObject {
-public:
-
-    void AddFont(wxFont* font);
-    wxFont * FindOrCreateFont(int point_size, int family, int style, int weight,
-                              bool underline = FALSE, const char* facename = NULL,
-                              wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
-    void RemoveFont(wxFont *font);
+%{
+    wxCursor* wxPyStockCursor(int id) {
+        return new wxCursor(id);
+    }

 
 

-    int GetCount();
-};
+    wxCursor* wxCursorFromImage(const wxImage& image) {
+        return new wxCursor(image);
+    }

 
 

+    wxCursor* wxCursorFromBits(PyObject* bits, int width, int  height,
+                               int hotSpotX=-1, int hotSpotY=-1,
+                               PyObject* maskBits=0) {
+        char* bitsbuf;
+        char* maskbuf = NULL;
+        int   length;
+        PyString_AsStringAndSize(bits, &bitsbuf, &length);
+        if (maskBits)
+            PyString_AsStringAndSize(maskBits, &maskbuf, &length);
+        return new wxCursor(bitsbuf, width, height, hotSpotX, hotSpotY, maskbuf);
+    }
+%}

 
 //----------------------------------------------------------------------
 
 
 //----------------------------------------------------------------------
 


@@ -562,15 +432,45 @@ public:
     %addmethods {
         PyObject* Get() {
             PyObject* rv = PyTuple_New(3);
     %addmethods {
         PyObject* Get() {
             PyObject* rv = PyTuple_New(3);

-            PyTuple_SetItem(rv, 0, PyInt_FromLong(self->Red()));
-            PyTuple_SetItem(rv, 1, PyInt_FromLong(self->Green()));
-            PyTuple_SetItem(rv, 2, PyInt_FromLong(self->Blue()));
+            int red = -1;
+            int green = -1;
+            int blue = -1;
+            if (self->Ok()) {
+                red =   self->Red();
+                green = self->Green();
+                blue =  self->Blue();
+            }
+            PyTuple_SetItem(rv, 0, PyInt_FromLong(red));
+            PyTuple_SetItem(rv, 1, PyInt_FromLong(green));
+            PyTuple_SetItem(rv, 2, PyInt_FromLong(blue));

             return rv;
         }
             return rv;
         }

+        bool __eq__(PyObject* obj) {
+            wxColour  tmp;
+            wxColour* ptr = &tmp;
+            if (obj == Py_None)    return FALSE;
+            wxPyBLOCK_THREADS(bool success = wxColour_helper(obj, &ptr); PyErr_Clear());
+            if (! success)         return FALSE;
+            return *self == *ptr;
+        }
+        bool __ne__(PyObject* obj) {
+            wxColour  tmp;
+            wxColour* ptr = &tmp;
+            if (obj == Py_None)    return TRUE;
+            wxPyBLOCK_THREADS(bool success = wxColour_helper(obj, &ptr); PyErr_Clear());
+            if (! success)         return TRUE;
+            return *self != *ptr;
+        }

     }
     }

-    %pragma(python) addtoclass = "asTuple = Get"
-    %pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
-    %pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"
+
+    %pragma(python) addtoclass = "asTuple = Get
+    def __str__(self):                  return str(self.asTuple())
+    def __repr__(self):                 return 'wxColour:' + str(self.asTuple())
+    def __nonzero__(self):              return self.Ok()
+    def __getinitargs__(self):          return ()
+    def __getstate__(self):             return self.asTuple()
+    def __setstate__(self, state):      self.Set(*state)
+"

 
 };
 
 
 };
 


@@ -587,12 +487,20 @@ public:
 class wxColourDatabase : public wxObject {
 public:
 
 class wxColourDatabase : public wxObject {
 public:
 

-    wxColour *FindColour(const wxString& colour);
+    wxColour *FindColour(const wxString& colour) ;
+    wxColour *FindColourNoAdd(const wxString& colour) const;

     wxString FindName(const wxColour& colour) const;
 
     %addmethods {
     wxString FindName(const wxColour& colour) const;
 
     %addmethods {

+        void AddColour(const wxString& name, wxColour* colour) {
+            // make a copy since the python one will be GC'd
+            wxColour* c = new wxColour(*colour);
+            self->AddColour(name, c);
+        }
+

         void Append(const wxString& name, int red, int green, int blue) {
         void Append(const wxString& name, int red, int green, int blue) {

-            self->Append(name.c_str(), new wxColour(red, green, blue));
+            wxColour* c = new wxColour(red, green, blue);
+            self->AddColour(name, c);

         }
     }
 };
         }
     }
 };


@@ -618,14 +526,28 @@ public:
     void SetStyle(int style);
     void SetWidth(int width);
 
     void SetStyle(int style);
     void SetWidth(int width);
 

-            // **** This one needs to return a list of ints (wxDash)
-    //int GetDashes(wxDash **dashes);
+

     void SetDashes(int LCOUNT, wxDash* choices);
     void SetDashes(int LCOUNT, wxDash* choices);

+    //int GetDashes(wxDash **dashes);
+    %addmethods {
+        PyObject* GetDashes() {
+            wxDash* dashes;
+            int count = self->GetDashes(&dashes);
+            wxPyBeginBlockThreads();
+            PyObject* retval = PyList_New(0);
+            for (int x=0; x<count; x++)
+                PyList_Append(retval, PyInt_FromLong(dashes[x]));
+            wxPyEndBlockThreads();
+            return retval;
+        }
+    }

 
 #ifdef __WXMSW__
     wxBitmap* GetStipple();
     void SetStipple(wxBitmap& stipple);
 #endif
 
 #ifdef __WXMSW__
     wxBitmap* GetStipple();
     void SetStipple(wxBitmap& stipple);
 #endif

+
+    %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"

 };
 
 
 };
 
 


@@ -699,6 +621,13 @@ public:
     void SetColour(wxColour &colour);
     void SetStipple(wxBitmap& bitmap);
     void SetStyle(int style);
     void SetColour(wxColour &colour);
     void SetStipple(wxBitmap& bitmap);
     void SetStyle(int style);

+
+#ifdef __WXMAC__
+    short GetMacTheme();
+    void SetMacTheme(short macThemeBrush);
+#endif
+
+    %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"

 };
 
 
 };
 
 


@@ -715,62 +644,80 @@ public:
 //----------------------------------------------------------------------
 
 
 //----------------------------------------------------------------------
 
 

-

 class wxDC : public wxObject {
 public:
 //    wxDC(); **** abstract base class, can't instantiate.
     ~wxDC();
 
     void BeginDrawing();
 class wxDC : public wxObject {
 public:
 //    wxDC(); **** abstract base class, can't instantiate.
     ~wxDC();
 
     void BeginDrawing();

+

 //  %name(BlitXY)
 //  %name(BlitXY)

-    bool Blit(long xdest, long ydest,
-              long width, long height,
-              wxDC *source, long xsrc, long ysrc,
+    bool Blit(wxCoord xdest, wxCoord ydest,
+              wxCoord width, wxCoord height,
+              wxDC *source, wxCoord xsrc, wxCoord ysrc,

               int logicalFunc = wxCOPY, int useMask = FALSE);
 //      bool Blit(const wxPoint& destPt, const wxSize& sz,
 //                wxDC *source, const wxPoint& srcPt,
 //                int logicalFunc = wxCOPY, int useMask = FALSE);
 
     void Clear();
               int logicalFunc = wxCOPY, int useMask = FALSE);
 //      bool Blit(const wxPoint& destPt, const wxSize& sz,
 //                wxDC *source, const wxPoint& srcPt,
 //                int logicalFunc = wxCOPY, int useMask = FALSE);
 
     void Clear();

-    void CrossHair(long x, long y);
+    void CrossHair(wxCoord x, wxCoord y);

     void DestroyClippingRegion();
     void DestroyClippingRegion();

-    long DeviceToLogicalX(long x);
-    long DeviceToLogicalXRel(long x);
-    long DeviceToLogicalY(long y);
-    long DeviceToLogicalYRel(long y);
-    void DrawArc(long x1, long y1, long x2, long y2, long xc, long yc);
-    void DrawCircle(long x, long y, long radius);
-    void DrawEllipse(long x, long y, long width, long height);
-    void DrawEllipticArc(long x, long y, long width, long height, long start, long end);
-    void DrawIcon(const wxIcon& icon, long x, long y);
-    void DrawLine(long x1, long y1, long x2, long y2);
-    void DrawLines(int PCOUNT, wxPoint* points, long xoffset=0, long yoffset=0);
-    void DrawPolygon(int PCOUNT, wxPoint* points, long xoffset=0, long yoffset=0,
+    wxCoord DeviceToLogicalX(wxCoord x);
+    wxCoord DeviceToLogicalXRel(wxCoord x);
+    wxCoord DeviceToLogicalY(wxCoord y);
+    wxCoord DeviceToLogicalYRel(wxCoord y);
+    void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord xc, wxCoord yc);
+    void DrawCircle(wxCoord x, wxCoord y, wxCoord radius);
+    void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
+    void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord width, wxCoord height, wxCoord start, wxCoord end);
+    void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y);
+
+    void DrawLabel(const wxString& text, const wxRect& rect,
+                   int alignment = wxALIGN_LEFT | wxALIGN_TOP,
+                   int indexAccel = -1);
+
+    %addmethods {
+        wxRect DrawImageLabel(const wxString& text,
+                              const wxBitmap& image,
+                              const wxRect& rect,
+                              int alignment = wxALIGN_LEFT | wxALIGN_TOP,
+                              int indexAccel = -1) {
+            wxRect rv;
+            self->DrawLabel(text, image, rect, alignment, indexAccel, &rv);
+            return rv;
+        }
+    }
+
+    void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
+    void DrawLines(int PCOUNT, wxPoint* points, wxCoord xoffset=0, wxCoord yoffset=0);
+    void DrawPolygon(int PCOUNT, wxPoint* points, wxCoord xoffset=0, wxCoord yoffset=0,

                      int fill_style=wxODDEVEN_RULE);
                      int fill_style=wxODDEVEN_RULE);

-    void DrawPoint(long x, long y);
-    void DrawRectangle(long x, long y, long width, long height);
+    void DrawPoint(wxCoord x, wxCoord y);
+    void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
+    %name(DrawRectangleRect)void DrawRectangle(const wxRect& rect);

     void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle);
     void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle);

-    void DrawRoundedRectangle(long x, long y, long width, long height, long radius=20);
+    void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, wxCoord radius=20);

     void DrawSpline(int PCOUNT, wxPoint* points);
     void DrawSpline(int PCOUNT, wxPoint* points);

-    void DrawText(const wxString& text, long x, long y);
+    void DrawText(const wxString& text, wxCoord x, wxCoord y);

     void EndDoc();
     void EndDrawing();
     void EndPage();
     void EndDoc();
     void EndDrawing();
     void EndPage();

-    void FloodFill(long x, long y, const wxColour& colour, int style=wxFLOOD_SURFACE);
-    wxBrush&  GetBackground();
-    wxBrush&  GetBrush();
-    long GetCharHeight();
-    long GetCharWidth();
-    void GetClippingBox(long *OUTPUT, long *OUTPUT,
-                        long *OUTPUT, long *OUTPUT);
-    wxFont& GetFont();
+    bool FloodFill(wxCoord x, wxCoord y, const wxColour& colour, int style=wxFLOOD_SURFACE);
+    wxBrush  GetBackground();
+    wxBrush  GetBrush();
+    wxCoord GetCharHeight();
+    wxCoord GetCharWidth();
+    void GetClippingBox(wxCoord *OUTPUT, wxCoord *OUTPUT,
+                        wxCoord *OUTPUT, wxCoord *OUTPUT);
+    wxFont GetFont();

     int GetLogicalFunction();
     void GetLogicalScale(double *OUTPUT, double *OUTPUT);
     int GetMapMode();
     bool GetOptimization();
     int GetLogicalFunction();
     void GetLogicalScale(double *OUTPUT, double *OUTPUT);
     int GetMapMode();
     bool GetOptimization();

-    wxPen& GetPen();
+    wxPen GetPen();

     %addmethods {
     %addmethods {

-        %new wxColour* GetPixel(long x, long y) {
+        %new wxColour* GetPixel(wxCoord x, wxCoord y) {

             wxColour* wc = new wxColour();
             self->GetPixel(x, y, wc);
             return wc;
             wxColour* wc = new wxColour();
             self->GetPixel(x, y, wc);
             return wc;


@@ -780,26 +727,29 @@ public:
     wxSize GetSize();
     wxSize GetSizeMM();
     wxColour GetTextBackground();
     wxSize GetSize();
     wxSize GetSizeMM();
     wxColour GetTextBackground();

-    void GetTextExtent(const wxString& string, long *OUTPUT, long *OUTPUT);
+    void GetTextExtent(const wxString& string, wxCoord *OUTPUT, wxCoord *OUTPUT);

     %name(GetFullTextExtent)void GetTextExtent(const wxString& string,
     %name(GetFullTextExtent)void GetTextExtent(const wxString& string,

-                       long *OUTPUT, long *OUTPUT, long *OUTPUT, long* OUTPUT,
+                       wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord* OUTPUT,

                        const wxFont* font = NULL);
                        const wxFont* font = NULL);

+    void GetMultiLineTextExtent(const wxString& text, wxCoord *OUTPUT, wxCoord *OUTPUT, wxCoord *OUTPUT,
+                                wxFont *font = NULL);

     wxColour GetTextForeground();
     void GetUserScale(double *OUTPUT, double *OUTPUT);
     wxColour GetTextForeground();
     void GetUserScale(double *OUTPUT, double *OUTPUT);

-    long LogicalToDeviceX(long x);
-    long LogicalToDeviceXRel(long x);
-    long LogicalToDeviceY(long y);
-    long LogicalToDeviceYRel(long y);
-    long MaxX();
-    long MaxY();
-    long MinX();
-    long MinY();
+    wxCoord LogicalToDeviceX(wxCoord x);
+    wxCoord LogicalToDeviceXRel(wxCoord x);
+    wxCoord LogicalToDeviceY(wxCoord y);
+    wxCoord LogicalToDeviceYRel(wxCoord y);
+    wxCoord MaxX();
+    wxCoord MaxY();
+    wxCoord MinX();
+    wxCoord MinY();

     bool Ok();
     bool Ok();

-    void SetDeviceOrigin(long x, long y);
+    void SetDeviceOrigin(wxCoord x, wxCoord y);

     void SetBackground(const wxBrush& brush);
     void SetBackgroundMode(int mode);
     void SetBackground(const wxBrush& brush);
     void SetBackgroundMode(int mode);

-    void SetClippingRegion(long x, long y, long width, long height);
+    void SetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height);

     %name(SetClippingRegionAsRegion) void SetClippingRegion(const wxRegion& region);
     %name(SetClippingRegionAsRegion) void SetClippingRegion(const wxRegion& region);

+    %name(SetClippingRect) void SetClippingRegion(const wxRect& rect);

     void SetPalette(const wxPalette& colourMap);
     void SetBrush(const wxBrush& brush);
     void SetFont(const wxFont& font);
     void SetPalette(const wxPalette& colourMap);
     void SetBrush(const wxBrush& brush);
     void SetFont(const wxFont& font);


@@ -816,7 +766,7 @@ public:
 
 
 
 
 
 

-    void DrawBitmap(const wxBitmap& bitmap, long x, long y,
+    void DrawBitmap(const wxBitmap& bitmap, wxCoord x, wxCoord y,

                     int useMask = FALSE);
 
     bool CanDrawBitmap();
                     int useMask = FALSE);
 
     bool CanDrawBitmap();


@@ -837,163 +787,46 @@ public:
         // See below for implementation
     }
 
         // See below for implementation
     }
 

+    %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"
+

 #ifdef __WXMSW__
     long GetHDC();
 #endif
 
 
 #ifdef __WXMSW__
     long GetHDC();
 #endif
 
 

-    %addmethods {
-        // NOTE: These methods are VERY SIMILAR in implentation.  It would be
-        // nice to factor out common code and or turn them into a set of
-        // template-like macros.
-
-        // Draw a point for every set of coordinants in pyPoints, optionally
-        // setting a new pen for each
-        PyObject* _DrawPointList(PyObject* pyPoints, PyObject* pyPens) {
-            bool      isFastSeq  = PyList_Check(pyPoints) || PyTuple_Check(pyPoints);
-            bool      isFastPens = PyList_Check(pyPens) || PyTuple_Check(pyPens);
-            int       numObjs = 0;
-            int       numPens = 0;
-            wxPen*    pen;
-            PyObject* obj;
-            int       x1, y1;
-            int       i = 0;
-
-            if (!PySequence_Check(pyPoints)) {
-                goto err0;
-            }
-            if (!PySequence_Check(pyPens)) {
-                goto err1;
-            }
-            numObjs = PySequence_Length(pyPoints);
-            numPens = PySequence_Length(pyPens);
-
-            for (i = 0; i < numObjs; i++) {
-                // Use a new pen?
-                if (i < numPens) {
-                    if (isFastPens) {
-                        obj = PySequence_Fast_GET_ITEM(pyPens, i);
-                    }
-                    else {
-                        obj = PySequence_GetItem(pyPens, i);
-                    }
-                    if (SWIG_GetPtrObj(obj, (void **) &pen, "_wxPen_p")) {
-                        if (!isFastPens)
-                            Py_DECREF(obj);
-                        goto err1;
-                    }
-
-                    self->SetPen(*pen);
-                    if (!isFastPens)
-                        Py_DECREF(obj);
-                }
-
-                // Get the point coordinants
-                if (isFastSeq) {
-                    obj = PySequence_Fast_GET_ITEM(pyPoints, i);
-                }
-                else {
-                    obj = PySequence_GetItem(pyPoints, i);
-                }
-                if (! _2int_seq_helper(obj, &x1, &y1)) {
-                    if (!isFastPens)
-                        Py_DECREF(obj);
-                    goto err0;
-                }
-
-                // Now draw the point
-                self->DrawPoint(x1, y1);
-
-                if (!isFastSeq)
-                    Py_DECREF(obj);
-            }
+    %addmethods {  // See drawlist.cpp for impplementaion of these...

 
 

-            Py_INCREF(Py_None);
-            return Py_None;
+        PyObject* _DrawPointList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
+        {
+            return wxPyDrawXXXList(*self, wxPyDrawXXXPoint, pyCoords, pyPens, pyBrushes);
+        }

 
 

-        err1:
-            PyErr_SetString(PyExc_TypeError, "Expected a sequence of wxPens");
-            return NULL;
-        err0:
-            PyErr_SetString(PyExc_TypeError, "Expected a sequence of (x,y) sequences.");
-            return NULL;
+        PyObject* _DrawLineList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
+        {
+            return wxPyDrawXXXList(*self, wxPyDrawXXXLine, pyCoords, pyPens, pyBrushes);

         }
 
         }
 

+        PyObject* _DrawRectangleList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
+        {
+            return wxPyDrawXXXList(*self, wxPyDrawXXXRectangle, pyCoords, pyPens, pyBrushes);
+        }

 
 

-        // Draw a line for every set of coordinants in pyLines, optionally
-        // setting a new pen for each
-        PyObject* _DrawLineList(PyObject* pyLines, PyObject* pyPens) {
-            bool      isFastSeq  = PyList_Check(pyLines) || PyTuple_Check(pyLines);
-            bool      isFastPens = PyList_Check(pyPens) || PyTuple_Check(pyPens);
-            int       numObjs = 0;
-            int       numPens = 0;
-            wxPen*    pen;
-            PyObject* obj;
-            int       x1, y1, x2, y2;
-            int       i = 0;
-
-            if (!PySequence_Check(pyLines)) {
-                goto err0;
-            }
-            if (!PySequence_Check(pyPens)) {
-                goto err1;
-            }
-            numObjs = PySequence_Length(pyLines);
-            numPens = PySequence_Length(pyPens);
-
-            for (i = 0; i < numObjs; i++) {
-                // Use a new pen?
-                if (i < numPens) {
-                    if (isFastPens) {
-                        obj = PySequence_Fast_GET_ITEM(pyPens, i);
-                    }
-                    else {
-                        obj = PySequence_GetItem(pyPens, i);
-                    }
-                    if (SWIG_GetPtrObj(obj, (void **) &pen, "_wxPen_p")) {
-                        if (!isFastPens)
-                            Py_DECREF(obj);
-                        goto err1;
-                    }
-
-                    self->SetPen(*pen);
-                    if (!isFastPens)
-                        Py_DECREF(obj);
-                }
-
-                // Get the line coordinants
-                if (isFastSeq) {
-                    obj = PySequence_Fast_GET_ITEM(pyLines, i);
-                }
-                else {
-                    obj = PySequence_GetItem(pyLines, i);
-                }
-                if (! _4int_seq_helper(obj, &x1, &y1, &x2, &y2)) {
-                    if (!isFastPens)
-                        Py_DECREF(obj);
-                    goto err0;
-                }
-
-                // Now draw the line
-                self->DrawLine(x1, y1, x2, y2);
-
-                if (!isFastSeq)
-                    Py_DECREF(obj);
-            }
+        PyObject* _DrawEllipseList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
+        {
+            return wxPyDrawXXXList(*self, wxPyDrawXXXEllipse, pyCoords, pyPens, pyBrushes);
+        }

 
 

-            Py_INCREF(Py_None);
-            return Py_None;
+        PyObject* _DrawPolygonList(PyObject* pyCoords, PyObject* pyPens, PyObject* pyBrushes)
+        {
+            return wxPyDrawXXXList(*self, wxPyDrawXXXPolygon, pyCoords, pyPens, pyBrushes);
+        }

 
 

-        err1:
-            PyErr_SetString(PyExc_TypeError, "Expected a sequence of wxPens");
-            return NULL;
-        err0:
-            PyErr_SetString(PyExc_TypeError, "Expected a sequence of (x1,y1, x2,y2) sequences.");
-            return NULL;
+        PyObject* _DrawTextList(PyObject* textList, PyObject* pyPoints,
+                                PyObject* foregroundList, PyObject* backgroundList) {
+            return wxPyDrawTextList(*self, textList, pyPoints, foregroundList, backgroundList);

         }
     }
 
         }
     }
 

-

     %pragma(python) addtoclass = "
     def DrawPointList(self, points, pens=None):
         if pens is None:
     %pragma(python) addtoclass = "
     def DrawPointList(self, points, pens=None):
         if pens is None:


@@ -1002,7 +835,8 @@ public:
            pens = [pens]
         elif len(pens) != len(points):
            raise ValueError('points and pens must have same length')
            pens = [pens]
         elif len(pens) != len(points):
            raise ValueError('points and pens must have same length')

-        return self._DrawPointList(points, pens)
+        return self._DrawPointList(points, pens, [])
+

 
     def DrawLineList(self, lines, pens=None):
         if pens is None:
 
     def DrawLineList(self, lines, pens=None):
         if pens is None:


@@ -1011,7 +845,83 @@ public:
            pens = [pens]
         elif len(pens) != len(lines):
            raise ValueError('lines and pens must have same length')
            pens = [pens]
         elif len(pens) != len(lines):
            raise ValueError('lines and pens must have same length')

-        return self._DrawLineList(lines, pens)
+        return self._DrawLineList(lines, pens, [])
+
+
+    def DrawRectangleList(self, rectangles, pens=None, brushes=None):
+        if pens is None:
+           pens = []
+        elif isinstance(pens, wxPenPtr):
+           pens = [pens]
+        elif len(pens) != len(rectangles):
+           raise ValueError('rectangles and pens must have same length')
+        if brushes is None:
+           brushes = []
+        elif isinstance(brushes, wxBrushPtr):
+           brushes = [brushes]
+        elif len(brushes) != len(rectangles):
+           raise ValueError('rectangles and brushes must have same length')
+        return self._DrawRectangleList(rectangles, pens, brushes)
+
+
+    def DrawEllipseList(self, ellipses, pens=None, brushes=None):
+        if pens is None:
+           pens = []
+        elif isinstance(pens, wxPenPtr):
+           pens = [pens]
+        elif len(pens) != len(ellipses):
+           raise ValueError('ellipses and pens must have same length')
+        if brushes is None:
+           brushes = []
+        elif isinstance(brushes, wxBrushPtr):
+           brushes = [brushes]
+        elif len(brushes) != len(ellipses):
+           raise ValueError('ellipses and brushes must have same length')
+        return self._DrawEllipseList(ellipses, pens, brushes)
+
+
+    def DrawPolygonList(self, polygons, pens=None, brushes=None):
+        ## Note: This does not currently support fill style or offset
+        ## you can always use the non-List version if need be.
+        ## I really would like to support fill-style, however,
+        ## but wxODDEVEN_RULE does not appear to be defined at the Python level
+        ## [It's in wx.py... --Robin]
+        if pens is None:
+           pens = []
+        elif isinstance(pens, wxPenPtr):
+           pens = [pens]
+        elif len(pens) != len(polygons):
+           raise ValueError('polygons and pens must have same length')
+        if brushes is None:
+           brushes = []
+        elif isinstance(brushes, wxBrushPtr):
+           brushes = [brushes]
+        elif len(brushes) != len(polygons):
+           raise ValueError('polygons and brushes must have same length')
+        return self._DrawPolygonList(polygons, pens, brushes)
+
+
+    def DrawTextList(self, textList, coords, foregrounds = None, backgrounds = None, fonts = None):
+        ## NOTE: this does not currently support changing the font
+        ##       Make sure you set Background mode to wxSolid (DC.SetBackgroundMode)
+        ##       If you want backgounds to do anything.
+        if type(textList) == type(''):
+           textList = [textList]
+        elif len(textList) != len(coords):
+           raise ValueError('textlist and coords must have same length')
+        if foregrounds is None:
+           foregrounds = []
+        elif isinstance(foregrounds, wxColourPtr):
+           foregrounds = [foregrounds]
+        elif len(foregrounds) != len(coords):
+           raise ValueError('foregrounds and coords must have same length')
+        if backgrounds is None:
+           backgrounds = []
+        elif isinstance(backgrounds, wxColourPtr):
+           backgrounds = [backgrounds]
+        elif len(backgrounds) != len(coords):
+           raise ValueError('backgrounds and coords must have same length')
+        return  self._DrawTextList(textList, coords, foregrounds, backgrounds)

 "
 
 
 "
 
 


@@ -1045,6 +955,39 @@ public:
 %}
 
 
 %}
 
 

+//---------------------------------------------------------------------------
+
+class wxBufferedDC : public wxMemoryDC {
+public:
+        // Construct a wxBufferedDC using a user supplied buffer.
+    wxBufferedDC( wxDC *dc, const wxBitmap &buffer );
+
+        // Construct a wxBufferedDC with an internal buffer of 'area'
+        // (where area is usually something like the size of the window
+        // being buffered)
+    %name(wxBufferedDCInternalBuffer)wxBufferedDC( wxDC *dc, const wxSize &area );
+
+        // Blits the buffer to the dc, and detaches the dc from
+        // the buffer.  Usually called in the dtor or by the dtor
+        // of derived classes if the BufferedDC must blit before
+        // the derived class (which may own the dc it's blitting
+        // to) is destroyed.
+    void UnMask();
+
+
+    %pragma(python) addtomethod =
+        "__init__:self._dc = _args[0] # save a ref so the other dc won't be deleted before self"
+    %pragma(python) addtomethod =
+        "wxBufferedDCInternalBuffer:val._dc = _args[0] # save a ref so the other dc won't be deleted before self"
+};
+
+
+class wxBufferedPaintDC : public wxBufferedDC
+{
+public:
+    wxBufferedPaintDC( wxWindow *window, const wxBitmap &buffer = wxNullBitmap );
+};
+

 //---------------------------------------------------------------------------
 
 class wxScreenDC : public wxDC {
 //---------------------------------------------------------------------------
 
 class wxScreenDC : public wxDC {


@@ -1079,6 +1022,20 @@ public:
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

+class wxMirrorDC : public wxDC
+{
+public:
+    // constructs a mirror DC associated with the given real DC
+    //
+    // if mirror parameter is true, all vertical and horizontal coordinates are
+    // exchanged, otherwise this class behaves in exactly the same way as a
+    // plain DC
+    //
+    wxMirrorDC(wxDC& dc, bool mirror);
+};
+
+//---------------------------------------------------------------------------
+

 
 #ifdef __WXMSW__
 
 
 #ifdef __WXMSW__
 


@@ -1088,7 +1045,7 @@ public:
 
 class wxMetaFile : public wxObject {
 public:
 
 class wxMetaFile : public wxObject {
 public:

-    wxMetaFile(const wxString& filename = wxPyEmptyStr);
+    wxMetaFile(const wxString& filename = wxPyEmptyString);

     ~wxMetaFile();
 
     bool Ok();
     ~wxMetaFile();
 
     bool Ok();


@@ -1100,6 +1057,7 @@ public:
 
     const wxString& GetFileName() const { return m_filename; }
 
 
     const wxString& GetFileName() const { return m_filename; }
 

+    %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"

 };
 
 // bool wxMakeMetaFilePlaceable(const wxString& filename,
 };
 
 // bool wxMakeMetaFilePlaceable(const wxString& filename,


@@ -1108,82 +1066,14 @@ public:
 
 class wxMetaFileDC : public wxDC {
 public:
 
 class wxMetaFileDC : public wxDC {
 public:

-    wxMetaFileDC(const wxString& filename = wxPyEmptyStr,
+    wxMetaFileDC(const wxString& filename = wxPyEmptyString,

                  int width = 0, int height = 0,
                  int width = 0, int height = 0,

-                 const wxString& description = wxPyEmptyStr);
+                 const wxString& description = wxPyEmptyString);

     wxMetaFile* Close();
 };
 
 #endif
 
     wxMetaFile* Close();
 };
 
 #endif
 

-//---------------------------------------------------------------------------
-//---------------------------------------------------------------------------
-
-
-%readonly
-%{
-#if 0
-%}
-extern wxFont *wxNORMAL_FONT;
-extern wxFont *wxSMALL_FONT;
-extern wxFont *wxITALIC_FONT;
-extern wxFont *wxSWISS_FONT;
-
-extern wxPen *wxRED_PEN;
-extern wxPen *wxCYAN_PEN;
-extern wxPen *wxGREEN_PEN;
-extern wxPen *wxBLACK_PEN;
-extern wxPen *wxWHITE_PEN;
-extern wxPen *wxTRANSPARENT_PEN;
-extern wxPen *wxBLACK_DASHED_PEN;
-extern wxPen *wxGREY_PEN;
-extern wxPen *wxMEDIUM_GREY_PEN;
-extern wxPen *wxLIGHT_GREY_PEN;
-
-extern wxBrush *wxBLUE_BRUSH;
-extern wxBrush *wxGREEN_BRUSH;
-extern wxBrush *wxWHITE_BRUSH;
-extern wxBrush *wxBLACK_BRUSH;
-extern wxBrush *wxTRANSPARENT_BRUSH;
-extern wxBrush *wxCYAN_BRUSH;
-extern wxBrush *wxRED_BRUSH;
-extern wxBrush *wxGREY_BRUSH;
-extern wxBrush *wxMEDIUM_GREY_BRUSH;
-extern wxBrush *wxLIGHT_GREY_BRUSH;
-
-extern wxColour *wxBLACK;
-extern wxColour *wxWHITE;
-extern wxColour *wxRED;
-extern wxColour *wxBLUE;
-extern wxColour *wxGREEN;
-extern wxColour *wxCYAN;
-extern wxColour *wxLIGHT_GREY;
-
-extern wxCursor *wxSTANDARD_CURSOR;
-extern wxCursor *wxHOURGLASS_CURSOR;
-extern wxCursor *wxCROSS_CURSOR;
-
-extern wxBitmap wxNullBitmap;
-extern wxIcon   wxNullIcon;
-extern wxCursor wxNullCursor;
-extern wxPen    wxNullPen;
-extern wxBrush  wxNullBrush;
-extern wxPalette wxNullPalette;
-extern wxFont   wxNullFont;
-extern wxColour wxNullColour;
-
-
-extern wxFontList*       wxTheFontList;
-extern wxPenList*        wxThePenList;
-extern wxBrushList*      wxTheBrushList;
-extern wxColourDatabase* wxTheColourDatabase;
-
-
-%readwrite
-%{
-#endif
-%}
-

 //---------------------------------------------------------------------------
 
 class wxPalette : public wxGDIObject {
 //---------------------------------------------------------------------------
 
 class wxPalette : public wxGDIObject {


@@ -1194,6 +1084,8 @@ public:
     int GetPixel(byte red, byte green, byte blue);
     bool GetRGB(int pixel, byte* OUTPUT, byte* OUTPUT, byte* OUTPUT);
     bool Ok();
     int GetPixel(byte red, byte green, byte blue);
     bool GetRGB(int pixel, byte* OUTPUT, byte* OUTPUT, byte* OUTPUT);
     bool Ok();

+
+    %pragma(python) addtoclass = "def __nonzero__(self): return self.Ok()"

 };
 
 //---------------------------------------------------------------------------
 };
 
 //---------------------------------------------------------------------------


@@ -1244,34 +1136,57 @@ enum wxRegionContain {
 
 class wxRegion : public wxGDIObject {
 public:
 
 class wxRegion : public wxGDIObject {
 public:

-    wxRegion(long x=0, long y=0, long width=0, long height=0);
+    wxRegion(wxCoord x=0, wxCoord y=0, wxCoord width=0, wxCoord height=0);
+#ifndef __WXMAC__
+    %name(wxRegionFromPoints)wxRegion(int PCOUNT, wxPoint* points, int fillStyle = wxWINDING_RULE);
+#endif
+    %name(wxRegionFromBitmap)wxRegion(const wxBitmap& bmp,
+                                      const wxColour& transColour = wxNullColour,
+                                      int   tolerance = 0);

     ~wxRegion();
 
     ~wxRegion();
 

+

     void Clear();
     void Clear();

-    wxRegionContain Contains(long x, long y);
+#ifndef __WXMAC__
+    bool Offset(wxCoord x, wxCoord y);
+#endif
+
+    wxRegionContain Contains(wxCoord x, wxCoord y);

     %name(ContainsPoint)wxRegionContain Contains(const wxPoint& pt);
     %name(ContainsRect)wxRegionContain Contains(const wxRect& rect);
     %name(ContainsPoint)wxRegionContain Contains(const wxPoint& pt);
     %name(ContainsRect)wxRegionContain Contains(const wxRect& rect);

-    %name(ContainsRectDim)wxRegionContain Contains(long x, long y, long w, long h);
+    %name(ContainsRectDim)wxRegionContain Contains(wxCoord x, wxCoord y, wxCoord w, wxCoord h);

 
     wxRect GetBox();
 
 
     wxRect GetBox();
 

-    bool Intersect(long x, long y, long width, long height);
+    bool Intersect(wxCoord x, wxCoord y, wxCoord width, wxCoord height);

     %name(IntersectRect)bool Intersect(const wxRect& rect);
     %name(IntersectRegion)bool Intersect(const wxRegion& region);
 
     bool IsEmpty();
 
     %name(IntersectRect)bool Intersect(const wxRect& rect);
     %name(IntersectRegion)bool Intersect(const wxRegion& region);
 
     bool IsEmpty();
 

-    bool Union(long x, long y, long width, long height);
+    bool Union(wxCoord x, wxCoord y, wxCoord width, wxCoord height);

     %name(UnionRect)bool Union(const wxRect& rect);
     %name(UnionRegion)bool Union(const wxRegion& region);
 
     %name(UnionRect)bool Union(const wxRect& rect);
     %name(UnionRegion)bool Union(const wxRegion& region);
 

-    bool Subtract(long x, long y, long width, long height);
+    bool Subtract(wxCoord x, wxCoord y, wxCoord width, wxCoord height);

     %name(SubtractRect)bool Subtract(const wxRect& rect);
     %name(SubtractRegion)bool Subtract(const wxRegion& region);
 
     %name(SubtractRect)bool Subtract(const wxRect& rect);
     %name(SubtractRegion)bool Subtract(const wxRegion& region);
 

-    bool Xor(long x, long y, long width, long height);
+    bool Xor(wxCoord x, wxCoord y, wxCoord width, wxCoord height);

     %name(XorRect)bool Xor(const wxRect& rect);
     %name(XorRegion)bool Xor(const wxRegion& region);
     %name(XorRect)bool Xor(const wxRect& rect);
     %name(XorRegion)bool Xor(const wxRegion& region);

+
+    // Convert the region to a B&W bitmap with the white pixels being inside
+    // the region.
+    wxBitmap ConvertToBitmap();
+
+    // Use the non-transparent pixels of a wxBitmap for the region to combine
+    // with this region.  If the bitmap has a mask then it will be used,
+    // otherwise the colour to be treated as transparent may be specified,
+    // along with an optional tolerance value.
+    %name(UnionBitmap)bool Union(const wxBitmap& bmp,
+                                 const wxColour& transColour = wxNullColour,
+                                 int   tolerance = 0);

 };
 
 
 };
 
 


@@ -1281,12 +1196,12 @@ public:
     wxRegionIterator(const wxRegion& region);
     ~wxRegionIterator();
 
     wxRegionIterator(const wxRegion& region);
     ~wxRegionIterator();
 

-    long GetX();
-    long GetY();
-    long GetW();
-    long GetWidth();
-    long GetH();
-    long GetHeight();
+    wxCoord GetX();
+    wxCoord GetY();
+    wxCoord GetW();
+    wxCoord GetWidth();
+    wxCoord GetH();
+    wxCoord GetHeight();

     wxRect GetRect();
     bool HaveRects();
     void Reset();
     wxRect GetRect();
     bool HaveRects();
     void Reset();


@@ -1301,3 +1216,75 @@ public:
 
 //---------------------------------------------------------------------------
 
 
 //---------------------------------------------------------------------------
 

+
+%readonly
+%{
+#if 0
+%}
+
+// See also wxPy_ReinitStockObjects in helpers.cpp
+
+extern wxFont *wxNORMAL_FONT;
+extern wxFont *wxSMALL_FONT;
+extern wxFont *wxITALIC_FONT;
+extern wxFont *wxSWISS_FONT;
+
+extern wxPen *wxRED_PEN;
+extern wxPen *wxCYAN_PEN;
+extern wxPen *wxGREEN_PEN;
+extern wxPen *wxBLACK_PEN;
+extern wxPen *wxWHITE_PEN;
+extern wxPen *wxTRANSPARENT_PEN;
+extern wxPen *wxBLACK_DASHED_PEN;
+extern wxPen *wxGREY_PEN;
+extern wxPen *wxMEDIUM_GREY_PEN;
+extern wxPen *wxLIGHT_GREY_PEN;
+
+extern wxBrush *wxBLUE_BRUSH;
+extern wxBrush *wxGREEN_BRUSH;
+extern wxBrush *wxWHITE_BRUSH;
+extern wxBrush *wxBLACK_BRUSH;
+extern wxBrush *wxTRANSPARENT_BRUSH;
+extern wxBrush *wxCYAN_BRUSH;
+extern wxBrush *wxRED_BRUSH;
+extern wxBrush *wxGREY_BRUSH;
+extern wxBrush *wxMEDIUM_GREY_BRUSH;
+extern wxBrush *wxLIGHT_GREY_BRUSH;
+
+extern wxColour *wxBLACK;
+extern wxColour *wxWHITE;
+extern wxColour *wxRED;
+extern wxColour *wxBLUE;
+extern wxColour *wxGREEN;
+extern wxColour *wxCYAN;
+extern wxColour *wxLIGHT_GREY;
+
+extern wxCursor *wxSTANDARD_CURSOR;
+extern wxCursor *wxHOURGLASS_CURSOR;
+extern wxCursor *wxCROSS_CURSOR;
+
+
+extern wxBitmap wxNullBitmap;
+extern wxIcon   wxNullIcon;
+extern wxCursor wxNullCursor;
+extern wxPen    wxNullPen;
+extern wxBrush  wxNullBrush;
+extern wxPalette wxNullPalette;
+extern wxFont   wxNullFont;
+extern wxColour wxNullColour;
+
+
+extern wxFontList*       wxTheFontList;
+extern wxPenList*        wxThePenList;
+extern wxBrushList*      wxTheBrushList;
+extern wxColourDatabase* wxTheColourDatabase;
+
+
+%readwrite
+%{
+#endif
+%}
+
+//---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
+