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
  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
 178     virtual int GetHeight() const = 0;
 179     virtual int GetWidth() const = 0;
 180     virtual int GetDepth() const = 0;
 181
 182     wxSize GetSize() const
 183         { return wxSize(GetWidth(), GetHeight()); }
 184
 185 #if wxUSE_IMAGE
 186     virtual wxImage ConvertToImage() const = 0;
 187
 188     // Convert to disabled (dimmed) bitmap.
 189     wxBitmap ConvertToDisabled(unsigned char brightness = 255) const;
 190 #endif // wxUSE_IMAGE
 191
 192     virtual wxMask *GetMask() const = 0;
 193     virtual void SetMask(wxMask *mask) = 0;
 194
 195     virtual wxBitmap GetSubBitmap(const wxRect& rect) const = 0;
 196
 197     virtual bool SaveFile(const wxString &name, wxBitmapType type,
 198                           const wxPalette *palette = NULL) const = 0;
 199     virtual bool LoadFile(const wxString &name, wxBitmapType type) = 0;
 200
 201     /*
 202        If raw bitmap access is supported (see wx/rawbmp.h), the following
 203        methods should be implemented:
 204
 205        virtual bool GetRawData(wxRawBitmapData *data) = 0;
 206        virtual void UngetRawData(wxRawBitmapData *data) = 0;
 207      */
 208
 209 #if wxUSE_PALETTE
 210     virtual wxPalette *GetPalette() const = 0;
 211     virtual void SetPalette(const wxPalette& palette) = 0;
 212 #endif // wxUSE_PALETTE
 213
 214     // copies the contents and mask of the given (colour) icon to the bitmap
 215     virtual bool CopyFromIcon(const wxIcon& icon) = 0;
 216
 217     // implementation:
 218     virtual void SetHeight(int height) = 0;
 219     virtual void SetWidth(int width) = 0;
 220     virtual void SetDepth(int depth) = 0;
 221
 222     // Format handling
 223     static inline wxList& GetHandlers() { return sm_handlers; }
 224     static void AddHandler(wxBitmapHandler *handler);
 225     static void InsertHandler(wxBitmapHandler *handler);
 226     static bool RemoveHandler(const wxString& name);
 227     static wxBitmapHandler *FindHandler(const wxString& name);
 228     static wxBitmapHandler *FindHandler(const wxString& extension, wxBitmapType bitmapType);
 229     static wxBitmapHandler *FindHandler(wxBitmapType bitmapType);
 230
 231     //static void InitStandardHandlers();
 232     //  (wxBitmap must implement this one)
 233
 234     static void CleanUpHandlers();
 235
 236     // this method is only used by the generic implementation of wxMask
 237     // currently but could be useful elsewhere in the future: it can be
 238     // overridden to quantize the colour to correspond to bitmap colour depth
 239     // if necessary; default implementation simply returns the colour as is
 240     virtual wxColour QuantizeColour(const wxColour& colour) const
 241     {
 242         return colour;
 243     }
 244
 245 protected:
 246     static wxList sm_handlers;
 247
 248     DECLARE_ABSTRACT_CLASS(wxBitmapBase)
 249 };
 250
 251 #endif // wxUSE_BITMAP_BASE
 252
 253
 254 // the wxBITMAP_DEFAULT_TYPE constant defines the default argument value
 255 // for wxBitmap's ctor and wxBitmap::LoadFile() functions.
 256 #if defined(__WXMSW__)
 257     #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_BMP_RESOURCE
 258     #include "wx/msw/bitmap.h"
 259 #elif defined(__WXMOTIF__)
 260     #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_XPM
 261     #include "wx/x11/bitmap.h"
 262 #elif defined(__WXGTK20__)
 263     #ifdef __WINDOWS__
 264         #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_BMP_RESOURCE
 265     #else
 266         #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_XPM
 267     #endif
 268     #include "wx/gtk/bitmap.h"
 269 #elif defined(__WXGTK__)
 270     #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_XPM
 271     #include "wx/gtk1/bitmap.h"
 272 #elif defined(__WXX11__)
 273     #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_XPM
 274     #include "wx/x11/bitmap.h"
 275 #elif defined(__WXDFB__)
 276     #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_BMP_RESOURCE
 277     #include "wx/dfb/bitmap.h"
 278 #elif defined(__WXMAC__)
 279     #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_PICT_RESOURCE
 280     #include "wx/osx/bitmap.h"
 281 #elif defined(__WXCOCOA__)
 282     #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_BMP_RESOURCE
 283     #include "wx/cocoa/bitmap.h"
 284 #elif defined(__WXPM__)
 285     #define wxBITMAP_DEFAULT_TYPE    wxBITMAP_TYPE_BMP_RESOURCE
 286     #include "wx/os2/bitmap.h"
 287 #endif
 288
 289 #if wxUSE_IMAGE
 290 inline
 291 wxBitmap
 292 #if wxUSE_BITMAP_BASE
 293 wxBitmapBase::
 294 #else
 295 wxBitmap::
 296 #endif
 297 ConvertToDisabled(unsigned char brightness) const
 298 {
 299     return ConvertToImage().ConvertToDisabled(brightness);
 300 }
 301 #endif // wxUSE_IMAGE
 302
 303 // we must include generic mask.h after wxBitmap definition
 304 #if defined(__WXDFB__)
 305     #define wxUSE_GENERIC_MASK 1
 306 #else
 307     #define wxUSE_GENERIC_MASK 0
 308 #endif
 309
 310 #if wxUSE_GENERIC_MASK
 311     #include "wx/generic/mask.h"
 312 #endif
 313
 314 #endif // _WX_BITMAP_H_BASE_