]> git.saurik.com Git - wxWidgets.git/blob - src/mgl/bitmap.cpp
Warning fix.
[wxWidgets.git] / src / mgl / bitmap.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/mgl/bitmap.cpp
3 // Author: Vaclav Slavik
4 // RCS-ID: $Id$
5 // Copyright: (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)
6 // Licence: wxWindows licence
7 /////////////////////////////////////////////////////////////////////////////
8
9 // For compilers that support precompilation, includes "wx.h".
10 #include "wx/wxprec.h"
11
12 #ifdef __BORLANDC__
13 #pragma hdrstop
14 #endif
15
16 #include "wx/bitmap.h"
17 #include "wx/icon.h"
18 #include "wx/filefn.h"
19 #include "wx/image.h"
20 #include "wx/dcmemory.h"
21 #include "wx/utils.h"
22 #include "wx/log.h"
23 #include "wx/intl.h"
24 #include "wx/image.h"
25 #include "wx/xpmdecod.h"
26
27 #include "wx/mgl/private.h"
28
29 #include <mgraph.hpp>
30
31 //-----------------------------------------------------------------------------
32 // MGL pixel formats:
33 //-----------------------------------------------------------------------------
34
35 static pixel_format_t gs_pixel_format_15 =
36 {0x1F,0x0A,3, 0x1F,0x05,3, 0x1F,0x00,3, 0x01,0x0F,7}; // 555 15bpp
37
38 static pixel_format_t gs_pixel_format_16 =
39 {0x1F,0x0B,3, 0x3F,0x05,2, 0x1F,0x00,3, 0x00,0x00,0}; // 565 16bpp
40
41 static pixel_format_t gs_pixel_format_24 =
42 {0xFF,0x10,0, 0xFF,0x08,0, 0xFF,0x00,0, 0x00,0x00,0}; // RGB 24bpp
43
44 static pixel_format_t gs_pixel_format_32 =
45 {0xFF,0x18,0, 0xFF,0x10,0, 0xFF,0x08,0, 0xFF,0x00,0}; // RGBA 32bpp
46
47 static pixel_format_t gs_pixel_format_wxImage =
48 {0xFF,0x00,0, 0xFF,0x08,0, 0xFF,0x10,0, 0x00,0x00,0}; // RGB 24bpp for wxImage
49
50 //-----------------------------------------------------------------------------
51 // helpers
52 //-----------------------------------------------------------------------------
53
54 // Convert wxColour into it's quantized value in lower-precision
55 // pixel format (needed for masking by colour).
56 static wxColour wxQuantizeColour(const wxColour& clr, const wxBitmap& bmp)
57 {
58 pixel_format_t *pf = bmp.GetMGLbitmap_t()->pf;
59
60 if ( pf->redAdjust == 0 && pf->greenAdjust == 0 && pf->blueAdjust == 0 )
61 return clr;
62 else
63 return wxColour((unsigned char)((clr.Red() >> pf->redAdjust) << pf->redAdjust),
64 (unsigned char)((clr.Green() >> pf->greenAdjust) << pf->greenAdjust),
65 (unsigned char)((clr.Blue() >> pf->blueAdjust) << pf->blueAdjust));
66 }
67
68
69
70 //-----------------------------------------------------------------------------
71 // wxMask
72 //-----------------------------------------------------------------------------
73
74 IMPLEMENT_DYNAMIC_CLASS(wxMask,wxObject)
75
76 wxMask::wxMask()
77 {
78 m_bitmap = NULL;
79 }
80
81 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
82 {
83 m_bitmap = NULL;
84 Create(bitmap, colour);
85 }
86
87 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
88 {
89 m_bitmap = NULL;
90 Create(bitmap, paletteIndex);
91 }
92
93 wxMask::wxMask(const wxBitmap& bitmap)
94 {
95 m_bitmap = NULL;
96 Create(bitmap);
97 }
98
99 wxMask::~wxMask()
100 {
101 delete m_bitmap;
102 }
103
104 bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
105 {
106 delete m_bitmap;
107 m_bitmap = NULL;
108
109 wxColour clr(wxQuantizeColour(colour, bitmap));
110
111 wxImage imgSrc(bitmap.ConvertToImage());
112 imgSrc.SetMask(false);
113 wxImage image(imgSrc.ConvertToMono(clr.Red(), clr.Green(), clr.Blue()));
114 if ( !image.Ok() )
115 return false;
116
117 m_bitmap = new wxBitmap(image, 1);
118
119 return m_bitmap->Ok();
120 }
121
122 bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
123 {
124 unsigned char r,g,b;
125 wxPalette *pal = bitmap.GetPalette();
126
127 wxCHECK_MSG( pal, false, wxT("Cannot create mask from bitmap without palette") );
128
129 pal->GetRGB(paletteIndex, &r, &g, &b);
130
131 return Create(bitmap, wxColour(r, g, b));
132 }
133
134 bool wxMask::Create(const wxBitmap& bitmap)
135 {
136 delete m_bitmap;
137 m_bitmap = NULL;
138
139 wxCHECK_MSG( bitmap.Ok(), false, wxT("Invalid bitmap") );
140 wxCHECK_MSG( bitmap.GetDepth() == 1, false, wxT("Cannot create mask from colour bitmap") );
141
142 m_bitmap = new wxBitmap(bitmap);
143 return true;
144 }
145
146
147 //-----------------------------------------------------------------------------
148 // wxBitmap
149 //-----------------------------------------------------------------------------
150
151 class wxBitmapRefData: public wxObjectRefData
152 {
153 public:
154 wxBitmapRefData();
155 ~wxBitmapRefData();
156
157 int m_width;
158 int m_height;
159 int m_bpp;
160 wxPalette *m_palette;
161 wxMask *m_mask;
162 bitmap_t *m_bitmap;
163 };
164
165 wxBitmapRefData::wxBitmapRefData()
166 {
167 m_mask = NULL;
168 m_width = 0;
169 m_height = 0;
170 m_bpp = 0;
171 m_palette = NULL;
172 m_bitmap = NULL;
173 }
174
175 wxBitmapRefData::~wxBitmapRefData()
176 {
177 if ( m_bitmap )
178 MGL_unloadBitmap(m_bitmap);
179 delete m_mask;
180 delete m_palette;
181 }
182
183 //-----------------------------------------------------------------------------
184
185 #define M_BMPDATA ((wxBitmapRefData *)m_refData)
186
187
188 IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler,wxObject)
189 IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxBitmapBase)
190
191 wxBitmap::wxBitmap(int width, int height, int depth)
192 {
193 Create(width, height, depth);
194 }
195
196
197 static bitmap_t *MyMGL_createBitmap(int width, int height,
198 int bpp, pixel_format_t *pf)
199 {
200 MGLMemoryDC mdc(width, height, bpp, pf);
201 return MGL_getBitmapFromDC(mdc.getDC(), 0, 0, width, height, TRUE);
202 }
203
204 bool wxBitmap::Create(int width, int height, int depth)
205 {
206 UnRef();
207
208 wxCHECK_MSG( (width > 0) && (height > 0), false, wxT("invalid bitmap size") );
209
210 pixel_format_t pf_dummy;
211 pixel_format_t *pf;
212 int mglDepth = depth;
213
214 switch ( depth )
215 {
216 case -1:
217 wxASSERT_MSG( g_displayDC, wxT("MGL display DC not created yet.") );
218
219 g_displayDC->getPixelFormat(pf_dummy);
220 mglDepth = g_displayDC->getBitsPerPixel();
221 pf = &pf_dummy;
222 break;
223 case 1:
224 case 8:
225 pf = NULL;
226 break;
227 case 15:
228 pf = &gs_pixel_format_15;
229 break;
230 case 16:
231 pf = &gs_pixel_format_16;
232 break;
233 case 24:
234 pf = &gs_pixel_format_24;
235 break;
236 case 32:
237 pf = &gs_pixel_format_32;
238 break;
239 default:
240 wxASSERT_MSG( 0, wxT("invalid bitmap depth") );
241 return false;
242 }
243
244 m_refData = new wxBitmapRefData();
245 M_BMPDATA->m_mask = (wxMask *) NULL;
246 M_BMPDATA->m_palette = (wxPalette *) NULL;
247 M_BMPDATA->m_width = width;
248 M_BMPDATA->m_height = height;
249 M_BMPDATA->m_bpp = mglDepth;
250
251 if ( mglDepth != 1 )
252 {
253 M_BMPDATA->m_bitmap = MyMGL_createBitmap(width, height, mglDepth, pf);
254 }
255 else
256 {
257 // MGL does not support mono DCs, so we have to emulate them with
258 // 8bpp ones. We do that by using a special palette with color 0
259 // set to black and all other colors set to white.
260
261 M_BMPDATA->m_bitmap = MyMGL_createBitmap(width, height, 8, pf);
262 SetMonoPalette(wxColour(255, 255, 255), wxColour(0, 0, 0));
263 }
264
265 return Ok();
266 }
267
268 bool wxBitmap::CreateFromXpm(const char **bits)
269 {
270 wxCHECK_MSG( bits != NULL, false, wxT("invalid bitmap data") );
271
272 wxXPMDecoder decoder;
273 wxImage img = decoder.ReadData(bits);
274 wxCHECK_MSG( img.Ok(), false, wxT("invalid bitmap data") );
275
276 *this = wxBitmap(img);
277
278 return true;
279 }
280
281 wxBitmap::wxBitmap(const wxImage& image, int depth)
282 {
283 long width, height;
284
285 wxCHECK_RET( image.Ok(), wxT("invalid image") );
286
287 width = image.GetWidth();
288 height = image.GetHeight();
289
290 if ( !Create(width, height, depth) ) return;
291
292 MGLMemoryDC idc(width, height, 24, &gs_pixel_format_wxImage,
293 width * 3, (void*)image.GetData(), NULL);
294 wxASSERT_MSG( idc.isValid(), wxT("cannot create custom MGLDC") );
295
296 MGLDevCtx *bdc = CreateTmpDC();
297
298 if ( GetDepth() <= 8 && image.HasPalette() )
299 SetPalette(image.GetPalette());
300
301 bdc->bitBlt(idc, 0, 0, width, height, 0, 0, MGL_REPLACE_MODE);
302 delete bdc;
303
304 if ( image.HasMask() )
305 {
306 wxImage mask_image = image.ConvertToMono(image.GetMaskRed(),
307 image.GetMaskGreen(),
308 image.GetMaskBlue());
309 mask_image.SetMask(false);
310 wxBitmap mask_bmp(mask_image, 1);
311 SetMask(new wxMask(mask_bmp));
312 }
313 }
314
315 wxImage wxBitmap::ConvertToImage() const
316 {
317 wxCHECK_MSG( Ok(), wxImage(), wxT("invalid bitmap") );
318
319 int width, height;
320 width = GetWidth();
321 height = GetHeight();
322
323 wxImage image(width, height);
324 wxASSERT_MSG( image.Ok(), wxT("cannot create image") );
325
326 MGLMemoryDC idc(width, height, 24, &gs_pixel_format_wxImage,
327 width * 3, (void*)image.GetData(), NULL);
328 wxASSERT_MSG( idc.isValid(), wxT("cannot create custom MGLDC") );
329
330 if ( M_BMPDATA->m_palette )
331 image.SetPalette(*(M_BMPDATA->m_palette));
332
333 if ( GetMask() )
334 {
335 // in consistency with other ports, we convert parts covered
336 // by the mask to <16,16,16> colour and set that colour to image's
337 // mask. We do that by OR-blitting the mask over image with
338 // bg colour set to black and fg colour to <16,16,16>
339
340 image.SetMaskColour(16, 16, 16);
341 image.SetMask(true);
342
343 wxDC tmpDC;
344 tmpDC.SetMGLDC(&idc, false);
345 tmpDC.SetBackground(wxBrush(wxColour(16,16,16), wxSOLID));
346 tmpDC.Clear();
347 tmpDC.DrawBitmap(*this, 0, 0, true);
348 }
349 else
350 {
351 image.SetMask(false);
352 idc.putBitmap(0, 0, M_BMPDATA->m_bitmap, MGL_REPLACE_MODE);
353 }
354
355 return image;
356 }
357
358 wxBitmap::wxBitmap(const wxString &filename, wxBitmapType type)
359 {
360 LoadFile(filename, type);
361 }
362
363 wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
364 {
365 wxCHECK_RET( depth == 1, wxT("can only create mono bitmap from XBM data") );
366
367 if ( !Create(width, height, 1) ) return;
368 MGLDevCtx *bdc = CreateTmpDC();
369 wxCurrentDCSwitcher curDC(bdc);
370 bdc->setColor(1);
371 bdc->setBackColor(0);
372 bdc->clearDevice();
373 bdc->putMonoImage(0, 0, width, (width + 7) / 8, height, (void*)bits);
374 delete bdc;
375 }
376
377 bool wxBitmap::operator == (const wxBitmap& bmp) const
378 {
379 return (m_refData == bmp.m_refData);
380 }
381
382 bool wxBitmap::operator != (const wxBitmap& bmp) const
383 {
384 return (m_refData != bmp.m_refData);
385 }
386
387 bool wxBitmap::Ok() const
388 {
389 return (m_refData != NULL && M_BMPDATA->m_bitmap != NULL);
390 }
391
392 int wxBitmap::GetHeight() const
393 {
394 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
395
396 return M_BMPDATA->m_height;
397 }
398
399 int wxBitmap::GetWidth() const
400 {
401 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
402
403 return M_BMPDATA->m_width;
404 }
405
406 int wxBitmap::GetDepth() const
407 {
408 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
409
410 return M_BMPDATA->m_bpp;
411 }
412
413 wxMask *wxBitmap::GetMask() const
414 {
415 wxCHECK_MSG( Ok(), (wxMask *) NULL, wxT("invalid bitmap") );
416
417 return M_BMPDATA->m_mask;
418 }
419
420 void wxBitmap::SetMask(wxMask *mask)
421 {
422 wxCHECK_RET( Ok(), wxT("invalid bitmap") );
423
424 delete M_BMPDATA->m_mask;
425 M_BMPDATA->m_mask = mask;
426 }
427
428 bool wxBitmap::CopyFromIcon(const wxIcon& icon)
429 {
430 wxBitmap *bmp = (wxBitmap*)(&icon);
431 *this = *bmp;
432 return true;
433 }
434
435 wxBitmap wxBitmap::GetSubBitmap(const wxRect& rect) const
436 {
437 wxCHECK_MSG( Ok() &&
438 (rect.x >= 0) && (rect.y >= 0) &&
439 (rect.x+rect.width <= M_BMPDATA->m_width) && (rect.y+rect.height <= M_BMPDATA->m_height),
440 wxNullBitmap, wxT("invalid bitmap or bitmap region") );
441
442 wxBitmap ret( rect.width, rect.height, M_BMPDATA->m_bpp );
443 wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
444
445 if ( GetPalette() )
446 ret.SetPalette(*GetPalette());
447
448 MGLDevCtx *tdc = ret.CreateTmpDC();
449 tdc->putBitmapSection(rect.x, rect.y,
450 rect.x + rect.width, rect.y + rect.height,
451 0, 0, M_BMPDATA->m_bitmap, MGL_REPLACE_MODE);
452 delete tdc;
453
454 if ( GetMask() )
455 {
456 wxBitmap submask = GetMask()->GetBitmap()->GetSubBitmap(rect);
457 ret.SetMask(new wxMask(submask));
458 }
459
460 return ret;
461 }
462
463 void wxBitmap::SetMonoPalette(const wxColour& fg, const wxColour& bg)
464 {
465 wxCHECK_RET( Ok(), wxT("invalid bitmap") );
466
467 palette_t *mono = M_BMPDATA->m_bitmap->pal;
468
469 wxCHECK_RET( M_BMPDATA->m_bpp == 1, wxT("bitmap is not 1bpp") );
470 wxCHECK_RET( mono != NULL, wxT("bitmap w/o palette") );
471
472 mono[0].red = bg.Red();
473 mono[0].green = bg.Green();
474 mono[0].blue = bg.Blue();
475 mono[0].alpha = 0;
476 for (size_t i = 1; i < 256; i++)
477 {
478 mono[i].red = fg.Red();
479 mono[i].green = fg.Green();
480 mono[i].blue = fg.Blue();
481 mono[i].alpha = 0;
482 }
483 }
484
485 MGLDevCtx *wxBitmap::CreateTmpDC() const
486 {
487 wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
488
489 MGLDevCtx *tdc = new MGLMemoryDC(GetWidth(), GetHeight(),
490 M_BMPDATA->m_bitmap->bitsPerPixel,
491 M_BMPDATA->m_bitmap->pf,
492 M_BMPDATA->m_bitmap->bytesPerLine,
493 M_BMPDATA->m_bitmap->surface,
494 NULL);
495 wxCHECK_MSG( tdc->isValid(), NULL, wxT("cannot create temporary MGLDC") );
496
497 if ( M_BMPDATA->m_bitmap->pal != NULL )
498 {
499 int cnt;
500
501 switch (M_BMPDATA->m_bitmap->bitsPerPixel)
502 {
503 case 2: cnt = 2; break;
504 case 4: cnt = 16; break;
505 case 8: cnt = 256; break;
506 default:
507 cnt = 0;
508 wxFAIL_MSG( wxT("bitmap with this depth cannot have palette") );
509 break;
510 }
511
512 tdc->setPalette(M_BMPDATA->m_bitmap->pal, cnt, 0);
513 tdc->realizePalette(cnt, 0, FALSE);
514 }
515
516 return tdc;
517 }
518
519 bool wxBitmap::LoadFile(const wxString &name, wxBitmapType type)
520 {
521 UnRef();
522
523 if ( type == wxBITMAP_TYPE_BMP || type == wxBITMAP_TYPE_PNG ||
524 type == wxBITMAP_TYPE_PCX || type == wxBITMAP_TYPE_JPEG )
525 {
526 // prevent accidental loading of bitmap from $MGL_ROOT:
527 if ( !wxFileExists(name) )
528 {
529 wxLogError(_("File %s does not exist."), name.c_str());
530 return false;
531 }
532 }
533
534 wxBitmapHandler *handler = FindHandler(type);
535
536 if ( handler == NULL )
537 {
538 wxImage image;
539 if ( !image.LoadFile(name, type) || !image.Ok() )
540 {
541 wxLogError("no bitmap handler for type %d defined.", type);
542 return false;
543 }
544 else
545 {
546 *this = wxBitmap(image);
547 return true;
548 }
549 }
550
551 m_refData = new wxBitmapRefData();
552
553 return handler->LoadFile(this, name, type, -1, -1);
554 }
555
556 bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type, const wxPalette *palette) const
557 {
558 wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
559
560 wxBitmapHandler *handler = FindHandler(type);
561
562 if ( handler == NULL )
563 {
564 wxImage image = ConvertToImage();
565 if ( palette )
566 image.SetPalette(*palette);
567
568 if ( image.Ok() )
569 return image.SaveFile(filename, type);
570 else
571 {
572 wxLogError("no bitmap handler for type %d defined.", type);
573 return false;
574 }
575 }
576
577 return handler->SaveFile(this, filename, type, palette);
578 }
579
580 wxPalette *wxBitmap::GetPalette() const
581 {
582 wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
583
584 return M_BMPDATA->m_palette;
585 }
586
587 void wxBitmap::SetPalette(const wxPalette& palette)
588 {
589 wxCHECK_RET( Ok(), wxT("invalid bitmap") );
590 wxCHECK_RET( GetDepth() > 1 && GetDepth() <= 8, wxT("cannot set palette for bitmap of this depth") );
591
592 delete M_BMPDATA->m_palette;
593 M_BMPDATA->m_palette = NULL;
594
595 if ( !palette.Ok() ) return;
596
597 M_BMPDATA->m_palette = new wxPalette(palette);
598
599 int cnt = palette.GetColoursCount();
600 palette_t *pal = palette.GetMGLpalette_t();
601 memcpy(M_BMPDATA->m_bitmap->pal, pal, cnt * sizeof(palette_t));
602 }
603
604 void wxBitmap::SetHeight(int height)
605 {
606 if (!m_refData) m_refData = new wxBitmapRefData();
607
608 M_BMPDATA->m_height = height;
609 }
610
611 void wxBitmap::SetWidth(int width)
612 {
613 if (!m_refData) m_refData = new wxBitmapRefData();
614
615 M_BMPDATA->m_width = width;
616 }
617
618 void wxBitmap::SetDepth(int depth)
619 {
620 if (!m_refData) m_refData = new wxBitmapRefData();
621
622 M_BMPDATA->m_bpp = depth;
623 }
624
625 bitmap_t *wxBitmap::GetMGLbitmap_t() const
626 {
627 return M_BMPDATA->m_bitmap;
628 }
629
630
631
632 //-----------------------------------------------------------------------------
633 // wxBitmap I/O handlers
634 //-----------------------------------------------------------------------------
635
636 class wxMGLBitmapHandler: public wxBitmapHandler
637 {
638 public:
639 wxMGLBitmapHandler(wxBitmapType type,
640 const wxString& extension, const wxString& name);
641
642 virtual bool Create(wxBitmap *WXUNUSED(bitmap),
643 void *WXUNUSED(data),
644 long WXUNUSED(flags),
645 int WXUNUSED(width),
646 int WXUNUSED(height),
647 int WXUNUSED(depth) = 1)
648 { return false; }
649
650 virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
651 int desiredWidth, int desiredHeight);
652 virtual bool SaveFile(const wxBitmap *bitmap, const wxString& name,
653 int type, const wxPalette *palette = NULL);
654 };
655
656 wxMGLBitmapHandler::wxMGLBitmapHandler(wxBitmapType type,
657 const wxString& extension,
658 const wxString& name)
659 : wxBitmapHandler()
660 {
661 SetType(type);
662 SetName(name);
663 SetExtension(extension);
664 }
665
666 bool wxMGLBitmapHandler::LoadFile(wxBitmap *bitmap, const wxString& name,
667 long flags,
668 int WXUNUSED(desiredWidth),
669 int WXUNUSED(desiredHeight))
670 {
671 int width, height, bpp;
672 pixel_format_t pf;
673 wxString fullname;
674 wxMemoryDC dc;
675
676 switch (flags)
677 {
678 case wxBITMAP_TYPE_BMP_RESOURCE:
679 case wxBITMAP_TYPE_JPEG_RESOURCE:
680 case wxBITMAP_TYPE_PNG_RESOURCE:
681 case wxBITMAP_TYPE_PCX_RESOURCE:
682 fullname = name + wxT(".bmp");
683 break;
684 default:
685 fullname= name;
686 break;
687 }
688
689 switch (flags)
690 {
691 case wxBITMAP_TYPE_BMP:
692 case wxBITMAP_TYPE_BMP_RESOURCE:
693 if ( !MGL_getBitmapSize(fullname.mb_str(), &width, &height, &bpp, &pf) )
694 return false;
695 bitmap->Create(width, height, -1);
696 if ( !bitmap->Ok() ) return false;
697 dc.SelectObject(*bitmap);
698 if ( !dc.GetMGLDC()->loadBitmapIntoDC(fullname.mb_str(), 0, 0, TRUE) )
699 return false;
700 break;
701
702 case wxBITMAP_TYPE_JPEG:
703 case wxBITMAP_TYPE_JPEG_RESOURCE:
704 if ( !MGL_getJPEGSize(fullname.mb_str(), &width, &height, &bpp, &pf) )
705 return false;
706 bitmap->Create(width, height, -1);
707 if ( !bitmap->Ok() ) return false;
708 dc.SelectObject(*bitmap);
709 if ( !dc.GetMGLDC()->loadJPEGIntoDC(fullname.mb_str(), 0, 0, TRUE) )
710 return false;
711 break;
712
713 case wxBITMAP_TYPE_PNG:
714 case wxBITMAP_TYPE_PNG_RESOURCE:
715 if ( !MGL_getPNGSize(fullname.mb_str(), &width, &height, &bpp, &pf) )
716 return false;
717 bitmap->Create(width, height, -1);
718 if ( !bitmap->Ok() ) return false;
719 dc.SelectObject(*bitmap);
720 if ( !dc.GetMGLDC()->loadPNGIntoDC(fullname.mb_str(), 0, 0, TRUE) )
721 return false;
722 break;
723
724 case wxBITMAP_TYPE_PCX:
725 case wxBITMAP_TYPE_PCX_RESOURCE:
726 if ( !MGL_getPCXSize(fullname.mb_str(), &width, &height, &bpp) )
727 return false;
728 bitmap->Create(width, height, -1);
729 if ( !bitmap->Ok() ) return false;
730 dc.SelectObject(*bitmap);
731 if ( !dc.GetMGLDC()->loadPCXIntoDC(fullname.mb_str(), 0, 0, TRUE) )
732 return false;
733 break;
734
735 default:
736 wxFAIL_MSG(wxT("Unsupported image format."));
737 break;
738 }
739
740 return true;
741 }
742
743 bool wxMGLBitmapHandler::SaveFile(const wxBitmap *bitmap, const wxString& name,
744 int type, const wxPalette * WXUNUSED(palette))
745 {
746 wxMemoryDC mem;
747 MGLDevCtx *tdc;
748 int w = bitmap->GetWidth(),
749 h = bitmap->GetHeight();
750
751 mem.SelectObject(*bitmap);
752 tdc = mem.GetMGLDC();
753
754 switch (type)
755 {
756 case wxBITMAP_TYPE_BMP:
757 return (bool)tdc->saveBitmapFromDC(name.mb_str(), 0, 0, w, h);
758 case wxBITMAP_TYPE_JPEG:
759 return (bool)tdc->saveJPEGFromDC(name.mb_str(), 0, 0, w, h, 75);
760 case wxBITMAP_TYPE_PNG:
761 return (bool)tdc->savePNGFromDC(name.mb_str(), 0, 0, w, h);
762 case wxBITMAP_TYPE_PCX:
763 return (bool)tdc->savePCXFromDC(name.mb_str(), 0, 0, w, h);
764 }
765
766 return false;
767 }
768
769
770
771 // let's handle PNGs in special way because they have alpha channel
772 // which we can access via bitmap_t most easily
773 class wxPNGBitmapHandler: public wxMGLBitmapHandler
774 {
775 public:
776 wxPNGBitmapHandler(wxBitmapType type,
777 const wxString& extension, const wxString& name)
778 : wxMGLBitmapHandler(type, extension, name) {}
779
780 virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
781 int desiredWidth, int desiredHeight);
782 };
783
784 bool wxPNGBitmapHandler::LoadFile(wxBitmap *bitmap, const wxString& name,
785 long flags,
786 int desiredWidth, int desiredHeight)
787 {
788 int width, height, bpp;
789 pixel_format_t pf;
790 wxString fullname;
791
792 if ( flags == wxBITMAP_TYPE_PNG_RESOURCE )
793 fullname = name + wxT(".png");
794 else
795 fullname = name;
796
797 if ( !MGL_getPNGSize(fullname.mb_str(), &width, &height, &bpp, &pf) )
798 return false;
799
800 if ( bpp != 32 )
801 {
802 // We can load ordinary PNGs faster with 'normal' MGL handler.
803 // Only RGBA PNGs need to be processed in special way because
804 // we have to convert alpha channel to mask
805 return wxMGLBitmapHandler::LoadFile(bitmap, name, flags,
806 desiredWidth, desiredHeight);
807 }
808
809 bitmap_t *bmp = MGL_loadPNG(fullname.mb_str(), TRUE);
810
811 if ( bmp == NULL ) return false;
812
813 bitmap->Create(bmp->width, bmp->height, -1);
814 if ( !bitmap->Ok() ) return false;
815
816 // convert bmp to display's depth and write it to *bitmap:
817 wxMemoryDC dc;
818 dc.SelectObject(*bitmap);
819 dc.GetMGLDC()->putBitmap(0, 0, bmp, MGL_REPLACE_MODE);
820 dc.SelectObject(wxNullBitmap);
821
822 // create mask, if bmp contains alpha channel (ARGB format):
823 if ( bmp->bitsPerPixel == 32 )
824 {
825 int x, y;
826 wxUint32 *s = (wxUint32*)bmp->surface;
827 for (y = 0; y < bmp->height; y++)
828 {
829 s = ((wxUint32*)bmp->surface) + y * bmp->bytesPerLine/4;
830 for (x = 0; x < bmp->width; x++, s ++)
831 {
832 if ( ((((*s) >> bmp->pf->alphaPos) & bmp->pf->alphaMask)
833 << bmp->pf->alphaAdjust) < 128 )
834 *s = 0;
835 else
836 *s = 0x00FFFFFF; // white
837 }
838 }
839 wxBitmap mask(bmp->width, bmp->height, 1);
840 dc.SelectObject(mask);
841 dc.GetMGLDC()->putBitmap(0, 0, bmp, MGL_REPLACE_MODE);
842 dc.SelectObject(wxNullBitmap);
843 bitmap->SetMask(new wxMask(mask));
844 }
845
846 MGL_unloadBitmap(bmp);
847
848 return true;
849 }
850
851
852
853
854 class wxICOBitmapHandler: public wxBitmapHandler
855 {
856 public:
857 wxICOBitmapHandler(wxBitmapType type,
858 const wxString& extension, const wxString& name);
859
860 virtual bool Create(wxBitmap *WXUNUSED(bitmap),
861 void *WXUNUSED(data),
862 long WXUNUSED(flags),
863 int WXUNUSED(width),
864 int WXUNUSED(height),
865 int WXUNUSED(depth) = 1)
866 { return false; }
867
868 virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
869 int desiredWidth, int desiredHeight);
870 virtual bool SaveFile(const wxBitmap *bitmap, const wxString& name,
871 int type, const wxPalette *palette = NULL);
872 };
873
874 wxICOBitmapHandler::wxICOBitmapHandler(wxBitmapType type,
875 const wxString& extension,
876 const wxString& name)
877 : wxBitmapHandler()
878 {
879 SetType(type);
880 SetName(name);
881 SetExtension(extension);
882 }
883
884 bool wxICOBitmapHandler::LoadFile(wxBitmap *bitmap, const wxString& name,
885 long flags,
886 int WXUNUSED(desiredWidth),
887 int WXUNUSED(desiredHeight))
888 {
889 icon_t *icon = NULL;
890 MGLDevCtx *dc;
891
892 if ( flags == wxBITMAP_TYPE_ICO_RESOURCE )
893 icon = MGL_loadIcon(wxString(name + wxT(".ico")).mb_str(), TRUE);
894 else
895 icon = MGL_loadIcon(name.mb_str(), TRUE);
896
897 if ( icon == NULL ) return false;
898
899 bitmap->Create(icon->xorMask.width, icon->xorMask.height);
900
901 wxMemoryDC mem;
902 mem.SelectObject(*bitmap);
903 dc = mem.GetMGLDC();
904 dc->putBitmap(0, 0, &(icon->xorMask), MGL_REPLACE_MODE);
905 mem.SelectObject(wxNullBitmap);
906
907 wxBitmap mask(icon->xorMask.width, icon->xorMask.height, 1);
908 mem.SelectObject(mask);
909 dc = mem.GetMGLDC();
910
911 wxCurrentDCSwitcher curDC(dc);
912 dc->setColor(0);
913 dc->setBackColor(1);
914 dc->clearDevice();
915 dc->putMonoImage(0, 0, icon->xorMask.width, icon->byteWidth,
916 icon->xorMask.height, (void*)icon->andMask);
917
918 bitmap->SetMask(new wxMask(mask));
919
920 MGL_unloadIcon(icon);
921
922 return true;
923 }
924
925 bool wxICOBitmapHandler::SaveFile(const wxBitmap *WXUNUSED(bitmap),
926 const wxString& WXUNUSED(name),
927 int WXUNUSED(type),
928 const wxPalette * WXUNUSED(palette))
929 {
930 return false;
931 }
932
933
934
935
936 /*static*/ void wxBitmap::InitStandardHandlers()
937 {
938 AddHandler(new wxMGLBitmapHandler(wxBITMAP_TYPE_BMP, wxT("bmp"), wxT("Windows bitmap")));
939 AddHandler(new wxMGLBitmapHandler(wxBITMAP_TYPE_BMP_RESOURCE, wxEmptyString, wxT("Windows bitmap resource")));
940 AddHandler(new wxMGLBitmapHandler(wxBITMAP_TYPE_JPEG, wxT("jpg"), wxT("JPEG image")));
941 AddHandler(new wxMGLBitmapHandler(wxBITMAP_TYPE_JPEG_RESOURCE, wxEmptyString, wxT("JPEG resource")));
942 AddHandler(new wxMGLBitmapHandler(wxBITMAP_TYPE_PCX, wxT("pcx"), wxT("PCX image")));
943 AddHandler(new wxMGLBitmapHandler(wxBITMAP_TYPE_PCX_RESOURCE, wxEmptyString, wxT("PCX resource")));
944
945 AddHandler(new wxPNGBitmapHandler(wxBITMAP_TYPE_PNG, wxT("png"), wxT("PNG image")));
946 AddHandler(new wxPNGBitmapHandler(wxBITMAP_TYPE_PNG_RESOURCE, wxEmptyString, wxT("PNG resource")));
947
948 AddHandler(new wxICOBitmapHandler(wxBITMAP_TYPE_ICO, wxT("ico"), wxT("Icon resource")));
949 AddHandler(new wxICOBitmapHandler(wxBITMAP_TYPE_ICO_RESOURCE, wxEmptyString, wxT("Icon resource")));
950 }