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