]>
Commit | Line | Data |
---|---|---|
1 | /////////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/msw/dib.cpp | |
3 | // Purpose: implements wxDIB class | |
4 | // Author: Vadim Zeitlin | |
5 | // Modified by: | |
6 | // Created: 03.03.03 (replaces the old file with the same name) | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 2003 Vadim Zeitlin <vadim@wxwindows.org> | |
9 | // License: wxWindows licence | |
10 | /////////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | /* | |
13 | TODO: support for palettes is very incomplete, several functions simply | |
14 | ignore them (we should select and realize the palette, if any, before | |
15 | caling GetDIBits() in the DC we use with it. | |
16 | */ | |
17 | ||
18 | // ============================================================================ | |
19 | // declarations | |
20 | // ============================================================================ | |
21 | ||
22 | // ---------------------------------------------------------------------------- | |
23 | // headers | |
24 | // ---------------------------------------------------------------------------- | |
25 | ||
26 | // For compilers that support precompilation, includes "wx.h". | |
27 | #include "wx/wxprec.h" | |
28 | ||
29 | #ifdef __BORLANDC__ | |
30 | #pragma hdrstop | |
31 | #endif | |
32 | ||
33 | #if wxUSE_WXDIB | |
34 | ||
35 | #ifndef WX_PRECOMP | |
36 | #include "wx/string.h" | |
37 | #include "wx/log.h" | |
38 | #include "wx/intl.h" | |
39 | #include "wx/bitmap.h" | |
40 | #endif //WX_PRECOMP | |
41 | ||
42 | #include "wx/file.h" | |
43 | ||
44 | #include <stdio.h> | |
45 | #include <stdlib.h> | |
46 | ||
47 | #if !defined(__MWERKS__) && !defined(__SALFORDC__) | |
48 | #include <memory.h> | |
49 | #endif | |
50 | ||
51 | #include "wx/image.h" | |
52 | #include "wx/msw/dib.h" | |
53 | ||
54 | #ifdef __WXWINCE__ | |
55 | #include <shellapi.h> // for SHLoadDIBitmap() | |
56 | #endif | |
57 | ||
58 | // ---------------------------------------------------------------------------- | |
59 | // private functions | |
60 | // ---------------------------------------------------------------------------- | |
61 | ||
62 | // calculate the number of palette entries needed for the bitmap with this | |
63 | // number of bits per pixel | |
64 | static inline WORD GetNumberOfColours(WORD bitsPerPixel) | |
65 | { | |
66 | // only 1, 4 and 8bpp bitmaps use palettes (well, they could be used with | |
67 | // 24bpp ones too but we don't support this as I think it's quite uncommon) | |
68 | return (WORD)(bitsPerPixel <= 8 ? 1 << bitsPerPixel : 0); | |
69 | } | |
70 | ||
71 | // wrapper around ::GetObject() for DIB sections | |
72 | static inline bool GetDIBSection(HBITMAP hbmp, DIBSECTION *ds) | |
73 | { | |
74 | // note that at least under Win9x (this doesn't seem to happen under Win2K | |
75 | // but this doesn't mean anything, of course), GetObject() may return | |
76 | // sizeof(DIBSECTION) for a bitmap which is *not* a DIB section and the way | |
77 | // to check for it is by looking at the bits pointer | |
78 | return ::GetObject(hbmp, sizeof(DIBSECTION), ds) == sizeof(DIBSECTION) && | |
79 | ds->dsBm.bmBits; | |
80 | } | |
81 | ||
82 | // ============================================================================ | |
83 | // implementation | |
84 | // ============================================================================ | |
85 | ||
86 | // ---------------------------------------------------------------------------- | |
87 | // wxDIB creation | |
88 | // ---------------------------------------------------------------------------- | |
89 | ||
90 | bool wxDIB::Create(int width, int height, int depth) | |
91 | { | |
92 | // we don't support formats using palettes right now so we only create | |
93 | // either 24bpp (RGB) or 32bpp (RGBA) bitmaps | |
94 | wxASSERT_MSG( depth, _T("invalid image depth in wxDIB::Create()") ); | |
95 | if ( depth < 24 ) | |
96 | depth = 24; | |
97 | ||
98 | // allocate memory for bitmap structures | |
99 | static const int sizeHeader = sizeof(BITMAPINFOHEADER); | |
100 | ||
101 | BITMAPINFO *info = (BITMAPINFO *)malloc(sizeHeader); | |
102 | wxCHECK_MSG( info, false, _T("malloc(BITMAPINFO) failed") ); | |
103 | ||
104 | memset(info, 0, sizeHeader); | |
105 | ||
106 | info->bmiHeader.biSize = sizeHeader; | |
107 | info->bmiHeader.biWidth = width; | |
108 | ||
109 | // we use positive height here which corresponds to a DIB with normal, i.e. | |
110 | // bottom to top, order -- normally using negative height (which means | |
111 | // reversed for MS and hence natural for all the normal people top to | |
112 | // bottom line scan order) could be used to avoid the need for the image | |
113 | // reversal in Create(image) but this doesn't work under NT, only Win9x! | |
114 | info->bmiHeader.biHeight = height; | |
115 | ||
116 | info->bmiHeader.biPlanes = 1; | |
117 | info->bmiHeader.biBitCount = (WORD)depth; | |
118 | info->bmiHeader.biSizeImage = GetLineSize(width, depth)*height; | |
119 | ||
120 | m_handle = ::CreateDIBSection | |
121 | ( | |
122 | 0, // hdc (unused with DIB_RGB_COLORS) | |
123 | info, // bitmap description | |
124 | DIB_RGB_COLORS, // use RGB, not palette | |
125 | &m_data, // [out] DIB bits | |
126 | NULL, // don't use file mapping | |
127 | 0 // file mapping offset (not used here) | |
128 | ); | |
129 | ||
130 | free(info); | |
131 | ||
132 | if ( !m_handle ) | |
133 | { | |
134 | wxLogLastError(wxT("CreateDIBSection")); | |
135 | ||
136 | return false; | |
137 | } | |
138 | ||
139 | m_width = width; | |
140 | m_height = height; | |
141 | m_depth = depth; | |
142 | ||
143 | return true; | |
144 | } | |
145 | ||
146 | bool wxDIB::Create(const wxBitmap& bmp) | |
147 | { | |
148 | wxCHECK_MSG( bmp.Ok(), false, _T("wxDIB::Create(): invalid bitmap") ); | |
149 | ||
150 | if ( !Create(GetHbitmapOf(bmp)) ) | |
151 | return false; | |
152 | ||
153 | m_hasAlpha = bmp.HasAlpha(); | |
154 | ||
155 | return true; | |
156 | } | |
157 | ||
158 | bool wxDIB::Create(HBITMAP hbmp) | |
159 | { | |
160 | // this bitmap could already be a DIB section in which case we don't need | |
161 | // to convert it to DIB | |
162 | DIBSECTION ds; | |
163 | if ( GetDIBSection(hbmp, &ds) ) | |
164 | { | |
165 | m_handle = hbmp; | |
166 | ||
167 | // wxBitmap will free it, not we | |
168 | m_ownsHandle = false; | |
169 | ||
170 | // copy all the bitmap parameters too as we have them now anyhow | |
171 | m_width = ds.dsBm.bmWidth; | |
172 | m_height = ds.dsBm.bmHeight; | |
173 | m_depth = ds.dsBm.bmBitsPixel; | |
174 | ||
175 | m_data = ds.dsBm.bmBits; | |
176 | } | |
177 | else // no, it's a DDB -- convert it to DIB | |
178 | { | |
179 | // prepare all the info we need | |
180 | BITMAP bm; | |
181 | if ( !::GetObject(hbmp, sizeof(bm), &bm) ) | |
182 | { | |
183 | wxLogLastError(wxT("GetObject(bitmap)")); | |
184 | ||
185 | return false; | |
186 | } | |
187 | ||
188 | int d = bm.bmBitsPixel; | |
189 | if ( d <= 0 ) | |
190 | d = wxDisplayDepth(); | |
191 | ||
192 | if ( !Create(bm.bmWidth, bm.bmHeight, d) || !CopyFromDDB(hbmp) ) | |
193 | return false; | |
194 | } | |
195 | ||
196 | return true; | |
197 | } | |
198 | ||
199 | // Windows CE doesn't have GetDIBits() so use an alternative implementation | |
200 | // for it | |
201 | // | |
202 | // in fact I'm not sure if GetDIBits() is really much better than using | |
203 | // BitBlt() like this -- it should be faster but I didn't do any tests, if | |
204 | // anybody has time to do them and by chance finds that GetDIBits() is not | |
205 | // much faster than BitBlt(), we could always use the Win CE version here | |
206 | #ifdef __WXWINCE__ | |
207 | ||
208 | bool wxDIB::CopyFromDDB(HBITMAP hbmp) | |
209 | { | |
210 | MemoryHDC hdcSrc; | |
211 | if ( !hdcSrc ) | |
212 | return false; | |
213 | ||
214 | SelectInHDC selectSrc(hdcSrc, hbmp); | |
215 | if ( !selectSrc ) | |
216 | return false; | |
217 | ||
218 | MemoryHDC hdcDst; | |
219 | if ( !hdcDst ) | |
220 | return false; | |
221 | ||
222 | SelectInHDC selectDst(hdcDst, m_handle); | |
223 | if ( !selectDst ) | |
224 | return false; | |
225 | ||
226 | ||
227 | if ( !::BitBlt( | |
228 | hdcDst, | |
229 | 0, 0, m_width, m_height, | |
230 | hdcSrc, | |
231 | 0, 0, | |
232 | SRCCOPY | |
233 | ) ) | |
234 | { | |
235 | wxLogLastError(_T("BitBlt(DDB -> DIB)")); | |
236 | ||
237 | return false; | |
238 | } | |
239 | ||
240 | return true; | |
241 | } | |
242 | ||
243 | #else // !__WXWINCE__ | |
244 | ||
245 | bool wxDIB::CopyFromDDB(HBITMAP hbmp) | |
246 | { | |
247 | DIBSECTION ds; | |
248 | if ( !GetDIBSection(m_handle, &ds) ) | |
249 | { | |
250 | // we're sure that our handle is a DIB section, so this should work | |
251 | wxFAIL_MSG( _T("GetObject(DIBSECTION) unexpectedly failed") ); | |
252 | ||
253 | return false; | |
254 | } | |
255 | ||
256 | if ( !::GetDIBits | |
257 | ( | |
258 | ScreenHDC(), // the DC to use | |
259 | hbmp, // the source DDB | |
260 | 0, // first scan line | |
261 | m_height, // number of lines to copy | |
262 | ds.dsBm.bmBits, // pointer to the buffer | |
263 | (BITMAPINFO *)&ds.dsBmih, // bitmap header | |
264 | DIB_RGB_COLORS // and not DIB_PAL_COLORS | |
265 | ) ) | |
266 | { | |
267 | wxLogLastError(wxT("GetDIBits()")); | |
268 | ||
269 | return false; | |
270 | } | |
271 | ||
272 | return true; | |
273 | } | |
274 | ||
275 | #endif // __WXWINCE__/!__WXWINCE__ | |
276 | ||
277 | // ---------------------------------------------------------------------------- | |
278 | // Loading/saving the DIBs | |
279 | // ---------------------------------------------------------------------------- | |
280 | ||
281 | bool wxDIB::Load(const wxString& filename) | |
282 | { | |
283 | #ifdef __WXWINCE__ | |
284 | m_handle = SHLoadDIBitmap(filename); | |
285 | #else // !__WXWINCE__ | |
286 | m_handle = (HBITMAP)::LoadImage | |
287 | ( | |
288 | wxGetInstance(), | |
289 | filename, | |
290 | IMAGE_BITMAP, | |
291 | 0, 0, // don't specify the size | |
292 | LR_CREATEDIBSECTION | LR_LOADFROMFILE | |
293 | ); | |
294 | #endif // __WXWINCE__ | |
295 | ||
296 | if ( !m_handle ) | |
297 | { | |
298 | wxLogLastError(_T("Loading DIB from file")); | |
299 | ||
300 | return false; | |
301 | } | |
302 | ||
303 | return true; | |
304 | } | |
305 | ||
306 | bool wxDIB::Save(const wxString& filename) | |
307 | { | |
308 | wxCHECK_MSG( m_handle, false, _T("wxDIB::Save(): invalid object") ); | |
309 | ||
310 | wxFile file(filename, wxFile::write); | |
311 | bool ok = file.IsOpened(); | |
312 | if ( ok ) | |
313 | { | |
314 | DIBSECTION ds; | |
315 | if ( !GetDIBSection(m_handle, &ds) ) | |
316 | { | |
317 | wxLogLastError(_T("GetObject(hDIB)")); | |
318 | } | |
319 | else | |
320 | { | |
321 | BITMAPFILEHEADER bmpHdr; | |
322 | wxZeroMemory(bmpHdr); | |
323 | ||
324 | const size_t sizeHdr = ds.dsBmih.biSize; | |
325 | const size_t sizeImage = ds.dsBmih.biSizeImage; | |
326 | ||
327 | bmpHdr.bfType = 0x4d42; // 'BM' in little endian | |
328 | bmpHdr.bfOffBits = sizeof(BITMAPFILEHEADER) + ds.dsBmih.biSize; | |
329 | bmpHdr.bfSize = bmpHdr.bfOffBits + sizeImage; | |
330 | ||
331 | // first write the file header, then the bitmap header and finally the | |
332 | // bitmap data itself | |
333 | ok = file.Write(&bmpHdr, sizeof(bmpHdr)) == sizeof(bmpHdr) && | |
334 | file.Write(&ds.dsBmih, sizeHdr) == sizeHdr && | |
335 | file.Write(ds.dsBm.bmBits, sizeImage) == sizeImage; | |
336 | } | |
337 | } | |
338 | ||
339 | if ( !ok ) | |
340 | { | |
341 | wxLogError(_("Failed to save the bitmap image to file \"%s\"."), | |
342 | filename.c_str()); | |
343 | } | |
344 | ||
345 | return ok; | |
346 | } | |
347 | ||
348 | // ---------------------------------------------------------------------------- | |
349 | // wxDIB accessors | |
350 | // ---------------------------------------------------------------------------- | |
351 | ||
352 | void wxDIB::DoGetObject() const | |
353 | { | |
354 | // only do something if we have a valid DIB but we don't [yet] have valid | |
355 | // data | |
356 | if ( m_handle && !m_data ) | |
357 | { | |
358 | // although all the info we need is in BITMAP and so we don't really | |
359 | // need DIBSECTION we still ask for it as modifying the bit values only | |
360 | // works for the real DIBs and not for the bitmaps and it's better to | |
361 | // check for this now rather than trying to find out why it doesn't | |
362 | // work later | |
363 | DIBSECTION ds; | |
364 | if ( !GetDIBSection(m_handle, &ds) ) | |
365 | { | |
366 | wxLogLastError(_T("GetObject(hDIB)")); | |
367 | return; | |
368 | } | |
369 | ||
370 | wxDIB *self = wxConstCast(this, wxDIB); | |
371 | ||
372 | self->m_width = ds.dsBm.bmWidth; | |
373 | self->m_height = ds.dsBm.bmHeight; | |
374 | self->m_depth = ds.dsBm.bmBitsPixel; | |
375 | self->m_data = ds.dsBm.bmBits; | |
376 | } | |
377 | } | |
378 | ||
379 | // ---------------------------------------------------------------------------- | |
380 | // DDB <-> DIB conversions | |
381 | // ---------------------------------------------------------------------------- | |
382 | ||
383 | #ifndef __WXWINCE__ | |
384 | ||
385 | HBITMAP wxDIB::CreateDDB(HDC hdc) const | |
386 | { | |
387 | wxCHECK_MSG( m_handle, 0, _T("wxDIB::CreateDDB(): invalid object") ); | |
388 | ||
389 | DIBSECTION ds; | |
390 | if ( !GetDIBSection(m_handle, &ds) ) | |
391 | { | |
392 | wxLogLastError(_T("GetObject(hDIB)")); | |
393 | ||
394 | return 0; | |
395 | } | |
396 | ||
397 | // how many colours are we going to have in the palette? | |
398 | DWORD biClrUsed = ds.dsBmih.biClrUsed; | |
399 | if ( !biClrUsed ) | |
400 | { | |
401 | // biClrUsed field might not be set | |
402 | biClrUsed = GetNumberOfColours(ds.dsBmih.biBitCount); | |
403 | } | |
404 | ||
405 | if ( !biClrUsed ) | |
406 | { | |
407 | return ConvertToBitmap((BITMAPINFO *)&ds.dsBmih, hdc, ds.dsBm.bmBits); | |
408 | } | |
409 | else | |
410 | { | |
411 | // fake a BITMAPINFO w/o bits, just the palette info | |
412 | wxCharBuffer bmi(sizeof(BITMAPINFO) + (biClrUsed - 1)*sizeof(RGBQUAD)); | |
413 | BITMAPINFO *pBmi = (BITMAPINFO *)bmi.data(); | |
414 | MemoryHDC hDC; | |
415 | // get the colour table | |
416 | SelectInHDC sDC(hDC, m_handle); | |
417 | ::GetDIBColorTable(hDC, 0, biClrUsed, pBmi->bmiColors); | |
418 | memcpy(&pBmi->bmiHeader, &ds.dsBmih, ds.dsBmih.biSize); | |
419 | ||
420 | return ConvertToBitmap(pBmi, hdc, ds.dsBm.bmBits); | |
421 | } | |
422 | } | |
423 | ||
424 | /* static */ | |
425 | HBITMAP wxDIB::ConvertToBitmap(const BITMAPINFO *pbmi, HDC hdc, void *bits) | |
426 | { | |
427 | wxCHECK_MSG( pbmi, 0, _T("invalid DIB in ConvertToBitmap") ); | |
428 | ||
429 | // here we get BITMAPINFO struct followed by the actual bitmap bits and | |
430 | // BITMAPINFO starts with BITMAPINFOHEADER followed by colour info | |
431 | const BITMAPINFOHEADER *pbmih = &pbmi->bmiHeader; | |
432 | ||
433 | // get the pointer to the start of the real image data if we have a plain | |
434 | // DIB and not a DIB section (in the latter case the pointer must be passed | |
435 | // to us by the caller) | |
436 | if ( !bits ) | |
437 | { | |
438 | // we must skip over the colour table to get to the image data | |
439 | // | |
440 | // colour table either has the real colour data in which case its | |
441 | // number of entries is given by biClrUsed or is used for masks to be | |
442 | // used for extracting colour information from true colour bitmaps in | |
443 | // which case it always have exactly 3 DWORDs | |
444 | int numColors; | |
445 | switch ( pbmih->biCompression ) | |
446 | { | |
447 | case BI_BITFIELDS: | |
448 | numColors = 3; | |
449 | break; | |
450 | ||
451 | case BI_RGB: | |
452 | // biClrUsed has the number of colors but it may be not initialized at | |
453 | // all | |
454 | numColors = pbmih->biClrUsed; | |
455 | if ( !numColors ) | |
456 | { | |
457 | numColors = GetNumberOfColours(pbmih->biBitCount); | |
458 | } | |
459 | break; | |
460 | ||
461 | default: | |
462 | // no idea how it should be calculated for the other cases | |
463 | numColors = 0; | |
464 | } | |
465 | ||
466 | bits = (char *)pbmih + sizeof(*pbmih) + numColors*sizeof(RGBQUAD); | |
467 | } | |
468 | ||
469 | HBITMAP hbmp = ::CreateDIBitmap | |
470 | ( | |
471 | hdc ? hdc // create bitmap compatible | |
472 | : (HDC) ScreenHDC(), // with this DC | |
473 | pbmih, // used to get size &c | |
474 | CBM_INIT, // initialize bitmap bits too | |
475 | bits, // ... using this data | |
476 | pbmi, // this is used for palette only | |
477 | DIB_RGB_COLORS // direct or indexed palette? | |
478 | ); | |
479 | ||
480 | if ( !hbmp ) | |
481 | { | |
482 | wxLogLastError(wxT("CreateDIBitmap")); | |
483 | } | |
484 | ||
485 | return hbmp; | |
486 | } | |
487 | ||
488 | /* static */ | |
489 | size_t wxDIB::ConvertFromBitmap(BITMAPINFO *pbi, HBITMAP hbmp) | |
490 | { | |
491 | wxASSERT_MSG( hbmp, wxT("invalid bmp can't be converted to DIB") ); | |
492 | ||
493 | // prepare all the info we need | |
494 | BITMAP bm; | |
495 | if ( !::GetObject(hbmp, sizeof(bm), &bm) ) | |
496 | { | |
497 | wxLogLastError(wxT("GetObject(bitmap)")); | |
498 | ||
499 | return 0; | |
500 | } | |
501 | ||
502 | // we need a BITMAPINFO anyhow and if we're not given a pointer to it we | |
503 | // use this one | |
504 | BITMAPINFO bi2; | |
505 | ||
506 | const bool wantSizeOnly = pbi == NULL; | |
507 | if ( wantSizeOnly ) | |
508 | pbi = &bi2; | |
509 | ||
510 | // just for convenience | |
511 | const int h = bm.bmHeight; | |
512 | ||
513 | // init the header | |
514 | BITMAPINFOHEADER& bi = pbi->bmiHeader; | |
515 | wxZeroMemory(bi); | |
516 | bi.biSize = sizeof(BITMAPINFOHEADER); | |
517 | bi.biWidth = bm.bmWidth; | |
518 | bi.biHeight = h; | |
519 | bi.biPlanes = 1; | |
520 | bi.biBitCount = bm.bmBitsPixel; | |
521 | ||
522 | // memory we need for BITMAPINFO only | |
523 | DWORD dwLen = bi.biSize + GetNumberOfColours(bm.bmBitsPixel) * sizeof(RGBQUAD); | |
524 | ||
525 | // get either just the image size or the image bits | |
526 | if ( !::GetDIBits | |
527 | ( | |
528 | ScreenHDC(), // the DC to use | |
529 | hbmp, // the source DDB | |
530 | 0, // first scan line | |
531 | h, // number of lines to copy | |
532 | wantSizeOnly ? NULL // pointer to the buffer or | |
533 | : (char *)pbi + dwLen, // NULL if we don't have it | |
534 | pbi, // bitmap header | |
535 | DIB_RGB_COLORS // or DIB_PAL_COLORS | |
536 | ) ) | |
537 | { | |
538 | wxLogLastError(wxT("GetDIBits()")); | |
539 | ||
540 | return 0; | |
541 | } | |
542 | ||
543 | // return the total size | |
544 | return dwLen + bi.biSizeImage; | |
545 | } | |
546 | ||
547 | /* static */ | |
548 | HGLOBAL wxDIB::ConvertFromBitmap(HBITMAP hbmp) | |
549 | { | |
550 | // first calculate the size needed | |
551 | const size_t size = ConvertFromBitmap(NULL, hbmp); | |
552 | if ( !size ) | |
553 | { | |
554 | // conversion to DDB failed? | |
555 | return NULL; | |
556 | } | |
557 | ||
558 | HGLOBAL hDIB = ::GlobalAlloc(GMEM_MOVEABLE, size); | |
559 | if ( !hDIB ) | |
560 | { | |
561 | // this is an error which does risk to happen especially under Win9x | |
562 | // and which the user may understand so let him know about it | |
563 | wxLogError(_("Failed to allocated %luKb of memory for bitmap data."), | |
564 | (unsigned long)(size / 1024)); | |
565 | ||
566 | return NULL; | |
567 | } | |
568 | ||
569 | if ( !ConvertFromBitmap((BITMAPINFO *)(void *)GlobalPtrLock(hDIB), hbmp) ) | |
570 | { | |
571 | // this really shouldn't happen... it worked the first time, why not | |
572 | // now? | |
573 | wxFAIL_MSG( _T("wxDIB::ConvertFromBitmap() unexpectedly failed") ); | |
574 | ||
575 | return NULL; | |
576 | } | |
577 | ||
578 | return hDIB; | |
579 | } | |
580 | ||
581 | #endif // __WXWINCE__ | |
582 | ||
583 | // ---------------------------------------------------------------------------- | |
584 | // palette support | |
585 | // ---------------------------------------------------------------------------- | |
586 | ||
587 | #if wxUSE_PALETTE | |
588 | ||
589 | wxPalette *wxDIB::CreatePalette() const | |
590 | { | |
591 | // GetDIBColorTable not available in eVC3 | |
592 | #if defined(_WIN32_WCE) && _WIN32_WCE < 400 | |
593 | return NULL; | |
594 | #else | |
595 | wxCHECK_MSG( m_handle, NULL, _T("wxDIB::CreatePalette(): invalid object") ); | |
596 | ||
597 | DIBSECTION ds; | |
598 | if ( !GetDIBSection(m_handle, &ds) ) | |
599 | { | |
600 | wxLogLastError(_T("GetObject(hDIB)")); | |
601 | ||
602 | return 0; | |
603 | } | |
604 | ||
605 | // how many colours are we going to have in the palette? | |
606 | DWORD biClrUsed = ds.dsBmih.biClrUsed; | |
607 | if ( !biClrUsed ) | |
608 | { | |
609 | // biClrUsed field might not be set | |
610 | biClrUsed = GetNumberOfColours(ds.dsBmih.biBitCount); | |
611 | } | |
612 | ||
613 | if ( !biClrUsed ) | |
614 | { | |
615 | // bitmaps of this depth don't have palettes at all | |
616 | // | |
617 | // NB: another possibility would be to return | |
618 | // GetStockObject(DEFAULT_PALETTE) or even CreateHalftonePalette()? | |
619 | return NULL; | |
620 | } | |
621 | ||
622 | MemoryHDC hDC; | |
623 | ||
624 | // LOGPALETTE struct has only 1 element in palPalEntry array, we're | |
625 | // going to have biClrUsed of them so add necessary space | |
626 | LOGPALETTE *pPalette = (LOGPALETTE *) | |
627 | malloc(sizeof(LOGPALETTE) + (biClrUsed - 1)*sizeof(PALETTEENTRY)); | |
628 | wxCHECK_MSG( pPalette, NULL, _T("out of memory") ); | |
629 | ||
630 | // initialize the palette header | |
631 | pPalette->palVersion = 0x300; // magic number, not in docs but works | |
632 | pPalette->palNumEntries = (WORD)biClrUsed; | |
633 | ||
634 | // and the colour table | |
635 | wxCharBuffer rgb(sizeof(RGBQUAD) * biClrUsed); | |
636 | RGBQUAD *pRGB = (RGBQUAD*)rgb.data(); | |
637 | SelectInHDC selectHandle(hDC, m_handle); | |
638 | ::GetDIBColorTable(hDC, 0, biClrUsed, pRGB); | |
639 | for ( DWORD i = 0; i < biClrUsed; i++, pRGB++ ) | |
640 | { | |
641 | pPalette->palPalEntry[i].peRed = pRGB->rgbRed; | |
642 | pPalette->palPalEntry[i].peGreen = pRGB->rgbGreen; | |
643 | pPalette->palPalEntry[i].peBlue = pRGB->rgbBlue; | |
644 | pPalette->palPalEntry[i].peFlags = 0; | |
645 | } | |
646 | ||
647 | HPALETTE hPalette = ::CreatePalette(pPalette); | |
648 | ||
649 | free(pPalette); | |
650 | ||
651 | if ( !hPalette ) | |
652 | { | |
653 | wxLogLastError(_T("CreatePalette")); | |
654 | ||
655 | return NULL; | |
656 | } | |
657 | ||
658 | wxPalette *palette = new wxPalette; | |
659 | palette->SetHPALETTE((WXHPALETTE)hPalette); | |
660 | ||
661 | return palette; | |
662 | #endif | |
663 | } | |
664 | ||
665 | #endif // wxUSE_PALETTE | |
666 | ||
667 | // ---------------------------------------------------------------------------- | |
668 | // wxImage support | |
669 | // ---------------------------------------------------------------------------- | |
670 | ||
671 | #if wxUSE_IMAGE | |
672 | ||
673 | bool wxDIB::Create(const wxImage& image) | |
674 | { | |
675 | wxCHECK_MSG( image.Ok(), false, _T("invalid wxImage in wxDIB ctor") ); | |
676 | ||
677 | const int h = image.GetHeight(); | |
678 | const int w = image.GetWidth(); | |
679 | ||
680 | // if we have alpha channel, we need to create a 32bpp RGBA DIB, otherwise | |
681 | // a 24bpp RGB is sufficient | |
682 | m_hasAlpha = image.HasAlpha(); | |
683 | const int bpp = m_hasAlpha ? 32 : 24; | |
684 | ||
685 | if ( !Create(w, h, bpp) ) | |
686 | return false; | |
687 | ||
688 | // DIBs are stored in bottom to top order (see also the comment above in | |
689 | // Create()) so we need to copy bits line by line and starting from the end | |
690 | const int srcBytesPerLine = w * 3; | |
691 | const int dstBytesPerLine = GetLineSize(w, bpp); | |
692 | const unsigned char *src = image.GetData() + ((h - 1) * srcBytesPerLine); | |
693 | const unsigned char *alpha = m_hasAlpha ? image.GetAlpha() + (h - 1)*w | |
694 | : NULL; | |
695 | unsigned char *dstLineStart = (unsigned char *)m_data; | |
696 | for ( int y = 0; y < h; y++ ) | |
697 | { | |
698 | // copy one DIB line | |
699 | unsigned char *dst = dstLineStart; | |
700 | if ( alpha ) | |
701 | { | |
702 | for ( int x = 0; x < w; x++ ) | |
703 | { | |
704 | // RGB order is reversed, and we need to premultiply | |
705 | // all channels by alpha value for use with ::AlphaBlend. | |
706 | const unsigned char a = *alpha++; | |
707 | *dst++ = (unsigned char)((src[2] * a + 127) / 255); | |
708 | *dst++ = (unsigned char)((src[1] * a + 127) / 255); | |
709 | *dst++ = (unsigned char)((src[0] * a + 127) / 255); | |
710 | *dst++ = a; | |
711 | src += 3; | |
712 | } | |
713 | } | |
714 | else // no alpha channel | |
715 | { | |
716 | for ( int x = 0; x < w; x++ ) | |
717 | { | |
718 | // RGB order is reversed. | |
719 | *dst++ = src[2]; | |
720 | *dst++ = src[1]; | |
721 | *dst++ = src[0]; | |
722 | src += 3; | |
723 | } | |
724 | } | |
725 | ||
726 | // pass to the previous line in the image | |
727 | src -= 2*srcBytesPerLine; | |
728 | if ( alpha ) | |
729 | alpha -= 2*w; | |
730 | ||
731 | // and to the next one in the DIB | |
732 | dstLineStart += dstBytesPerLine; | |
733 | } | |
734 | ||
735 | return true; | |
736 | } | |
737 | ||
738 | wxImage wxDIB::ConvertToImage() const | |
739 | { | |
740 | wxCHECK_MSG( IsOk(), wxNullImage, | |
741 | wxT("can't convert invalid DIB to wxImage") ); | |
742 | ||
743 | // create the wxImage object | |
744 | const int w = GetWidth(); | |
745 | const int h = GetHeight(); | |
746 | wxImage image(w, h, false /* don't bother clearing memory */); | |
747 | if ( !image.Ok() ) | |
748 | { | |
749 | wxFAIL_MSG( wxT("could not allocate data for image") ); | |
750 | return wxNullImage; | |
751 | } | |
752 | ||
753 | if ( m_hasAlpha ) | |
754 | { | |
755 | image.SetAlpha(); | |
756 | } | |
757 | ||
758 | // this is the same loop as in Create() just above but with copy direction | |
759 | // reversed | |
760 | const int bpp = GetDepth(); | |
761 | const int dstBytesPerLine = w * 3; | |
762 | const int srcBytesPerLine = GetLineSize(w, bpp); | |
763 | unsigned char *dst = image.GetData() + ((h - 1) * dstBytesPerLine); | |
764 | unsigned char *alpha = image.HasAlpha() ? image.GetAlpha() + (h - 1)*w | |
765 | : NULL; | |
766 | const bool is32bit = bpp == 32; | |
767 | const unsigned char *srcLineStart = (unsigned char *)GetData(); | |
768 | for ( int y = 0; y < h; y++ ) | |
769 | { | |
770 | // copy one DIB line | |
771 | const unsigned char *src = srcLineStart; | |
772 | for ( int x = 0; x < w; x++ ) | |
773 | { | |
774 | dst[2] = *src++; | |
775 | dst[1] = *src++; | |
776 | dst[0] = *src++; | |
777 | ||
778 | dst += 3; | |
779 | ||
780 | if ( is32bit ) | |
781 | { | |
782 | if ( alpha ) | |
783 | *alpha++ = *src; | |
784 | src++; | |
785 | } | |
786 | } | |
787 | ||
788 | // pass to the previous line in the image | |
789 | dst -= 2*dstBytesPerLine; | |
790 | if ( alpha ) | |
791 | alpha -= 2*w; | |
792 | ||
793 | // and to the next one in the DIB | |
794 | srcLineStart += srcBytesPerLine; | |
795 | } | |
796 | ||
797 | return image; | |
798 | } | |
799 | ||
800 | #endif // wxUSE_IMAGE | |
801 | ||
802 | #endif // wxUSE_WXDIB |