include/wx/image.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        image.h
   3 // Purpose:     wxImage class
   4 // Author:      Robert Roebling
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #ifndef _WX_IMAGE_H_
  11 #define _WX_IMAGE_H_
  12
  13 #ifdef __GNUG__
  14 #pragma interface "image.h"
  15 #endif
  16
  17 #include "wx/setup.h"
  18 #include "wx/object.h"
  19 #include "wx/string.h"
  20 #include "wx/gdicmn.h"
  21 #include "wx/bitmap.h"
  22
  23 #if wxUSE_STREAMS
  24 #  include "wx/stream.h"
  25 #endif
  26
  27 //-----------------------------------------------------------------------------
  28 // classes
  29 //-----------------------------------------------------------------------------
  30
  31 class WXDLLEXPORT wxImageHandler;
  32 #if wxUSE_LIBPNG
  33 class WXDLLEXPORT wxPNGHandler;
  34 #endif
  35 #if wxUSE_LIBJPEG
  36 class WXDLLEXPORT wxJPEGHandler;
  37 #endif
  38 #if wxUSE_LIBTIFF
  39 class WXDLLEXPORT wxTIFFHandler;
  40 #endif
  41 class WXDLLEXPORT wxBMPHandler;
  42 #if wxUSE_GIF
  43 class WXDLLEXPORT wxGIFHandler;
  44 #endif
  45 #if wxUSE_PNM
  46 class WXDLLEXPORT wxPNMHandler;
  47 #endif
  48 #if wxUSE_PCX
  49 class WXDLLEXPORT wxPCXHandler;
  50 #endif
  51 class WXDLLEXPORT wxImage;
  52
  53 //-----------------------------------------------------------------------------
  54 // wxImageHandler
  55 //-----------------------------------------------------------------------------
  56
  57 class WXDLLEXPORT wxImageHandler: public wxObject
  58 {
  59   DECLARE_CLASS(wxImageHandler)
  60
  61 public:
  62   wxImageHandler() { m_name = ""; m_extension = ""; m_type = 0; }
  63
  64 #if wxUSE_STREAMS
  65   virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=TRUE, int index=0 );
  66   virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=TRUE );
  67
  68   virtual int GetImageCount( wxInputStream& stream );
  69
  70   bool CanRead( wxInputStream& stream ) { return DoCanRead(stream); }
  71   bool CanRead( const wxString& name );
  72 #endif
  73
  74   void SetName(const wxString& name) { m_name = name; }
  75   void SetExtension(const wxString& ext) { m_extension = ext; }
  76   void SetType(long type) { m_type = type; }
  77   void SetMimeType(const wxString& type) { m_mime = type; }
  78   wxString GetName() const { return m_name; }
  79   wxString GetExtension() const { return m_extension; }
  80   long GetType() const { return m_type; }
  81   wxString GetMimeType() const { return m_mime; }
  82
  83 protected:
  84   virtual bool DoCanRead( wxInputStream& stream ) = 0;
  85
  86   wxString  m_name;
  87   wxString  m_extension;
  88   wxString  m_mime;
  89   long      m_type;
  90
  91 };
  92
  93 //-----------------------------------------------------------------------------
  94 // wxPNGHandler
  95 //-----------------------------------------------------------------------------
  96
  97 #if wxUSE_LIBPNG
  98 class WXDLLEXPORT wxPNGHandler: public wxImageHandler
  99 {
 100   DECLARE_DYNAMIC_CLASS(wxPNGHandler)
 101
 102 public:
 103
 104   inline wxPNGHandler()
 105   {
 106       m_name = "PNG file";
 107       m_extension = "png";
 108       m_type = wxBITMAP_TYPE_PNG;
 109       m_mime = "image/png";
 110   };
 111
 112 #if wxUSE_STREAMS
 113   virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=TRUE, int index=0 );
 114   virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=TRUE );
 115   virtual bool DoCanRead( wxInputStream& stream );
 116 #endif
 117 };
 118 #endif
 119
 120 //-----------------------------------------------------------------------------
 121 // wxJPEGHandler
 122 //-----------------------------------------------------------------------------
 123
 124 #if wxUSE_LIBJPEG
 125 class WXDLLEXPORT wxJPEGHandler: public wxImageHandler
 126 {
 127   DECLARE_DYNAMIC_CLASS(wxJPEGHandler)
 128
 129 public:
 130
 131   inline wxJPEGHandler()
 132   {
 133       m_name = "JPEG file";
 134       m_extension = "jpg";
 135       m_type = wxBITMAP_TYPE_JPEG;
 136       m_mime = "image/jpeg";
 137   };
 138
 139 #if wxUSE_STREAMS
 140   virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=TRUE, int index=0 );
 141   virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=TRUE );
 142   virtual bool DoCanRead( wxInputStream& stream );
 143 #endif
 144 };
 145 #endif
 146
 147 //-----------------------------------------------------------------------------
 148 // wxTIFFHandler
 149 //-----------------------------------------------------------------------------
 150
 151 #if wxUSE_LIBTIFF
 152 class WXDLLEXPORT wxTIFFHandler: public wxImageHandler
 153 {
 154   DECLARE_DYNAMIC_CLASS(wxTIFFHandler)
 155
 156 public:
 157
 158   inline wxTIFFHandler()
 159   {
 160       m_name = "TIFF file";
 161       m_extension = "tif";
 162       m_type = wxBITMAP_TYPE_TIF;
 163       m_mime = "image/tiff";
 164   };
 165
 166 #if wxUSE_STREAMS
 167   virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=TRUE, int index=0 );
 168   virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=TRUE );
 169   virtual bool DoCanRead( wxInputStream& stream );
 170   virtual int GetImageCount( wxInputStream& stream );
 171 #endif
 172 };
 173 #endif
 174
 175 //-----------------------------------------------------------------------------
 176 // wxBMPHandler
 177 //-----------------------------------------------------------------------------
 178
 179 class WXDLLEXPORT wxBMPHandler: public wxImageHandler
 180 {
 181   DECLARE_DYNAMIC_CLASS(wxBMPHandler)
 182
 183 public:
 184
 185   inline wxBMPHandler()
 186   {
 187       m_name = "BMP file";
 188       m_extension = "bmp";
 189       m_type = wxBITMAP_TYPE_BMP;
 190       m_mime = "image/bmp";
 191   };
 192
 193 #if wxUSE_STREAMS
 194   virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=TRUE, int index=0 );
 195   virtual bool DoCanRead( wxInputStream& stream );
 196 #endif
 197 };
 198
 199 //-----------------------------------------------------------------------------
 200 // wxGIFHandler
 201 //-----------------------------------------------------------------------------
 202
 203 #if wxUSE_GIF
 204
 205 class WXDLLEXPORT wxGIFHandler : public wxImageHandler
 206 {
 207   DECLARE_DYNAMIC_CLASS(wxGIFHandler)
 208
 209 public:
 210
 211   inline wxGIFHandler()
 212   {
 213       m_name = "GIF file";
 214       m_extension = "gif";
 215       m_type = wxBITMAP_TYPE_GIF;
 216       m_mime = "image/gif";
 217   };
 218
 219 #if wxUSE_STREAMS
 220   virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=TRUE, int index=0 );
 221   virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=TRUE );
 222   virtual bool DoCanRead( wxInputStream& stream );
 223 #endif
 224 };
 225 #endif
 226
 227 //-----------------------------------------------------------------------------
 228 // wxPNMHandler
 229 //-----------------------------------------------------------------------------
 230
 231 #if wxUSE_PNM
 232 class WXDLLEXPORT wxPNMHandler : public wxImageHandler
 233 {
 234   DECLARE_DYNAMIC_CLASS(wxPNMHandler)
 235
 236 public:
 237
 238   inline wxPNMHandler()
 239   {
 240       m_name = "PNM file";
 241       m_extension = "pnm";
 242       m_type = wxBITMAP_TYPE_PNM;
 243       m_mime = "image/pnm";
 244   };
 245
 246 #if wxUSE_STREAMS
 247   virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=TRUE, int index=0 );
 248   virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=TRUE );
 249   virtual bool DoCanRead( wxInputStream& stream );
 250 #endif
 251 };
 252 #endif
 253
 254 //-----------------------------------------------------------------------------
 255 // wxPCXHandler
 256 //-----------------------------------------------------------------------------
 257
 258 #if wxUSE_PCX
 259 class WXDLLEXPORT wxPCXHandler : public wxImageHandler
 260 {
 261   DECLARE_DYNAMIC_CLASS(wxPCXHandler)
 262
 263 public:
 264
 265   inline wxPCXHandler()
 266   {
 267       m_name = "PCX file";
 268       m_extension = "pcx";
 269       m_type = wxBITMAP_TYPE_PCX;
 270       m_mime = "image/pcx";
 271   };
 272
 273 #if wxUSE_STREAMS
 274   virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=TRUE, int index=0 );
 275   virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=TRUE );
 276   virtual bool DoCanRead( wxInputStream& stream );
 277 #endif // wxUSE_STREAMS
 278 };
 279 #endif // wxUSE_PCX
 280
 281 //-----------------------------------------------------------------------------
 282 // wxImage
 283 //-----------------------------------------------------------------------------
 284
 285
 286 // GRG: Dic/99
 287 class WXDLLEXPORT wxHNode
 288 {
 289 public:
 290     unsigned long index;
 291     unsigned long value;
 292 };
 293
 294
 295 class WXDLLEXPORT wxImage: public wxObject
 296 {
 297   DECLARE_DYNAMIC_CLASS(wxImage)
 298
 299   friend class WXDLLEXPORT wxImageHandler;
 300
 301 public:
 302
 303   wxImage();
 304   wxImage( int width, int height );
 305   wxImage( const wxString& name, long type = wxBITMAP_TYPE_ANY );
 306   wxImage( wxInputStream& stream, long type = wxBITMAP_TYPE_ANY );
 307   wxImage( const wxString& name, const wxString& mimetype );
 308   wxImage( wxInputStream& stream, const wxString& mimetype );
 309
 310   wxImage( const wxImage& image );
 311   wxImage( const wxImage* image );
 312
 313   // these functions get implemented in /src/(platform)/bitmap.cpp
 314   wxImage( const wxBitmap &bitmap );
 315   operator wxBitmap() const { return ConvertToBitmap(); }
 316   wxBitmap ConvertToBitmap() const;
 317
 318   void Create( int width, int height );
 319   void Destroy();
 320
 321   // return the new image with size width*height
 322   wxImage GetSubImage( const wxRect& ) const;
 323
 324   // return the new image with size width*height
 325   wxImage Scale( int width, int height ) const;
 326
 327   // rescales the image in place
 328   void Rescale( int width, int height ) { *this = Scale(width, height); }
 329
 330   // these routines are slow but safe
 331   void SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b );
 332   unsigned char GetRed( int x, int y );
 333   unsigned char GetGreen( int x, int y );
 334   unsigned char GetBlue( int x, int y );
 335
 336   static bool CanRead( const wxString& name );
 337   virtual bool LoadFile( const wxString& name, long type = wxBITMAP_TYPE_ANY );
 338   virtual bool LoadFile( const wxString& name, const wxString& mimetype );
 339
 340 #if wxUSE_STREAMS
 341   static bool CanRead( wxInputStream& stream );
 342   virtual bool LoadFile( wxInputStream& stream, long type = wxBITMAP_TYPE_ANY );
 343   virtual bool LoadFile( wxInputStream& stream, const wxString& mimetype );
 344 #endif
 345
 346   virtual bool SaveFile( const wxString& name, int type );
 347   virtual bool SaveFile( const wxString& name, const wxString& mimetype );
 348
 349 #if wxUSE_STREAMS
 350   virtual bool SaveFile( wxOutputStream& stream, int type );
 351   virtual bool SaveFile( wxOutputStream& stream, const wxString& mimetype );
 352 #endif
 353
 354   bool Ok() const;
 355   int GetWidth() const;
 356   int GetHeight() const;
 357
 358   char unsigned *GetData() const;
 359   void SetData( char unsigned *data );
 360
 361   void SetMaskColour( unsigned char r, unsigned char g, unsigned char b );
 362   unsigned char GetMaskRed() const;
 363   unsigned char GetMaskGreen() const;
 364   unsigned char GetMaskBlue() const;
 365   void SetMask( bool mask = TRUE );
 366   bool HasMask() const;
 367
 368   wxImage& operator = (const wxImage& image)
 369   {
 370     if ( (*this) != image )
 371       Ref(image);
 372     return *this;
 373   }
 374
 375   bool operator == (const wxImage& image)
 376     { return m_refData == image.m_refData; }
 377   bool operator != (const wxImage& image)
 378     { return m_refData != image.m_refData; }
 379
 380   static wxList& GetHandlers() { return sm_handlers; }
 381   static void AddHandler( wxImageHandler *handler );
 382   static void InsertHandler( wxImageHandler *handler );
 383   static bool RemoveHandler( const wxString& name );
 384   static wxImageHandler *FindHandler( const wxString& name );
 385   static wxImageHandler *FindHandler( const wxString& extension, long imageType );
 386   static wxImageHandler *FindHandler( long imageType );
 387   static wxImageHandler *FindHandlerMime( const wxString& mimetype );
 388
 389   static void CleanUpHandlers();
 390   static void InitStandardHandlers();
 391
 392   // GRG: Dic/99
 393   unsigned long CountColours( unsigned long stopat = -1 );
 394   unsigned long ComputeHistogram( wxHashTable &h );
 395
 396
 397 protected:
 398
 399   static wxList sm_handlers;
 400
 401 };
 402
 403 extern void WXDLLEXPORT wxInitAllImageHandlers();
 404
 405 #endif
 406   // _WX_IMAGE_H_
 407