]> git.saurik.com Git - wxWidgets.git/blob - src/msw/dib.cpp
implement editing_started and _done events for GTK+ >= 2.6
[wxWidgets.git] / src / msw / dib.cpp
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 #include "wx/image.h"
41 #endif //WX_PRECOMP
42
43 #include "wx/file.h"
44
45 #include <stdio.h>
46 #include <stdlib.h>
47
48 #if !defined(__MWERKS__) && !defined(__SALFORDC__)
49 #include <memory.h>
50 #endif
51
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.fn_str(),
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 #if wxUSE_FILE
311 wxFile file(filename, wxFile::write);
312 bool ok = file.IsOpened();
313 if ( ok )
314 {
315 DIBSECTION ds;
316 if ( !GetDIBSection(m_handle, &ds) )
317 {
318 wxLogLastError(_T("GetObject(hDIB)"));
319 }
320 else
321 {
322 BITMAPFILEHEADER bmpHdr;
323 wxZeroMemory(bmpHdr);
324
325 const size_t sizeHdr = ds.dsBmih.biSize;
326 const size_t sizeImage = ds.dsBmih.biSizeImage;
327
328 bmpHdr.bfType = 0x4d42; // 'BM' in little endian
329 bmpHdr.bfOffBits = sizeof(BITMAPFILEHEADER) + ds.dsBmih.biSize;
330 bmpHdr.bfSize = bmpHdr.bfOffBits + sizeImage;
331
332 // first write the file header, then the bitmap header and finally the
333 // bitmap data itself
334 ok = file.Write(&bmpHdr, sizeof(bmpHdr)) == sizeof(bmpHdr) &&
335 file.Write(&ds.dsBmih, sizeHdr) == sizeHdr &&
336 file.Write(ds.dsBm.bmBits, sizeImage) == sizeImage;
337 }
338 }
339 #else // !wxUSE_FILE
340 bool ok = false;
341 #endif // wxUSE_FILE/!wxUSE_FILE
342
343 if ( !ok )
344 {
345 wxLogError(_("Failed to save the bitmap image to file \"%s\"."),
346 filename.c_str());
347 }
348
349 return ok;
350 }
351
352 // ----------------------------------------------------------------------------
353 // wxDIB accessors
354 // ----------------------------------------------------------------------------
355
356 void wxDIB::DoGetObject() const
357 {
358 // only do something if we have a valid DIB but we don't [yet] have valid
359 // data
360 if ( m_handle && !m_data )
361 {
362 // although all the info we need is in BITMAP and so we don't really
363 // need DIBSECTION we still ask for it as modifying the bit values only
364 // works for the real DIBs and not for the bitmaps and it's better to
365 // check for this now rather than trying to find out why it doesn't
366 // work later
367 DIBSECTION ds;
368 if ( !GetDIBSection(m_handle, &ds) )
369 {
370 wxLogLastError(_T("GetObject(hDIB)"));
371 return;
372 }
373
374 wxDIB *self = wxConstCast(this, wxDIB);
375
376 self->m_width = ds.dsBm.bmWidth;
377 self->m_height = ds.dsBm.bmHeight;
378 self->m_depth = ds.dsBm.bmBitsPixel;
379 self->m_data = ds.dsBm.bmBits;
380 }
381 }
382
383 // ----------------------------------------------------------------------------
384 // DDB <-> DIB conversions
385 // ----------------------------------------------------------------------------
386
387 #ifndef __WXWINCE__
388
389 HBITMAP wxDIB::CreateDDB(HDC hdc) const
390 {
391 wxCHECK_MSG( m_handle, 0, _T("wxDIB::CreateDDB(): invalid object") );
392
393 DIBSECTION ds;
394 if ( !GetDIBSection(m_handle, &ds) )
395 {
396 wxLogLastError(_T("GetObject(hDIB)"));
397
398 return 0;
399 }
400
401 // how many colours are we going to have in the palette?
402 DWORD biClrUsed = ds.dsBmih.biClrUsed;
403 if ( !biClrUsed )
404 {
405 // biClrUsed field might not be set
406 biClrUsed = GetNumberOfColours(ds.dsBmih.biBitCount);
407 }
408
409 if ( !biClrUsed )
410 {
411 return ConvertToBitmap((BITMAPINFO *)&ds.dsBmih, hdc, ds.dsBm.bmBits);
412 }
413 else
414 {
415 // fake a BITMAPINFO w/o bits, just the palette info
416 wxCharBuffer bmi(sizeof(BITMAPINFO) + (biClrUsed - 1)*sizeof(RGBQUAD));
417 BITMAPINFO *pBmi = (BITMAPINFO *)bmi.data();
418 MemoryHDC hDC;
419 // get the colour table
420 SelectInHDC sDC(hDC, m_handle);
421 ::GetDIBColorTable(hDC, 0, biClrUsed, pBmi->bmiColors);
422 memcpy(&pBmi->bmiHeader, &ds.dsBmih, ds.dsBmih.biSize);
423
424 return ConvertToBitmap(pBmi, hdc, ds.dsBm.bmBits);
425 }
426 }
427
428 /* static */
429 HBITMAP wxDIB::ConvertToBitmap(const BITMAPINFO *pbmi, HDC hdc, void *bits)
430 {
431 wxCHECK_MSG( pbmi, 0, _T("invalid DIB in ConvertToBitmap") );
432
433 // here we get BITMAPINFO struct followed by the actual bitmap bits and
434 // BITMAPINFO starts with BITMAPINFOHEADER followed by colour info
435 const BITMAPINFOHEADER *pbmih = &pbmi->bmiHeader;
436
437 // get the pointer to the start of the real image data if we have a plain
438 // DIB and not a DIB section (in the latter case the pointer must be passed
439 // to us by the caller)
440 if ( !bits )
441 {
442 // we must skip over the colour table to get to the image data
443 //
444 // colour table either has the real colour data in which case its
445 // number of entries is given by biClrUsed or is used for masks to be
446 // used for extracting colour information from true colour bitmaps in
447 // which case it always have exactly 3 DWORDs
448 int numColors;
449 switch ( pbmih->biCompression )
450 {
451 case BI_BITFIELDS:
452 numColors = 3;
453 break;
454
455 case BI_RGB:
456 // biClrUsed has the number of colors but it may be not initialized at
457 // all
458 numColors = pbmih->biClrUsed;
459 if ( !numColors )
460 {
461 numColors = GetNumberOfColours(pbmih->biBitCount);
462 }
463 break;
464
465 default:
466 // no idea how it should be calculated for the other cases
467 numColors = 0;
468 }
469
470 bits = (char *)pbmih + sizeof(*pbmih) + numColors*sizeof(RGBQUAD);
471 }
472
473 HBITMAP hbmp = ::CreateDIBitmap
474 (
475 hdc ? hdc // create bitmap compatible
476 : (HDC) ScreenHDC(), // with this DC
477 pbmih, // used to get size &c
478 CBM_INIT, // initialize bitmap bits too
479 bits, // ... using this data
480 pbmi, // this is used for palette only
481 DIB_RGB_COLORS // direct or indexed palette?
482 );
483
484 if ( !hbmp )
485 {
486 wxLogLastError(wxT("CreateDIBitmap"));
487 }
488
489 return hbmp;
490 }
491
492 /* static */
493 size_t wxDIB::ConvertFromBitmap(BITMAPINFO *pbi, HBITMAP hbmp)
494 {
495 wxASSERT_MSG( hbmp, wxT("invalid bmp can't be converted to DIB") );
496
497 // prepare all the info we need
498 BITMAP bm;
499 if ( !::GetObject(hbmp, sizeof(bm), &bm) )
500 {
501 wxLogLastError(wxT("GetObject(bitmap)"));
502
503 return 0;
504 }
505
506 // we need a BITMAPINFO anyhow and if we're not given a pointer to it we
507 // use this one
508 BITMAPINFO bi2;
509
510 const bool wantSizeOnly = pbi == NULL;
511 if ( wantSizeOnly )
512 pbi = &bi2;
513
514 // just for convenience
515 const int h = bm.bmHeight;
516
517 // init the header
518 BITMAPINFOHEADER& bi = pbi->bmiHeader;
519 wxZeroMemory(bi);
520 bi.biSize = sizeof(BITMAPINFOHEADER);
521 bi.biWidth = bm.bmWidth;
522 bi.biHeight = h;
523 bi.biPlanes = 1;
524 bi.biBitCount = bm.bmBitsPixel;
525
526 // memory we need for BITMAPINFO only
527 DWORD dwLen = bi.biSize + GetNumberOfColours(bm.bmBitsPixel) * sizeof(RGBQUAD);
528
529 // get either just the image size or the image bits
530 if ( !::GetDIBits
531 (
532 ScreenHDC(), // the DC to use
533 hbmp, // the source DDB
534 0, // first scan line
535 h, // number of lines to copy
536 wantSizeOnly ? NULL // pointer to the buffer or
537 : (char *)pbi + dwLen, // NULL if we don't have it
538 pbi, // bitmap header
539 DIB_RGB_COLORS // or DIB_PAL_COLORS
540 ) )
541 {
542 wxLogLastError(wxT("GetDIBits()"));
543
544 return 0;
545 }
546
547 // return the total size
548 return dwLen + bi.biSizeImage;
549 }
550
551 /* static */
552 HGLOBAL wxDIB::ConvertFromBitmap(HBITMAP hbmp)
553 {
554 // first calculate the size needed
555 const size_t size = ConvertFromBitmap(NULL, hbmp);
556 if ( !size )
557 {
558 // conversion to DDB failed?
559 return NULL;
560 }
561
562 HGLOBAL hDIB = ::GlobalAlloc(GMEM_MOVEABLE, size);
563 if ( !hDIB )
564 {
565 // this is an error which does risk to happen especially under Win9x
566 // and which the user may understand so let him know about it
567 wxLogError(_("Failed to allocated %luKb of memory for bitmap data."),
568 (unsigned long)(size / 1024));
569
570 return NULL;
571 }
572
573 if ( !ConvertFromBitmap((BITMAPINFO *)(void *)GlobalPtrLock(hDIB), hbmp) )
574 {
575 // this really shouldn't happen... it worked the first time, why not
576 // now?
577 wxFAIL_MSG( _T("wxDIB::ConvertFromBitmap() unexpectedly failed") );
578
579 return NULL;
580 }
581
582 return hDIB;
583 }
584
585 #endif // __WXWINCE__
586
587 // ----------------------------------------------------------------------------
588 // palette support
589 // ----------------------------------------------------------------------------
590
591 #if wxUSE_PALETTE
592
593 wxPalette *wxDIB::CreatePalette() const
594 {
595 // GetDIBColorTable not available in eVC3
596 #if defined(_WIN32_WCE) && _WIN32_WCE < 400
597 return NULL;
598 #else
599 wxCHECK_MSG( m_handle, NULL, _T("wxDIB::CreatePalette(): invalid object") );
600
601 DIBSECTION ds;
602 if ( !GetDIBSection(m_handle, &ds) )
603 {
604 wxLogLastError(_T("GetObject(hDIB)"));
605
606 return 0;
607 }
608
609 // how many colours are we going to have in the palette?
610 DWORD biClrUsed = ds.dsBmih.biClrUsed;
611 if ( !biClrUsed )
612 {
613 // biClrUsed field might not be set
614 biClrUsed = GetNumberOfColours(ds.dsBmih.biBitCount);
615 }
616
617 if ( !biClrUsed )
618 {
619 // bitmaps of this depth don't have palettes at all
620 //
621 // NB: another possibility would be to return
622 // GetStockObject(DEFAULT_PALETTE) or even CreateHalftonePalette()?
623 return NULL;
624 }
625
626 MemoryHDC hDC;
627
628 // LOGPALETTE struct has only 1 element in palPalEntry array, we're
629 // going to have biClrUsed of them so add necessary space
630 LOGPALETTE *pPalette = (LOGPALETTE *)
631 malloc(sizeof(LOGPALETTE) + (biClrUsed - 1)*sizeof(PALETTEENTRY));
632 wxCHECK_MSG( pPalette, NULL, _T("out of memory") );
633
634 // initialize the palette header
635 pPalette->palVersion = 0x300; // magic number, not in docs but works
636 pPalette->palNumEntries = (WORD)biClrUsed;
637
638 // and the colour table
639 wxCharBuffer rgb(sizeof(RGBQUAD) * biClrUsed);
640 RGBQUAD *pRGB = (RGBQUAD*)rgb.data();
641 SelectInHDC selectHandle(hDC, m_handle);
642 ::GetDIBColorTable(hDC, 0, biClrUsed, pRGB);
643 for ( DWORD i = 0; i < biClrUsed; i++, pRGB++ )
644 {
645 pPalette->palPalEntry[i].peRed = pRGB->rgbRed;
646 pPalette->palPalEntry[i].peGreen = pRGB->rgbGreen;
647 pPalette->palPalEntry[i].peBlue = pRGB->rgbBlue;
648 pPalette->palPalEntry[i].peFlags = 0;
649 }
650
651 HPALETTE hPalette = ::CreatePalette(pPalette);
652
653 free(pPalette);
654
655 if ( !hPalette )
656 {
657 wxLogLastError(_T("CreatePalette"));
658
659 return NULL;
660 }
661
662 wxPalette *palette = new wxPalette;
663 palette->SetHPALETTE((WXHPALETTE)hPalette);
664
665 return palette;
666 #endif
667 }
668
669 #endif // wxUSE_PALETTE
670
671 // ----------------------------------------------------------------------------
672 // wxImage support
673 // ----------------------------------------------------------------------------
674
675 #if wxUSE_IMAGE
676
677 bool wxDIB::Create(const wxImage& image)
678 {
679 wxCHECK_MSG( image.Ok(), false, _T("invalid wxImage in wxDIB ctor") );
680
681 const int h = image.GetHeight();
682 const int w = image.GetWidth();
683
684 // if we have alpha channel, we need to create a 32bpp RGBA DIB, otherwise
685 // a 24bpp RGB is sufficient
686 m_hasAlpha = image.HasAlpha();
687 const int bpp = m_hasAlpha ? 32 : 24;
688
689 if ( !Create(w, h, bpp) )
690 return false;
691
692 // DIBs are stored in bottom to top order (see also the comment above in
693 // Create()) so we need to copy bits line by line and starting from the end
694 const int srcBytesPerLine = w * 3;
695 const int dstBytesPerLine = GetLineSize(w, bpp);
696 const unsigned char *src = image.GetData() + ((h - 1) * srcBytesPerLine);
697 const unsigned char *alpha = m_hasAlpha ? image.GetAlpha() + (h - 1)*w
698 : NULL;
699 unsigned char *dstLineStart = (unsigned char *)m_data;
700 for ( int y = 0; y < h; y++ )
701 {
702 // copy one DIB line
703 unsigned char *dst = dstLineStart;
704 if ( alpha )
705 {
706 for ( int x = 0; x < w; x++ )
707 {
708 // RGB order is reversed, and we need to premultiply
709 // all channels by alpha value for use with ::AlphaBlend.
710 const unsigned char a = *alpha++;
711 *dst++ = (unsigned char)((src[2] * a + 127) / 255);
712 *dst++ = (unsigned char)((src[1] * a + 127) / 255);
713 *dst++ = (unsigned char)((src[0] * a + 127) / 255);
714 *dst++ = a;
715 src += 3;
716 }
717 }
718 else // no alpha channel
719 {
720 for ( int x = 0; x < w; x++ )
721 {
722 // RGB order is reversed.
723 *dst++ = src[2];
724 *dst++ = src[1];
725 *dst++ = src[0];
726 src += 3;
727 }
728 }
729
730 // pass to the previous line in the image
731 src -= 2*srcBytesPerLine;
732 if ( alpha )
733 alpha -= 2*w;
734
735 // and to the next one in the DIB
736 dstLineStart += dstBytesPerLine;
737 }
738
739 return true;
740 }
741
742 wxImage wxDIB::ConvertToImage() const
743 {
744 wxCHECK_MSG( IsOk(), wxNullImage,
745 wxT("can't convert invalid DIB to wxImage") );
746
747 // create the wxImage object
748 const int w = GetWidth();
749 const int h = GetHeight();
750 wxImage image(w, h, false /* don't bother clearing memory */);
751 if ( !image.Ok() )
752 {
753 wxFAIL_MSG( wxT("could not allocate data for image") );
754 return wxNullImage;
755 }
756
757 if ( m_hasAlpha )
758 {
759 image.SetAlpha();
760 }
761
762 // this is the same loop as in Create() just above but with copy direction
763 // reversed
764 const int bpp = GetDepth();
765 const int dstBytesPerLine = w * 3;
766 const int srcBytesPerLine = GetLineSize(w, bpp);
767 unsigned char *dst = image.GetData() + ((h - 1) * dstBytesPerLine);
768 unsigned char *alpha = image.HasAlpha() ? image.GetAlpha() + (h - 1)*w
769 : NULL;
770 const bool is32bit = bpp == 32;
771 const unsigned char *srcLineStart = (unsigned char *)GetData();
772 for ( int y = 0; y < h; y++ )
773 {
774 // copy one DIB line
775 const unsigned char *src = srcLineStart;
776 for ( int x = 0; x < w; x++ )
777 {
778 dst[2] = *src++;
779 dst[1] = *src++;
780 dst[0] = *src++;
781
782 if ( is32bit )
783 {
784 if ( alpha )
785 {
786 // wxImage uses non premultiplied alpha so undo
787 // premultiplication done in Create() above
788 const unsigned char a = *src;
789 *alpha++ = a;
790 if ( a > 0 )
791 {
792 dst[0] = (dst[0] * 255 - 127) / a;
793 dst[1] = (dst[1] * 255 - 127) / a;
794 dst[2] = (dst[2] * 255 - 127) / a;
795 }
796 }
797
798 src++;
799 }
800
801 dst += 3;
802 }
803
804 // pass to the previous line in the image
805 dst -= 2*dstBytesPerLine;
806 if ( alpha )
807 alpha -= 2*w;
808
809 // and to the next one in the DIB
810 srcLineStart += srcBytesPerLine;
811 }
812
813 return image;
814 }
815
816 #endif // wxUSE_IMAGE
817
818 #endif // wxUSE_WXDIB