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