]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/dfb/bitmap.cpp | |
3 | // Purpose: wxBitmap implementation | |
4 | // Author: Vaclav Slavik | |
5 | // Created: 2006-08-04 | |
6 | // RCS-ID: $Id$ | |
7 | // Copyright: (c) 2006 REA Elektronik GmbH | |
8 | // Licence: wxWindows licence | |
9 | ///////////////////////////////////////////////////////////////////////////// | |
10 | ||
11 | // For compilers that support precompilation, includes "wx.h". | |
12 | #include "wx/wxprec.h" | |
13 | ||
14 | #ifdef __BORLANDC__ | |
15 | #pragma hdrstop | |
16 | #endif | |
17 | ||
18 | #ifndef WX_PRECOMP | |
19 | #include "wx/app.h" | |
20 | #include "wx/log.h" | |
21 | #endif | |
22 | ||
23 | #include "wx/bitmap.h" | |
24 | #include "wx/colour.h" | |
25 | #include "wx/image.h" | |
26 | ||
27 | #include "wx/dfb/private.h" | |
28 | ||
29 | //----------------------------------------------------------------------------- | |
30 | // helpers | |
31 | //----------------------------------------------------------------------------- | |
32 | ||
33 | // Creates a surface that will use wxImage's pixel data (RGB only) | |
34 | static wxIDirectFBSurfacePtr CreateSurfaceForImage(const wxImage& image) | |
35 | { | |
36 | wxCHECK_MSG( image.Ok(), NULL, _T("invalid image") ); | |
37 | // FIXME_DFB: implement alpha handling by merging alpha buffer with RGB | |
38 | // into a temporary RGBA surface | |
39 | wxCHECK_MSG( !image.HasAlpha(), NULL, _T("alpha channel not supported") ); | |
40 | ||
41 | DFBSurfaceDescription desc; | |
42 | desc.flags = (DFBSurfaceDescriptionFlags) | |
43 | (DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | | |
44 | DSDESC_PREALLOCATED); | |
45 | desc.caps = DSCAPS_NONE; | |
46 | desc.width = image.GetWidth(); | |
47 | desc.height = image.GetHeight(); | |
48 | desc.pixelformat = DSPF_RGB24; | |
49 | desc.preallocated[0].data = image.GetData(); | |
50 | desc.preallocated[0].pitch = 3 * desc.width; | |
51 | ||
52 | return wxIDirectFB::Get()->CreateSurface(&desc); | |
53 | } | |
54 | ||
55 | //----------------------------------------------------------------------------- | |
56 | // wxBitmapRefData | |
57 | //----------------------------------------------------------------------------- | |
58 | ||
59 | class wxBitmapRefData: public wxObjectRefData | |
60 | { | |
61 | public: | |
62 | wxBitmapRefData() | |
63 | { | |
64 | m_mask = NULL; | |
65 | #if wxUSE_PALETTE | |
66 | m_palette = NULL; | |
67 | #endif | |
68 | } | |
69 | ||
70 | wxBitmapRefData(const wxBitmapRefData& data) | |
71 | { | |
72 | if ( data.m_surface ) | |
73 | m_surface = data.m_surface->Clone(); | |
74 | ||
75 | m_mask = data.m_mask ? new wxMask(*data.m_mask) : NULL; | |
76 | #if wxUSE_PALETTE | |
77 | m_palette = data.m_palette ? new wxPalette(*data.m_palette) : NULL; | |
78 | #endif | |
79 | } | |
80 | ||
81 | ~wxBitmapRefData() | |
82 | { | |
83 | delete m_mask; | |
84 | #if wxUSE_PALETTE | |
85 | delete m_palette; | |
86 | #endif | |
87 | } | |
88 | ||
89 | wxIDirectFBSurfacePtr m_surface; | |
90 | wxMask *m_mask; | |
91 | #if wxUSE_PALETTE | |
92 | wxPalette *m_palette; | |
93 | #endif | |
94 | }; | |
95 | ||
96 | #define M_BITMAP ((wxBitmapRefData *)m_refData) | |
97 | ||
98 | //----------------------------------------------------------------------------- | |
99 | // wxBitmap | |
100 | //----------------------------------------------------------------------------- | |
101 | ||
102 | IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase) | |
103 | IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxBitmapBase) | |
104 | ||
105 | wxBitmap::wxBitmap(int width, int height, int depth) | |
106 | { | |
107 | Create(width, height, depth); | |
108 | } | |
109 | ||
110 | bool wxBitmap::Create(const wxIDirectFBSurfacePtr& surface) | |
111 | { | |
112 | UnRef(); | |
113 | ||
114 | wxCHECK_MSG( surface, false, _T("invalid surface") ); | |
115 | ||
116 | m_refData = new wxBitmapRefData(); | |
117 | M_BITMAP->m_surface = surface; | |
118 | return true; | |
119 | } | |
120 | ||
121 | bool wxBitmap::Create(int width, int height, int depth) | |
122 | { | |
123 | UnRef(); | |
124 | ||
125 | wxCHECK_MSG( width > 0 && height > 0, false, wxT("invalid bitmap size") ); | |
126 | wxCHECK_MSG( depth == -1, false, wxT("only default depth supported now") ); | |
127 | ||
128 | DFBSurfaceDescription desc; | |
129 | desc.flags = (DFBSurfaceDescriptionFlags)( | |
130 | DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT); | |
131 | desc.caps = DSCAPS_NONE; | |
132 | desc.width = width; | |
133 | desc.height = height; | |
134 | ||
135 | return Create(wxIDirectFB::Get()->CreateSurface(&desc)); | |
136 | } | |
137 | ||
138 | #if wxUSE_IMAGE | |
139 | wxBitmap::wxBitmap(const wxImage& image, int depth) | |
140 | { | |
141 | wxCHECK_RET( image.Ok(), wxT("invalid image") ); | |
142 | ||
143 | // create surface in screen's format: | |
144 | if ( !Create(image.GetWidth(), image.GetHeight(), depth) ) | |
145 | return; | |
146 | ||
147 | // then copy the image to it: | |
148 | wxIDirectFBSurfacePtr src(CreateSurfaceForImage(image)); | |
149 | wxIDirectFBSurfacePtr dst = M_BITMAP->m_surface; | |
150 | ||
151 | if ( !dst->SetBlittingFlags(DSBLIT_NOFX) ) | |
152 | return; | |
153 | if ( !dst->Blit(src->GetRaw(), NULL, 0, 0) ) | |
154 | return; | |
155 | ||
156 | // FIXME: implement mask creation from image's mask (or alpha channel?) | |
157 | wxASSERT_MSG( !image.HasMask(), _T("image masks are ignored for now") ); | |
158 | } | |
159 | ||
160 | wxImage wxBitmap::ConvertToImage() const | |
161 | { | |
162 | wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") ); | |
163 | ||
164 | wxImage img(GetWidth(), GetHeight()); | |
165 | wxIDirectFBSurfacePtr dst(CreateSurfaceForImage(img)); | |
166 | wxIDirectFBSurfacePtr src = M_BITMAP->m_surface; | |
167 | ||
168 | if ( !dst->SetBlittingFlags(DSBLIT_NOFX) ) | |
169 | return wxNullImage; | |
170 | if ( !dst->Blit(src->GetRaw(), NULL, 0, 0) ) | |
171 | return wxNullImage; | |
172 | ||
173 | // FIXME: implement mask setting in the image | |
174 | wxASSERT_MSG( GetMask() == NULL, _T("bitmap masks are ignored for now") ); | |
175 | ||
176 | return img; | |
177 | } | |
178 | #endif // wxUSE_IMAGE | |
179 | ||
180 | wxBitmap::wxBitmap(const wxString &filename, wxBitmapType type) | |
181 | { | |
182 | LoadFile(filename, type); | |
183 | } | |
184 | ||
185 | wxBitmap::wxBitmap(const char bits[], int width, int height, int depth) | |
186 | { | |
187 | wxCHECK_RET( depth == 1, wxT("can only create mono bitmap from XBM data") ); | |
188 | ||
189 | wxFAIL_MSG( _T("not implemented") ); | |
190 | } | |
191 | ||
192 | bool wxBitmap::IsOk() const | |
193 | { | |
194 | return (m_refData != NULL && M_BITMAP->m_surface); | |
195 | } | |
196 | ||
197 | bool wxBitmap::operator==(const wxBitmap& bmp) const | |
198 | { | |
199 | // FIXME: is this the right way to compare bitmaps? | |
200 | return (m_refData == bmp.m_refData); | |
201 | } | |
202 | ||
203 | int wxBitmap::GetHeight() const | |
204 | { | |
205 | wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") ); | |
206 | ||
207 | int h = -1; | |
208 | M_BITMAP->m_surface->GetSize(NULL, &h); | |
209 | return h; | |
210 | } | |
211 | ||
212 | int wxBitmap::GetWidth() const | |
213 | { | |
214 | wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") ); | |
215 | ||
216 | int w = -1; | |
217 | M_BITMAP->m_surface->GetSize(&w, NULL); | |
218 | return w; | |
219 | } | |
220 | ||
221 | int wxBitmap::GetDepth() const | |
222 | { | |
223 | wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") ); | |
224 | ||
225 | return M_BITMAP->m_surface->GetDepth(); | |
226 | } | |
227 | ||
228 | wxMask *wxBitmap::GetMask() const | |
229 | { | |
230 | wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") ); | |
231 | ||
232 | return M_BITMAP->m_mask; | |
233 | } | |
234 | ||
235 | void wxBitmap::SetMask(wxMask *mask) | |
236 | { | |
237 | wxCHECK_RET( Ok(), wxT("invalid bitmap") ); | |
238 | ||
239 | delete M_BITMAP->m_mask; | |
240 | M_BITMAP->m_mask = mask; | |
241 | } | |
242 | ||
243 | bool wxBitmap::CopyFromIcon(const wxIcon& icon) | |
244 | { | |
245 | *this = *((wxBitmap*)(&icon)); | |
246 | return true; | |
247 | } | |
248 | ||
249 | wxBitmap wxBitmap::GetSubBitmap(const wxRect& rect) const | |
250 | { | |
251 | wxCHECK_MSG( Ok() && | |
252 | rect.x >= 0 && rect.y >= 0 && | |
253 | rect.x+rect.width <= GetWidth() && | |
254 | rect.y+rect.height <= GetHeight(), | |
255 | wxNullBitmap, | |
256 | wxT("invalid bitmap or bitmap region") ); | |
257 | ||
258 | // NB: DirectFB subsurfaces share the same pixels buffer, so we must | |
259 | // clone the obtained subsurface | |
260 | DFBRectangle r = { rect.x, rect.y, rect.width, rect.height }; | |
261 | return wxBitmap(M_BITMAP->m_surface->GetSubSurface(&r)->Clone()); | |
262 | } | |
263 | ||
264 | #warning "to common code" | |
265 | bool wxBitmap::LoadFile(const wxString &name, wxBitmapType type) | |
266 | { | |
267 | UnRef(); | |
268 | ||
269 | wxBitmapHandler *handler = FindHandler(type); | |
270 | ||
271 | if ( handler == NULL ) | |
272 | { | |
273 | wxImage image; | |
274 | if ( !image.LoadFile(name, type) || !image.Ok() ) | |
275 | { | |
276 | wxLogError("no bitmap handler for type %d defined.", type); | |
277 | return false; | |
278 | } | |
279 | else | |
280 | { | |
281 | *this = wxBitmap(image); | |
282 | return true; | |
283 | } | |
284 | } | |
285 | ||
286 | m_refData = new wxBitmapRefData(); | |
287 | ||
288 | return handler->LoadFile(this, name, type, -1, -1); | |
289 | } | |
290 | ||
291 | #warning "to common code" | |
292 | bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type, const wxPalette *palette) const | |
293 | { | |
294 | wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") ); | |
295 | ||
296 | wxBitmapHandler *handler = FindHandler(type); | |
297 | ||
298 | if ( handler == NULL ) | |
299 | { | |
300 | wxImage image = ConvertToImage(); | |
301 | #if wxUSE_PALETTE | |
302 | if ( palette ) | |
303 | image.SetPalette(*palette); | |
304 | #endif // wxUSE_PALETTE | |
305 | ||
306 | if ( image.Ok() ) | |
307 | return image.SaveFile(filename, type); | |
308 | else | |
309 | { | |
310 | wxLogError("no bitmap handler for type %d defined.", type); | |
311 | return false; | |
312 | } | |
313 | } | |
314 | ||
315 | return handler->SaveFile(this, filename, type, palette); | |
316 | } | |
317 | ||
318 | #if wxUSE_PALETTE | |
319 | wxPalette *wxBitmap::GetPalette() const | |
320 | { | |
321 | wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") ); | |
322 | ||
323 | return M_BITMAP->m_palette; | |
324 | } | |
325 | ||
326 | void wxBitmap::SetPalette(const wxPalette& palette) | |
327 | { | |
328 | wxCHECK_RET( Ok(), wxT("invalid bitmap") ); | |
329 | wxCHECK_RET( GetDepth() > 1 && GetDepth() <= 8, wxT("cannot set palette for bitmap of this depth") ); | |
330 | ||
331 | delete M_BITMAP->m_palette; | |
332 | M_BITMAP->m_palette = NULL; | |
333 | ||
334 | if ( !palette.Ok() ) return; | |
335 | ||
336 | M_BITMAP->m_palette = new wxPalette(palette); | |
337 | } | |
338 | #endif // wxUSE_PALETTE | |
339 | ||
340 | void wxBitmap::SetHeight(int height) | |
341 | { | |
342 | AllocExclusive(); | |
343 | ||
344 | wxFAIL_MSG( _T("SetHeight not implemented") ); | |
345 | } | |
346 | ||
347 | void wxBitmap::SetWidth(int width) | |
348 | { | |
349 | AllocExclusive(); | |
350 | ||
351 | wxFAIL_MSG( _T("SetWidth not implemented") ); | |
352 | } | |
353 | ||
354 | void wxBitmap::SetDepth(int depth) | |
355 | { | |
356 | AllocExclusive(); | |
357 | ||
358 | wxFAIL_MSG( _T("SetDepth not implemented") ); | |
359 | } | |
360 | ||
361 | wxIDirectFBSurfacePtr wxBitmap::GetDirectFBSurface() const | |
362 | { | |
363 | wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") ); | |
364 | ||
365 | return M_BITMAP->m_surface; | |
366 | } | |
367 | ||
368 | wxObjectRefData *wxBitmap::CreateRefData() const | |
369 | { | |
370 | return new wxBitmapRefData; | |
371 | } | |
372 | ||
373 | wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *data) const | |
374 | { | |
375 | return new wxBitmapRefData(*(wxBitmapRefData *)data); | |
376 | } | |
377 | ||
378 | ||
379 | /*static*/ | |
380 | void wxBitmap::InitStandardHandlers() | |
381 | { | |
382 | // not wxBitmap handlers, we rely on wxImage | |
383 | } |