wxPython/src/_image.i

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        _image.i
   3 // Purpose:     SWIG definitions for wxImage and such
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     25-Sept-2000
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 2003 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 // Not a %module
  14
  15
  16 //---------------------------------------------------------------------------
  17
  18 %{
  19 #include "wx/wxPython/pyistream.h"
  20 %}
  21
  22 //---------------------------------------------------------------------------
  23 %newgroup
  24
  25
  26 class wxImageHandler : public wxObject {
  27 public:
  28     // wxImageHandler();    Abstract Base Class
  29     wxString GetName();
  30     wxString GetExtension();
  31     long GetType();
  32     wxString GetMimeType();
  33
  34     //bool LoadFile(wxImage* image, wxInputStream& stream);
  35     //bool SaveFile(wxImage* image, wxOutputStream& stream);
  36     //virtual int GetImageCount( wxInputStream& stream );
  37     //bool CanRead( wxInputStream& stream );
  38
  39     bool CanRead( const wxString& name );
  40
  41     void SetName(const wxString& name);
  42     void SetExtension(const wxString& extension);
  43     void SetType(long type);
  44     void SetMimeType(const wxString& mimetype);
  45 };
  46
  47
  48 //---------------------------------------------------------------------------
  49
  50 class wxImageHistogram /* : public wxImageHistogramBase */
  51 {
  52 public:
  53     wxImageHistogram();
  54
  55     DocStr(MakeKey, "Get the key in the histogram for the given RGB values");
  56     static unsigned long MakeKey(unsigned char r,
  57                                  unsigned char g,
  58                                  unsigned char b);
  59
  60     DocDeclAStr(
  61         bool, FindFirstUnusedColour(unsigned char *OUTPUT,
  62                                     unsigned char *OUTPUT,
  63                                     unsigned char *OUTPUT,
  64                                     unsigned char startR = 1,
  65                                     unsigned char startG = 0,
  66                                     unsigned char startB = 0 ) const,
  67         "FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)",
  68         "Find first colour that is not used in the image and has higher RGB values than\n"
  69         "startR, startG, startB.  Returns a tuple consisting of a success flag and rgb\n"
  70         "values.");
  71 };
  72
  73
  74 //---------------------------------------------------------------------------
  75
  76
  77 class wxImage : public wxObject {
  78 public:
  79     wxImage( const wxString& name, long type = wxBITMAP_TYPE_ANY, int index = -1 );
  80     ~wxImage();
  81
  82     // Alternate constructors
  83     %name(ImageFromMime) wxImage(const wxString& name, const wxString& mimetype, int index = -1);
  84     %name(ImageFromStream) wxImage(wxInputStream& stream, long type = wxBITMAP_TYPE_ANY, int index = -1);
  85     %name(ImageFromStreamMime) wxImage(wxInputStream& stream, const wxString& mimetype, int index = -1 );
  86     %extend {
  87         %name(EmptyImage) wxImage(int width=0, int height=0, bool clear = True) {
  88             if (width > 0 && height > 0)
  89                 return new wxImage(width, height, clear);
  90             else
  91                 return new wxImage;
  92         }
  93
  94         %name(ImageFromBitmap) wxImage(const wxBitmap &bitmap) {
  95             return new wxImage(bitmap.ConvertToImage());
  96         }
  97
  98         %name(ImageFromData) wxImage(int width, int height, unsigned char* data) {
  99             // Copy the source data so the wxImage can clean it up later
 100             unsigned char* copy = (unsigned char*)malloc(width*height*3);
 101             if (copy == NULL) {
 102                 PyErr_NoMemory();
 103                 return NULL;
 104             }
 105             memcpy(copy, data, width*height*3);
 106             return new wxImage(width, height, copy, False);
 107         }
 108     }
 109
 110     void Create( int width, int height );
 111     void Destroy();
 112
 113     wxImage Scale( int width, int height );
 114     wxImage ShrinkBy( int xFactor , int yFactor ) const ;
 115     wxImage& Rescale(int width, int height);
 116
 117     void SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b );
 118     unsigned char GetRed( int x, int y );
 119     unsigned char GetGreen( int x, int y );
 120     unsigned char GetBlue( int x, int y );
 121
 122     void SetAlpha(int x, int y, unsigned char alpha);
 123     unsigned char GetAlpha(int x, int y);
 124     bool HasAlpha();
 125
 126     // find first colour that is not used in the image and has higher
 127     // RGB values than <startR,startG,startB>
 128     DocDeclAStr(
 129         bool, FindFirstUnusedColour( byte *OUTPUT, byte *OUTPUT, byte *OUTPUT,
 130                                      byte startR = 0, byte startG = 0, byte startB = 0 ) const,
 131         "FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)",
 132         "Find first colour that is not used in the image and has higher RGB values than\n"
 133         "startR, startG, startB.  Returns a tuple consisting of a success flag and rgb\n"
 134         "values.");
 135
 136
 137     // Set image's mask to the area of 'mask' that has <mr,mg,mb> colour
 138     bool SetMaskFromImage(const wxImage & mask,
 139                           byte mr, byte mg, byte mb);
 140
 141 //      void DoFloodFill (wxCoord x, wxCoord y,
 142 //          const wxBrush & fillBrush,
 143 //          const wxColour& testColour,
 144 //          int style = wxFLOOD_SURFACE,
 145 //          int LogicalFunction = wxCOPY /* currently unused */ ) ;
 146
 147     static bool CanRead( const wxString& name );
 148     static int GetImageCount( const wxString& name, long type = wxBITMAP_TYPE_ANY );
 149
 150     bool LoadFile( const wxString& name, long type = wxBITMAP_TYPE_ANY, int index = -1 );
 151     %name(LoadMimeFile)bool LoadFile( const wxString& name, const wxString& mimetype, int index = -1 );
 152
 153     bool SaveFile( const wxString& name, int type );
 154     %name(SaveMimeFile)bool SaveFile( const wxString& name, const wxString& mimetype );
 155
 156     %name(CanReadStream) static bool CanRead( wxInputStream& stream );
 157     %name(LoadStream) bool LoadFile( wxInputStream& stream, long type = wxBITMAP_TYPE_ANY, int index = -1 );
 158     %name(LoadMimeStream) bool LoadFile( wxInputStream& stream, const wxString& mimetype, int index = -1 );
 159
 160     bool Ok();
 161     int GetWidth();
 162     int GetHeight();
 163
 164     wxImage GetSubImage(const wxRect& rect);
 165     wxImage Copy();
 166     void Paste( const wxImage &image, int x, int y );
 167
 168     //unsigned char *GetData();
 169     //void SetData( unsigned char *data );
 170
 171     %extend {
 172         PyObject* GetData() {
 173             unsigned char* data = self->GetData();
 174             int len = self->GetWidth() * self->GetHeight() * 3;
 175             PyObject* rv;
 176             wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
 177             return rv;
 178         }
 179         void SetData(PyObject* data) {
 180             unsigned char* dataPtr;
 181
 182             if (! PyString_Check(data)) {
 183                 PyErr_SetString(PyExc_TypeError, "Expected string object");
 184                 return /* NULL */ ;
 185             }
 186
 187             size_t len = self->GetWidth() * self->GetHeight() * 3;
 188             dataPtr = (unsigned char*) malloc(len);
 189             wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
 190             self->SetData(dataPtr);
 191             // wxImage takes ownership of dataPtr...
 192         }
 193
 194
 195
 196         PyObject* GetDataBuffer() {
 197             unsigned char* data = self->GetData();
 198             int len = self->GetWidth() * self->GetHeight() * 3;
 199             PyObject* rv;
 200             wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
 201             return rv;
 202         }
 203         void SetDataBuffer(PyObject* data) {
 204             unsigned char* buffer;
 205             int size;
 206
 207             bool blocked = wxPyBeginBlockThreads();
 208             if (!PyArg_Parse(data, "t#", &buffer, &size))
 209                 goto done;
 210
 211             if (size != self->GetWidth() * self->GetHeight() * 3) {
 212                 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
 213                 goto done;
 214             }
 215             self->SetData(buffer);
 216         done:
 217             wxPyEndBlockThreads(blocked);
 218         }
 219
 220
 221
 222         PyObject* GetAlphaData() {
 223             unsigned char* data = self->GetAlpha();
 224             if (! data) {
 225                 RETURN_NONE();
 226             } else {
 227                 int len = self->GetWidth() * self->GetHeight();
 228                 PyObject* rv;
 229                 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
 230                 return rv;
 231             }
 232         }
 233         void SetAlphaData(PyObject* data) {
 234             unsigned char* dataPtr;
 235
 236             if (! PyString_Check(data)) {
 237                 PyErr_SetString(PyExc_TypeError, "Expected string object");
 238                 return /* NULL */ ;
 239             }
 240
 241             size_t len = self->GetWidth() * self->GetHeight();
 242             dataPtr = (unsigned char*) malloc(len);
 243             wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
 244             self->SetAlpha(dataPtr);
 245             // wxImage takes ownership of dataPtr...
 246         }
 247
 248
 249
 250         PyObject* GetAlphaBuffer() {
 251             unsigned char* data = self->GetAlpha();
 252             int len = self->GetWidth() * self->GetHeight();
 253             PyObject* rv;
 254             wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
 255             return rv;
 256         }
 257         void SetAlphaBuffer(PyObject* data) {
 258             unsigned char* buffer;
 259             int size;
 260
 261             bool blocked = wxPyBeginBlockThreads();
 262             if (!PyArg_Parse(data, "t#", &buffer, &size))
 263                 goto done;
 264
 265             if (size != self->GetWidth() * self->GetHeight()) {
 266                 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
 267                 goto done;
 268             }
 269             self->SetAlpha(buffer);
 270         done:
 271             wxPyEndBlockThreads(blocked);
 272         }
 273     }
 274
 275     void SetMaskColour( unsigned char r, unsigned char g, unsigned char b );
 276     unsigned char GetMaskRed();
 277     unsigned char GetMaskGreen();
 278     unsigned char GetMaskBlue();
 279     void SetMask( bool mask = True );
 280     bool HasMask();
 281
 282     wxImage Rotate(double angle, const wxPoint & centre_of_rotation,
 283                    bool interpolating = True, wxPoint * offset_after_rotation = NULL) const ;
 284     wxImage Rotate90( bool clockwise = True ) ;
 285     wxImage Mirror( bool horizontally = True ) ;
 286
 287     void Replace( unsigned char r1, unsigned char g1, unsigned char b1,
 288                   unsigned char r2, unsigned char g2, unsigned char b2 );
 289
 290     // convert to monochrome image (<r,g,b> will be replaced by white, everything else by black)
 291     wxImage ConvertToMono( unsigned char r, unsigned char g, unsigned char b ) const;
 292
 293     void SetOption(const wxString& name, const wxString& value);
 294     %name(SetOptionInt)void SetOption(const wxString& name, int value);
 295     wxString GetOption(const wxString& name) const;
 296     int GetOptionInt(const wxString& name) const;
 297     bool HasOption(const wxString& name) const;
 298
 299     unsigned long CountColours( unsigned long stopafter = (unsigned long) -1 );
 300     unsigned long ComputeHistogram( wxImageHistogram& h );
 301
 302     static void AddHandler( wxImageHandler *handler );
 303     static void InsertHandler( wxImageHandler *handler );
 304     static bool RemoveHandler( const wxString& name );
 305     static wxString GetImageExtWildcard();
 306
 307
 308     %extend {
 309         wxBitmap ConvertToBitmap() {
 310             wxBitmap bitmap(*self);
 311             return bitmap;
 312         }
 313
 314         wxBitmap ConvertToMonoBitmap( unsigned char red,
 315                                       unsigned char green,
 316                                       unsigned char blue ) {
 317             wxImage mono = self->ConvertToMono( red, green, blue );
 318             wxBitmap bitmap( mono, 1 );
 319             return bitmap;
 320         }
 321     }
 322
 323     %pythoncode { def __nonzero__(self): return self.Ok() }
 324 };
 325
 326
 327
 328 void wxInitAllImageHandlers();
 329
 330
 331 // See also wxPy_ReinitStockObjects in helpers.cpp
 332 %immutable;
 333 const wxImage    wxNullImage;
 334 %mutable;
 335
 336 //---------------------------------------------------------------------------
 337
 338
 339 MAKE_CONST_WXSTRING(IMAGE_OPTION_BMP_FORMAT);
 340 MAKE_CONST_WXSTRING(IMAGE_OPTION_CUR_HOTSPOT_X);
 341 MAKE_CONST_WXSTRING(IMAGE_OPTION_CUR_HOTSPOT_Y);
 342 MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTION);
 343 MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTIONUNIT);
 344
 345 enum
 346 {
 347     wxIMAGE_RESOLUTION_INCHES = 1,
 348     wxIMAGE_RESOLUTION_CM = 2
 349 };
 350
 351
 352 enum
 353 {
 354     wxBMP_24BPP        = 24, // default, do not need to set
 355     //wxBMP_16BPP      = 16, // wxQuantize can only do 236 colors?
 356     wxBMP_8BPP         =  8, // 8bpp, quantized colors
 357     wxBMP_8BPP_GREY    =  9, // 8bpp, rgb averaged to greys
 358     wxBMP_8BPP_GRAY    =  wxBMP_8BPP_GREY,
 359     wxBMP_8BPP_RED     = 10, // 8bpp, red used as greyscale
 360     wxBMP_8BPP_PALETTE = 11, // 8bpp, use the wxImage's palette
 361     wxBMP_4BPP         =  4, // 4bpp, quantized colors
 362     wxBMP_1BPP         =  1, // 1bpp, quantized "colors"
 363     wxBMP_1BPP_BW      =  2  // 1bpp, black & white from red
 364 };
 365
 366
 367 class wxBMPHandler : public wxImageHandler {
 368 public:
 369     wxBMPHandler();
 370 };
 371
 372 class wxICOHandler : public wxBMPHandler {
 373 public:
 374     wxICOHandler();
 375 };
 376
 377 class wxCURHandler : public wxICOHandler {
 378 public:
 379     wxCURHandler();
 380 };
 381
 382 class wxANIHandler : public wxCURHandler {
 383 public:
 384     wxANIHandler();
 385 };
 386
 387
 388 //---------------------------------------------------------------------------
 389
 390 class wxPNGHandler : public wxImageHandler {
 391 public:
 392     wxPNGHandler();
 393 };
 394
 395
 396 class wxGIFHandler : public wxImageHandler {
 397 public:
 398     wxGIFHandler();
 399 };
 400
 401
 402 class wxPCXHandler : public wxImageHandler {
 403 public:
 404     wxPCXHandler();
 405 };
 406
 407
 408 class wxJPEGHandler : public wxImageHandler {
 409 public:
 410     wxJPEGHandler();
 411 };
 412
 413
 414 class wxPNMHandler : public wxImageHandler {
 415 public:
 416     wxPNMHandler();
 417 };
 418
 419 class wxXPMHandler : public wxImageHandler {
 420 public:
 421     wxXPMHandler();
 422 };
 423
 424 class wxTIFFHandler : public wxImageHandler {
 425 public:
 426     wxTIFFHandler();
 427 };
 428
 429
 430 #if wxUSE_IFF
 431 class wxIFFHandler : public wxImageHandler {
 432 public:
 433     wxIFFHandler();
 434 };
 435 #endif
 436
 437 //---------------------------------------------------------------------------