1 ///////////////////////////////////////////////////////////////////////////////
3 // Purpose: wxBitmap class interface
4 // Author: Vaclav Slavik
8 // Copyright: (c) wxWidgets team
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
12 #ifndef _WX_BITMAP_H_BASE_
13 #define _WX_BITMAP_H_BASE_
15 // ----------------------------------------------------------------------------
17 // ----------------------------------------------------------------------------
19 #include "wx/string.h"
20 #include "wx/gdicmn.h" // for wxBitmapType
21 #include "wx/colour.h"
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
;
31 // ----------------------------------------------------------------------------
33 // ----------------------------------------------------------------------------
36 #include "wx/variant.h"
37 DECLARE_VARIANT_OBJECT_EXPORTED(wxBitmap
,WXDLLIMPEXP_CORE
)
40 // ----------------------------------------------------------------------------
41 // wxMask represents the transparent area of the bitmap
42 // ----------------------------------------------------------------------------
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
49 // create the mask from bitmap pixels of the given colour
50 bool Create(const wxBitmap
& bitmap
, const wxColour
& colour
);
53 // create the mask from bitmap pixels with the given palette index
54 bool Create(const wxBitmap
& bitmap
, int paletteIndex
);
55 #endif // wxUSE_PALETTE
57 // create the mask from the given mono bitmap
58 bool Create(const wxBitmap
& bitmap
);
61 // this function is called from Create() to free the existing mask data
62 virtual void FreeData() = 0;
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;
72 #if defined(__WXDFB__) || \
73 defined(__WXMAC__) || \
74 defined(__WXGTK__) || \
75 defined(__WXCOCOA__) || \
76 defined(__WXMOTIF__) || \
78 #define wxUSE_BITMAP_BASE 1
80 #define wxUSE_BITMAP_BASE 0
83 // a more readable way to tell
84 #define wxBITMAP_SCREEN_DEPTH (-1)
87 // ----------------------------------------------------------------------------
88 // wxBitmapHelpers: container for various bitmap methods common to all ports.
89 // ----------------------------------------------------------------------------
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
99 // Create a new wxBitmap from the PNG data in the given buffer.
100 static wxBitmap
NewFromPNGData(const void* data
, size_t size
);
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
109 // ----------------------------------------------------------------------------
110 // wxBitmapHandler: class which knows how to create/load/save bitmaps in
112 // ----------------------------------------------------------------------------
114 class WXDLLIMPEXP_CORE wxBitmapHandler
: public wxObject
117 wxBitmapHandler() { m_type
= wxBITMAP_TYPE_INVALID
; }
118 virtual ~wxBitmapHandler() { }
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"...
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)
129 virtual bool LoadFile(wxBitmap
*WXUNUSED(bitmap
), const wxString
& WXUNUSED(name
),
130 wxBitmapType
WXUNUSED(type
), int WXUNUSED(desiredWidth
),
131 int WXUNUSED(desiredHeight
))
134 virtual bool SaveFile(const wxBitmap
*WXUNUSED(bitmap
), const wxString
& WXUNUSED(name
),
135 wxBitmapType
WXUNUSED(type
), const wxPalette
*WXUNUSED(palette
) = NULL
) const
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
; }
147 wxString m_extension
;
150 DECLARE_ABSTRACT_CLASS(wxBitmapHandler
)
153 // ----------------------------------------------------------------------------
154 // wxBitmap: class which represents platform-dependent bitmap (unlike wxImage)
155 // ----------------------------------------------------------------------------
157 class WXDLLIMPEXP_CORE wxBitmapBase
: public wxGDIObject
,
158 public wxBitmapHelpers
162 Derived class must implement these:
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);
173 static void InitStandardHandlers();
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 virtual bool CreateScaled(int w
, int h
, int d
, double logicalScale
)
179 { return Create(w
*logicalScale
,h
*logicalScale
,d
);
181 virtual int GetHeight() const = 0;
182 virtual int GetWidth() const = 0;
183 virtual int GetDepth() const = 0;
185 wxSize
GetSize() const
186 { return wxSize(GetWidth(), GetHeight()); }
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()); }
196 virtual wxImage
ConvertToImage() const = 0;
198 // Convert to disabled (dimmed) bitmap.
199 wxBitmap
ConvertToDisabled(unsigned char brightness
= 255) const;
200 #endif // wxUSE_IMAGE
202 virtual wxMask
*GetMask() const = 0;
203 virtual void SetMask(wxMask
*mask
) = 0;
205 virtual wxBitmap
GetSubBitmap(const wxRect
& rect
) const = 0;
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;
212 If raw bitmap access is supported (see wx/rawbmp.h), the following
213 methods should be implemented:
215 virtual bool GetRawData(wxRawBitmapData *data) = 0;
216 virtual void UngetRawData(wxRawBitmapData *data) = 0;
220 virtual wxPalette
*GetPalette() const = 0;
221 virtual void SetPalette(const wxPalette
& palette
) = 0;
222 #endif // wxUSE_PALETTE
224 // copies the contents and mask of the given (colour) icon to the bitmap
225 virtual bool CopyFromIcon(const wxIcon
& icon
) = 0;
228 virtual void SetHeight(int height
) = 0;
229 virtual void SetWidth(int width
) = 0;
230 virtual void SetDepth(int depth
) = 0;
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
);
241 //static void InitStandardHandlers();
242 // (wxBitmap must implement this one)
244 static void CleanUpHandlers();
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
256 static wxList sm_handlers
;
258 DECLARE_ABSTRACT_CLASS(wxBitmapBase
)
261 #endif // wxUSE_BITMAP_BASE
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__)
274 #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_BMP_RESOURCE
276 #define wxBITMAP_DEFAULT_TYPE wxBITMAP_TYPE_XPM
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"
302 #if wxUSE_BITMAP_BASE
307 ConvertToDisabled(unsigned char brightness
) const
309 return ConvertToImage().ConvertToDisabled(brightness
);
311 #endif // wxUSE_IMAGE
313 // we must include generic mask.h after wxBitmap definition
314 #if defined(__WXDFB__)
315 #define wxUSE_GENERIC_MASK 1
317 #define wxUSE_GENERIC_MASK 0
320 #if wxUSE_GENERIC_MASK
321 #include "wx/generic/mask.h"
324 #endif // _WX_BITMAP_H_BASE_