]>
Commit | Line | Data |
---|---|---|
0becd470 | 1 | //////////////////////////////////////////////////////////////////////////// |
2bda0e17 KB |
2 | // Name: bitmap.cpp |
3 | // Purpose: wxBitmap | |
4 | // Author: Julian Smart | |
5 | // Modified by: | |
6 | // Created: 04/01/98 | |
7 | // RCS-ID: $Id$ | |
6c9a19aa JS |
8 | // Copyright: (c) Julian Smart |
9 | // Licence: wxWindows licence | |
2bda0e17 KB |
10 | ///////////////////////////////////////////////////////////////////////////// |
11 | ||
10fcf31a VZ |
12 | // ============================================================================ |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
2bda0e17 | 20 | #ifdef __GNUG__ |
10fcf31a | 21 | #pragma implementation "bitmap.h" |
2bda0e17 KB |
22 | #endif |
23 | ||
24 | // For compilers that support precompilation, includes "wx.h". | |
25 | #include "wx/wxprec.h" | |
26 | ||
27 | #ifdef __BORLANDC__ | |
10fcf31a | 28 | #pragma hdrstop |
2bda0e17 KB |
29 | #endif |
30 | ||
31 | #ifndef WX_PRECOMP | |
10fcf31a VZ |
32 | #include <stdio.h> |
33 | ||
34 | #include "wx/list.h" | |
35 | #include "wx/utils.h" | |
36 | #include "wx/app.h" | |
37 | #include "wx/palette.h" | |
38 | #include "wx/dcmemory.h" | |
39 | #include "wx/bitmap.h" | |
40 | #include "wx/icon.h" | |
2bda0e17 KB |
41 | #endif |
42 | ||
43 | #include "wx/msw/private.h" | |
1d792928 VZ |
44 | #include "wx/log.h" |
45 | ||
04ef50df | 46 | #if !defined(__WXMICROWIN__) |
2bda0e17 | 47 | #include "wx/msw/dib.h" |
04ef50df JS |
48 | #endif |
49 | ||
b75dd496 | 50 | #include "wx/image.h" |
66e23ad2 | 51 | #include "wx/xpmdecod.h" |
2bda0e17 | 52 | |
1e3c12d7 | 53 | #ifdef wxHAVE_RAW_BITMAP |
2cf45d69 | 54 | #include "wx/rawbmp.h" |
1e3c12d7 | 55 | #endif |
2cf45d69 | 56 | |
3c1a88d8 VZ |
57 | // missing from mingw32 header |
58 | #ifndef CLR_INVALID | |
59 | #define CLR_INVALID ((COLORREF)-1) | |
60 | #endif // no CLR_INVALID | |
61 | ||
8bbbae21 VZ |
62 | // ---------------------------------------------------------------------------- |
63 | // Bitmap data | |
64 | // ---------------------------------------------------------------------------- | |
65 | ||
66 | class WXDLLEXPORT wxBitmapRefData : public wxGDIImageRefData | |
67 | { | |
68 | public: | |
69 | wxBitmapRefData(); | |
70 | virtual ~wxBitmapRefData() { Free(); } | |
71 | ||
72 | virtual void Free(); | |
73 | ||
74 | // set the mask object to use as the mask, we take ownership of it | |
75 | void SetMask(wxMask *mask) | |
76 | { | |
77 | delete m_bitmapMask; | |
78 | m_bitmapMask = mask; | |
79 | } | |
80 | ||
81 | // set the HBITMAP to use as the mask | |
82 | void SetMask(HBITMAP hbmpMask) | |
83 | { | |
84 | SetMask(new wxMask((WXHBITMAP)hbmpMask)); | |
85 | } | |
86 | ||
87 | // return the mask | |
88 | wxMask *GetMask() const { return m_bitmapMask; } | |
89 | ||
90 | public: | |
8bbbae21 VZ |
91 | #if wxUSE_PALETTE |
92 | wxPalette m_bitmapPalette; | |
93 | #endif // wxUSE_PALETTE | |
94 | ||
95 | // MSW-specific | |
96 | // ------------ | |
97 | ||
acf8e3d2 | 98 | #ifdef __WXDEBUG__ |
8bbbae21 VZ |
99 | // this field is solely for error checking: we detect selecting a bitmap |
100 | // into more than one DC at once or deleting a bitmap still selected into a | |
101 | // DC (both are serious programming errors under Windows) | |
102 | wxDC *m_selectedInto; | |
acf8e3d2 | 103 | #endif // __WXDEBUG__ |
8bbbae21 | 104 | |
fa275e86 VZ |
105 | // when GetRawData() is called for a DDB we need to convert it to a DIB |
106 | // first to be able to provide direct access to it and we cache that DIB | |
107 | // here and convert it back to DDB when UngetRawData() is called | |
108 | wxDIB *m_dib; | |
109 | ||
acf8e3d2 VZ |
110 | // true if we have alpha transparency info and can be drawn using |
111 | // AlphaBlend() | |
112 | bool m_hasAlpha; | |
8bbbae21 | 113 | |
fa275e86 VZ |
114 | // true if our HBITMAP is a DIB section, false if it is a DDB |
115 | bool m_isDIB; | |
116 | ||
8bbbae21 VZ |
117 | private: |
118 | // optional mask for transparent drawing | |
119 | wxMask *m_bitmapMask; | |
120 | ||
121 | DECLARE_NO_COPY_CLASS(wxBitmapRefData) | |
122 | }; | |
123 | ||
10fcf31a VZ |
124 | // ---------------------------------------------------------------------------- |
125 | // macros | |
126 | // ---------------------------------------------------------------------------- | |
127 | ||
4b7f2165 VZ |
128 | IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject) |
129 | IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject) | |
6d167489 | 130 | |
4b7f2165 | 131 | IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject) |
2bda0e17 | 132 | |
10fcf31a VZ |
133 | // ============================================================================ |
134 | // implementation | |
135 | // ============================================================================ | |
136 | ||
2cf45d69 VZ |
137 | // ---------------------------------------------------------------------------- |
138 | // helper functions | |
139 | // ---------------------------------------------------------------------------- | |
140 | ||
141 | // decide whether we should create a DIB or a DDB for the given parameters | |
142 | static bool wxShouldCreateDIB(int w, int h, int d, WXHDC hdc) | |
143 | { | |
144 | // here is the logic: | |
145 | // | |
146 | // (a) if hdc is specified, the caller explicitly wants DDB | |
147 | // (b) otherwise, create a DIB if depth >= 24 (we don't support 16bpp or | |
148 | // less DIBs anyhow) | |
149 | // (c) finally, create DIBs under Win9x even if the depth hasn't been | |
150 | // explicitly specified but the current display depth is 24 or more | |
151 | // and the image is "big", i.e. > 16Mb which is the theoretical limit | |
152 | // for DDBs under Win9x | |
153 | // | |
154 | // consequences (all of which seem to make sense): | |
155 | // | |
156 | // (i) by default, DDBs are created (depth == -1 usually) | |
157 | // (ii) DIBs can be created by explicitly specifying the depth | |
158 | // (iii) using a DC always forces creating a DDB | |
159 | return !hdc && | |
160 | (d >= 24 || | |
161 | (d == -1 && | |
162 | wxDIB::GetLineSize(w, wxDisplayDepth())*h > 16*1024*1024)); | |
163 | } | |
164 | ||
10fcf31a VZ |
165 | // ---------------------------------------------------------------------------- |
166 | // wxBitmapRefData | |
167 | // ---------------------------------------------------------------------------- | |
168 | ||
169 | wxBitmapRefData::wxBitmapRefData() | |
2bda0e17 | 170 | { |
3ca22d5e | 171 | #ifdef __WXDEBUG__ |
6d167489 | 172 | m_selectedInto = NULL; |
3ca22d5e | 173 | #endif |
6d167489 | 174 | m_bitmapMask = NULL; |
fa275e86 | 175 | |
340196c0 | 176 | m_hBitmap = (WXHBITMAP) NULL; |
fa275e86 VZ |
177 | m_dib = NULL; |
178 | ||
179 | m_isDIB = | |
acf8e3d2 | 180 | m_hasAlpha = FALSE; |
2bda0e17 KB |
181 | } |
182 | ||
6d167489 | 183 | void wxBitmapRefData::Free() |
2bda0e17 | 184 | { |
d59ceba5 VZ |
185 | wxASSERT_MSG( !m_selectedInto, |
186 | wxT("deleting bitmap still selected into wxMemoryDC") ); | |
2bda0e17 | 187 | |
fa275e86 VZ |
188 | wxASSERT_MSG( !m_dib, _T("forgot to call wxBitmap::UngetRawData()!") ); |
189 | ||
d59ceba5 | 190 | if ( m_hBitmap) |
6d167489 VZ |
191 | { |
192 | if ( !::DeleteObject((HBITMAP)m_hBitmap) ) | |
193 | { | |
f6bcfd97 | 194 | wxLogLastError(wxT("DeleteObject(hbitmap)")); |
6d167489 VZ |
195 | } |
196 | } | |
e7003166 | 197 | |
6d167489 VZ |
198 | delete m_bitmapMask; |
199 | m_bitmapMask = NULL; | |
2bda0e17 KB |
200 | } |
201 | ||
10fcf31a | 202 | // ---------------------------------------------------------------------------- |
6d167489 | 203 | // wxBitmap creation |
10fcf31a VZ |
204 | // ---------------------------------------------------------------------------- |
205 | ||
4fe5383d VZ |
206 | // this function should be called from all wxBitmap ctors |
207 | void wxBitmap::Init() | |
2bda0e17 | 208 | { |
4fe5383d | 209 | // m_refData = NULL; done in the base class ctor |
4fe5383d VZ |
210 | } |
211 | ||
8bbbae21 VZ |
212 | wxGDIImageRefData *wxBitmap::CreateData() const |
213 | { | |
214 | return new wxBitmapRefData; | |
215 | } | |
216 | ||
6d167489 VZ |
217 | #ifdef __WIN32__ |
218 | ||
219 | bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& icon) | |
220 | { | |
04ef50df | 221 | #ifndef __WXMICROWIN__ |
6d167489 VZ |
222 | // it may be either HICON or HCURSOR |
223 | HICON hicon = (HICON)icon.GetHandle(); | |
224 | ||
225 | ICONINFO iconInfo; | |
226 | if ( !::GetIconInfo(hicon, &iconInfo) ) | |
227 | { | |
f6bcfd97 | 228 | wxLogLastError(wxT("GetIconInfo")); |
6d167489 VZ |
229 | |
230 | return FALSE; | |
231 | } | |
232 | ||
233 | wxBitmapRefData *refData = new wxBitmapRefData; | |
234 | m_refData = refData; | |
235 | ||
d9c8e68e VZ |
236 | int w = icon.GetWidth(), |
237 | h = icon.GetHeight(); | |
238 | ||
239 | refData->m_width = w; | |
240 | refData->m_height = h; | |
6d167489 VZ |
241 | refData->m_depth = wxDisplayDepth(); |
242 | ||
243 | refData->m_hBitmap = (WXHBITMAP)iconInfo.hbmColor; | |
d9c8e68e VZ |
244 | |
245 | // the mask returned by GetIconInfo() is inversed compared to the usual | |
246 | // wxWin convention | |
8bbbae21 | 247 | refData->SetMask(wxInvertMask(iconInfo.hbmMask, w, h)); |
6d167489 | 248 | |
68f36a2c VZ |
249 | |
250 | // delete the old one now as we don't need it any more | |
251 | ::DeleteObject(iconInfo.hbmMask); | |
252 | ||
6d167489 VZ |
253 | #if WXWIN_COMPATIBILITY_2 |
254 | refData->m_ok = TRUE; | |
255 | #endif // WXWIN_COMPATIBILITY_2 | |
256 | ||
257 | return TRUE; | |
04ef50df JS |
258 | #else |
259 | return FALSE; | |
260 | #endif | |
6d167489 VZ |
261 | } |
262 | ||
263 | #endif // Win32 | |
264 | ||
265 | bool wxBitmap::CopyFromCursor(const wxCursor& cursor) | |
4fe5383d VZ |
266 | { |
267 | UnRef(); | |
07cf98cb | 268 | |
6d167489 | 269 | if ( !cursor.Ok() ) |
4fe5383d | 270 | return FALSE; |
07cf98cb | 271 | |
6d167489 VZ |
272 | #ifdef __WIN16__ |
273 | wxFAIL_MSG( _T("don't know how to convert cursor to bitmap") ); | |
274 | ||
275 | return FALSE; | |
8f177c8e | 276 | #else |
6d167489 | 277 | return CopyFromIconOrCursor(cursor); |
8f177c8e | 278 | #endif // Win16 |
6d167489 VZ |
279 | } |
280 | ||
281 | bool wxBitmap::CopyFromIcon(const wxIcon& icon) | |
282 | { | |
283 | UnRef(); | |
07cf98cb | 284 | |
6d167489 VZ |
285 | if ( !icon.Ok() ) |
286 | return FALSE; | |
4fe5383d VZ |
287 | |
288 | // GetIconInfo() doesn't exist under Win16 and I don't know any other way | |
289 | // to create a bitmap from icon there - but using this way we won't have | |
290 | // the mask (FIXME) | |
291 | #ifdef __WIN16__ | |
6d167489 VZ |
292 | int width = icon.GetWidth(), |
293 | height = icon.GetHeight(); | |
294 | ||
4fe5383d | 295 | // copy the icon to the bitmap |
6d167489 | 296 | ScreenHDC hdcScreen; |
4fe5383d VZ |
297 | HDC hdc = ::CreateCompatibleDC(hdcScreen); |
298 | HBITMAP hbitmap = ::CreateCompatibleBitmap(hdcScreen, width, height); | |
07cf98cb VZ |
299 | HBITMAP hbmpOld = (HBITMAP)::SelectObject(hdc, hbitmap); |
300 | ||
6d167489 | 301 | ::DrawIcon(hdc, 0, 0, GetHiconOf(icon)); |
07cf98cb VZ |
302 | |
303 | ::SelectObject(hdc, hbmpOld); | |
304 | ::DeleteDC(hdc); | |
4fe5383d | 305 | |
6d167489 VZ |
306 | wxBitmapRefData *refData = new wxBitmapRefData; |
307 | m_refData = refData; | |
4fe5383d | 308 | |
6d167489 VZ |
309 | refData->m_width = width; |
310 | refData->m_height = height; | |
311 | refData->m_depth = wxDisplayDepth(); | |
07cf98cb | 312 | |
6d167489 | 313 | refData->m_hBitmap = (WXHBITMAP)hbitmap; |
07cf98cb | 314 | |
6d167489 VZ |
315 | #if WXWIN_COMPATIBILITY_2 |
316 | refData->m_ok = TRUE; | |
317 | #endif // WXWIN_COMPATIBILITY_2 | |
222594ea | 318 | |
4fe5383d | 319 | return TRUE; |
6d167489 VZ |
320 | #else // Win32 |
321 | return CopyFromIconOrCursor(icon); | |
322 | #endif // Win16/Win32 | |
10fcf31a VZ |
323 | } |
324 | ||
b0ea5d96 VZ |
325 | bool wxBitmap::CopyFromDIB(const wxDIB& dib) |
326 | { | |
327 | wxCHECK_MSG( dib.IsOk(), FALSE, _T("invalid DIB in CopyFromDIB") ); | |
328 | ||
329 | HBITMAP hbitmap = dib.CreateDDB(); | |
330 | if ( !hbitmap ) | |
331 | return FALSE; | |
332 | ||
333 | UnRef(); | |
334 | ||
335 | wxBitmapRefData *refData = new wxBitmapRefData; | |
336 | m_refData = refData; | |
337 | ||
338 | refData->m_width = dib.GetWidth(); | |
339 | refData->m_height = dib.GetHeight(); | |
340 | refData->m_depth = dib.GetDepth(); | |
341 | ||
342 | refData->m_hBitmap = (WXHBITMAP)hbitmap; | |
343 | ||
344 | #if wxUSE_PALETTE | |
345 | wxPalette *palette = dib.CreatePalette(); | |
346 | if ( palette ) | |
347 | { | |
348 | refData->m_bitmapPalette = *palette; | |
349 | } | |
350 | ||
351 | delete palette; | |
352 | #endif // wxUSE_PALETTE | |
353 | ||
354 | return TRUE; | |
355 | } | |
356 | ||
10fcf31a | 357 | wxBitmap::~wxBitmap() |
2bda0e17 | 358 | { |
2bda0e17 KB |
359 | } |
360 | ||
5bd3a2da | 361 | wxBitmap::wxBitmap(const char bits[], int width, int height, int depth) |
2bda0e17 | 362 | { |
4fe5383d | 363 | Init(); |
2bda0e17 | 364 | |
04ef50df | 365 | #ifndef __WXMICROWIN__ |
6d167489 VZ |
366 | wxBitmapRefData *refData = new wxBitmapRefData; |
367 | m_refData = refData; | |
2bda0e17 | 368 | |
5bd3a2da VZ |
369 | refData->m_width = width; |
370 | refData->m_height = height; | |
371 | refData->m_depth = depth; | |
2bda0e17 | 372 | |
5bd3a2da VZ |
373 | char *data; |
374 | if ( depth == 1 ) | |
375 | { | |
376 | // we assume that it is in XBM format which is not quite the same as | |
377 | // the format CreateBitmap() wants because the order of bytes in the | |
378 | // line is inversed! | |
4d24ece7 VZ |
379 | const size_t bytesPerLine = (width + 7) / 8; |
380 | const size_t padding = bytesPerLine % 2; | |
381 | const size_t len = height * ( padding + bytesPerLine ); | |
5bd3a2da VZ |
382 | data = (char *)malloc(len); |
383 | const char *src = bits; | |
384 | char *dst = data; | |
385 | ||
386 | for ( int rows = 0; rows < height; rows++ ) | |
387 | { | |
0765adca | 388 | for ( size_t cols = 0; cols < bytesPerLine; cols++ ) |
5bd3a2da | 389 | { |
0765adca VZ |
390 | unsigned char val = *src++; |
391 | unsigned char reversed = 0; | |
392 | ||
393 | for ( int bits = 0; bits < 8; bits++) | |
394 | { | |
395 | reversed <<= 1; | |
396 | reversed |= (val & 0x01); | |
397 | val >>= 1; | |
398 | } | |
399 | *dst++ = reversed; | |
5bd3a2da VZ |
400 | } |
401 | ||
402 | if ( padding ) | |
403 | *dst++ = 0; | |
5bd3a2da VZ |
404 | } |
405 | } | |
406 | else | |
407 | { | |
408 | // bits should already be in Windows standard format | |
409 | data = (char *)bits; // const_cast is harmless | |
410 | } | |
411 | ||
412 | HBITMAP hbmp = ::CreateBitmap(width, height, 1, depth, data); | |
6d167489 VZ |
413 | if ( !hbmp ) |
414 | { | |
f6bcfd97 | 415 | wxLogLastError(wxT("CreateBitmap")); |
6d167489 | 416 | } |
2bda0e17 | 417 | |
5bd3a2da VZ |
418 | if ( data != bits ) |
419 | { | |
420 | free(data); | |
421 | } | |
422 | ||
6d167489 | 423 | SetHBITMAP((WXHBITMAP)hbmp); |
04ef50df | 424 | #endif |
2bda0e17 KB |
425 | } |
426 | ||
2fd284a4 | 427 | // Create from XPM data |
4b7f2165 | 428 | bool wxBitmap::CreateFromXpm(const char **data) |
2fd284a4 | 429 | { |
66e23ad2 | 430 | #if wxUSE_IMAGE && wxUSE_XPM |
4fe5383d VZ |
431 | Init(); |
432 | ||
66e23ad2 | 433 | wxCHECK_MSG( data != NULL, FALSE, wxT("invalid bitmap data") ) |
4d24ece7 | 434 | |
66e23ad2 VS |
435 | wxXPMDecoder decoder; |
436 | wxImage img = decoder.ReadData(data); | |
437 | wxCHECK_MSG( img.Ok(), FALSE, wxT("invalid bitmap data") ) | |
4d24ece7 | 438 | |
c59b4b01 | 439 | *this = wxBitmap(img); |
66e23ad2 VS |
440 | return TRUE; |
441 | #else | |
4d24ece7 | 442 | return FALSE; |
66e23ad2 | 443 | #endif |
2fd284a4 JS |
444 | } |
445 | ||
debe6624 | 446 | wxBitmap::wxBitmap(int w, int h, int d) |
2bda0e17 | 447 | { |
4fe5383d | 448 | Init(); |
2bda0e17 | 449 | |
4fe5383d | 450 | (void)Create(w, h, d); |
2bda0e17 KB |
451 | } |
452 | ||
98ea6b7d VZ |
453 | wxBitmap::wxBitmap(int w, int h, const wxDC& dc) |
454 | { | |
455 | Init(); | |
456 | ||
457 | (void)Create(w, h, dc); | |
458 | } | |
459 | ||
debe6624 | 460 | wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth) |
2bda0e17 | 461 | { |
4fe5383d | 462 | Init(); |
2bda0e17 | 463 | |
6d167489 | 464 | (void)Create(data, type, width, height, depth); |
2bda0e17 KB |
465 | } |
466 | ||
2aeec9ec | 467 | wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type) |
2bda0e17 | 468 | { |
4fe5383d | 469 | Init(); |
2bda0e17 | 470 | |
4fe5383d | 471 | LoadFile(filename, (int)type); |
2bda0e17 KB |
472 | } |
473 | ||
2cf45d69 VZ |
474 | bool wxBitmap::Create(int width, int height, int depth) |
475 | { | |
476 | return DoCreate(width, height, depth, 0); | |
477 | } | |
478 | ||
479 | bool wxBitmap::Create(int width, int height, const wxDC& dc) | |
480 | { | |
481 | wxCHECK_MSG( dc.Ok(), FALSE, _T("invalid HDC in wxBitmap::Create()") ); | |
482 | ||
483 | return DoCreate(width, height, -1, dc.GetHDC()); | |
484 | } | |
485 | ||
486 | bool wxBitmap::DoCreate(int w, int h, int d, WXHDC hdc) | |
2bda0e17 | 487 | { |
6d167489 VZ |
488 | UnRef(); |
489 | ||
490 | m_refData = new wxBitmapRefData; | |
491 | ||
2cf45d69 VZ |
492 | GetBitmapData()->m_width = w; |
493 | GetBitmapData()->m_height = h; | |
494 | ||
495 | HBITMAP hbmp; | |
496 | ||
497 | if ( wxShouldCreateDIB(w, h, d, hdc) ) | |
6d167489 | 498 | { |
2cf45d69 VZ |
499 | if ( d == -1 ) |
500 | { | |
501 | // create DIBs without alpha channel by default | |
502 | d = 24; | |
503 | } | |
504 | ||
505 | wxDIB dib(w, h, d); | |
506 | if ( !dib.IsOk() ) | |
0becd470 | 507 | return FALSE; |
2cf45d69 VZ |
508 | |
509 | // don't delete the DIB section in dib object dtor | |
510 | hbmp = dib.Detach(); | |
511 | ||
fa275e86 | 512 | GetBitmapData()->m_isDIB = TRUE; |
2cf45d69 | 513 | GetBitmapData()->m_depth = d; |
6d167489 | 514 | } |
2cf45d69 | 515 | else // create a DDB |
6d167489 | 516 | { |
2cf45d69 VZ |
517 | if ( d == -1 ) |
518 | d = wxDisplayDepth(); | |
519 | ||
0becd470 VZ |
520 | GetBitmapData()->m_depth = d; |
521 | ||
0becd470 VZ |
522 | #ifndef __WXMICROWIN__ |
523 | if ( d > 0 ) | |
6d167489 | 524 | { |
0becd470 VZ |
525 | hbmp = ::CreateBitmap(w, h, 1, d, NULL); |
526 | if ( !hbmp ) | |
527 | { | |
528 | wxLogLastError(wxT("CreateBitmap")); | |
529 | } | |
6d167489 | 530 | } |
0becd470 VZ |
531 | else |
532 | #endif // !__WXMICROWIN__ | |
533 | { | |
534 | ScreenHDC dc; | |
535 | hbmp = ::CreateCompatibleBitmap(dc, w, h); | |
536 | if ( !hbmp ) | |
537 | { | |
538 | wxLogLastError(wxT("CreateCompatibleBitmap")); | |
539 | } | |
6d167489 | 540 | |
0becd470 VZ |
541 | GetBitmapData()->m_depth = wxDisplayDepth(); |
542 | } | |
2cf45d69 | 543 | } |
2bda0e17 | 544 | |
2cf45d69 | 545 | SetHBITMAP((WXHBITMAP)hbmp); |
2bda0e17 | 546 | |
6d167489 | 547 | #if WXWIN_COMPATIBILITY_2 |
2cf45d69 | 548 | GetBitmapData()->m_ok = hbmp != 0; |
6d167489 | 549 | #endif // WXWIN_COMPATIBILITY_2 |
0becd470 | 550 | |
6d167489 | 551 | return Ok(); |
2bda0e17 KB |
552 | } |
553 | ||
acf8e3d2 | 554 | #if wxUSE_IMAGE |
0becd470 | 555 | |
6d51f220 | 556 | // ---------------------------------------------------------------------------- |
acf8e3d2 | 557 | // wxImage to/from conversions for Microwin |
6d51f220 VZ |
558 | // ---------------------------------------------------------------------------- |
559 | ||
acf8e3d2 VZ |
560 | // Microwin versions are so different from normal ones that it really doesn't |
561 | // make sense to use #ifdefs inside the function bodies | |
562 | #ifdef __WXMICROWIN__ | |
6d51f220 | 563 | |
2cf45d69 | 564 | bool wxBitmap::CreateFromImage(const wxImage& image, int depth, const wxDC& dc) |
fec19ea9 | 565 | { |
acf8e3d2 VZ |
566 | // Set this to 1 to experiment with mask code, |
567 | // which currently doesn't work | |
568 | #define USE_MASKS 0 | |
62e1ba75 | 569 | |
54a96d02 | 570 | m_refData = new wxBitmapRefData(); |
e640f823 JS |
571 | |
572 | // Initial attempt at a simple-minded implementation. | |
573 | // The bitmap will always be created at the screen depth, | |
574 | // so the 'depth' argument is ignored. | |
8e9ff815 | 575 | |
e640f823 JS |
576 | HDC hScreenDC = ::GetDC(NULL); |
577 | int screenDepth = ::GetDeviceCaps(hScreenDC, BITSPIXEL); | |
578 | ||
579 | HBITMAP hBitmap = ::CreateCompatibleBitmap(hScreenDC, image.GetWidth(), image.GetHeight()); | |
62e1ba75 JS |
580 | HBITMAP hMaskBitmap = NULL; |
581 | HBITMAP hOldMaskBitmap = NULL; | |
582 | HDC hMaskDC = NULL; | |
583 | unsigned char maskR = 0; | |
584 | unsigned char maskG = 0; | |
585 | unsigned char maskB = 0; | |
586 | ||
54a96d02 | 587 | // printf("Created bitmap %d\n", (int) hBitmap); |
e640f823 JS |
588 | if (hBitmap == NULL) |
589 | { | |
590 | ::ReleaseDC(NULL, hScreenDC); | |
8e9ff815 | 591 | return FALSE; |
e640f823 JS |
592 | } |
593 | HDC hMemDC = ::CreateCompatibleDC(hScreenDC); | |
e640f823 JS |
594 | |
595 | HBITMAP hOldBitmap = ::SelectObject(hMemDC, hBitmap); | |
62e1ba75 JS |
596 | ::ReleaseDC(NULL, hScreenDC); |
597 | ||
598 | // created an mono-bitmap for the possible mask | |
599 | bool hasMask = image.HasMask(); | |
600 | ||
601 | if ( hasMask ) | |
602 | { | |
603 | #if USE_MASKS | |
604 | // FIXME: we should be able to pass bpp = 1, but | |
605 | // GdBlit can't handle a different depth | |
606 | #if 0 | |
607 | hMaskBitmap = ::CreateBitmap( (WORD)image.GetWidth(), (WORD)image.GetHeight(), 1, 1, NULL ); | |
608 | #else | |
609 | hMaskBitmap = ::CreateCompatibleBitmap( hMemDC, (WORD)image.GetWidth(), (WORD)image.GetHeight()); | |
610 | #endif | |
611 | maskR = image.GetMaskRed(); | |
612 | maskG = image.GetMaskGreen(); | |
613 | maskB = image.GetMaskBlue(); | |
614 | ||
615 | if (!hMaskBitmap) | |
616 | { | |
617 | hasMask = FALSE; | |
8e9ff815 | 618 | } |
62e1ba75 JS |
619 | else |
620 | { | |
621 | hScreenDC = ::GetDC(NULL); | |
622 | hMaskDC = ::CreateCompatibleDC(hScreenDC); | |
623 | ::ReleaseDC(NULL, hScreenDC); | |
624 | ||
625 | hOldMaskBitmap = ::SelectObject( hMaskDC, hMaskBitmap); | |
8e9ff815 | 626 | } |
62e1ba75 JS |
627 | #else |
628 | hasMask = FALSE; | |
629 | #endif | |
630 | } | |
e640f823 JS |
631 | |
632 | int i, j; | |
633 | for (i = 0; i < image.GetWidth(); i++) | |
634 | { | |
8e9ff815 VZ |
635 | for (j = 0; j < image.GetHeight(); j++) |
636 | { | |
637 | unsigned char red = image.GetRed(i, j); | |
638 | unsigned char green = image.GetGreen(i, j); | |
639 | unsigned char blue = image.GetBlue(i, j); | |
e640f823 | 640 | |
8e9ff815 | 641 | ::SetPixel(hMemDC, i, j, PALETTERGB(red, green, blue)); |
62e1ba75 JS |
642 | |
643 | if (hasMask) | |
644 | { | |
645 | // scan the bitmap for the transparent colour and set the corresponding | |
646 | // pixels in the mask to BLACK and the rest to WHITE | |
647 | if (maskR == red && maskG == green && maskB == blue) | |
648 | ::SetPixel(hMaskDC, i, j, PALETTERGB(0, 0, 0)); | |
649 | else | |
650 | ::SetPixel(hMaskDC, i, j, PALETTERGB(255, 255, 255)); | |
8e9ff815 VZ |
651 | } |
652 | } | |
e640f823 JS |
653 | } |
654 | ||
655 | ::SelectObject(hMemDC, hOldBitmap); | |
656 | ::DeleteDC(hMemDC); | |
62e1ba75 JS |
657 | if (hasMask) |
658 | { | |
659 | ::SelectObject(hMaskDC, hOldMaskBitmap); | |
8e9ff815 | 660 | ::DeleteDC(hMaskDC); |
62e1ba75 | 661 | |
8bbbae21 | 662 | ((wxBitmapRefData*)m_refData)->SetMask(hMaskBitmap); |
62e1ba75 | 663 | } |
8e9ff815 | 664 | |
e640f823 JS |
665 | SetWidth(image.GetWidth()); |
666 | SetHeight(image.GetHeight()); | |
667 | SetDepth(screenDepth); | |
668 | SetHBITMAP( (WXHBITMAP) hBitmap ); | |
8e9ff815 | 669 | |
e640f823 JS |
670 | #if wxUSE_PALETTE |
671 | // Copy the palette from the source image | |
672 | SetPalette(image.GetPalette()); | |
673 | #endif // wxUSE_PALETTE | |
674 | ||
54a96d02 JS |
675 | #if WXWIN_COMPATIBILITY_2 |
676 | // check the wxBitmap object | |
677 | GetBitmapData()->SetOk(); | |
678 | #endif // WXWIN_COMPATIBILITY_2 | |
679 | ||
e640f823 | 680 | return TRUE; |
fec19ea9 VS |
681 | } |
682 | ||
683 | wxImage wxBitmap::ConvertToImage() const | |
684 | { | |
e640f823 JS |
685 | // Initial attempt at a simple-minded implementation. |
686 | // The bitmap will always be created at the screen depth, | |
687 | // so the 'depth' argument is ignored. | |
688 | // TODO: transparency (create a mask image) | |
689 | ||
690 | if (!Ok()) | |
691 | { | |
692 | wxFAIL_MSG( wxT("bitmap is invalid") ); | |
8e9ff815 | 693 | return wxNullImage; |
e640f823 JS |
694 | } |
695 | ||
696 | wxImage image; | |
697 | ||
698 | wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") ); | |
699 | ||
700 | // create an wxImage object | |
701 | int width = GetWidth(); | |
702 | int height = GetHeight(); | |
703 | image.Create( width, height ); | |
704 | unsigned char *data = image.GetData(); | |
705 | if( !data ) | |
706 | { | |
707 | wxFAIL_MSG( wxT("could not allocate data for image") ); | |
708 | return wxNullImage; | |
709 | } | |
8e9ff815 | 710 | |
e640f823 JS |
711 | HDC hScreenDC = ::GetDC(NULL); |
712 | ||
713 | HDC hMemDC = ::CreateCompatibleDC(hScreenDC); | |
714 | ::ReleaseDC(NULL, hScreenDC); | |
715 | ||
716 | HBITMAP hBitmap = (HBITMAP) GetHBITMAP(); | |
8e9ff815 | 717 | |
e640f823 JS |
718 | HBITMAP hOldBitmap = ::SelectObject(hMemDC, hBitmap); |
719 | ||
720 | int i, j; | |
721 | for (i = 0; i < GetWidth(); i++) | |
722 | { | |
8e9ff815 VZ |
723 | for (j = 0; j < GetHeight(); j++) |
724 | { | |
725 | COLORREF color = ::GetPixel(hMemDC, i, j); | |
726 | unsigned char red = GetRValue(color); | |
727 | unsigned char green = GetGValue(color); | |
728 | unsigned char blue = GetBValue(color); | |
729 | ||
730 | image.SetRGB(i, j, red, green, blue); | |
731 | } | |
e640f823 JS |
732 | } |
733 | ||
734 | ::SelectObject(hMemDC, hOldBitmap); | |
735 | ::DeleteDC(hMemDC); | |
8e9ff815 | 736 | |
e640f823 JS |
737 | #if wxUSE_PALETTE |
738 | // Copy the palette from the source image | |
739 | if (GetPalette()) | |
740 | image.SetPalette(* GetPalette()); | |
741 | #endif // wxUSE_PALETTE | |
742 | ||
743 | return image; | |
acf8e3d2 VZ |
744 | } |
745 | ||
746 | #endif // __WXMICROWIN__ | |
747 | ||
748 | // ---------------------------------------------------------------------------- | |
749 | // wxImage to/from conversions | |
750 | // ---------------------------------------------------------------------------- | |
751 | ||
2cf45d69 VZ |
752 | bool wxBitmap::CreateFromImage(const wxImage& image, int depth) |
753 | { | |
754 | return CreateFromImage(image, depth, 0); | |
755 | } | |
756 | ||
757 | bool wxBitmap::CreateFromImage(const wxImage& image, const wxDC& dc) | |
758 | { | |
759 | wxCHECK_MSG( dc.Ok(), FALSE, | |
760 | _T("invalid HDC in wxBitmap::CreateFromImage()") ); | |
761 | ||
762 | return CreateFromImage(image, -1, dc.GetHDC()); | |
763 | } | |
764 | ||
765 | bool wxBitmap::CreateFromImage(const wxImage& image, int depth, WXHDC hdc ) | |
acf8e3d2 VZ |
766 | { |
767 | wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") ); | |
768 | ||
769 | UnRef(); | |
770 | ||
771 | // first convert the image to DIB | |
772 | const int h = image.GetHeight(); | |
773 | const int w = image.GetWidth(); | |
774 | ||
775 | wxDIB dib(image); | |
776 | if ( !dib.IsOk() ) | |
777 | return FALSE; | |
778 | ||
779 | ||
780 | // store the bitmap parameters | |
781 | wxBitmapRefData *refData = new wxBitmapRefData; | |
782 | refData->m_width = w; | |
783 | refData->m_height = h; | |
acf8e3d2 VZ |
784 | refData->m_hasAlpha = image.HasAlpha(); |
785 | ||
786 | m_refData = refData; | |
787 | ||
788 | ||
789 | // next either store DIB as is or create a DDB from it | |
790 | HBITMAP hbitmap; | |
791 | ||
2cf45d69 | 792 | // are we going to use DIB? |
4b8ab2f9 VZ |
793 | // |
794 | // NB: DDBs don't support alpha so if we have alpha channel we must use DIB | |
795 | if ( image.HasAlpha() || wxShouldCreateDIB(w, h, depth, hdc) ) | |
2cf45d69 VZ |
796 | { |
797 | // don't delete the DIB section in dib object dtor | |
798 | hbitmap = dib.Detach(); | |
799 | ||
fa275e86 | 800 | refData->m_isDIB = TRUE; |
2cf45d69 VZ |
801 | refData->m_depth = dib.GetDepth(); |
802 | } | |
803 | else // we need to convert DIB to DDB | |
acf8e3d2 | 804 | { |
b0ea5d96 | 805 | hbitmap = dib.CreateDDB((HDC)hdc); |
2cf45d69 VZ |
806 | |
807 | refData->m_depth = depth == -1 ? wxDisplayDepth() : depth; | |
acf8e3d2 VZ |
808 | } |
809 | ||
810 | // validate this object | |
811 | SetHBITMAP((WXHBITMAP)hbitmap); | |
812 | ||
813 | #if WXWIN_COMPATIBILITY_2 | |
814 | m_refData->m_ok = TRUE; | |
815 | #endif // WXWIN_COMPATIBILITY_2 | |
816 | ||
817 | // finally also set the mask if we have one | |
818 | if ( image.HasMask() ) | |
819 | { | |
820 | SetMask(new wxMask(*this, wxColour(image.GetMaskRed(), | |
821 | image.GetMaskGreen(), | |
822 | image.GetMaskBlue()))); | |
823 | } | |
824 | ||
825 | return TRUE; | |
826 | } | |
827 | ||
828 | wxImage wxBitmap::ConvertToImage() const | |
829 | { | |
c8688869 VZ |
830 | // the colour used as transparent one in wxImage and the one it is replaced |
831 | // with when it really occurs in the bitmap | |
832 | static const int MASK_RED = 1; | |
833 | static const int MASK_GREEN = 2; | |
834 | static const int MASK_BLUE = 3; | |
835 | static const int MASK_BLUE_REPLACEMENT = 2; | |
836 | ||
fec19ea9 | 837 | wxImage image; |
6d51f220 | 838 | |
fec19ea9 VS |
839 | wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") ); |
840 | ||
841 | // create an wxImage object | |
842 | int width = GetWidth(); | |
843 | int height = GetHeight(); | |
844 | image.Create( width, height ); | |
845 | unsigned char *data = image.GetData(); | |
846 | if( !data ) | |
847 | { | |
848 | wxFAIL_MSG( wxT("could not allocate data for image") ); | |
849 | return wxNullImage; | |
850 | } | |
851 | ||
852 | // calc the number of bytes per scanline and padding in the DIB | |
853 | int bytePerLine = width*3; | |
854 | int sizeDWORD = sizeof( DWORD ); | |
855 | int lineBoundary = bytePerLine % sizeDWORD; | |
856 | int padding = 0; | |
857 | if( lineBoundary > 0 ) | |
858 | { | |
859 | padding = sizeDWORD - lineBoundary; | |
860 | bytePerLine += padding; | |
861 | } | |
862 | ||
863 | // create a DIB header | |
864 | int headersize = sizeof(BITMAPINFOHEADER); | |
865 | BITMAPINFO *lpDIBh = (BITMAPINFO *) malloc( headersize ); | |
866 | if( !lpDIBh ) | |
867 | { | |
868 | wxFAIL_MSG( wxT("could not allocate data for DIB header") ); | |
869 | free( data ); | |
870 | return wxNullImage; | |
871 | } | |
872 | // Fill in the DIB header | |
873 | lpDIBh->bmiHeader.biSize = headersize; | |
874 | lpDIBh->bmiHeader.biWidth = width; | |
875 | lpDIBh->bmiHeader.biHeight = -height; | |
876 | lpDIBh->bmiHeader.biSizeImage = bytePerLine * height; | |
877 | lpDIBh->bmiHeader.biPlanes = 1; | |
878 | lpDIBh->bmiHeader.biBitCount = 24; | |
879 | lpDIBh->bmiHeader.biCompression = BI_RGB; | |
880 | lpDIBh->bmiHeader.biClrUsed = 0; | |
881 | // These seem not really needed for our purpose here. | |
882 | lpDIBh->bmiHeader.biClrImportant = 0; | |
883 | lpDIBh->bmiHeader.biXPelsPerMeter = 0; | |
884 | lpDIBh->bmiHeader.biYPelsPerMeter = 0; | |
885 | // memory for DIB data | |
886 | unsigned char *lpBits; | |
887 | lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage ); | |
888 | if( !lpBits ) | |
889 | { | |
890 | wxFAIL_MSG( wxT("could not allocate data for DIB") ); | |
891 | free( data ); | |
892 | free( lpDIBh ); | |
893 | return wxNullImage; | |
894 | } | |
895 | ||
896 | // copy data from the device-dependent bitmap to the DIB | |
897 | HDC hdc = ::GetDC(NULL); | |
898 | HBITMAP hbitmap; | |
899 | hbitmap = (HBITMAP) GetHBITMAP(); | |
900 | ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS ); | |
901 | ||
902 | // copy DIB data into the wxImage object | |
903 | int i, j; | |
904 | unsigned char *ptdata = data; | |
905 | unsigned char *ptbits = lpBits; | |
906 | for( i=0; i<height; i++ ) | |
907 | { | |
908 | for( j=0; j<width; j++ ) | |
909 | { | |
910 | *(ptdata++) = *(ptbits+2); | |
911 | *(ptdata++) = *(ptbits+1); | |
912 | *(ptdata++) = *(ptbits ); | |
913 | ptbits += 3; | |
914 | } | |
915 | ptbits += padding; | |
916 | } | |
917 | ||
918 | // similarly, set data according to the possible mask bitmap | |
919 | if( GetMask() && GetMask()->GetMaskBitmap() ) | |
920 | { | |
921 | hbitmap = (HBITMAP) GetMask()->GetMaskBitmap(); | |
922 | // memory DC created, color set, data copied, and memory DC deleted | |
923 | HDC memdc = ::CreateCompatibleDC( hdc ); | |
924 | ::SetTextColor( memdc, RGB( 0, 0, 0 ) ); | |
925 | ::SetBkColor( memdc, RGB( 255, 255, 255 ) ); | |
926 | ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS ); | |
927 | ::DeleteDC( memdc ); | |
fec19ea9 VS |
928 | ptdata = data; |
929 | ptbits = lpBits; | |
930 | for( i=0; i<height; i++ ) | |
931 | { | |
932 | for( j=0; j<width; j++ ) | |
933 | { | |
c8688869 VZ |
934 | // is this pixel transparent? |
935 | if ( *ptbits != 0 ) | |
936 | { | |
937 | if ( (ptdata[0] == MASK_RED) && | |
938 | (ptdata[1] == MASK_GREEN) && | |
939 | (ptdata[2] == MASK_BLUE) ) | |
940 | { | |
941 | // we have to fudge the colour a bit to prevent this | |
942 | // pixel from appearing transparent | |
943 | ptdata[2] = MASK_BLUE_REPLACEMENT; | |
944 | } | |
fec19ea9 | 945 | ptdata += 3; |
c8688869 VZ |
946 | } |
947 | else // masked pixel | |
fec19ea9 | 948 | { |
c8688869 VZ |
949 | *(ptdata++) = MASK_RED; |
950 | *(ptdata++) = MASK_GREEN; | |
951 | *(ptdata++) = MASK_BLUE; | |
fec19ea9 VS |
952 | } |
953 | ptbits += 3; | |
954 | } | |
955 | ptbits += padding; | |
956 | } | |
c8688869 VZ |
957 | |
958 | image.SetMaskColour( MASK_RED, MASK_GREEN, MASK_BLUE ); | |
fec19ea9 VS |
959 | image.SetMask( TRUE ); |
960 | } | |
961 | else | |
962 | { | |
963 | image.SetMask( FALSE ); | |
964 | } | |
965 | // free allocated resources | |
966 | ::ReleaseDC(NULL, hdc); | |
967 | free(lpDIBh); | |
968 | free(lpBits); | |
969 | ||
970 | return image; | |
971 | } | |
972 | ||
6d51f220 VZ |
973 | #endif // wxUSE_IMAGE |
974 | ||
acf8e3d2 VZ |
975 | // ---------------------------------------------------------------------------- |
976 | // loading and saving bitmaps | |
977 | // ---------------------------------------------------------------------------- | |
978 | ||
debe6624 | 979 | bool wxBitmap::LoadFile(const wxString& filename, long type) |
2bda0e17 | 980 | { |
6d167489 | 981 | UnRef(); |
2bda0e17 | 982 | |
6d167489 | 983 | wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler); |
2bda0e17 | 984 | |
6d167489 VZ |
985 | if ( handler ) |
986 | { | |
987 | m_refData = new wxBitmapRefData; | |
2bda0e17 | 988 | |
6d167489 VZ |
989 | return handler->LoadFile(this, filename, type, -1, -1); |
990 | } | |
6d51f220 | 991 | #if wxUSE_IMAGE |
6d167489 | 992 | else |
b75dd496 | 993 | { |
6d167489 | 994 | wxImage image; |
6d51f220 VZ |
995 | if ( image.LoadFile( filename, type ) && image.Ok() ) |
996 | { | |
368d59f0 | 997 | *this = wxBitmap(image); |
6d167489 | 998 | |
6d51f220 VZ |
999 | return TRUE; |
1000 | } | |
b75dd496 | 1001 | } |
6d51f220 VZ |
1002 | #endif // wxUSE_IMAGE |
1003 | ||
1004 | return FALSE; | |
2bda0e17 KB |
1005 | } |
1006 | ||
debe6624 | 1007 | bool wxBitmap::Create(void *data, long type, int width, int height, int depth) |
2bda0e17 | 1008 | { |
6d167489 | 1009 | UnRef(); |
2bda0e17 | 1010 | |
6d167489 | 1011 | wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler); |
2bda0e17 | 1012 | |
6d167489 VZ |
1013 | if ( !handler ) |
1014 | { | |
9b601c24 | 1015 | wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for type %ld defined."), type); |
2bda0e17 | 1016 | |
6d167489 VZ |
1017 | return FALSE; |
1018 | } | |
1d792928 | 1019 | |
6d167489 | 1020 | m_refData = new wxBitmapRefData; |
1d792928 | 1021 | |
6d167489 | 1022 | return handler->Create(this, data, type, width, height, depth); |
2bda0e17 KB |
1023 | } |
1024 | ||
d275c7eb VZ |
1025 | bool wxBitmap::SaveFile(const wxString& filename, |
1026 | int type, | |
1027 | const wxPalette *palette) | |
2bda0e17 | 1028 | { |
6d167489 | 1029 | wxBitmapHandler *handler = wxDynamicCast(FindHandler(type), wxBitmapHandler); |
2bda0e17 | 1030 | |
6d167489 VZ |
1031 | if ( handler ) |
1032 | { | |
1033 | return handler->SaveFile(this, filename, type, palette); | |
1034 | } | |
6d51f220 | 1035 | #if wxUSE_IMAGE |
6d167489 VZ |
1036 | else |
1037 | { | |
1038 | // FIXME what about palette? shouldn't we use it? | |
368d59f0 | 1039 | wxImage image = ConvertToImage(); |
6d51f220 VZ |
1040 | if ( image.Ok() ) |
1041 | { | |
1042 | return image.SaveFile(filename, type); | |
1043 | } | |
6d167489 | 1044 | } |
6d51f220 VZ |
1045 | #endif // wxUSE_IMAGE |
1046 | ||
1047 | return FALSE; | |
2bda0e17 KB |
1048 | } |
1049 | ||
4b7f2165 VZ |
1050 | // ---------------------------------------------------------------------------- |
1051 | // sub bitmap extraction | |
1052 | // ---------------------------------------------------------------------------- | |
1053 | ||
1054 | wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const | |
1055 | { | |
1056 | wxCHECK_MSG( Ok() && | |
1057 | (rect.x >= 0) && (rect.y >= 0) && | |
1058 | (rect.x+rect.width <= GetWidth()) && | |
1059 | (rect.y+rect.height <= GetHeight()), | |
1060 | wxNullBitmap, wxT("Invalid bitmap or bitmap region") ); | |
1061 | ||
acf8e3d2 | 1062 | wxBitmap ret( rect.width, rect.height ); |
4b7f2165 VZ |
1063 | wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") ); |
1064 | ||
8e9ff815 | 1065 | #ifndef __WXMICROWIN__ |
acf8e3d2 VZ |
1066 | // TODO: copy alpha channel data if any |
1067 | ||
4b7f2165 | 1068 | // copy bitmap data |
acf8e3d2 VZ |
1069 | MemoryHDC dcSrc, |
1070 | dcDst; | |
8e9ff815 VZ |
1071 | |
1072 | { | |
1073 | SelectInHDC selectSrc(dcSrc, GetHbitmap()), | |
1074 | selectDst(dcDst, GetHbitmapOf(ret)); | |
1075 | ||
acf8e3d2 VZ |
1076 | if ( !selectSrc || !selectDst ) |
1077 | { | |
1078 | wxLogLastError(_T("SelectObjct(hBitmap)")); | |
1079 | } | |
1080 | ||
8e9ff815 VZ |
1081 | if ( !::BitBlt(dcDst, 0, 0, rect.width, rect.height, |
1082 | dcSrc, rect.x, rect.y, SRCCOPY) ) | |
1083 | { | |
1084 | wxLogLastError(_T("BitBlt")); | |
1085 | } | |
1086 | } | |
4b7f2165 VZ |
1087 | |
1088 | // copy mask if there is one | |
8e9ff815 | 1089 | if ( GetMask() ) |
4b7f2165 VZ |
1090 | { |
1091 | HBITMAP hbmpMask = ::CreateBitmap(rect.width, rect.height, 1, 1, 0); | |
1092 | ||
8e9ff815 VZ |
1093 | SelectInHDC selectSrc(dcSrc, (HBITMAP) GetMask()->GetMaskBitmap()), |
1094 | selectDst(dcDst, hbmpMask); | |
1095 | ||
1096 | if ( !::BitBlt(dcDst, 0, 0, rect.width, rect.height, | |
1097 | dcSrc, rect.x, rect.y, SRCCOPY) ) | |
1098 | { | |
1099 | wxLogLastError(_T("BitBlt")); | |
1100 | } | |
4b7f2165 VZ |
1101 | |
1102 | wxMask *mask = new wxMask((WXHBITMAP) hbmpMask); | |
1103 | ret.SetMask(mask); | |
1104 | } | |
8e9ff815 | 1105 | #endif // !__WXMICROWIN__ |
4b7f2165 VZ |
1106 | |
1107 | return ret; | |
1108 | } | |
1109 | ||
6d167489 VZ |
1110 | // ---------------------------------------------------------------------------- |
1111 | // wxBitmap accessors | |
1112 | // ---------------------------------------------------------------------------- | |
2bda0e17 | 1113 | |
adf9e099 | 1114 | #if wxUSE_PALETTE |
8bbbae21 | 1115 | wxPalette* wxBitmap::GetPalette() const |
2bda0e17 | 1116 | { |
8bbbae21 VZ |
1117 | return GetBitmapData() ? &GetBitmapData()->m_bitmapPalette |
1118 | : (wxPalette *) NULL; | |
1119 | } | |
adf9e099 | 1120 | #endif |
8bbbae21 VZ |
1121 | |
1122 | wxMask *wxBitmap::GetMask() const | |
1123 | { | |
1124 | return GetBitmapData() ? GetBitmapData()->GetMask() : (wxMask *) NULL; | |
1125 | } | |
2bda0e17 | 1126 | |
3ca22d5e MB |
1127 | #ifdef __WXDEBUG__ |
1128 | ||
8bbbae21 VZ |
1129 | wxDC *wxBitmap::GetSelectedInto() const |
1130 | { | |
1131 | return GetBitmapData() ? GetBitmapData()->m_selectedInto : (wxDC *) NULL; | |
2bda0e17 KB |
1132 | } |
1133 | ||
3ca22d5e MB |
1134 | #endif |
1135 | ||
8bbbae21 VZ |
1136 | #if WXWIN_COMPATIBILITY_2_4 |
1137 | ||
1138 | int wxBitmap::GetQuality() const | |
1139 | { | |
1140 | return 0; | |
1141 | } | |
1142 | ||
1143 | #endif // WXWIN_COMPATIBILITY_2_4 | |
1144 | ||
10b41b53 VZ |
1145 | void wxBitmap::UseAlpha() |
1146 | { | |
1147 | if ( GetBitmapData() ) | |
1148 | GetBitmapData()->m_hasAlpha = true; | |
1149 | } | |
1150 | ||
acf8e3d2 VZ |
1151 | bool wxBitmap::HasAlpha() const |
1152 | { | |
1153 | return GetBitmapData() && GetBitmapData()->m_hasAlpha; | |
1154 | } | |
1155 | ||
8bbbae21 VZ |
1156 | // ---------------------------------------------------------------------------- |
1157 | // wxBitmap setters | |
1158 | // ---------------------------------------------------------------------------- | |
1159 | ||
3ca22d5e MB |
1160 | #ifdef __WXDEBUG__ |
1161 | ||
8bbbae21 VZ |
1162 | void wxBitmap::SetSelectedInto(wxDC *dc) |
1163 | { | |
1164 | if ( GetBitmapData() ) | |
1165 | GetBitmapData()->m_selectedInto = dc; | |
2bda0e17 KB |
1166 | } |
1167 | ||
3ca22d5e MB |
1168 | #endif |
1169 | ||
d275c7eb VZ |
1170 | #if wxUSE_PALETTE |
1171 | ||
2bda0e17 KB |
1172 | void wxBitmap::SetPalette(const wxPalette& palette) |
1173 | { | |
6d167489 | 1174 | EnsureHasData(); |
2bda0e17 | 1175 | |
6d167489 | 1176 | GetBitmapData()->m_bitmapPalette = palette; |
2bda0e17 KB |
1177 | } |
1178 | ||
d275c7eb VZ |
1179 | #endif // wxUSE_PALETTE |
1180 | ||
2bda0e17 KB |
1181 | void wxBitmap::SetMask(wxMask *mask) |
1182 | { | |
6d167489 | 1183 | EnsureHasData(); |
2bda0e17 | 1184 | |
8bbbae21 VZ |
1185 | GetBitmapData()->SetMask(mask); |
1186 | } | |
1187 | ||
1188 | #if WXWIN_COMPATIBILITY_2 | |
1189 | ||
1190 | void wxBitmap::SetOk(bool isOk) | |
1191 | { | |
1192 | EnsureHasData(); | |
1193 | ||
1194 | GetBitmapData()->m_ok = isOk; | |
1195 | } | |
1196 | ||
1197 | #endif // WXWIN_COMPATIBILITY_2 | |
1198 | ||
1199 | #if WXWIN_COMPATIBILITY_2_4 | |
1200 | ||
1201 | void wxBitmap::SetQuality(int WXUNUSED(quality)) | |
1202 | { | |
2bda0e17 KB |
1203 | } |
1204 | ||
8bbbae21 VZ |
1205 | #endif // WXWIN_COMPATIBILITY_2_4 |
1206 | ||
2cf45d69 VZ |
1207 | // ---------------------------------------------------------------------------- |
1208 | // raw bitmap access support | |
1209 | // ---------------------------------------------------------------------------- | |
1210 | ||
1e3c12d7 | 1211 | #ifdef wxHAVE_RAW_BITMAP |
b9bcaf11 | 1212 | void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp) |
2cf45d69 | 1213 | { |
2cf45d69 VZ |
1214 | if ( !Ok() ) |
1215 | { | |
1216 | // no bitmap, no data (raw or otherwise) | |
b9bcaf11 | 1217 | return NULL; |
2cf45d69 VZ |
1218 | } |
1219 | ||
fa275e86 VZ |
1220 | // if we're already a DIB we can access our data directly, but if not we |
1221 | // need to convert this DDB to a DIB section and use it for raw access and | |
1222 | // then convert it back | |
1223 | HBITMAP hDIB; | |
1224 | if ( !GetBitmapData()->m_isDIB ) | |
1225 | { | |
1226 | wxCHECK_MSG( !GetBitmapData()->m_dib, FALSE, | |
1227 | _T("GetRawData() may be called only once") ); | |
1228 | ||
1229 | wxDIB *dib = new wxDIB(*this); | |
1230 | if ( !dib->IsOk() ) | |
1231 | { | |
1232 | delete dib; | |
1233 | ||
b9bcaf11 | 1234 | return NULL; |
fa275e86 VZ |
1235 | } |
1236 | ||
1237 | // we'll free it in UngetRawData() | |
1238 | GetBitmapData()->m_dib = dib; | |
1239 | ||
1240 | hDIB = dib->GetHandle(); | |
1241 | } | |
1242 | else // we're a DIB | |
1243 | { | |
1244 | hDIB = GetHbitmap(); | |
1245 | } | |
1246 | ||
2cf45d69 | 1247 | DIBSECTION ds; |
fa275e86 | 1248 | if ( ::GetObject(hDIB, sizeof(ds), &ds) != sizeof(DIBSECTION) ) |
2cf45d69 | 1249 | { |
fa275e86 VZ |
1250 | wxFAIL_MSG( _T("failed to get DIBSECTION from a DIB?") ); |
1251 | ||
b9bcaf11 VZ |
1252 | return NULL; |
1253 | } | |
1254 | ||
1255 | // check that the bitmap is in correct format | |
1256 | if ( ds.dsBm.bmBitsPixel != bpp ) | |
1257 | { | |
1258 | wxFAIL_MSG( _T("incorrect bitmap type in wxBitmap::GetRawData()") ); | |
1259 | ||
1260 | return NULL; | |
2cf45d69 VZ |
1261 | } |
1262 | ||
b9bcaf11 | 1263 | // ok, store the relevant info in wxPixelDataBase |
2cf45d69 VZ |
1264 | const LONG h = ds.dsBm.bmHeight; |
1265 | ||
b9bcaf11 VZ |
1266 | data.m_width = ds.dsBm.bmWidth; |
1267 | data.m_height = h; | |
2cf45d69 VZ |
1268 | |
1269 | // remember that DIBs are stored in top to bottom order! | |
1270 | const LONG bytesPerRow = ds.dsBm.bmWidthBytes; | |
b9bcaf11 VZ |
1271 | data.m_stride = -bytesPerRow; |
1272 | ||
1273 | char *bits = (char *)ds.dsBm.bmBits; | |
2cf45d69 VZ |
1274 | if ( h > 1 ) |
1275 | { | |
b9bcaf11 | 1276 | bits += (h - 1)*bytesPerRow; |
2cf45d69 VZ |
1277 | } |
1278 | ||
b9bcaf11 | 1279 | return bits; |
2cf45d69 VZ |
1280 | } |
1281 | ||
b9bcaf11 | 1282 | void wxBitmap::UngetRawData(wxPixelDataBase& dataBase) |
13c13ecb | 1283 | { |
fa275e86 VZ |
1284 | if ( !Ok() ) |
1285 | return; | |
1286 | ||
b9bcaf11 VZ |
1287 | // the cast is ugly but we can't do without it and without making this |
1288 | // function template (and hence inline) unfortunately | |
1289 | typedef wxPixelData<wxBitmap, wxAlphaPixelFormat> PixelData; | |
1290 | PixelData& data = (PixelData &)dataBase; | |
1291 | ||
1292 | if ( !data ) | |
7af64aac VZ |
1293 | { |
1294 | // invalid data, don't crash -- but don't assert neither as we're | |
b9bcaf11 | 1295 | // called automatically from wxPixelDataBase dtor and so there is no |
7af64aac VZ |
1296 | // way to prevent this from happening |
1297 | return; | |
1298 | } | |
1299 | ||
b9bcaf11 | 1300 | if ( GetBitmapData()->m_hasAlpha ) |
13c13ecb | 1301 | { |
b9bcaf11 VZ |
1302 | // AlphaBlend() wants to have premultiplied source alpha but |
1303 | // wxRawBitmap API uses normal, not premultiplied, colours, so adjust | |
1304 | // them here now | |
1305 | PixelData::Iterator p(data); | |
106c33bb | 1306 | |
b9bcaf11 VZ |
1307 | const int w = data.GetWidth(); |
1308 | const int h = data.GetHeight(); | |
1309 | ||
1310 | for ( int y = 0; y < h; y++ ) | |
13c13ecb | 1311 | { |
b9bcaf11 | 1312 | PixelData::Iterator rowStart = p; |
106c33bb | 1313 | |
b9bcaf11 VZ |
1314 | for ( int x = 0; x < w; x++ ) |
1315 | { | |
1316 | const unsigned alpha = p.Alpha(); | |
106c33bb | 1317 | |
b9bcaf11 VZ |
1318 | p.Red() = (p.Red() * alpha + 127) / 255; |
1319 | p.Blue() = (p.Blue() * alpha + 127) / 255; | |
1320 | p.Green() = (p.Green() * alpha + 127) / 255; | |
106c33bb | 1321 | |
b9bcaf11 VZ |
1322 | ++p; |
1323 | } | |
fa275e86 | 1324 | |
b9bcaf11 VZ |
1325 | p = rowStart; |
1326 | p.OffsetY(data, 1); | |
1327 | } | |
1328 | ||
1329 | // if we're a DDB we need to convert DIB back to DDB now to make the | |
1330 | // changes made via raw bitmap access effective | |
1331 | if ( !GetBitmapData()->m_isDIB ) | |
1332 | { | |
1333 | wxDIB *dib = GetBitmapData()->m_dib; | |
1334 | GetBitmapData()->m_dib = NULL; | |
fa275e86 | 1335 | |
b9bcaf11 | 1336 | // TODO: convert |
fa275e86 | 1337 | |
b9bcaf11 VZ |
1338 | delete dib; |
1339 | } | |
fa275e86 | 1340 | } |
13c13ecb | 1341 | } |
1e3c12d7 | 1342 | #endif // #ifdef wxHAVE_RAW_BITMAP |
13c13ecb | 1343 | |
6d167489 VZ |
1344 | // ---------------------------------------------------------------------------- |
1345 | // wxMask | |
1346 | // ---------------------------------------------------------------------------- | |
2bda0e17 | 1347 | |
10fcf31a | 1348 | wxMask::wxMask() |
2bda0e17 KB |
1349 | { |
1350 | m_maskBitmap = 0; | |
1351 | } | |
1352 | ||
1353 | // Construct a mask from a bitmap and a colour indicating | |
1354 | // the transparent area | |
1355 | wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour) | |
1356 | { | |
1357 | m_maskBitmap = 0; | |
6d167489 | 1358 | Create(bitmap, colour); |
2bda0e17 KB |
1359 | } |
1360 | ||
1361 | // Construct a mask from a bitmap and a palette index indicating | |
1362 | // the transparent area | |
debe6624 | 1363 | wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex) |
2bda0e17 KB |
1364 | { |
1365 | m_maskBitmap = 0; | |
6d167489 | 1366 | Create(bitmap, paletteIndex); |
2bda0e17 KB |
1367 | } |
1368 | ||
1369 | // Construct a mask from a mono bitmap (copies the bitmap). | |
1370 | wxMask::wxMask(const wxBitmap& bitmap) | |
1371 | { | |
1372 | m_maskBitmap = 0; | |
6d167489 | 1373 | Create(bitmap); |
2bda0e17 KB |
1374 | } |
1375 | ||
10fcf31a | 1376 | wxMask::~wxMask() |
2bda0e17 KB |
1377 | { |
1378 | if ( m_maskBitmap ) | |
1379 | ::DeleteObject((HBITMAP) m_maskBitmap); | |
1380 | } | |
1381 | ||
1382 | // Create a mask from a mono bitmap (copies the bitmap). | |
1383 | bool wxMask::Create(const wxBitmap& bitmap) | |
1384 | { | |
04ef50df | 1385 | #ifndef __WXMICROWIN__ |
a58a12e9 VZ |
1386 | wxCHECK_MSG( bitmap.Ok() && bitmap.GetDepth() == 1, FALSE, |
1387 | _T("can't create mask from invalid or not monochrome bitmap") ); | |
1388 | ||
2bda0e17 | 1389 | if ( m_maskBitmap ) |
6d167489 VZ |
1390 | { |
1391 | ::DeleteObject((HBITMAP) m_maskBitmap); | |
1392 | m_maskBitmap = 0; | |
1393 | } | |
a58a12e9 | 1394 | |
6d167489 VZ |
1395 | m_maskBitmap = (WXHBITMAP) CreateBitmap( |
1396 | bitmap.GetWidth(), | |
1397 | bitmap.GetHeight(), | |
1398 | 1, 1, 0 | |
1399 | ); | |
1400 | HDC srcDC = CreateCompatibleDC(0); | |
1401 | SelectObject(srcDC, (HBITMAP) bitmap.GetHBITMAP()); | |
1402 | HDC destDC = CreateCompatibleDC(0); | |
1403 | SelectObject(destDC, (HBITMAP) m_maskBitmap); | |
1404 | BitBlt(destDC, 0, 0, bitmap.GetWidth(), bitmap.GetHeight(), srcDC, 0, 0, SRCCOPY); | |
1405 | SelectObject(srcDC, 0); | |
1406 | DeleteDC(srcDC); | |
1407 | SelectObject(destDC, 0); | |
1408 | DeleteDC(destDC); | |
1409 | return TRUE; | |
04ef50df JS |
1410 | #else |
1411 | return FALSE; | |
1412 | #endif | |
2bda0e17 KB |
1413 | } |
1414 | ||
1415 | // Create a mask from a bitmap and a palette index indicating | |
1416 | // the transparent area | |
debe6624 | 1417 | bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex) |
2bda0e17 KB |
1418 | { |
1419 | if ( m_maskBitmap ) | |
1d792928 | 1420 | { |
6d167489 VZ |
1421 | ::DeleteObject((HBITMAP) m_maskBitmap); |
1422 | m_maskBitmap = 0; | |
1d792928 | 1423 | } |
d275c7eb VZ |
1424 | |
1425 | #if wxUSE_PALETTE | |
6d167489 VZ |
1426 | if (bitmap.Ok() && bitmap.GetPalette()->Ok()) |
1427 | { | |
1428 | unsigned char red, green, blue; | |
1429 | if (bitmap.GetPalette()->GetRGB(paletteIndex, &red, &green, &blue)) | |
1430 | { | |
1431 | wxColour transparentColour(red, green, blue); | |
1432 | return Create(bitmap, transparentColour); | |
1433 | } | |
1434 | } | |
d275c7eb VZ |
1435 | #endif // wxUSE_PALETTE |
1436 | ||
6d167489 | 1437 | return FALSE; |
2bda0e17 KB |
1438 | } |
1439 | ||
1440 | // Create a mask from a bitmap and a colour indicating | |
1441 | // the transparent area | |
1442 | bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour) | |
1443 | { | |
04ef50df | 1444 | #ifndef __WXMICROWIN__ |
4b7f2165 VZ |
1445 | wxCHECK_MSG( bitmap.Ok(), FALSE, _T("invalid bitmap in wxMask::Create") ); |
1446 | ||
2bda0e17 | 1447 | if ( m_maskBitmap ) |
1d792928 | 1448 | { |
6d167489 VZ |
1449 | ::DeleteObject((HBITMAP) m_maskBitmap); |
1450 | m_maskBitmap = 0; | |
1451 | } | |
4b7f2165 VZ |
1452 | |
1453 | int width = bitmap.GetWidth(), | |
1454 | height = bitmap.GetHeight(); | |
1455 | ||
1456 | // scan the bitmap for the transparent colour and set the corresponding | |
1457 | // pixels in the mask to BLACK and the rest to WHITE | |
f423f4db | 1458 | COLORREF maskColour = wxColourToPalRGB(colour); |
4b7f2165 VZ |
1459 | m_maskBitmap = (WXHBITMAP)::CreateBitmap(width, height, 1, 1, 0); |
1460 | ||
1461 | HDC srcDC = ::CreateCompatibleDC(NULL); | |
1462 | HDC destDC = ::CreateCompatibleDC(NULL); | |
1463 | if ( !srcDC || !destDC ) | |
1464 | { | |
f6bcfd97 | 1465 | wxLogLastError(wxT("CreateCompatibleDC")); |
4b7f2165 VZ |
1466 | } |
1467 | ||
0bafad0c VZ |
1468 | bool ok = TRUE; |
1469 | ||
1e6feb95 VZ |
1470 | // SelectObject() will fail |
1471 | wxASSERT_MSG( !bitmap.GetSelectedInto(), | |
1472 | _T("bitmap can't be selected in another DC") ); | |
1473 | ||
0bafad0c VZ |
1474 | HGDIOBJ hbmpSrcOld = ::SelectObject(srcDC, GetHbitmapOf(bitmap)); |
1475 | if ( !hbmpSrcOld ) | |
6d167489 | 1476 | { |
f6bcfd97 | 1477 | wxLogLastError(wxT("SelectObject")); |
0bafad0c VZ |
1478 | |
1479 | ok = FALSE; | |
4b7f2165 | 1480 | } |
0bafad0c VZ |
1481 | |
1482 | HGDIOBJ hbmpDstOld = ::SelectObject(destDC, (HBITMAP)m_maskBitmap); | |
1483 | if ( !hbmpDstOld ) | |
4b7f2165 | 1484 | { |
f6bcfd97 | 1485 | wxLogLastError(wxT("SelectObject")); |
0bafad0c VZ |
1486 | |
1487 | ok = FALSE; | |
1d792928 | 1488 | } |
2bda0e17 | 1489 | |
59ff46cb | 1490 | if ( ok ) |
2bda0e17 | 1491 | { |
59ff46cb VZ |
1492 | // this will create a monochrome bitmap with 0 points for the pixels |
1493 | // which have the same value as the background colour and 1 for the | |
1494 | // others | |
1495 | ::SetBkColor(srcDC, maskColour); | |
1496 | ::BitBlt(destDC, 0, 0, width, height, srcDC, 0, 0, NOTSRCCOPY); | |
2bda0e17 | 1497 | } |
4b7f2165 | 1498 | |
0bafad0c | 1499 | ::SelectObject(srcDC, hbmpSrcOld); |
6d167489 | 1500 | ::DeleteDC(srcDC); |
0bafad0c | 1501 | ::SelectObject(destDC, hbmpDstOld); |
6d167489 | 1502 | ::DeleteDC(destDC); |
4b7f2165 | 1503 | |
0bafad0c | 1504 | return ok; |
59ff46cb | 1505 | #else // __WXMICROWIN__ |
04ef50df | 1506 | return FALSE; |
59ff46cb | 1507 | #endif // __WXMICROWIN__/!__WXMICROWIN__ |
6d167489 VZ |
1508 | } |
1509 | ||
1510 | // ---------------------------------------------------------------------------- | |
1511 | // wxBitmapHandler | |
1512 | // ---------------------------------------------------------------------------- | |
1d792928 | 1513 | |
6d167489 VZ |
1514 | bool wxBitmapHandler::Create(wxGDIImage *image, |
1515 | void *data, | |
1516 | long flags, | |
1517 | int width, int height, int depth) | |
1518 | { | |
1519 | wxBitmap *bitmap = wxDynamicCast(image, wxBitmap); | |
1d792928 | 1520 | |
8c1375b9 | 1521 | return bitmap ? Create(bitmap, data, flags, width, height, depth) : FALSE; |
2bda0e17 KB |
1522 | } |
1523 | ||
6d167489 VZ |
1524 | bool wxBitmapHandler::Load(wxGDIImage *image, |
1525 | const wxString& name, | |
1526 | long flags, | |
1527 | int width, int height) | |
2bda0e17 | 1528 | { |
6d167489 | 1529 | wxBitmap *bitmap = wxDynamicCast(image, wxBitmap); |
2bda0e17 | 1530 | |
6d167489 VZ |
1531 | return bitmap ? LoadFile(bitmap, name, flags, width, height) : FALSE; |
1532 | } | |
2bda0e17 | 1533 | |
6d167489 VZ |
1534 | bool wxBitmapHandler::Save(wxGDIImage *image, |
1535 | const wxString& name, | |
1536 | int type) | |
2bda0e17 | 1537 | { |
6d167489 VZ |
1538 | wxBitmap *bitmap = wxDynamicCast(image, wxBitmap); |
1539 | ||
1540 | return bitmap ? SaveFile(bitmap, name, type) : FALSE; | |
2bda0e17 KB |
1541 | } |
1542 | ||
6d167489 VZ |
1543 | bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap), |
1544 | void *WXUNUSED(data), | |
1545 | long WXUNUSED(type), | |
1546 | int WXUNUSED(width), | |
1547 | int WXUNUSED(height), | |
1548 | int WXUNUSED(depth)) | |
2bda0e17 | 1549 | { |
6d167489 | 1550 | return FALSE; |
2bda0e17 KB |
1551 | } |
1552 | ||
6d167489 VZ |
1553 | bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap), |
1554 | const wxString& WXUNUSED(name), | |
1555 | long WXUNUSED(type), | |
1556 | int WXUNUSED(desiredWidth), | |
1557 | int WXUNUSED(desiredHeight)) | |
2bda0e17 | 1558 | { |
6d167489 | 1559 | return FALSE; |
2bda0e17 KB |
1560 | } |
1561 | ||
6d167489 VZ |
1562 | bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap), |
1563 | const wxString& WXUNUSED(name), | |
1564 | int WXUNUSED(type), | |
1565 | const wxPalette *WXUNUSED(palette)) | |
2bda0e17 | 1566 | { |
6d167489 | 1567 | return FALSE; |
7b46ecac JS |
1568 | } |
1569 | ||
6d167489 VZ |
1570 | // ---------------------------------------------------------------------------- |
1571 | // DIB functions | |
1572 | // ---------------------------------------------------------------------------- | |
1573 | ||
04ef50df | 1574 | #ifndef __WXMICROWIN__ |
6d167489 VZ |
1575 | bool wxCreateDIB(long xSize, long ySize, long bitsPerPixel, |
1576 | HPALETTE hPal, LPBITMAPINFO* lpDIBHeader) | |
7b46ecac JS |
1577 | { |
1578 | unsigned long i, headerSize; | |
1579 | LPBITMAPINFO lpDIBheader = NULL; | |
1580 | LPPALETTEENTRY lpPe = NULL; | |
1581 | ||
1582 | ||
1583 | // Allocate space for a DIB header | |
1584 | headerSize = (sizeof(BITMAPINFOHEADER) + (256 * sizeof(PALETTEENTRY))); | |
1585 | lpDIBheader = (BITMAPINFO *) malloc(headerSize); | |
1586 | lpPe = (PALETTEENTRY *)((BYTE*)lpDIBheader + sizeof(BITMAPINFOHEADER)); | |
1587 | ||
1588 | GetPaletteEntries(hPal, 0, 256, lpPe); | |
1589 | ||
7b46ecac JS |
1590 | memset(lpDIBheader, 0x00, sizeof(BITMAPINFOHEADER)); |
1591 | ||
7b46ecac JS |
1592 | // Fill in the static parts of the DIB header |
1593 | lpDIBheader->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); | |
1594 | lpDIBheader->bmiHeader.biWidth = xSize; | |
1595 | lpDIBheader->bmiHeader.biHeight = ySize; | |
1596 | lpDIBheader->bmiHeader.biPlanes = 1; | |
1597 | ||
1598 | // this value must be 1, 4, 8 or 24 so PixelDepth can only be | |
1599 | lpDIBheader->bmiHeader.biBitCount = (WORD)(bitsPerPixel); | |
1600 | lpDIBheader->bmiHeader.biCompression = BI_RGB; | |
6d167489 | 1601 | lpDIBheader->bmiHeader.biSizeImage = xSize * abs(ySize) * bitsPerPixel >> 3; |
7b46ecac JS |
1602 | lpDIBheader->bmiHeader.biClrUsed = 256; |
1603 | ||
1604 | ||
1605 | // Initialize the DIB palette | |
1606 | for (i = 0; i < 256; i++) { | |
1607 | lpDIBheader->bmiColors[i].rgbReserved = lpPe[i].peFlags; | |
1608 | lpDIBheader->bmiColors[i].rgbRed = lpPe[i].peRed; | |
1609 | lpDIBheader->bmiColors[i].rgbGreen = lpPe[i].peGreen; | |
1610 | lpDIBheader->bmiColors[i].rgbBlue = lpPe[i].peBlue; | |
1611 | } | |
1612 | ||
1613 | *lpDIBHeader = lpDIBheader; | |
1614 | ||
6d167489 | 1615 | return TRUE; |
7b46ecac JS |
1616 | } |
1617 | ||
6d167489 | 1618 | void wxFreeDIB(LPBITMAPINFO lpDIBHeader) |
7b46ecac | 1619 | { |
6d167489 | 1620 | free(lpDIBHeader); |
7b46ecac | 1621 | } |
04ef50df | 1622 | #endif |
7b46ecac | 1623 | |
4b7f2165 | 1624 | // ---------------------------------------------------------------------------- |
211b54b1 | 1625 | // global helper functions implemented here |
4b7f2165 VZ |
1626 | // ---------------------------------------------------------------------------- |
1627 | ||
211b54b1 VZ |
1628 | // helper of wxBitmapToHICON/HCURSOR |
1629 | static | |
1630 | HICON wxBitmapToIconOrCursor(const wxBitmap& bmp, | |
1631 | bool iconWanted, | |
1632 | int hotSpotX, | |
1633 | int hotSpotY) | |
1634 | { | |
1635 | if ( !bmp.Ok() ) | |
1636 | { | |
1637 | // we can't create an icon/cursor form nothing | |
1638 | return 0; | |
1639 | } | |
1640 | ||
1641 | wxMask *mask = bmp.GetMask(); | |
1642 | if ( !mask ) | |
1643 | { | |
1644 | // we must have a mask for an icon, so even if it's probably incorrect, | |
1645 | // do create it (grey is the "standard" transparent colour) | |
1646 | mask = new wxMask(bmp, *wxLIGHT_GREY); | |
1647 | } | |
1648 | ||
1649 | ICONINFO iconInfo; | |
1650 | iconInfo.fIcon = iconWanted; // do we want an icon or a cursor? | |
1651 | if ( !iconWanted ) | |
1652 | { | |
1653 | iconInfo.xHotspot = hotSpotX; | |
1654 | iconInfo.yHotspot = hotSpotY; | |
1655 | } | |
1656 | ||
1657 | iconInfo.hbmMask = wxInvertMask((HBITMAP)mask->GetMaskBitmap()); | |
1658 | iconInfo.hbmColor = GetHbitmapOf(bmp); | |
1659 | ||
1660 | // black out the transparent area to preserve background colour, because | |
1661 | // Windows blits the original bitmap using SRCINVERT (XOR) after applying | |
1662 | // the mask to the dest rect. | |
1663 | { | |
1664 | MemoryHDC dcSrc, dcDst; | |
1665 | SelectInHDC selectMask(dcSrc, (HBITMAP)mask->GetMaskBitmap()), | |
1666 | selectBitmap(dcDst, iconInfo.hbmColor); | |
1667 | ||
1668 | if ( !::BitBlt(dcDst, 0, 0, bmp.GetWidth(), bmp.GetHeight(), | |
1669 | dcSrc, 0, 0, SRCAND) ) | |
1670 | { | |
1671 | wxLogLastError(_T("BitBlt")); | |
1672 | } | |
1673 | } | |
1674 | ||
1675 | HICON hicon = ::CreateIconIndirect(&iconInfo); | |
1676 | ||
1677 | if ( !bmp.GetMask() ) | |
1678 | { | |
1679 | // we created the mask, now delete it | |
1680 | delete mask; | |
1681 | } | |
1682 | ||
1683 | // delete the inverted mask bitmap we created as well | |
1684 | ::DeleteObject(iconInfo.hbmMask); | |
1685 | ||
1686 | return hicon; | |
1687 | } | |
1688 | ||
1689 | HICON wxBitmapToHICON(const wxBitmap& bmp) | |
1690 | { | |
1691 | return wxBitmapToIconOrCursor(bmp, TRUE, 0, 0); | |
1692 | } | |
1693 | ||
1694 | HCURSOR wxBitmapToHCURSOR(const wxBitmap& bmp, int hotSpotX, int hotSpotY) | |
1695 | { | |
1696 | return (HCURSOR)wxBitmapToIconOrCursor(bmp, FALSE, hotSpotX, hotSpotY); | |
1697 | } | |
1698 | ||
1699 | HBITMAP wxInvertMask(HBITMAP hbmpMask, int w, int h) | |
4b7f2165 | 1700 | { |
04ef50df | 1701 | #ifndef __WXMICROWIN__ |
4b7f2165 VZ |
1702 | wxCHECK_MSG( hbmpMask, 0, _T("invalid bitmap in wxInvertMask") ); |
1703 | ||
1704 | // get width/height from the bitmap if not given | |
1705 | if ( !w || !h ) | |
1706 | { | |
1707 | BITMAP bm; | |
1708 | ::GetObject(hbmpMask, sizeof(BITMAP), (LPVOID)&bm); | |
1709 | w = bm.bmWidth; | |
1710 | h = bm.bmHeight; | |
1711 | } | |
1712 | ||
1713 | HDC hdcSrc = ::CreateCompatibleDC(NULL); | |
1714 | HDC hdcDst = ::CreateCompatibleDC(NULL); | |
1715 | if ( !hdcSrc || !hdcDst ) | |
1716 | { | |
f6bcfd97 | 1717 | wxLogLastError(wxT("CreateCompatibleDC")); |
4b7f2165 VZ |
1718 | } |
1719 | ||
1720 | HBITMAP hbmpInvMask = ::CreateBitmap(w, h, 1, 1, 0); | |
1721 | if ( !hbmpInvMask ) | |
1722 | { | |
f6bcfd97 | 1723 | wxLogLastError(wxT("CreateBitmap")); |
4b7f2165 VZ |
1724 | } |
1725 | ||
1726 | ::SelectObject(hdcSrc, hbmpMask); | |
1727 | ::SelectObject(hdcDst, hbmpInvMask); | |
1728 | if ( !::BitBlt(hdcDst, 0, 0, w, h, | |
1729 | hdcSrc, 0, 0, | |
1730 | NOTSRCCOPY) ) | |
1731 | { | |
f6bcfd97 | 1732 | wxLogLastError(wxT("BitBlt")); |
4b7f2165 | 1733 | } |
7b46ecac | 1734 | |
4b7f2165 VZ |
1735 | ::DeleteDC(hdcSrc); |
1736 | ::DeleteDC(hdcDst); | |
1737 | ||
1738 | return hbmpInvMask; | |
04ef50df JS |
1739 | #else |
1740 | return 0; | |
1741 | #endif | |
4b7f2165 | 1742 | } |