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 class WXDLLEXPORT wxBMPHandler;
  39 #if wxUSE_GIF
  40 class WXDLLEXPORT wxGIFHandler;
  41 #endif
  42 #if wxUSE_PNM
  43 class WXDLLEXPORT wxPNMHandler;
  44 #endif
  45 #if wxUSE_PCX
  46 class WXDLLEXPORT wxPCXHandler;
  47 #endif
  48 class WXDLLEXPORT wxImage;
  49
  50 //-----------------------------------------------------------------------------
  51 // wxImageHandler
  52 //-----------------------------------------------------------------------------
  53
  54 class WXDLLEXPORT wxImageHandler: public wxObject
  55 {
  56   DECLARE_DYNAMIC_CLASS(wxImageHandler)
  57
  58 public:
  59   wxImageHandler() { m_name = ""; m_extension = ""; m_type = 0; }
  60
  61 #if wxUSE_STREAMS
  62   virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=TRUE );
  63   virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=TRUE );
  64
  65   bool CanRead( wxInputStream& stream ) { return DoCanRead(stream); }
  66   bool CanRead( const wxString& name );
  67 #endif
  68
  69   void SetName(const wxString& name) { m_name = name; }
  70   void SetExtension(const wxString& ext) { m_extension = ext; }
  71   void SetType(long type) { m_type = type; }
  72   void SetMimeType(const wxString& type) { m_mime = type; }
  73   wxString GetName() const { return m_name; }
  74   wxString GetExtension() const { return m_extension; }
  75   long GetType() const { return m_type; }
  76   wxString GetMimeType() const { return m_mime; }
  77
  78 protected:
  79   virtual bool DoCanRead( wxInputStream& stream ) = 0;
  80
  81   wxString  m_name;
  82   wxString  m_extension;
  83   wxString  m_mime;
  84   long      m_type;
  85
  86 };
  87
  88 //-----------------------------------------------------------------------------
  89 // wxPNGHandler
  90 //-----------------------------------------------------------------------------
  91
  92 #if wxUSE_LIBPNG
  93 class WXDLLEXPORT wxPNGHandler: public wxImageHandler
  94 {
  95   DECLARE_DYNAMIC_CLASS(wxPNGHandler)
  96
  97 public:
  98
  99   inline wxPNGHandler()
 100   {
 101       m_name = "PNG file";
 102       m_extension = "png";
 103       m_type = wxBITMAP_TYPE_PNG;
 104       m_mime = "image/png";
 105   };
 106
 107 #if wxUSE_STREAMS
 108   virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=TRUE );
 109   virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=TRUE );
 110   virtual bool DoCanRead( wxInputStream& stream );
 111 #endif
 112 };
 113 #endif
 114
 115 //-----------------------------------------------------------------------------
 116 // wxJPEGHandler
 117 //-----------------------------------------------------------------------------
 118
 119 #if wxUSE_LIBJPEG
 120 class WXDLLEXPORT wxJPEGHandler: public wxImageHandler
 121 {
 122   DECLARE_DYNAMIC_CLASS(wxJPEGHandler)
 123
 124 public:
 125
 126   inline wxJPEGHandler()
 127   {
 128       m_name = "JPEG file";
 129       m_extension = "jpg";
 130       m_type = wxBITMAP_TYPE_JPEG;
 131       m_mime = "image/jpeg";
 132   };
 133
 134 #if wxUSE_STREAMS
 135   virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=TRUE );
 136   virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=TRUE );
 137   virtual bool DoCanRead( wxInputStream& stream );
 138 #endif
 139 };
 140 #endif
 141
 142 //-----------------------------------------------------------------------------
 143 // wxBMPHandler
 144 //-----------------------------------------------------------------------------
 145
 146 class WXDLLEXPORT wxBMPHandler: public wxImageHandler
 147 {
 148   DECLARE_DYNAMIC_CLASS(wxBMPHandler)
 149
 150 public:
 151
 152   inline wxBMPHandler()
 153   {
 154       m_name = "BMP file";
 155       m_extension = "bmp";
 156       m_type = wxBITMAP_TYPE_BMP;
 157       m_mime = "image/bmp";
 158   };
 159
 160 #if wxUSE_STREAMS
 161   virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=TRUE );
 162   virtual bool DoCanRead( wxInputStream& stream );
 163 #endif
 164 };
 165
 166 //-----------------------------------------------------------------------------
 167 // wxGIFHandler
 168 //-----------------------------------------------------------------------------
 169
 170 #if wxUSE_GIF
 171
 172 class WXDLLEXPORT wxGIFHandler : public wxImageHandler
 173 {
 174   DECLARE_DYNAMIC_CLASS(wxGIFHandler)
 175
 176 public:
 177
 178   inline wxGIFHandler()
 179   {
 180       m_name = "GIF file";
 181       m_extension = "gif";
 182       m_type = wxBITMAP_TYPE_GIF;
 183       m_mime = "image/gif";
 184   };
 185
 186 #if wxUSE_STREAMS
 187   virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=TRUE );
 188   virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=TRUE );
 189   virtual bool DoCanRead( wxInputStream& stream );
 190 #endif
 191 };
 192 #endif
 193
 194 //-----------------------------------------------------------------------------
 195 // wxPNMHandler
 196 //-----------------------------------------------------------------------------
 197
 198 #if wxUSE_PNM
 199 class WXDLLEXPORT wxPNMHandler : public wxImageHandler
 200 {
 201   DECLARE_DYNAMIC_CLASS(wxPNMHandler)
 202
 203 public:
 204
 205   inline wxPNMHandler()
 206   {
 207       m_name = "PNM file";
 208       m_extension = "pnm";
 209       m_type = wxBITMAP_TYPE_PNM;
 210       m_mime = "image/pnm";
 211   };
 212
 213 #if wxUSE_STREAMS
 214   virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=TRUE );
 215   virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=TRUE );
 216   virtual bool DoCanRead( wxInputStream& stream );
 217 #endif
 218 };
 219 #endif
 220
 221 //-----------------------------------------------------------------------------
 222 // wxPCXHandler
 223 //-----------------------------------------------------------------------------
 224
 225 #if wxUSE_PCX
 226 class WXDLLEXPORT wxPCXHandler : public wxImageHandler
 227 {
 228   DECLARE_DYNAMIC_CLASS(wxPCXHandler)
 229
 230 public:
 231
 232   inline wxPCXHandler()
 233   {
 234       m_name = "PCX file";
 235       m_extension = "pcx";
 236       m_type = wxBITMAP_TYPE_PCX;
 237       m_mime = "image/pcx";
 238   };
 239
 240 #if wxUSE_STREAMS
 241   virtual bool LoadFile( wxImage *image, wxInputStream& stream, bool verbose=TRUE );
 242   virtual bool SaveFile( wxImage *image, wxOutputStream& stream, bool verbose=TRUE );
 243   virtual bool DoCanRead( wxInputStream& stream );
 244 };
 245 #endif
 246
 247 //-----------------------------------------------------------------------------
 248 // wxImage
 249 //-----------------------------------------------------------------------------
 250
 251 class WXDLLEXPORT wxImage: public wxObject
 252 {
 253   DECLARE_DYNAMIC_CLASS(wxImage)
 254
 255   friend class WXDLLEXPORT wxImageHandler;
 256
 257 public:
 258
 259   wxImage();
 260   wxImage( int width, int height );
 261   wxImage( const wxString& name, long type = wxBITMAP_TYPE_ANY );
 262   wxImage( wxInputStream& stream, long type = wxBITMAP_TYPE_ANY );
 263   wxImage( const wxString& name, const wxString& mimetype );
 264   wxImage( wxInputStream& stream, const wxString& mimetype );
 265
 266   wxImage( const wxImage& image );
 267   wxImage( const wxImage* image );
 268
 269   // these functions get implemented in /src/(platform)/bitmap.cpp
 270   wxImage( const wxBitmap &bitmap );
 271   operator wxBitmap() const { return ConvertToBitmap(); }
 272   wxBitmap ConvertToBitmap() const;
 273
 274   void Create( int width, int height );
 275   void Destroy();
 276
 277   // return the new image with size width*height
 278   wxImage GetSubImage( const wxRect& ) const;
 279
 280   // return the new image with size width*height
 281   wxImage Scale( int width, int height ) const;
 282
 283   // rescales the image in place
 284   void Rescale( int width, int height ) { *this = Scale(width, height); }
 285
 286   // these routines are slow but safe
 287   void SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b );
 288   unsigned char GetRed( int x, int y );
 289   unsigned char GetGreen( int x, int y );
 290   unsigned char GetBlue( int x, int y );
 291
 292   virtual bool LoadFile( const wxString& name, long type = wxBITMAP_TYPE_ANY );
 293   virtual bool LoadFile( const wxString& name, const wxString& mimetype );
 294
 295 #if wxUSE_STREAMS
 296   virtual bool LoadFile( wxInputStream& stream, long type = wxBITMAP_TYPE_ANY );
 297   virtual bool LoadFile( wxInputStream& stream, const wxString& mimetype );
 298 #endif
 299
 300   virtual bool SaveFile( const wxString& name, int type );
 301   virtual bool SaveFile( const wxString& name, const wxString& mimetype );
 302
 303 #if wxUSE_STREAMS
 304   virtual bool SaveFile( wxOutputStream& stream, int type );
 305   virtual bool SaveFile( wxOutputStream& stream, const wxString& mimetype );
 306 #endif
 307
 308   bool Ok() const;
 309   int GetWidth() const;
 310   int GetHeight() const;
 311
 312   char unsigned *GetData() const;
 313   void SetData( char unsigned *data );
 314
 315   void SetMaskColour( unsigned char r, unsigned char g, unsigned char b );
 316   unsigned char GetMaskRed() const;
 317   unsigned char GetMaskGreen() const;
 318   unsigned char GetMaskBlue() const;
 319   void SetMask( bool mask = TRUE );
 320   bool HasMask() const;
 321
 322   wxImage& operator = (const wxImage& image)
 323   {
 324     if ( (*this) != image )
 325       Ref(image);
 326     return *this;
 327   }
 328
 329   bool operator == (const wxImage& image)
 330     { return m_refData == image.m_refData; }
 331   bool operator != (const wxImage& image)
 332     { return m_refData != image.m_refData; }
 333
 334   static wxList& GetHandlers() { return sm_handlers; }
 335   static void AddHandler( wxImageHandler *handler );
 336   static void InsertHandler( wxImageHandler *handler );
 337   static bool RemoveHandler( const wxString& name );
 338   static wxImageHandler *FindHandler( const wxString& name );
 339   static wxImageHandler *FindHandler( const wxString& extension, long imageType );
 340   static wxImageHandler *FindHandler( long imageType );
 341   static wxImageHandler *FindHandlerMime( const wxString& mimetype );
 342
 343   static void CleanUpHandlers();
 344   static void InitStandardHandlers();
 345
 346 protected:
 347
 348   static wxList sm_handlers;
 349
 350 };
 351
 352 extern void WXDLLEXPORT wxInitAllImageHandlers();
 353
 354 #endif
 355   // _WX_IMAGE_H_
 356