include/wx/bitmap.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/bitmap.h
   3 // Purpose:     wxBitmap class interface
   4 // Author:      Vaclav Slavik
   5 // Modified by:
   6 // Created:     22.04.01
   7 // Copyright:   (c) wxWidgets team
   8 // Licence:     wxWindows licence
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 #ifndef _WX_BITMAP_H_BASE_
  12 #define _WX_BITMAP_H_BASE_
  13
  14 // ----------------------------------------------------------------------------
  15 // headers
  16 // ----------------------------------------------------------------------------
  17
  18 #include "wx/string.h"
  19 #include "wx/gdicmn.h"  // for wxBitmapType
  20 #include "wx/colour.h"
  21 #include "wx/image.h"
  22
  23 class WXDLLIMPEXP_FWD_CORE wxBitmap;
  24 class WXDLLIMPEXP_FWD_CORE wxBitmapHandler;
  25 class WXDLLIMPEXP_FWD_CORE wxIcon;
  26 class WXDLLIMPEXP_FWD_CORE wxMask;
  27 class WXDLLIMPEXP_FWD_CORE wxPalette;
  28 class WXDLLIMPEXP_FWD_CORE wxDC;
  29
  30 // ----------------------------------------------------------------------------
  31 // wxVariant support
  32 // ----------------------------------------------------------------------------
  33
  34 #if wxUSE_VARIANT
  35 #include "wx/variant.h"
  36 DECLARE_VARIANT_OBJECT_EXPORTED(wxBitmap,WXDLLIMPEXP_CORE)
  37 #endif
  38
  39 // ----------------------------------------------------------------------------
  40 // wxMask represents the transparent area of the bitmap
  41 // ----------------------------------------------------------------------------
  42
  43 // TODO: all implementation of wxMask, except the generic one,
  44 //       do not derive from wxMaskBase,,, they should
  45 class WXDLLIMPEXP_CORE wxMaskBase : public wxObject
  46 {
  47 public:
  48     // create the mask from bitmap pixels of the given colour
  49     bool Create(const wxBitmap& bitmap, const wxColour& colour);
  50
  51 #if wxUSE_PALETTE
  52     // create the mask from bitmap pixels with the given palette index
  53     bool Create(const wxBitmap& bitmap, int paletteIndex);
  54 #endif // wxUSE_PALETTE
  55
  56     // create the mask from the given mono bitmap
  57     bool Create(const wxBitmap& bitmap);
  58
  59 protected:
  60     // this function is called from Create() to free the existing mask data
  61     virtual void FreeData() = 0;
  62
  63     // these functions must be overridden to implement the corresponding public
  64     // Create() methods, they shouldn't call FreeData() as it's already called
  65     // by the public wrappers
  66     virtual bool InitFromColour(const wxBitmap& bitmap,
  67                                 const wxColour& colour) = 0;
  68     virtual bool InitFromMonoBitmap(const wxBitmap& bitmap) = 0;
  69 };
  70
  71 #if defined(__WXDFB__) || \
  72     defined(__WXMAC__) || \
  73     defined(__WXGTK__) || \
  74     defined(__WXCOCOA__) || \
  75     defined(__WXMOTIF__) || \
  76     defined(__WXX11__)
  77     #define wxUSE_BITMAP_BASE 1
  78 #else
  79     #define wxUSE_BITMAP_BASE 0
  80 #endif
  81
  82 // a more readable way to tell
  83 #define wxBITMAP_SCREEN_DEPTH       (-1)
  84
  85
  86 // ----------------------------------------------------------------------------
  87 // wxBitmapHelpers: container for various bitmap methods common to all ports.
  88 // ----------------------------------------------------------------------------
  89
  90 // Unfortunately, currently wxBitmap does not inherit from wxBitmapBase on all
  91 // platforms and this is not easy to fix. So we extract at least some common
  92 // methods into this class from which both wxBitmapBase (and hence wxBitmap on
  93 // all platforms where it does inherit from it) and wxBitmap in wxMSW and other
  94 // exceptional ports (only wxPM and old wxCocoa) inherit.
  95 class WXDLLIMPEXP_CORE wxBitmapHelpers
  96 {
  97 public:
  98     // Create a new wxBitmap from the PNG data in the given buffer.
  99     static wxBitmap NewFromPNGData(const void* data, size_t size);
 100 };
 101
 102
 103 // All ports except wxMSW and wxOS2 use wxBitmapHandler and wxBitmapBase as
 104 // base class for wxBitmapHandler; wxMSW and wxOS2 use wxGDIImageHandler as
 105 // base class since it allows some code reuse there.
 106 #if wxUSE_BITMAP_BASE
 107
 108 // ----------------------------------------------------------------------------
 109 // wxBitmapHandler: class which knows how to create/load/save bitmaps in
 110 // different formats
 111 // ----------------------------------------------------------------------------
 112
 113 class WXDLLIMPEXP_CORE wxBitmapHandler : public wxObject
 114 {
 115 public:
 116     wxBitmapHandler() { m_type = wxBITMAP_TYPE_INVALID; }
 117     virtual ~wxBitmapHandler() { }
 118
 119     // NOTE: the following functions should be pure virtuals, but they aren't
 120     //       because otherwise almost all ports would have to implement
 121     //       them as "return false"...
 122
 123     virtual bool Create(wxBitmap *WXUNUSED(bitmap), const void* WXUNUSED(data),
 124                          wxBitmapType WXUNUSED(type), int WXUNUSED(width), int WXUNUSED(height),
 125                          int WXUNUSED(depth) = 1)
 126         { return false; }
 127
 128     virtual bool LoadFile(wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name),
 129                            wxBitmapType WXUNUSED(type), int WXUNUSED(desiredWidth),
 130                            int WXUNUSED(desiredHeight))
 131         { return false; }
 132
 133     virtual bool SaveFile(const wxBitmap *WXUNUSED(bitmap), const wxString& WXUNUSED(name),
 134                            wxBitmapType WXUNUSED(type), const wxPalette *WXUNUSED(palette) = NULL) const
 135         { return false; }
 136
 137     void SetName(const wxString& name)      { m_name = name; }
 138     void SetExtension(const wxString& ext)  { m_extension = ext; }
 139     void SetType(wxBitmapType type)         { m_type = type; }
 140     const wxString& GetName() const         { return m_name; }
 141     const wxString& GetExtension() const    { return m_extension; }
 142     wxBitmapType GetType() const            { return m_type; }
 143
 144 private:
 145     wxString      m_name;
 146     wxString      m_extension;
 147     wxBitmapType  m_type;
 148
 149     DECLARE_ABSTRACT_CLASS(wxBitmapHandler)
 150 };
 151
 152 // ----------------------------------------------------------------------------
 153 // wxBitmap: class which represents platform-dependent bitmap (unlike wxImage)
 154 // ----------------------------------------------------------------------------
 155
 156 class WXDLLIMPEXP_CORE wxBitmapBase : public wxGDIObject,
 157                                       public wxBitmapHelpers
 158 {
 159 public:
 160     /*
 161     Derived class must implement these:
 162
 163     wxBitmap();
 164     wxBitmap(const wxBitmap& bmp);
 165     wxBitmap(const char bits[], int width, int height, int depth = 1);
 166     wxBitmap(int width, int height, int depth = wxBITMAP_SCREEN_DEPTH);
 167     wxBitmap(const wxSize& sz, int depth = wxBITMAP_SCREEN_DEPTH);
 168     wxBitmap(const char* const* bits);
 169     wxBitmap(const wxString &filename, wxBitmapType type = wxBITMAP_TYPE_XPM);
 170     wxBitmap(const wxImage& image, int depth = wxBITMAP_SCREEN_DEPTH);
 171
 172     static void InitStandardHandlers();
 173     */
 174
 175     virtual bool Create(int width, int height, int depth = wxBITMAP_SCREEN_DEPTH) = 0;
 176     virtual bool Create(const wxSize& sz, int depth = wxBITMAP_SCREEN_DEPTH) = 0;
 177     virtual bool CreateScaled(int w, int h, int d, double logicalScale)
 178         { return Create(w*logicalScale,h*logicalScale,d); }
 179
 180     virtual int GetHeight() const = 0;
 181     virtual int GetWidth() const = 0;
 182     virtual int GetDepth() const = 0;
 183
 184     wxSize GetSize() const
 185         { return wxSize(GetWidth(), GetHeight()); }
 186
 187     // support for scaled bitmaps
 188     virtual double GetScaleFactor() const { return 1.0; }
 189     virtual double GetScaledWidth() const { return GetWidth() / GetScaleFactor(); }
 190     virtual double GetScaledHeight() const { return GetHeight() / GetScaleFactor(); }
 191     virtual wxSize GetScaledSize() const
 192     { return wxSize(GetScaledWidth(), GetScaledHeight()); }
 193
 194 #if wxUSE_IMAGE
 195     virtual wxImage ConvertToImage() const = 0;
 196
 197     // Convert to disabled (dimmed) bitmap.
 198     wxBitmap ConvertToDisabled(unsigned char brightness = 255) const;
 199 #endif // wxUSE_IMAGE
 200
 201     virtual wxMask *GetMask() const = 0;
 202     virtual void SetMask(wxMask *mask) = 0;
 203
 204     virtual wxBitmap GetSubBitmap(const wxRect& rect) const = 0;
 205
 206     virtual bool SaveFile(const wxString &name, wxBitmapType type,
 207                           const wxPalette *palette = NULL) const = 0;
 208     virtual bool LoadFile(const wxString &name, wxBitmapType type) = 0;
 209
 210     /*
 211        If raw bitmap access is supported (see wx/rawbmp.h), the following
 212        methods should be implemented:
 213
 214        virtual bool GetRawData(wxRawBitmapData *data) = 0;
 215        virtual void UngetRawData(wxRawBitmapData *data) = 0;
 216      */
 217
 218 #if wxUSE_PALETTE
 219     virtual wxPalette *GetPalette() const = 0;
 220     virtual void SetPalette(const wxPalette& palette) = 0;
 221 #endif // wxUSE_PALETTE
 222
 223     // copies the contents and mask of the given (colour) icon to the bitmap
 224     virtual bool CopyFromIcon(const wxIcon& icon) = 0;
 225
 226     // implementation:
 227     virtual void SetHeight(int height) = 0;
 228     virtual void SetWidth(int width) = 0;
 229     virtual void SetDepth(int depth) = 0;
 230
 231     // Format handling
 232     static inline wxList& GetHandlers() { return sm_handlers; }
 233     static void AddHandler(wxBitmapHandler *handler);
 234     static void InsertHandler(wxBitmapHandler *handler);
 235     static bool RemoveHandler(const wxString& name);
 236     static wxBitmapHandler *FindHandler(const wxString& name);
 237     static wxBitmapHandler *FindHandler(const wxString& extension, wxBitmapType bitmapType);
 238     static wxBitmapHandler *FindHandler(wxBitmapType bitmapType);
 239
 240     //static void InitStandardHandlers();
 241     //  (wxBitmap must implement this one)
 242
 243     static void CleanUpHandlers();
 244
 245     // this method is only used by the generic implementation of wxMask
 246     // currently but could be useful elsewhere in the future: it can be
 247     // overridden to quantize the colour to correspond to bitmap colour depth
 248     // if necessary; default implementation simply returns the colour as is
 249     virtual wxColour QuantizeColour(const wxColour& colour) const
 250     {
 251         return colour;
 252     }
 253
 254 protected:
 255     static wxList sm_handlers;
 256
 257     DECLARE_ABSTRACT_CLASS(wxBitmapBase)
 258 };
 259
 260 #endif // wxUSE_BITMAP_BASE
 261
 262
 263 // the wxBITMAP_DEFAULT_TYPE constant defines the default argument value
 264 // for wxBitmap's ctor and wxBitmap::LoadFile() functions.
 265 #if defined(__WXMSW__)
 266     #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_BMP_RESOURCE
 267     #include "wx/msw/bitmap.h"
 268 #elif defined(__WXMOTIF__)
 269     #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_XPM
 270     #include "wx/x11/bitmap.h"
 271 #elif defined(__WXGTK20__)
 272     #ifdef __WINDOWS__
 273         #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_BMP_RESOURCE
 274     #else
 275         #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_XPM
 276     #endif
 277     #include "wx/gtk/bitmap.h"
 278 #elif defined(__WXGTK__)
 279     #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_XPM
 280     #include "wx/gtk1/bitmap.h"
 281 #elif defined(__WXX11__)
 282     #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_XPM
 283     #include "wx/x11/bitmap.h"
 284 #elif defined(__WXDFB__)
 285     #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_BMP_RESOURCE
 286     #include "wx/dfb/bitmap.h"
 287 #elif defined(__WXMAC__)
 288     #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_PICT_RESOURCE
 289     #include "wx/osx/bitmap.h"
 290 #elif defined(__WXCOCOA__)
 291     #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_BMP_RESOURCE
 292     #include "wx/cocoa/bitmap.h"
 293 #elif defined(__WXPM__)
 294     #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_BMP_RESOURCE
 295     #include "wx/os2/bitmap.h"
 296 #endif
 297
 298 #if wxUSE_IMAGE
 299 inline
 300 wxBitmap
 301 #if wxUSE_BITMAP_BASE
 302 wxBitmapBase::
 303 #else
 304 wxBitmap::
 305 #endif
 306 ConvertToDisabled(unsigned char brightness) const
 307 {
 308     return ConvertToImage().ConvertToDisabled(brightness);
 309 }
 310 #endif // wxUSE_IMAGE
 311
 312 // we must include generic mask.h after wxBitmap definition
 313 #if defined(__WXDFB__)
 314     #define wxUSE_GENERIC_MASK 1
 315 #else
 316     #define wxUSE_GENERIC_MASK 0
 317 #endif
 318
 319 #if wxUSE_GENERIC_MASK
 320     #include "wx/generic/mask.h"
 321 #endif
 322
 323 #endif // _WX_BITMAP_H_BASE_