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
  24 enum {
  25     wxIMAGE_ALPHA_TRANSPARENT,
  26     wxIMAGE_ALPHA_THRESHOLD,
  27     wxIMAGE_ALPHA_OPAQUE
  28 };
  29
  30
  31 //---------------------------------------------------------------------------
  32 %newgroup
  33
  34 DocStr(wxImageHandler,
  35 "This is the base class for implementing image file loading/saving, and
  36 image creation from data. It is used within `wx.Image` and is not
  37 normally seen by the application.", "");
  38 class wxImageHandler : public wxObject {
  39 public:
  40     // wxImageHandler();    Abstract Base Class
  41     wxString GetName();
  42     wxString GetExtension();
  43     long GetType();
  44     wxString GetMimeType();
  45
  46     //bool LoadFile(wxImage* image, wxInputStream& stream);
  47     //bool SaveFile(wxImage* image, wxOutputStream& stream);
  48     //virtual int GetImageCount( wxInputStream& stream );
  49
  50     bool CanRead( const wxString& name );
  51     %Rename(CanReadStream, bool, CanRead( wxInputStream& stream ));
  52
  53     void SetName(const wxString& name);
  54     void SetExtension(const wxString& extension);
  55     void SetType(long type);
  56     void SetMimeType(const wxString& mimetype);
  57 };
  58
  59
  60 //---------------------------------------------------------------------------
  61
  62
  63 DocStr(wxPyImageHandler,
  64 "This is the base class for implementing image file loading/saving, and
  65 image creation from data, all written in Python.  To create a custom
  66 image handler derive a new class from wx.PyImageHandler and provide
  67 the following methods::
  68
  69     def DoCanRead(self, stream) --> bool
  70         '''Check if this handler can read the image on the stream'''
  71
  72     def LoadFile(self, image, stream, verbose, index) --> bool
  73         '''Load image data from the stream and load it into image.'''
  74
  75     def SaveFile(self, image, stream, verbose) --> bool
  76         '''Save the iamge data in image to the stream using
  77            this handler's image file format.'''
  78
  79     def GetImageCount(self, stream) --> int
  80         '''If this image format can hold more than one image,
  81            how many does the image on the stream have?'''
  82
  83 To activate your handler create an instance of it and pass it to
  84 `wx.Image_AddHandler`.  Be sure to call `SetName`, `SetType`, and
  85 `SetExtension` from your constructor.
  86 ", "");
  87
  88 class wxPyImageHandler: public wxImageHandler {
  89 public:
  90     %pythonAppend wxPyImageHandler() "self._SetSelf(self)"
  91     wxPyImageHandler();
  92     void _SetSelf(PyObject *self);
  93 };
  94
  95
  96 //---------------------------------------------------------------------------
  97
  98
  99 class wxImageHistogram /* : public wxImageHistogramBase */
 100 {
 101 public:
 102     wxImageHistogram();
 103
 104     DocStr(MakeKey, "Get the key in the histogram for the given RGB values", "");
 105     static unsigned long MakeKey(byte r,
 106                                  byte g,
 107                                  byte b);
 108
 109     DocDeclAStr(
 110         bool, FindFirstUnusedColour(byte *OUTPUT,
 111                                     byte *OUTPUT,
 112                                     byte *OUTPUT,
 113                                     byte startR = 1,
 114                                     byte startG = 0,
 115                                     byte startB = 0 ) const,
 116         "FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)",
 117         "Find first colour that is not used in the image and has higher RGB
 118 values than startR, startG, startB.  Returns a tuple consisting of a
 119 success flag and rgb values.", "");
 120
 121     %extend {
 122         DocStr(GetCount,
 123                "Returns the pixel count for the given key.  Use `MakeKey` to create a
 124 key value from a RGB tripple.", "");
 125         unsigned long GetCount(unsigned long key) {
 126             wxImageHistogramEntry e = (*self)[key];
 127             return e.value;
 128         }
 129
 130         DocStr(GetCountRGB,
 131                "Returns the pixel count for the given RGB values.", "");
 132         unsigned long GetCountRGB(byte r,
 133                                   byte g,
 134                                   byte b) {
 135             unsigned long key = wxImageHistogram::MakeKey(r, g, b);
 136             wxImageHistogramEntry e = (*self)[key];
 137             return e.value;
 138         }
 139
 140         DocStr(GetCountColour,
 141                "Returns the pixel count for the given `wx.Colour` value.", "");
 142         unsigned long GetCountColour(const wxColour& colour) {
 143             unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
 144                                                           colour.Green(),
 145                                                           colour.Blue());
 146             wxImageHistogramEntry e = (*self)[key];
 147             return e.value;
 148         }
 149     }
 150
 151 };
 152
 153
 154 //---------------------------------------------------------------------------
 155
 156 %{
 157     typedef unsigned char* buffer;
 158 %}
 159
 160 %typemap(in) (buffer data, int DATASIZE)
 161     { if (!PyArg_Parse($input, "t#", &$1, &$2)) SWIG_fail; }
 162
 163 %typemap(in) (buffer alpha, int ALPHASIZE)
 164     { if (!PyArg_Parse($input, "t#", &$1, &$2)) SWIG_fail; }
 165
 166 //---------------------------------------------------------------------------
 167
 168
 169 DocStr(wxImage,
 170 "A platform-independent image class.  An image can be created from
 171 data, or using `wx.Bitmap.ConvertToImage`, or loaded from a file in a
 172 variety of formats.  Functions are available to set and get image
 173 bits, so it can be used for basic image manipulation.
 174
 175 A wx.Image cannot be drawn directly to a `wx.DC`.  Instead, a
 176 platform-specific `wx.Bitmap` object must be created from it using the
 177 `wx.BitmapFromImage` constructor. This bitmap can then be drawn in a
 178 device context, using `wx.DC.DrawBitmap`.
 179
 180 One colour value of the image may be used as a mask colour which will
 181 lead to the automatic creation of a `wx.Mask` object associated to the
 182 bitmap object.
 183
 184 wx.Image supports alpha channel data, that is in addition to a byte
 185 for the red, green and blue colour components for each pixel it also
 186 stores a byte representing the pixel opacity. An alpha value of 0
 187 corresponds to a transparent pixel (null opacity) while a value of 255
 188 means that the pixel is 100% opaque.
 189
 190 Unlike RGB data, not all images have an alpha channel and before using
 191 `GetAlpha` you should check if this image contains an alpha channel
 192 with `HasAlpha`. Note that currently only images loaded from PNG files
 193 with transparency information will have an alpha channel.", "");
 194
 195
 196 %{
 197 // Pull the nested class out to the top level for SWIG's sake
 198 #define wxImage_RGBValue wxImage::RGBValue
 199 #define wxImage_HSVValue wxImage::HSVValue
 200 %}
 201
 202 DocStr(wxImage_RGBValue,
 203 "An object that contains values for red, green and blue which represent
 204 the value of a color. It is used by `wx.Image.HSVtoRGB` and
 205 `wx.Image.RGBtoHSV`, which converts between HSV color space and RGB
 206 color space.", "");
 207 class wxImage_RGBValue
 208 {
 209 public:
 210     DocCtorStr(
 211         wxImage_RGBValue(byte r=0, byte g=0, byte b=0),
 212         "Constructor.", "");
 213     byte red;
 214     byte green;
 215     byte blue;
 216 };
 217
 218
 219 DocStr(wxImage_HSVValue,
 220 "An object that contains values for hue, saturation and value which
 221 represent the value of a color.  It is used by `wx.Image.HSVtoRGB` and
 222 `wx.Image.RGBtoHSV`, which +converts between HSV color space and RGB
 223 color space.", "");
 224 class wxImage_HSVValue
 225 {
 226 public:
 227     DocCtorStr(
 228         wxImage_HSVValue(double h=0.0, double s=0.0, double v=0.0),
 229         "Constructor.", "");
 230     double hue;
 231     double saturation;
 232     double value;
 233 };
 234
 235
 236 class wxImage : public wxObject {
 237 public:
 238     %typemap(out) wxImage*;    // turn off this typemap
 239
 240     DocCtorStr(
 241         wxImage( const wxString& name, long type = wxBITMAP_TYPE_ANY, int index = -1 ),
 242         "Loads an image from a file.",
 243         "
 244     :param name:  Name of the file from which to load the image.
 245
 246     :param type: May be one of the following:
 247
 248         ====================    =======================================
 249         wx.BITMAP_TYPE_BMP      Load a Windows bitmap file.
 250         wx.BITMAP_TYPE_GIF      Load a GIF bitmap file.
 251         wx.BITMAP_TYPE_JPEG     Load a JPEG bitmap file.
 252         wx.BITMAP_TYPE_PNG      Load a PNG bitmap file.
 253         wx.BITMAP_TYPE_PCX      Load a PCX bitmap file.
 254         wx.BITMAP_TYPE_PNM      Load a PNM bitmap file.
 255         wx.BITMAP_TYPE_TIF      Load a TIFF bitmap file.
 256         wx.BITMAP_TYPE_XPM      Load a XPM bitmap file.
 257         wx.BITMAP_TYPE_ICO      Load a Windows icon file (ICO).
 258         wx.BITMAP_TYPE_CUR      Load a Windows cursor file (CUR).
 259         wx.BITMAP_TYPE_ANI      Load a Windows animated cursor file (ANI).
 260         wx.BITMAP_TYPE_ANY      Will try to autodetect the format.
 261         ====================    =======================================
 262
 263     :param index: Index of the image to load in the case that the
 264         image file contains multiple images. This is only used by GIF,
 265         ICO and TIFF handlers. The default value (-1) means to choose
 266         the default image and is interpreted as the first image (the
 267         one with index=0) by the GIF and TIFF handler and as the
 268         largest and most colourful one by the ICO handler.
 269
 270 :see: `wx.ImageFromMime`, `wx.ImageFromStream`, `wx.ImageFromStreamMime`,
 271       `wx.EmptyImage`, `wx.ImageFromBitmap`, `wx.ImageFromBuffer`,
 272       `wx.ImageFromData`, `wx.ImageFromDataWithAlpha`
 273 ");
 274
 275     ~wxImage();
 276
 277     // Alternate constructors
 278     DocCtorStrName(
 279         wxImage(const wxString& name, const wxString& mimetype, int index = -1),
 280         "Loads an image from a file, using a MIME type string (such as
 281 'image/jpeg') to specify image type.", "
 282
 283 :see: `wx.Image`",
 284         ImageFromMime);
 285
 286     DocCtorStrName(
 287         wxImage(wxInputStream& stream, long type = wxBITMAP_TYPE_ANY, int index = -1),
 288         "Loads an image from an input stream, or any readable Python file-like
 289 object.", "
 290
 291 :see: `wx.Image`",
 292         ImageFromStream);
 293
 294     DocCtorStrName(
 295         wxImage(wxInputStream& stream, const wxString& mimetype, int index = -1 ),
 296         "Loads an image from an input stream, or any readable Python file-like
 297 object, specifying the image format with a MIME type string.", "
 298
 299 :see: `wx.Image`",
 300         ImageFromStreamMime);
 301
 302     %extend {
 303         %RenameDocCtor(
 304             EmptyImage,
 305             "Construct an empty image of a given size, optionally setting all
 306 pixels to black.", "
 307
 308 :see: `wx.Image`",
 309             wxImage(int width=0, int height=0, bool clear = true))
 310             {
 311                 if (width > 0 && height > 0)
 312                     return new wxImage(width, height, clear);
 313                 else
 314                     return new wxImage;
 315             }
 316
 317
 318        MustHaveApp(wxImage(const wxBitmap &bitmap));
 319
 320         %RenameDocCtor(
 321             ImageFromBitmap,
 322             "Construct an Image from a `wx.Bitmap`.", "
 323
 324 :see: `wx.Image`",
 325             wxImage(const wxBitmap &bitmap))
 326             {
 327                 return new wxImage(bitmap.ConvertToImage());
 328             }
 329
 330         %RenameDocCtor(
 331             ImageFromData,
 332             "Construct an Image from a buffer of RGB bytes.  Accepts either a
 333 string or a buffer object holding the data and the length of the data
 334 must be width*height*3.", "
 335
 336 :see: `wx.Image`",
 337             wxImage(int width, int height, buffer data, int DATASIZE))
 338             {
 339                 if (DATASIZE != width*height*3) {
 340                     wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
 341                     return NULL;
 342                 }
 343
 344                 // Copy the source data so the wxImage can clean it up later
 345                 buffer copy = (buffer)malloc(DATASIZE);
 346                 if (copy == NULL) {
 347                     wxPyBLOCK_THREADS(PyErr_NoMemory());
 348                     return NULL;
 349                 }
 350                 memcpy(copy, data, DATASIZE);
 351                 return new wxImage(width, height, copy, false);
 352             }
 353
 354
 355         %RenameDocCtor(
 356             ImageFromDataWithAlpha,
 357             "Construct an Image from a buffer of RGB bytes with an Alpha channel.
 358 Accepts either a string or a buffer object holding the data and the
 359 length of the data must be width*height*3 bytes, and the length of the
 360 alpha data must be width*height bytes.", "
 361
 362 :see: `wx.Image`",
 363             wxImage(int width, int height, buffer data, int DATASIZE, buffer alpha, int ALPHASIZE))
 364             {
 365                 if (DATASIZE != width*height*3) {
 366                     wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
 367                     return NULL;
 368                 }
 369                 if (ALPHASIZE != width*height) {
 370                     wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
 371                     return NULL;
 372                 }
 373
 374                 // Copy the source data so the wxImage can clean it up later
 375                 buffer dcopy = (buffer)malloc(DATASIZE);
 376                 if (dcopy == NULL) {
 377                     wxPyBLOCK_THREADS(PyErr_NoMemory());
 378                     return NULL;
 379                 }
 380                 memcpy(dcopy, data, DATASIZE);
 381
 382                 buffer acopy = (buffer)malloc(ALPHASIZE);
 383                 if (acopy == NULL) {
 384                     wxPyBLOCK_THREADS(PyErr_NoMemory());
 385                     return NULL;
 386                 }
 387                 memcpy(acopy, alpha, ALPHASIZE);
 388
 389                 return new wxImage(width, height, dcopy, acopy, false);
 390             }
 391
 392        // NOTE: We need the junk parameter so the compiler will be able
 393        // differentiate from the two functions above.  It isn't used for
 394        // anything else.
 395         %RenameDocCtor(
 396             _ImageFromBuffer, ":see: `wx.ImageFromBuffer`", "",
 397             wxImage(int width, int height, buffer data, int DATASIZE, PyObject* junk))
 398             {
 399                 wxUnusedVar(junk);
 400                 if (DATASIZE != width*height*3) {
 401                     wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
 402                     return NULL;
 403                 }
 404                 return new wxImage(width, height, data, true);
 405             }
 406
 407         %RenameDocCtor(
 408             _ImageFromBufferWithAlpha, ":see: `wx.ImageFromBuffer`", "",
 409             wxImage(int width, int height, buffer data, int DATASIZE, buffer alpha, int ALPHASIZE, PyObject* junk))
 410             {
 411                 wxUnusedVar(junk);
 412                 if (DATASIZE != width*height*3) {
 413                     wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
 414                     return NULL;
 415                 }
 416                 if (ALPHASIZE != width*height) {
 417                     wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
 418                     return NULL;
 419                 }
 420                 return new wxImage(width, height, data, alpha, true);
 421             }
 422     }
 423
 424     // TODO: wxImage( char** xpmData );
 425
 426     // Turn the typemap back on again
 427     %typemap(out) wxImage* { $result = wxPyMake_wxObject($1, $owner); }
 428
 429
 430     DocDeclStr(
 431         void , Create( int width, int height, bool clear=true ),
 432         "Creates a fresh image.  If clear is ``True``, the new image will be
 433 initialized to black. Otherwise, the image data will be uninitialized.", "");
 434
 435     DocDeclStr(
 436         void , Destroy(),
 437         "Destroys the image data.", "");
 438
 439
 440     DocDeclStr(
 441         wxImage , Scale( int width, int height ),
 442         "Returns a scaled version of the image. This is also useful for scaling
 443 bitmaps in general as the only other way to scale bitmaps is to blit a
 444 `wx.MemoryDC` into another `wx.MemoryDC`.", "
 445
 446 :see: `Rescale`");
 447
 448     DocDeclStr(
 449         wxImage , ShrinkBy( int xFactor , int yFactor ) const ,
 450         "Return a version of the image scaled smaller by the given factors.", "");
 451
 452     DocDeclStr(
 453         wxImage& , Rescale(int width, int height),
 454         "Changes the size of the image in-place by scaling it: after a call to
 455 this function, the image will have the given width and height.
 456
 457 Returns the (modified) image itself.", "
 458
 459 :see: `Scale`");
 460
 461
 462     // resizes the image in place
 463     DocDeclStr(
 464         wxImage& , Resize( const wxSize& size, const wxPoint& pos,
 465                            int r = -1, int g = -1, int b = -1 ),
 466         "Changes the size of the image in-place without scaling it, by adding
 467 either a border with the given colour or cropping as necessary. The
 468 image is pasted into a new image with the given size and background
 469 colour at the position pos relative to the upper left of the new
 470 image. If red = green = blue = -1 then use either the current mask
 471 colour if set or find, use, and set a suitable mask colour for any
 472 newly exposed areas.
 473
 474 Returns the (modified) image itself.", "
 475
 476 :see: `Size`");
 477
 478
 479     DocDeclStr(
 480         void , SetRGB( int x, int y, byte r, byte g, byte b ),
 481         "Sets the pixel at the given coordinate. This routine performs
 482 bounds-checks for the coordinate so it can be considered a safe way to
 483 manipulate the data, but in some cases this might be too slow so that
 484 the data will have to be set directly. In that case you will have to
 485 get access to the image data using the `GetData` method.", "");
 486
 487
 488     DocDeclStrName(
 489             void, SetRGB( const wxRect& rect,
 490                           byte r, byte g, byte b ),
 491             "Sets the colour of the pixels within the given rectangle. This routine
 492 performs bounds-checks for the rectangle so it can be considered a
 493 safe way to manipulate the data.", "",
 494             SetRGBRect);
 495
 496     DocDeclStr(
 497         byte , GetRed( int x, int y ),
 498         "Returns the red intensity at the given coordinate.", "");
 499
 500     DocDeclStr(
 501         byte , GetGreen( int x, int y ),
 502         "Returns the green intensity at the given coordinate.", "");
 503
 504     DocDeclStr(
 505         byte , GetBlue( int x, int y ),
 506         "Returns the blue intensity at the given coordinate.", "");
 507
 508
 509     DocDeclStr(
 510         void , SetAlpha(int x, int y, byte alpha),
 511         "Sets the alpha value for the given pixel. This function should only be
 512 called if the image has alpha channel data, use `HasAlpha` to check
 513 for this.", "");
 514
 515     DocDeclStr(
 516         byte , GetAlpha(int x, int y),
 517         "Returns the alpha value for the given pixel. This function may only be
 518 called for the images with alpha channel, use `HasAlpha` to check for
 519 this.
 520
 521 The returned value is the *opacity* of the image, i.e. the value of 0
 522 corresponds to the fully transparent pixels while the value of 255 to
 523 the fully opaque pixels.", "");
 524
 525     DocDeclStr(
 526         bool , HasAlpha(),
 527         "Returns true if this image has alpha channel, false otherwise.", "
 528
 529 :see: `GetAlpha`, `SetAlpha`");
 530
 531
 532     DocDeclStr(
 533         void , InitAlpha(),
 534         "Initializes the image alpha channel data. It is an error to call it if
 535 the image already has alpha data. If it doesn't, alpha data will be by
 536 default initialized to all pixels being fully opaque. But if the image
 537 has a a mask colour, all mask pixels will be completely transparent.", "");
 538
 539
 540     DocDeclStr(
 541         bool , IsTransparent(int x, int y,
 542                              byte threshold = wxIMAGE_ALPHA_THRESHOLD) const,
 543         "Returns ``True`` if this pixel is masked or has an alpha value less
 544 than the spcified threshold.", "");
 545
 546
 547     // find first colour that is not used in the image and has higher
 548     // RGB values than <startR,startG,startB>
 549     DocDeclAStr(
 550         bool, FindFirstUnusedColour( byte *OUTPUT, byte *OUTPUT, byte *OUTPUT,
 551                                      byte startR = 0, byte startG = 0, byte startB = 0 ) const,
 552         "FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b)",
 553         "Find first colour that is not used in the image and has higher RGB
 554 values than startR, startG, startB.  Returns a tuple consisting of a
 555 success flag and rgb values.", "");
 556
 557
 558     DocDeclStr(
 559         bool , ConvertAlphaToMask(byte threshold = wxIMAGE_ALPHA_THRESHOLD),
 560         "If the image has alpha channel, this method converts it to mask. All
 561 pixels with alpha value less than ``threshold`` are replaced with the
 562 mask colour and the alpha channel is removed. The mask colour is
 563 chosen automatically using `FindFirstUnusedColour`.
 564
 565 If the image image doesn't have alpha channel, ConvertAlphaToMask does
 566 nothing.", "");
 567
 568
 569     DocDeclStr(
 570         bool , ConvertColourToAlpha( byte r, byte g, byte b ),
 571         "This method converts an image where the original alpha information is
 572 only available as a shades of a colour (actually shades of grey)
 573 typically when you draw anti-aliased text into a bitmap. The DC
 574 drawing routines draw grey values on the black background although
 575 they actually mean to draw white with differnt alpha values.  This
 576 method reverses it, assuming a black (!) background and white text.
 577 The method will then fill up the whole image with the colour given.", "");
 578
 579
 580
 581     DocDeclStr(
 582         bool , SetMaskFromImage(const wxImage & mask,
 583                                 byte mr, byte mg, byte mb),
 584         "Sets the image's mask so that the pixels that have RGB value of
 585 ``(mr,mg,mb)`` in ``mask`` will be masked in this image. This is done
 586 by first finding an unused colour in the image, setting this colour as
 587 the mask colour and then using this colour to draw all pixels in the
 588 image who corresponding pixel in mask has given RGB value.
 589
 590 Returns ``False`` if ``mask`` does not have same dimensions as the
 591 image or if there is no unused colour left. Returns ``True`` if the
 592 mask was successfully applied.
 593
 594 Note that this method involves computing the histogram, which is
 595 computationally intensive operation.", "");
 596
 597
 598 //      void DoFloodFill (wxCoord x, wxCoord y,
 599 //          const wxBrush & fillBrush,
 600 //          const wxColour& testColour,
 601 //          int style = wxFLOOD_SURFACE,
 602 //          int LogicalFunction = wxCOPY /* currently unused */ ) ;
 603
 604     DocDeclStr(
 605         static bool , CanRead( const wxString& filename ),
 606         "Returns True if the image handlers can read this file.", "");
 607
 608     DocDeclStr(
 609         static int , GetImageCount( const wxString& filename, long type = wxBITMAP_TYPE_ANY ),
 610         "If the image file contains more than one image and the image handler
 611 is capable of retrieving these individually, this function will return
 612 the number of available images.", "");
 613
 614
 615     DocDeclStr(
 616         bool , LoadFile( const wxString& name, long type = wxBITMAP_TYPE_ANY, int index = -1 ),
 617         "Loads an image from a file. If no handler type is provided, the
 618 library will try to autodetect the format.", "");
 619
 620     DocDeclStrName(
 621         bool , LoadFile( const wxString& name, const wxString& mimetype, int index = -1 ),
 622         "Loads an image from a file, specifying the image type with a MIME type
 623 string.", "",
 624         LoadMimeFile);
 625
 626
 627     DocDeclStr(
 628         bool , SaveFile( const wxString& name, int type ),
 629         "Saves an image in the named file.", "");
 630
 631
 632     DocDeclStrName(
 633         bool , SaveFile( const wxString& name, const wxString& mimetype ),
 634         "Saves an image in the named file.", "",
 635         SaveMimeFile);
 636
 637
 638     DocDeclStrName(
 639         static bool , CanRead( wxInputStream& stream ),
 640         "Returns True if the image handlers can read an image file from the
 641 data currently on the input stream, or a readable Python file-like
 642 object.", "",
 643         CanReadStream);
 644
 645
 646     DocDeclStrName(
 647         bool , LoadFile( wxInputStream& stream, long type = wxBITMAP_TYPE_ANY, int index = -1 ),
 648         "Loads an image from an input stream or a readable Python file-like
 649 object. If no handler type is provided, the library will try to
 650 autodetect the format.", "",
 651         LoadStream);
 652
 653
 654     DocDeclStrName(
 655         bool , LoadFile( wxInputStream& stream, const wxString& mimetype, int index = -1 ),
 656         "Loads an image from an input stream or a readable Python file-like
 657 object, using a MIME type string to specify the image file format.", "",
 658         LoadMimeStream);
 659
 660
 661     DocDeclStr(
 662         bool , Ok(),
 663         "Returns true if image data is present.", "");
 664
 665     DocDeclStr(
 666         int , GetWidth(),
 667         "Gets the width of the image in pixels.", "");
 668
 669     DocDeclStr(
 670         int , GetHeight(),
 671         "Gets the height of the image in pixels.", "");
 672
 673
 674     %extend {
 675         DocStr(GetSize,
 676                "Returns the size of the image in pixels.", "");
 677         wxSize GetSize() {
 678             wxSize size(self->GetWidth(), self->GetHeight());
 679             return size;
 680         }
 681     }
 682
 683
 684     DocDeclStr(
 685         wxImage , GetSubImage(const wxRect& rect),
 686         "Returns a sub image of the current one as long as the rect belongs
 687 entirely to the image.", "");
 688
 689
 690     DocDeclStr(
 691         wxImage , Size( const wxSize& size, const wxPoint& pos,
 692                         int r = -1, int g = -1, int b = -1 ) const,
 693         "Returns a resized version of this image without scaling it by adding
 694 either a border with the given colour or cropping as necessary. The
 695 image is pasted into a new image with the given size and background
 696 colour at the position ``pos`` relative to the upper left of the new
 697 image. If red = green = blue = -1 then use either the current mask
 698 colour if set or find, use, and set a suitable mask colour for any
 699 newly exposed areas.", "
 700
 701 :see: `Resize`");
 702
 703
 704     DocDeclStr(
 705         wxImage , Copy(),
 706         "Returns an identical copy of the image.", "");
 707
 708     DocDeclStr(
 709         void , Paste( const wxImage &image, int x, int y ),
 710         "Pastes ``image`` into this instance and takes care of the mask colour
 711 and any out of bounds problems.", "");
 712
 713
 714     //unsigned char *GetData();
 715     //void SetData( unsigned char *data );
 716
 717     %extend {
 718         DocStr(GetData,
 719                "Returns a string containing a copy of the RGB bytes of the image.", "");
 720         PyObject* GetData()
 721         {
 722             buffer data = self->GetData();
 723             int len = self->GetWidth() * self->GetHeight() * 3;
 724             PyObject* rv;
 725             wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
 726             return rv;
 727         }
 728         DocStr(SetData,
 729                "Resets the Image's RGB data from a buffer of RGB bytes.  Accepts
 730 either a string or a buffer object holding the data and the length of
 731 the data must be width*height*3.", "");
 732         void SetData(buffer data, int DATASIZE)
 733         {
 734             if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
 735                 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
 736                 return;
 737             }
 738             buffer copy = (buffer)malloc(DATASIZE);
 739             if (copy == NULL) {
 740                 wxPyBLOCK_THREADS(PyErr_NoMemory());
 741                 return;
 742             }
 743             memcpy(copy, data, DATASIZE);
 744             self->SetData(copy, false);
 745             // wxImage takes ownership of copy...
 746         }
 747
 748
 749         DocStr(GetDataBuffer,
 750                "Returns a writable Python buffer object that is pointing at the RGB
 751 image data buffer inside the wx.Image. You need to ensure that you do
 752 not use this buffer object after the image has been destroyed.", "");
 753         PyObject* GetDataBuffer()
 754         {
 755             buffer data = self->GetData();
 756             int len = self->GetWidth() * self->GetHeight() * 3;
 757             PyObject* rv;
 758             wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
 759             return rv;
 760         }
 761
 762         DocStr(SetDataBuffer,
 763                "Sets the internal image data pointer to point at a Python buffer
 764 object.  This can save making an extra copy of the data but you must
 765 ensure that the buffer object lives longer than the wx.Image does.", "");
 766         void SetDataBuffer(buffer data, int DATASIZE)
 767         {
 768             if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
 769                 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
 770                 return;
 771             }
 772             self->SetData(data, true);
 773         }
 774
 775
 776
 777         DocStr(GetAlphaData,
 778                "Returns a string containing a copy of the alpha bytes of the image.", "");
 779         PyObject* GetAlphaData() {
 780             buffer data = self->GetAlpha();
 781             if (! data) {
 782                 RETURN_NONE();
 783             } else {
 784                 int len = self->GetWidth() * self->GetHeight();
 785                 PyObject* rv;
 786                 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
 787                 return rv;
 788             }
 789         }
 790
 791         DocStr(SetAlphaData,
 792                "Resets the Image's alpha data from a buffer of bytes.  Accepts either
 793 a string or a buffer object holding the data and the length of the
 794 data must be width*height.", "");
 795         void SetAlphaData(buffer alpha, int ALPHASIZE)
 796         {
 797             if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
 798                 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
 799                 return;
 800             }
 801             buffer acopy = (buffer)malloc(ALPHASIZE);
 802             if (acopy == NULL) {
 803                 wxPyBLOCK_THREADS(PyErr_NoMemory());
 804                 return;
 805             }
 806             memcpy(acopy, alpha, ALPHASIZE);
 807             self->SetAlpha(acopy, false);
 808             // wxImage takes ownership of acopy...
 809         }
 810
 811
 812
 813         DocStr(GetAlphaBuffer,
 814                "Returns a writable Python buffer object that is pointing at the Alpha
 815 data buffer inside the wx.Image. You need to ensure that you do not
 816 use this buffer object after the image has been destroyed.", "");
 817         PyObject* GetAlphaBuffer()
 818         {
 819             buffer data = self->GetAlpha();
 820             int len = self->GetWidth() * self->GetHeight();
 821             PyObject* rv;
 822             wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
 823             return rv;
 824         }
 825
 826
 827         DocStr(SetAlphaBuffer,
 828                "Sets the internal image alpha pointer to point at a Python buffer
 829 object.  This can save making an extra copy of the data but you must
 830 ensure that the buffer object lives as long as the wx.Image does.", "");
 831         void SetAlphaBuffer(buffer alpha, int ALPHASIZE)
 832         {
 833             if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
 834                 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
 835                 return;
 836             }
 837             self->SetAlpha(alpha, true);
 838         }
 839     }
 840
 841
 842
 843     DocDeclStr(
 844         void , SetMaskColour( byte r, byte g, byte b ),
 845         "Sets the mask colour for this image (and tells the image to use the
 846 mask).", "");
 847
 848
 849     DocDeclAStr(
 850         /*bool*/ void , GetOrFindMaskColour( byte *OUTPUT,
 851                                              byte *OUTPUT,
 852                                              byte *OUTPUT ) const,
 853         "GetOrFindMaskColour() -> (r,g,b)",
 854         "Get the current mask colour or find a suitable colour.", "");
 855
 856
 857     DocDeclStr(
 858         byte , GetMaskRed(),
 859         "Gets the red component of the mask colour.", "");
 860
 861     DocDeclStr(
 862         byte , GetMaskGreen(),
 863         "Gets the green component of the mask colour.", "");
 864
 865     DocDeclStr(
 866         byte , GetMaskBlue(),
 867         "Gets the blue component of the mask colour.", "");
 868
 869     DocDeclStr(
 870         void , SetMask( bool mask = true ),
 871         "Specifies whether there is a mask or not. The area of the mask is
 872 determined by the current mask colour.", "");
 873
 874     DocDeclStr(
 875         bool , HasMask(),
 876         "Returns ``True`` if there is a mask active, ``False`` otherwise.", "");
 877
 878
 879     DocDeclStr(
 880         wxImage , Rotate(double angle, const wxPoint & centre_of_rotation,
 881                          bool interpolating = true, wxPoint * offset_after_rotation = NULL) const ,
 882         "Rotates the image about the given point, by ``angle`` radians. Passing
 883 ``True`` to ``interpolating`` results in better image quality, but is
 884 slower. If the image has a mask, then the mask colour is used for the
 885 uncovered pixels in the rotated image background. Otherwise, black
 886 will be used as the fill colour.
 887
 888 Returns the rotated image, leaving this image intact.", "");
 889
 890     DocDeclStr(
 891         wxImage , Rotate90( bool clockwise = true ) ,
 892         "Returns a copy of the image rotated 90 degrees in the direction
 893 indicated by ``clockwise``.", "");
 894
 895     DocDeclStr(
 896         wxImage , Mirror( bool horizontally = true ) ,
 897         "Returns a mirrored copy of the image. The parameter ``horizontally``
 898 indicates the orientation.", "");
 899
 900
 901     DocDeclStr(
 902         void , Replace( byte r1, byte g1, byte b1,
 903                         byte r2, byte g2, byte b2 ),
 904         "Replaces the colour specified by ``(r1,g1,b1)`` by the colour
 905 ``(r2,g2,b2)``.", "");
 906
 907     DocDeclStr(
 908         wxImage , ConvertToGreyscale( double lr = 0.299,
 909                                       double lg = 0.587,
 910                                       double lb = 0.114 ) const,
 911         "Convert to greyscale image. Uses the luminance component (Y) of the
 912 image.  The luma value (YUV) is calculated using (R * lr) + (G * lg) + (B * lb),
 913 defaults to ITU-T BT.601", "");
 914
 915
 916     DocDeclStr(
 917         wxImage , ConvertToMono( byte r, byte g, byte b ) const,
 918         "Returns monochromatic version of the image. The returned image has
 919 white colour where the original has ``(r,g,b)`` colour and black
 920 colour everywhere else.", "");
 921
 922
 923     DocDeclStr(
 924         void , SetOption(const wxString& name, const wxString& value),
 925         "Sets an image handler defined option.  For example, when saving as a
 926 JPEG file, the option ``wx.IMAGE_OPTION_QUALITY`` is used, which is a
 927 number between 0 and 100 (0 is terrible, 100 is very good).", "
 928
 929     ================================= ===
 930     wx.IMAGE_OPTION_BMP_FORMAT
 931     wx.IMAGE_OPTION_CUR_HOTSPOT_X
 932     wx.IMAGE_OPTION_CUR_HOTSPOT_Y
 933     wx.IMAGE_OPTION_RESOLUTION
 934     wx.IMAGE_OPTION_RESOLUTIONX
 935     wx.IMAGE_OPTION_RESOLUTIONY
 936     wx.IMAGE_OPTION_RESOLUTIONUNIT
 937     wx.IMAGE_OPTION_QUALITY
 938     wx.IMAGE_OPTION_BITSPERSAMPLE
 939     wx.IMAGE_OPTION_SAMPLESPERPIXEL
 940     wx.IMAGE_OPTION_COMPRESSION
 941     wx.IMAGE_OPTION_IMAGEDESCRIPTOR
 942     wx.IMAGE_OPTION_PNG_FORMAT
 943     wx.IMAGE_OPTION_PNG_BITDEPTH
 944     ================================= ===
 945
 946 :see: `HasOption`, `GetOption`, `GetOptionInt`, `SetOptionInt`");
 947
 948     DocDeclStrName(
 949         void,  SetOption(const wxString& name, int value),
 950         "Sets an image option as an integer.", "
 951
 952 :see: `HasOption`, `GetOption`, `GetOptionInt`, `SetOption`",
 953         SetOptionInt);
 954
 955     DocDeclStr(
 956         wxString , GetOption(const wxString& name) const,
 957         "Gets the value of an image handler option.", "
 958
 959 :see: `HasOption`, `GetOptionInt`, `SetOption`, `SetOptionInt`");
 960
 961     DocDeclStr(
 962         int , GetOptionInt(const wxString& name) const,
 963         "Gets the value of an image handler option as an integer.  If the given
 964 option is not present, the function returns 0.", "
 965
 966 :see: `HasOption`, `GetOption`, `SetOptionInt`, `SetOption`");
 967
 968     DocDeclStr(
 969         bool , HasOption(const wxString& name) const,
 970         "Returns true if the given option is present.", "
 971
 972 :see: `GetOption`, `GetOptionInt`, `SetOption`, `SetOptionInt`");
 973
 974
 975     unsigned long CountColours( unsigned long stopafter = (unsigned long) -1 );
 976     unsigned long ComputeHistogram( wxImageHistogram& h );
 977
 978     static void AddHandler( wxImageHandler *handler );
 979     static void InsertHandler( wxImageHandler *handler );
 980     static bool RemoveHandler( const wxString& name );
 981     %extend {
 982         static PyObject* GetHandlers() {
 983             wxList& list = wxImage::GetHandlers();
 984             return wxPy_ConvertList(&list);
 985         }
 986     }
 987
 988     DocDeclStr(
 989         static wxString , GetImageExtWildcard(),
 990         "Iterates all registered wxImageHandler objects, and returns a string
 991 containing file extension masks suitable for passing to file open/save
 992 dialog boxes.", "");
 993
 994
 995
 996 MustHaveApp(ConvertToBitmap);
 997 MustHaveApp(ConvertToMonoBitmap);
 998
 999     %extend {
1000         wxBitmap ConvertToBitmap(int depth=-1) {
1001             wxBitmap bitmap(*self, depth);
1002             return bitmap;
1003         }
1004
1005         wxBitmap ConvertToMonoBitmap( byte red,
1006                                       byte green,
1007                                       byte blue ) {
1008             wxImage mono = self->ConvertToMono( red, green, blue );
1009             wxBitmap bitmap( mono, 1 );
1010             return bitmap;
1011         }
1012     }
1013
1014
1015     DocDeclStr(
1016         void , RotateHue(double angle),
1017         "Rotates the hue of each pixel of the image. Hue is a double in the
1018 range -1.0..1.0 where -1.0 is -360 degrees and 1.0 is 360 degrees", "");
1019
1020     DocDeclStr(
1021         static wxImage_HSVValue , RGBtoHSV(wxImage_RGBValue rgb),
1022         "Converts a color in RGB color space to HSV color space.", "");
1023
1024     DocDeclStr(
1025         static wxImage_RGBValue , HSVtoRGB(wxImage_HSVValue hsv),
1026         "Converts a color in HSV color space to RGB color space.", "");
1027
1028
1029     %pythoncode { def __nonzero__(self): return self.Ok() }
1030 };
1031
1032
1033 %pythoncode {
1034 def ImageFromBuffer(width, height, dataBuffer, alphaBuffer=None):
1035     """
1036     Creates a `wx.Image` from the data in dataBuffer.  The dataBuffer
1037     parameter must be a Python object that implements the buffer
1038     interface, such as a string, array, etc.  The dataBuffer object is
1039     expected to contain a series of RGB bytes and be width*height*3
1040     bytes long.  A buffer object can optionally be supplied for the
1041     image's alpha channel data, and it is expected to be width*height
1042     bytes long.
1043
1044     A reference to the data and alpha buffer objects are kept with the
1045     wx.Image, so that they won't get deleted until after the wx.Image
1046     is deleted.  However please be aware that it is not guaranteed that
1047     an object won't move its memory buffer to a new location when it
1048     needs to resize its contents.  If that happens then the wx.Image
1049     will end up referring to an invalid memory location and could cause
1050     the application to crash.  Therefore care should be taken to not
1051     manipulate the objects used for the data and alpha buffers in a
1052     way that would cause them to change size.
1053     """
1054     if alphaBuffer is not None:
1055         image = _ImageFromBufferWithAlpha(width, height, dataBuffer, alphaBuffer, None)
1056     else:
1057         image = _ImageFromBuffer(width, height, dataBuffer, None)
1058     image._buffer = dataBuffer
1059     image._alpha = alphaBuffer
1060     return image
1061 }
1062
1063
1064 ///void wxInitAllImageHandlers();
1065
1066 %pythoncode {
1067     def InitAllImageHandlers():
1068         """
1069         The former functionality of InitAllImageHanders is now done internal to
1070         the _core_ extension module and so this function has become a simple NOP.
1071         """
1072         pass
1073 }
1074
1075
1076
1077 %immutable;
1078 const wxImage    wxNullImage;
1079 %mutable;
1080
1081 //---------------------------------------------------------------------------
1082
1083 MAKE_CONST_WXSTRING(IMAGE_OPTION_FILENAME);
1084 MAKE_CONST_WXSTRING(IMAGE_OPTION_BMP_FORMAT);
1085 MAKE_CONST_WXSTRING(IMAGE_OPTION_CUR_HOTSPOT_X);
1086 MAKE_CONST_WXSTRING(IMAGE_OPTION_CUR_HOTSPOT_Y);
1087 MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTION);
1088 MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTIONX);
1089 MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTIONY);
1090 MAKE_CONST_WXSTRING(IMAGE_OPTION_RESOLUTIONUNIT);
1091 MAKE_CONST_WXSTRING(IMAGE_OPTION_QUALITY);
1092
1093 enum
1094 {
1095     wxIMAGE_RESOLUTION_INCHES = 1,
1096     wxIMAGE_RESOLUTION_CM = 2
1097 };
1098
1099
1100 MAKE_CONST_WXSTRING(IMAGE_OPTION_BITSPERSAMPLE);
1101 MAKE_CONST_WXSTRING(IMAGE_OPTION_SAMPLESPERPIXEL);
1102 MAKE_CONST_WXSTRING(IMAGE_OPTION_COMPRESSION);
1103 MAKE_CONST_WXSTRING(IMAGE_OPTION_IMAGEDESCRIPTOR);
1104
1105 MAKE_CONST_WXSTRING(IMAGE_OPTION_PNG_FORMAT);
1106 MAKE_CONST_WXSTRING(IMAGE_OPTION_PNG_BITDEPTH);
1107
1108 enum
1109 {
1110     wxPNG_TYPE_COLOUR = 0,
1111     wxPNG_TYPE_GREY = 2,
1112     wxPNG_TYPE_GREY_RED = 3
1113 };
1114
1115 enum
1116 {
1117     wxBMP_24BPP        = 24, // default, do not need to set
1118     //wxBMP_16BPP      = 16, // wxQuantize can only do 236 colors?
1119     wxBMP_8BPP         =  8, // 8bpp, quantized colors
1120     wxBMP_8BPP_GREY    =  9, // 8bpp, rgb averaged to greys
1121     wxBMP_8BPP_GRAY    =  wxBMP_8BPP_GREY,
1122     wxBMP_8BPP_RED     = 10, // 8bpp, red used as greyscale
1123     wxBMP_8BPP_PALETTE = 11, // 8bpp, use the wxImage's palette
1124     wxBMP_4BPP         =  4, // 4bpp, quantized colors
1125     wxBMP_1BPP         =  1, // 1bpp, quantized "colors"
1126     wxBMP_1BPP_BW      =  2  // 1bpp, black & white from red
1127 };
1128
1129
1130 DocStr(wxBMPHandler,
1131 "A `wx.ImageHandler` for \*.bmp bitmap files.", "");
1132 class wxBMPHandler : public wxImageHandler {
1133 public:
1134     wxBMPHandler();
1135 };
1136
1137 DocStr(wxICOHandler,
1138 "A `wx.ImageHandler` for \*.ico icon files.", "");
1139 class wxICOHandler : public wxBMPHandler {
1140 public:
1141     wxICOHandler();
1142 };
1143
1144 DocStr(wxCURHandler,
1145 "A `wx.ImageHandler` for \*.cur cursor files.", "");
1146 class wxCURHandler : public wxICOHandler {
1147 public:
1148     wxCURHandler();
1149 };
1150
1151 DocStr(wxANIHandler,
1152 "A `wx.ImageHandler` for \*.ani animated cursor files.", "");
1153 class wxANIHandler : public wxCURHandler {
1154 public:
1155     wxANIHandler();
1156 };
1157
1158
1159 //---------------------------------------------------------------------------
1160
1161 DocStr(wxPNGHandler,
1162 "A `wx.ImageHandler` for PNG image files.", "");
1163 class wxPNGHandler : public wxImageHandler {
1164 public:
1165     wxPNGHandler();
1166 };
1167
1168
1169 DocStr(wxGIFHandler,
1170 "A `wx.ImageHandler` for GIF image files.", "");
1171 class wxGIFHandler : public wxImageHandler {
1172 public:
1173     wxGIFHandler();
1174 };
1175
1176
1177 DocStr(wxPCXHandler,
1178 "A `wx.ImageHandler` for PCX imager files.", "");
1179 class wxPCXHandler : public wxImageHandler {
1180 public:
1181     wxPCXHandler();
1182 };
1183
1184
1185 DocStr(wxJPEGHandler,
1186 "A `wx.ImageHandler` for JPEG/JPG image files.", "");
1187 class wxJPEGHandler : public wxImageHandler {
1188 public:
1189     wxJPEGHandler();
1190 };
1191
1192
1193 DocStr(wxPNMHandler,
1194 "A `wx.ImageHandler` for PNM image files.", "");
1195 class wxPNMHandler : public wxImageHandler {
1196 public:
1197     wxPNMHandler();
1198 };
1199
1200 DocStr(wxXPMHandler,
1201 "A `wx.ImageHandler` for XPM image.", "");
1202 class wxXPMHandler : public wxImageHandler {
1203 public:
1204     wxXPMHandler();
1205 };
1206
1207 DocStr(wxTIFFHandler,
1208 "A `wx.ImageHandler` for TIFF image files.", "");
1209 class wxTIFFHandler : public wxImageHandler {
1210 public:
1211     wxTIFFHandler();
1212 };
1213
1214
1215 #if wxUSE_IFF
1216 DocStr(wxIFFHandler,
1217 "A `wx.ImageHandler` for IFF image files.", "");
1218 class wxIFFHandler : public wxImageHandler {
1219 public:
1220     wxIFFHandler();
1221 };
1222 #endif
1223
1224 //---------------------------------------------------------------------------
1225
1226 %{
1227 #include <wx/quantize.h>
1228 %}
1229
1230 enum {
1231     wxQUANTIZE_INCLUDE_WINDOWS_COLOURS,
1232 //    wxQUANTIZE_RETURN_8BIT_DATA,
1233     wxQUANTIZE_FILL_DESTINATION_IMAGE
1234 };
1235
1236
1237 DocStr(wxQuantize,
1238        "Performs quantization, or colour reduction, on a wxImage.", "");
1239
1240 class wxQuantize /*: public wxObject */
1241 {
1242 public:
1243
1244     %extend {
1245         DocStr(
1246             Quantize,
1247             "Reduce the colours in the source image and put the result into the
1248 destination image, setting the palette in the destination if
1249 needed. Both images may be the same, to overwrite the source image.", "
1250 :todo: Create a version that returns the wx.Palette used.");
1251
1252         static bool Quantize(const wxImage& src, wxImage& dest, int desiredNoColours = 236,
1253                              int flags = wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE)
1254         {
1255                 return wxQuantize::Quantize(src, dest,
1256                                             //NULL, // palette
1257                                             desiredNoColours,
1258                                             NULL, // eightBitData
1259                                             flags);
1260         }
1261     }
1262 };
1263
1264
1265 //---------------------------------------------------------------------------