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
  69 values than startR, startG, startB.  Returns a tuple consisting of a
  70 success flag and rgb 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
 133 values than startR, startG, startB.  Returns a tuple consisting of a
 134 success flag and rgb 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     %extend {
 165         wxSize GetSize() {
 166             wxSize size(self->GetWidth(), self->GetHeight());
 167             return size;
 168         }
 169     }
 170
 171     wxImage GetSubImage(const wxRect& rect);
 172     wxImage Copy();
 173     void Paste( const wxImage &image, int x, int y );
 174
 175     //unsigned char *GetData();
 176     //void SetData( unsigned char *data );
 177
 178     %extend {
 179         PyObject* GetData() {
 180             unsigned char* data = self->GetData();
 181             int len = self->GetWidth() * self->GetHeight() * 3;
 182             PyObject* rv;
 183             wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
 184             return rv;
 185         }
 186         void SetData(PyObject* data) {
 187             unsigned char* dataPtr;
 188
 189             if (! PyString_Check(data)) {
 190                 PyErr_SetString(PyExc_TypeError, "Expected string object");
 191                 return /* NULL */ ;
 192             }
 193
 194             size_t len = self->GetWidth() * self->GetHeight() * 3;
 195             dataPtr = (unsigned char*) malloc(len);
 196             wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
 197             self->SetData(dataPtr);
 198             // wxImage takes ownership of dataPtr...
 199         }
 200
 201
 202
 203         PyObject* GetDataBuffer() {
 204             unsigned char* data = self->GetData();
 205             int len = self->GetWidth() * self->GetHeight() * 3;
 206             PyObject* rv;
 207             wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
 208             return rv;
 209         }
 210         void SetDataBuffer(PyObject* data) {
 211             unsigned char* buffer;
 212             int size;
 213
 214             bool blocked = wxPyBeginBlockThreads();
 215             if (!PyArg_Parse(data, "t#", &buffer, &size))
 216                 goto done;
 217
 218             if (size != self->GetWidth() * self->GetHeight() * 3) {
 219                 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
 220                 goto done;
 221             }
 222             self->SetData(buffer);
 223         done:
 224             wxPyEndBlockThreads(blocked);
 225         }
 226
 227
 228
 229         PyObject* GetAlphaData() {
 230             unsigned char* data = self->GetAlpha();
 231             if (! data) {
 232                 RETURN_NONE();
 233             } else {
 234                 int len = self->GetWidth() * self->GetHeight();
 235                 PyObject* rv;
 236                 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
 237                 return rv;
 238             }
 239         }
 240         void SetAlphaData(PyObject* data) {
 241             unsigned char* dataPtr;
 242
 243             if (! PyString_Check(data)) {
 244                 PyErr_SetString(PyExc_TypeError, "Expected string object");
 245                 return /* NULL */ ;
 246             }
 247
 248             size_t len = self->GetWidth() * self->GetHeight();
 249             dataPtr = (unsigned char*) malloc(len);
 250             wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
 251             self->SetAlpha(dataPtr);
 252             // wxImage takes ownership of dataPtr...
 253         }
 254
 255
 256
 257         PyObject* GetAlphaBuffer() {
 258             unsigned char* data = self->GetAlpha();
 259             int len = self->GetWidth() * self->GetHeight();
 260             PyObject* rv;
 261             wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
 262             return rv;
 263         }
 264         void SetAlphaBuffer(PyObject* data) {
 265             unsigned char* buffer;
 266             int size;
 267
 268             bool blocked = wxPyBeginBlockThreads();
 269             if (!PyArg_Parse(data, "t#", &buffer, &size))
 270                 goto done;
 271
 272             if (size != self->GetWidth() * self->GetHeight()) {
 273                 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
 274                 goto done;
 275             }
 276             self->SetAlpha(buffer);
 277         done:
 278             wxPyEndBlockThreads(blocked);
 279         }
 280     }
 281
 282     void SetMaskColour( unsigned char r, unsigned char g, unsigned char b );
 283     unsigned char GetMaskRed();
 284     unsigned char GetMaskGreen();
 285     unsigned char GetMaskBlue();
 286     void SetMask( bool mask = True );
 287     bool HasMask();
 288
 289     wxImage Rotate(double angle, const wxPoint & centre_of_rotation,
 290                    bool interpolating = True, wxPoint * offset_after_rotation = NULL) const ;
 291     wxImage Rotate90( bool clockwise = True ) ;
 292     wxImage Mirror( bool horizontally = True ) ;
 293
 294     void Replace( unsigned char r1, unsigned char g1, unsigned char b1,
 295                   unsigned char r2, unsigned char g2, unsigned char b2 );
 296
 297     // convert to monochrome image (<r,g,b> will be replaced by white, everything else by black)
 298     wxImage ConvertToMono( unsigned char r, unsigned char g, unsigned char b ) const;
 299
 300     void SetOption(const wxString& name, const wxString& value);
 301     %name(SetOptionInt)void SetOption(const wxString& name, int value);
 302     wxString GetOption(const wxString& name) const;
 303     int GetOptionInt(const wxString& name) const;
 304     bool HasOption(const wxString& name) const;
 305
 306     unsigned long CountColours( unsigned long stopafter = (unsigned long) -1 );
 307     unsigned long ComputeHistogram( wxImageHistogram& h );
 308
 309     static void AddHandler( wxImageHandler *handler );
 310     static void InsertHandler( wxImageHandler *handler );
 311     static bool RemoveHandler( const wxString& name );
 312     static wxString GetImageExtWildcard();
 313
 314
 315     %extend {
 316         wxBitmap ConvertToBitmap() {
 317             wxBitmap bitmap(*self);
 318             return bitmap;
 319         }
 320
 321         wxBitmap ConvertToMonoBitmap( unsigned char red,
 322                                       unsigned char green,
 323                                       unsigned char blue ) {
 324             wxImage mono = self->ConvertToMono( red, green, blue );
 325             wxBitmap bitmap( mono, 1 );
 326             return bitmap;
 327         }
 328     }
 329
 330     %pythoncode { def __nonzero__(self): return self.Ok() }
 331 };
 332
 333
 334
 335 ///void wxInitAllImageHandlers();
 336
 337 %pythoncode {
 338     def InitAllImageHandlers():
 339         """
 340         The former functionality of InitAllImageHanders is now done internal to
 341         the _core_ extension module and so this function has become a simple NOP.
 342         """
 343         pass
 344 }
 345
 346
 347
 348 // See also wxPy_ReinitStockObjects in helpers.cpp
 349 %immutable;
 350 const wxImage    wxNullImage;
 351 %mutable;
 352
 353 //---------------------------------------------------------------------------
 354
 355
 356 MAKE_CONST_WXSTRING(IMAGE_OPTION_BMP_FORMAT);
 357 MAKE_CONST_WXSTRING(IMAGE_OPTION_CUR_HOTSPOT_X);
 358 MAKE_CONST_WXSTRING(IMAGE_OPTION_CUR_HOTSPOT_Y);
 359 MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTION);
 360 MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTIONUNIT);
 361
 362 enum
 363 {
 364     wxIMAGE_RESOLUTION_INCHES = 1,
 365     wxIMAGE_RESOLUTION_CM = 2
 366 };
 367
 368
 369 enum
 370 {
 371     wxBMP_24BPP        = 24, // default, do not need to set
 372     //wxBMP_16BPP      = 16, // wxQuantize can only do 236 colors?
 373     wxBMP_8BPP         =  8, // 8bpp, quantized colors
 374     wxBMP_8BPP_GREY    =  9, // 8bpp, rgb averaged to greys
 375     wxBMP_8BPP_GRAY    =  wxBMP_8BPP_GREY,
 376     wxBMP_8BPP_RED     = 10, // 8bpp, red used as greyscale
 377     wxBMP_8BPP_PALETTE = 11, // 8bpp, use the wxImage's palette
 378     wxBMP_4BPP         =  4, // 4bpp, quantized colors
 379     wxBMP_1BPP         =  1, // 1bpp, quantized "colors"
 380     wxBMP_1BPP_BW      =  2  // 1bpp, black & white from red
 381 };
 382
 383
 384 class wxBMPHandler : public wxImageHandler {
 385 public:
 386     wxBMPHandler();
 387 };
 388
 389 class wxICOHandler : public wxBMPHandler {
 390 public:
 391     wxICOHandler();
 392 };
 393
 394 class wxCURHandler : public wxICOHandler {
 395 public:
 396     wxCURHandler();
 397 };
 398
 399 class wxANIHandler : public wxCURHandler {
 400 public:
 401     wxANIHandler();
 402 };
 403
 404
 405 //---------------------------------------------------------------------------
 406
 407 class wxPNGHandler : public wxImageHandler {
 408 public:
 409     wxPNGHandler();
 410 };
 411
 412
 413 class wxGIFHandler : public wxImageHandler {
 414 public:
 415     wxGIFHandler();
 416 };
 417
 418
 419 class wxPCXHandler : public wxImageHandler {
 420 public:
 421     wxPCXHandler();
 422 };
 423
 424
 425 class wxJPEGHandler : public wxImageHandler {
 426 public:
 427     wxJPEGHandler();
 428 };
 429
 430
 431 class wxPNMHandler : public wxImageHandler {
 432 public:
 433     wxPNMHandler();
 434 };
 435
 436 class wxXPMHandler : public wxImageHandler {
 437 public:
 438     wxXPMHandler();
 439 };
 440
 441 class wxTIFFHandler : public wxImageHandler {
 442 public:
 443     wxTIFFHandler();
 444 };
 445
 446
 447 #if wxUSE_IFF
 448 class wxIFFHandler : public wxImageHandler {
 449 public:
 450     wxIFFHandler();
 451 };
 452 #endif
 453
 454 //---------------------------------------------------------------------------