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_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 #endif // wxUSE_STREAMS
 245 };
 246 #endif // wxUSE_PCX
 247
 248 //-----------------------------------------------------------------------------
 249 // wxImage
 250 //-----------------------------------------------------------------------------
 251
 252 class WXDLLEXPORT wxImage: public wxObject
 253 {
 254   DECLARE_DYNAMIC_CLASS(wxImage)
 255
 256   friend class WXDLLEXPORT wxImageHandler;
 257
 258 public:
 259
 260   wxImage();
 261   wxImage( int width, int height );
 262   wxImage( const wxString& name, long type = wxBITMAP_TYPE_ANY );
 263   wxImage( wxInputStream& stream, long type = wxBITMAP_TYPE_ANY );
 264   wxImage( const wxString& name, const wxString& mimetype );
 265   wxImage( wxInputStream& stream, const wxString& mimetype );
 266
 267   wxImage( const wxImage& image );
 268   wxImage( const wxImage* image );
 269
 270   // these functions get implemented in /src/(platform)/bitmap.cpp
 271   wxImage( const wxBitmap &bitmap );
 272   operator wxBitmap() const { return ConvertToBitmap(); }
 273   wxBitmap ConvertToBitmap() const;
 274
 275   void Create( int width, int height );
 276   void Destroy();
 277
 278   // return the new image with size width*height
 279   wxImage GetSubImage( const wxRect& ) const;
 280
 281   // return the new image with size width*height
 282   wxImage Scale( int width, int height ) const;
 283
 284   // rescales the image in place
 285   void Rescale( int width, int height ) { *this = Scale(width, height); }
 286
 287   // these routines are slow but safe
 288   void SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b );
 289   unsigned char GetRed( int x, int y );
 290   unsigned char GetGreen( int x, int y );
 291   unsigned char GetBlue( int x, int y );
 292
 293   static bool CanRead( const wxString& name );
 294   virtual bool LoadFile( const wxString& name, long type = wxBITMAP_TYPE_ANY );
 295   virtual bool LoadFile( const wxString& name, const wxString& mimetype );
 296
 297 #if wxUSE_STREAMS
 298   static bool CanRead( wxInputStream& stream );
 299   virtual bool LoadFile( wxInputStream& stream, long type = wxBITMAP_TYPE_ANY );
 300   virtual bool LoadFile( wxInputStream& stream, const wxString& mimetype );
 301 #endif
 302
 303   virtual bool SaveFile( const wxString& name, int type );
 304   virtual bool SaveFile( const wxString& name, const wxString& mimetype );
 305
 306 #if wxUSE_STREAMS
 307   virtual bool SaveFile( wxOutputStream& stream, int type );
 308   virtual bool SaveFile( wxOutputStream& stream, const wxString& mimetype );
 309 #endif
 310
 311   bool Ok() const;
 312   int GetWidth() const;
 313   int GetHeight() const;
 314
 315   char unsigned *GetData() const;
 316   void SetData( char unsigned *data );
 317
 318   void SetMaskColour( unsigned char r, unsigned char g, unsigned char b );
 319   unsigned char GetMaskRed() const;
 320   unsigned char GetMaskGreen() const;
 321   unsigned char GetMaskBlue() const;
 322   void SetMask( bool mask = TRUE );
 323   bool HasMask() const;
 324
 325   wxImage& operator = (const wxImage& image)
 326   {
 327     if ( (*this) != image )
 328       Ref(image);
 329     return *this;
 330   }
 331
 332   bool operator == (const wxImage& image)
 333     { return m_refData == image.m_refData; }
 334   bool operator != (const wxImage& image)
 335     { return m_refData != image.m_refData; }
 336
 337   static wxList& GetHandlers() { return sm_handlers; }
 338   static void AddHandler( wxImageHandler *handler );
 339   static void InsertHandler( wxImageHandler *handler );
 340   static bool RemoveHandler( const wxString& name );
 341   static wxImageHandler *FindHandler( const wxString& name );
 342   static wxImageHandler *FindHandler( const wxString& extension, long imageType );
 343   static wxImageHandler *FindHandler( long imageType );
 344   static wxImageHandler *FindHandlerMime( const wxString& mimetype );
 345
 346   static void CleanUpHandlers();
 347   static void InitStandardHandlers();
 348
 349 protected:
 350
 351   static wxList sm_handlers;
 352
 353 };
 354
 355 extern void WXDLLEXPORT wxInitAllImageHandlers();
 356
 357 #endif
 358   // _WX_IMAGE_H_
 359