Patches from KevinO that work around issues where the widget isn't

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

diff --git a/wxPython/src/_bitmap.i b/wxPython/src/_bitmap.i
index ce0bbd9a0dabc7830b9f23eab8146badd7981a0d..44f39290e6aa9a9f457d6b9be5269f58b6f12d9e 100644 (file)
--- a/wxPython/src/_bitmap.i
+++ b/wxPython/src/_bitmap.i
@@ -47,14 +47,36 @@
 class wxBitmap : public wxGDIObject
 {
 public:
 class wxBitmap : public wxGDIObject
 {
 public:

-    wxBitmap(const wxString& name, wxBitmapType type=wxBITMAP_TYPE_ANY);
+    DocCtorStr(
+        wxBitmap(const wxString& name, wxBitmapType type=wxBITMAP_TYPE_ANY),
+        "Loads a bitmap from a file.");
+        

     ~wxBitmap();
 
     ~wxBitmap();
 

-    // alternate constructors
-    %name(EmptyBitmap) wxBitmap(int width, int height, int depth=-1);
-    %name(BitmapFromIcon) wxBitmap(const wxIcon& icon);
-    %name(BitmapFromImage) wxBitmap(const wxImage& image, int depth=-1);
+//     DocCtorStrName(
+//         wxBitmap(int width, int height, int depth=-1),
+//         "Creates a new bitmap of the given size.  A depth of -1 indicates the depth of\n"
+//         "the current screen or visual. Some platforms only support 1 for monochrome and\n"
+//         "-1 for the current colour setting.",
+//         EmptyBitmap);
+
+    DocCtorStrName(
+        wxBitmap(const wxIcon& icon),
+        "Create a new bitmap from an Icon object.",
+        BitmapFromIcon);
+
+    DocCtorStrName(
+        wxBitmap(const wxImage& image, int depth=-1),
+        "Creates bitmap object from the image. This has to be done to actually display\n"
+        "an image as you cannot draw an image directly on a window. The resulting\n"
+        "bitmap will use the provided colour depth (or that of the current system if\n"
+        "depth is -1) which entails that a colour reduction has to take place.",
+        BitmapFromImage);
+
+    

     %extend {
     %extend {

+        DocStr(wxBitmap(PyObject* listOfStrings),
+               "Construct a Bitmap from a list of strings formatted as XPM data.");

         %name(BitmapFromXPMData) wxBitmap(PyObject* listOfStrings) {
             char**    cArray = NULL;
             wxBitmap* bmp;
         %name(BitmapFromXPMData) wxBitmap(PyObject* listOfStrings) {
             char**    cArray = NULL;
             wxBitmap* bmp;


@@ -67,12 +89,32 @@ public:
             return bmp;
         }
 
             return bmp;
         }
 

-        %name(BitmapFromBits) wxBitmap(PyObject* bits, int width, int height, int depth = 1 ) {
+        DocStr(wxBitmap(PyObject* bits, int width, int height, int depth=1 ),
+               "Creates a bitmap from an array of bits.  You should only use this function for\n"
+               "monochrome bitmaps (depth 1) in portable programs: in this case the bits\n"
+               "parameter should contain an XBM image.  For other bit depths, the behaviour is\n"
+               "platform dependent.");
+        %name(BitmapFromBits) wxBitmap(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);
         }
             char* buf;
             int   length;
             PyString_AsStringAndSize(bits, &buf, &length);
             return new wxBitmap(buf, width, height, depth);
         }

+
+
+        DocStr(wxBitmap(const wxSize& size, int depth=-1), 
+               "Creates a new bitmap of the given size.  A depth of -1 indicates
+the depth of the current screen or visual. Some platforms only
+support 1 for monochrome and -1 for the current colour setting.");
+
+        %nokwargs wxBitmap(int width, int height, int depth=-1);
+        %nokwargs wxBitmap(const wxSize& size, int depth=-1);
+        %name(EmptyBitmap)wxBitmap(int width, int height, int depth=-1) {
+            return new wxBitmap(width, height, depth);
+        }
+        %name(EmptyBitmap)wxBitmap(const wxSize& size, int depth=-1) {
+            return new wxBitmap(size.x, size.y, depth);
+        }

     }    
 
     
     }    
 
     


@@ -83,33 +125,68 @@ public:
     // wxGDIImage methods
 #ifdef __WXMSW__
     long GetHandle();
     // wxGDIImage methods
 #ifdef __WXMSW__
     long GetHandle();

-    void SetHandle(long handle);
+    %extend {
+        void SetHandle(long handle) { self->SetHandle((WXHANDLE)handle); }
+    }

 #endif
 
     bool Ok();
     
 #endif
 
     bool Ok();
     

+    DocStr(GetWidth, "Gets the width of the bitmap in pixels.");

     int GetWidth();
     int GetWidth();

+
+    DocStr(GetHeight, "Gets the height of the bitmap in pixels.");

     int GetHeight();
     int GetHeight();

+
+    DocStr(GetDepth,
+           "Gets the colour depth of the bitmap. A value of 1 indicates a\n"
+           "monochrome bitmap.");

     int GetDepth();
 
     int GetDepth();
 

+
+    %extend {
+        DocStr(GetSize, "Get the size of the bitmap.");
+        wxSize GetSize() {
+            wxSize size(self->GetWidth(), self->GetHeight());
+            return size;
+        }
+    }
+
+    
+    DocStr(ConvertToImage,
+           "Creates a platform-independent image from a platform-dependent bitmap. This\n"
+           "preserves mask information so that bitmaps and images can be converted back\n"
+           "and forth without loss in that respect.");

     virtual wxImage ConvertToImage() const;
 
     virtual wxImage ConvertToImage() const;
 

+    DocStr(GetMask,
+           "Gets the associated mask (if any) which may have been loaded from a file\n"
+           "or explpicitly set for the bitmap.");

     virtual wxMask* GetMask() const;
     virtual wxMask* GetMask() const;

+
+    DocStr(SetMask,
+           "Sets the mask for this bitmap.");

     virtual void SetMask(wxMask* mask);
     virtual void SetMask(wxMask* mask);

+    

     %extend {
     %extend {

+        DocStr(SetMaskColour,
+               "Create a Mask based on a specified colour in the Bitmap.");

         void SetMaskColour(const wxColour& colour) {
             wxMask *mask = new wxMask(*self, colour);
             self->SetMask(mask);
         }
     }
         void SetMaskColour(const wxColour& colour) {
             wxMask *mask = new wxMask(*self, colour);
             self->SetMask(mask);
         }
     }

-//     def SetMaskColour(self, colour):
-//         mask = wxMaskColour(self, colour)
-//         self.SetMask(mask)

 
 

+    DocStr(GetSubBitmap,
+           "Returns a sub bitmap of the current one as long as the rect belongs entirely\n"
+           "to the bitmap. This function preserves bit depth and mask information.");

     virtual wxBitmap GetSubBitmap(const wxRect& rect) const;
 
     virtual wxBitmap GetSubBitmap(const wxRect& rect) const;
 

+    DocStr(SaveFile, "Saves a bitmap in the named file.");

     virtual bool SaveFile(const wxString &name, wxBitmapType type,
                           wxPalette *palette = (wxPalette *)NULL);
     virtual bool SaveFile(const wxString &name, wxBitmapType type,
                           wxPalette *palette = (wxPalette *)NULL);

+
+    DocStr(LoadFile, "Loads a bitmap from a file");

     virtual bool LoadFile(const wxString &name, wxBitmapType type);
 
     
     virtual bool LoadFile(const wxString &name, wxBitmapType type);
 
     


@@ -118,13 +195,26 @@ public:
     virtual void SetPalette(const wxPalette& palette);
 #endif
     
     virtual void SetPalette(const wxPalette& palette);
 #endif
     

-    // copies the contents and mask of the given (colour) icon to the bitmap
-    virtual bool CopyFromIcon(const wxIcon& icon);

     
     

+    virtual bool CopyFromIcon(const wxIcon& icon);
+
+    DocStr(SetHeight, "Set the height property (does not affect the bitmap data).")

     virtual void SetHeight(int height);
     virtual void SetHeight(int height);

+    
+    DocStr(SetWidth, "Set the width property (does not affect the bitmap data).")

     virtual void SetWidth(int width);
     virtual void SetWidth(int width);

+
+    DocStr(SetDepth, "Set the depth property (does not affect the bitmap data).")

     virtual void SetDepth(int depth);
 
     virtual void SetDepth(int depth);
 

+    %extend {
+        DocStr(SetSize, "Set the bitmap size");
+        void SetSize(const wxSize& size) {
+            self->SetWidth(size.x);
+            self->SetHeight(size.y);
+        }
+    }
+    

 #ifdef __WXMSW__
     bool CopyFromCursor(const wxCursor& cursor);
     int GetQuality();
 #ifdef __WXMSW__
     bool CopyFromCursor(const wxCursor& cursor);
     int GetQuality();


@@ -132,19 +222,47 @@ public:
 #endif
 
     %pythoncode { def __nonzero__(self): return self.Ok() }
 #endif
 
     %pythoncode { def __nonzero__(self): return self.Ok() }

+
+    %extend {
+        bool __eq__(const wxBitmap* other) { return other ? (*self == *other) : False; }
+        bool __ne__(const wxBitmap* other) { return other ? (*self != *other) : True;  }
+    }

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

+DocStr(wxMask,
+       "This class encapsulates a monochrome mask bitmap, where the masked area is\n"
+       "black and the unmasked area is white. When associated with a bitmap and drawn\n"
+       "in a device context, the unmasked area of the bitmap will be drawn, and the\n"
+       "masked area will not be drawn.");
+

 class wxMask : public wxObject {
 public:
 class wxMask : public wxObject {
 public:

-    wxMask(const wxBitmap& bitmap);
-    %name(MaskColour) wxMask(const wxBitmap& bitmap, const wxColour& colour);
+#if 0
+    DocCtorStr(
+        wxMask(const wxBitmap& bitmap),
+        "Constructs a mask from a monochrome bitmap.");
+#endif
+
+    DocStr(wxMask,
+           "Constructs a mask from a bitmap and a colour in that bitmap that indicates\n"
+           "the transparent portions of the mask, by default BLACK is used.");
+    
+    %extend {
+        wxMask(const wxBitmap& bitmap, const wxColour& colour = wxNullColour) {
+            if ( !colour.Ok() )
+                return new wxMask(bitmap, *wxBLACK);
+            else
+                return new wxMask(bitmap, colour);
+        }
+    }

     
     //~wxMask();
     
     //~wxMask();

-

 };
 
 };
 

+%pythoncode { MaskColour = Mask }
+

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