]> git.saurik.com Git - wxWidgets.git/blob - include/wx/bitmap.h
Use kCGBlendModeExclusion for wxCOMPOSITION_XOR operation.
[wxWidgets.git] / 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_