src/dfb/bitmap.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/dfb/bitmap.cpp
   3 // Purpose:     wxBitmap implementation
   4 // Author:      Vaclav Slavik
   5 // Created:     2006-08-04
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2006 REA Elektronik GmbH
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 // For compilers that support precompilation, includes "wx.h".
  12 #include "wx/wxprec.h"
  13
  14 #ifdef __BORLANDC__
  15     #pragma hdrstop
  16 #endif
  17
  18 #ifndef WX_PRECOMP
  19     #include "wx/app.h"
  20     #include "wx/log.h"
  21 #endif
  22
  23 #include "wx/bitmap.h"
  24 #include "wx/colour.h"
  25 #include "wx/image.h"
  26
  27 #warning "move this to common"
  28 #include "wx/xpmdecod.h"
  29
  30 #include "wx/dfb/private.h"
  31
  32 //-----------------------------------------------------------------------------
  33 // helpers
  34 //-----------------------------------------------------------------------------
  35
  36 // Convert wxColour into it's quantized value in lower-precision
  37 // pixel format (needed for masking by colour).
  38 static wxColour wxQuantizeColour(const wxColour& clr, const wxBitmap& bmp)
  39 {
  40 #if 0
  41     pixel_format_t *pf = bmp.GetMGLbitmap_t()->pf;
  42
  43     if ( pf->redAdjust == 0 && pf->greenAdjust == 0 && pf->blueAdjust == 0 )
  44         return clr;
  45     else
  46         return wxColour((unsigned char)((clr.Red() >> pf->redAdjust) << pf->redAdjust),
  47                         (unsigned char)((clr.Green() >> pf->greenAdjust) << pf->greenAdjust),
  48                         (unsigned char)((clr.Blue() >> pf->blueAdjust) << pf->blueAdjust));
  49 #endif
  50 }
  51
  52
  53 //-----------------------------------------------------------------------------
  54 // wxMask
  55 //-----------------------------------------------------------------------------
  56
  57 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
  58
  59 wxMask::wxMask() : m_bitmap(NULL)
  60 {
  61 }
  62
  63 wxMask::wxMask(const wxBitmap& bitmap)
  64     : m_bitmap(NULL)
  65 {
  66     Create(bitmap);
  67 }
  68
  69 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
  70     : m_bitmap(NULL)
  71 {
  72     Create(bitmap, colour);
  73 }
  74
  75 #if wxUSE_PALETTE
  76 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
  77     : m_bitmap(NULL)
  78 {
  79     Create(bitmap, paletteIndex);
  80 }
  81 #endif // wxUSE_PALETTE
  82
  83 wxMask::wxMask(const wxMask& mask)
  84 {
  85     m_bitmap = mask.m_bitmap ? new wxBitmap(*mask.m_bitmap) : NULL;
  86 }
  87
  88 wxMask::~wxMask()
  89 {
  90     delete m_bitmap;
  91 }
  92
  93 #warning "move this to common code"
  94 bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
  95 {
  96     delete m_bitmap;
  97     m_bitmap = NULL;
  98
  99     wxColour clr(wxQuantizeColour(colour, bitmap));
 100
 101     wxImage imgSrc(bitmap.ConvertToImage());
 102     imgSrc.SetMask(false);
 103     wxImage image(imgSrc.ConvertToMono(clr.Red(), clr.Green(), clr.Blue()));
 104     if ( !image.Ok() )
 105         return false;
 106
 107     m_bitmap = new wxBitmap(image, 1);
 108
 109     return m_bitmap->Ok();
 110 }
 111
 112 #if wxUSE_PALETTE
 113 bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
 114 {
 115     unsigned char r,g,b;
 116     wxPalette *pal = bitmap.GetPalette();
 117
 118     wxCHECK_MSG( pal, false, wxT("Cannot create mask from bitmap without palette") );
 119
 120     pal->GetRGB(paletteIndex, &r, &g, &b);
 121
 122     return Create(bitmap, wxColour(r, g, b));
 123 }
 124 #endif // wxUSE_PALETTE
 125
 126 bool wxMask::Create(const wxBitmap& bitmap)
 127 {
 128     delete m_bitmap;
 129     m_bitmap = NULL;
 130
 131     wxCHECK_MSG( bitmap.Ok(), false, wxT("Invalid bitmap") );
 132     wxCHECK_MSG( bitmap.GetDepth() == 1, false, wxT("Cannot create mask from colour bitmap") );
 133
 134     m_bitmap = new wxBitmap(bitmap);
 135     return true;
 136 }
 137
 138 const wxBitmap& wxMask::GetBitmap() const
 139 {
 140     return m_bitmap ? *m_bitmap : wxNullBitmap;
 141 }
 142
 143
 144 //-----------------------------------------------------------------------------
 145 // wxBitmapRefData
 146 //-----------------------------------------------------------------------------
 147
 148 class wxBitmapRefData: public wxObjectRefData
 149 {
 150 public:
 151     wxBitmapRefData()
 152     {
 153         m_mask = NULL;
 154 #if wxUSE_PALETTE
 155         m_palette = NULL;
 156 #endif
 157     }
 158
 159     wxBitmapRefData(const wxBitmapRefData& data)
 160     {
 161         if ( data.m_surface )
 162             m_surface = data.m_surface->Clone();
 163
 164         m_mask = data.m_mask ? new wxMask(*data.m_mask) : NULL;
 165 #if wxUSE_PALETTE
 166         m_palette = data.m_palette ? new wxPalette(*data.m_palette) : NULL;
 167 #endif
 168     }
 169
 170     ~wxBitmapRefData()
 171     {
 172         delete m_mask;
 173 #if wxUSE_PALETTE
 174         delete m_palette;
 175 #endif
 176     }
 177
 178     wxIDirectFBSurfacePtr m_surface;
 179     wxMask               *m_mask;
 180 #if wxUSE_PALETTE
 181     wxPalette            *m_palette;
 182 #endif
 183 };
 184
 185 #define M_BITMAP ((wxBitmapRefData *)m_refData)
 186
 187 //-----------------------------------------------------------------------------
 188 // wxBitmap
 189 //-----------------------------------------------------------------------------
 190
 191 IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxObject)
 192 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxBitmapBase)
 193
 194 wxBitmap::wxBitmap(int width, int height, int depth)
 195 {
 196     Create(width, height, depth);
 197 }
 198
 199 bool wxBitmap::Create(const wxIDirectFBSurfacePtr& surface)
 200 {
 201     UnRef();
 202
 203     wxCHECK_MSG( surface, false, _T("invalid surface") );
 204
 205     m_refData = new wxBitmapRefData();
 206     M_BITMAP->m_surface = surface;
 207     return true;
 208 }
 209
 210 bool wxBitmap::Create(int width, int height, int depth)
 211 {
 212     UnRef();
 213
 214     wxCHECK_MSG( width > 0 && height > 0, false, wxT("invalid bitmap size") );
 215
 216     DFBSurfaceDescription desc;
 217     desc.flags = (DFBSurfaceDescriptionFlags)(
 218                         DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT);
 219     desc.caps = DSCAPS_NONE;
 220     desc.width = width;
 221     desc.height = height;
 222
 223     return Create(wxIDirectFB::Get()->CreateSurface(&desc));
 224 }
 225
 226 #warning "FIXME: move this to common code"
 227 bool wxBitmap::CreateFromXpm(const char **bits)
 228 {
 229     wxCHECK_MSG( bits != NULL, false, wxT("invalid bitmap data") );
 230
 231 #if wxUSE_IMAGE && wxUSE_XPM
 232     wxXPMDecoder decoder;
 233     wxImage img = decoder.ReadData(bits);
 234     wxCHECK_MSG( img.Ok(), false, wxT("invalid bitmap data") );
 235
 236     *this = wxBitmap(img);
 237
 238     return true;
 239 #else
 240     wxFAIL_MSG( _T("creating bitmaps from XPMs not supported") );
 241     return false;
 242 #endif // wxUSE_IMAGE && wxUSE_XPM
 243 }
 244
 245 #if wxUSE_IMAGE
 246 wxBitmap::wxBitmap(const wxImage& image, int depth)
 247 {
 248     wxCHECK_RET( image.Ok(), wxT("invalid image") );
 249 }
 250
 251 wxImage wxBitmap::ConvertToImage() const
 252 {
 253     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 254
 255     return wxNullImage; // FIXME
 256 }
 257 #endif // wxUSE_IMAGE
 258
 259 wxBitmap::wxBitmap(const wxString &filename, wxBitmapType type)
 260 {
 261     LoadFile(filename, type);
 262 }
 263
 264 wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
 265 {
 266     wxCHECK_RET( depth == 1, wxT("can only create mono bitmap from XBM data") );
 267 }
 268
 269 bool wxBitmap::Ok() const
 270 {
 271     return (m_refData != NULL && M_BITMAP->m_surface);
 272 }
 273
 274 bool wxBitmap::operator==(const wxBitmap& bmp) const
 275 {
 276     // FIXME: is this the right way to compare bitmaps?
 277     return (m_refData == bmp.m_refData);
 278 }
 279
 280 int wxBitmap::GetHeight() const
 281 {
 282     wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 283
 284     int h = -1;
 285     M_BITMAP->m_surface->GetSize(NULL, &h);
 286     return h;
 287 }
 288
 289 int wxBitmap::GetWidth() const
 290 {
 291     wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 292
 293     int w = -1;
 294     M_BITMAP->m_surface->GetSize(&w, NULL);
 295     return w;
 296 }
 297
 298 int wxBitmap::GetDepth() const
 299 {
 300     wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 301
 302     return M_BITMAP->m_surface->GetDepth();
 303 }
 304
 305 wxMask *wxBitmap::GetMask() const
 306 {
 307     wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
 308
 309     return M_BITMAP->m_mask;
 310 }
 311
 312 void wxBitmap::SetMask(wxMask *mask)
 313 {
 314     wxCHECK_RET( Ok(), wxT("invalid bitmap") );
 315
 316     delete M_BITMAP->m_mask;
 317     M_BITMAP->m_mask = mask;
 318 }
 319
 320 bool wxBitmap::CopyFromIcon(const wxIcon& icon)
 321 {
 322     *this = *((wxBitmap*)(&icon));
 323     return true;
 324 }
 325
 326 wxBitmap wxBitmap::GetSubBitmap(const wxRect& rect) const
 327 {
 328     wxCHECK_MSG( Ok() &&
 329                  rect.x >= 0 && rect.y >= 0 &&
 330                  rect.x+rect.width <= GetWidth() &&
 331                  rect.y+rect.height <= GetHeight(),
 332                  wxNullBitmap,
 333                  wxT("invalid bitmap or bitmap region") );
 334
 335     // NB: DirectFB subsurfaces share the same pixels buffer, so we must
 336     //     clone the obtained subsurface
 337     DFBRectangle r = { rect.x, rect.y, rect.width, rect.height };
 338     return wxBitmap(M_BITMAP->m_surface->GetSubSurface(&r)->Clone());
 339 }
 340
 341 #warning "to common code"
 342 bool wxBitmap::LoadFile(const wxString &name, wxBitmapType type)
 343 {
 344     UnRef();
 345
 346     wxBitmapHandler *handler = FindHandler(type);
 347
 348     if ( handler == NULL )
 349     {
 350         wxImage image;
 351         if ( !image.LoadFile(name, type) || !image.Ok() )
 352         {
 353             wxLogError("no bitmap handler for type %d defined.", type);
 354             return false;
 355         }
 356         else
 357         {
 358             *this = wxBitmap(image);
 359             return true;
 360         }
 361     }
 362
 363     m_refData = new wxBitmapRefData();
 364
 365     return handler->LoadFile(this, name, type, -1, -1);
 366 }
 367
 368 #warning "to common code"
 369 bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type, const wxPalette *palette) const
 370 {
 371     wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
 372
 373     wxBitmapHandler *handler = FindHandler(type);
 374
 375     if ( handler == NULL )
 376     {
 377         wxImage image = ConvertToImage();
 378 #if wxUSE_PALETTE
 379         if ( palette )
 380             image.SetPalette(*palette);
 381 #endif // wxUSE_PALETTE
 382
 383         if ( image.Ok() )
 384             return image.SaveFile(filename, type);
 385         else
 386         {
 387             wxLogError("no bitmap handler for type %d defined.", type);
 388             return false;
 389         }
 390     }
 391
 392     return handler->SaveFile(this, filename, type, palette);
 393 }
 394
 395 #if wxUSE_PALETTE
 396 wxPalette *wxBitmap::GetPalette() const
 397 {
 398     wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
 399
 400     return M_BITMAP->m_palette;
 401 }
 402
 403 void wxBitmap::SetPalette(const wxPalette& palette)
 404 {
 405     wxCHECK_RET( Ok(), wxT("invalid bitmap") );
 406     wxCHECK_RET( GetDepth() > 1 && GetDepth() <= 8, wxT("cannot set palette for bitmap of this depth") );
 407
 408     delete M_BITMAP->m_palette;
 409     M_BITMAP->m_palette = NULL;
 410
 411     if ( !palette.Ok() ) return;
 412
 413     M_BITMAP->m_palette = new wxPalette(palette);
 414 }
 415 #endif // wxUSE_PALETTE
 416
 417 void wxBitmap::SetHeight(int height)
 418 {
 419     AllocExclusive();
 420 #warning "todo"
 421 }
 422
 423 void wxBitmap::SetWidth(int width)
 424 {
 425     AllocExclusive();
 426 #warning "todo"
 427 }
 428
 429 void wxBitmap::SetDepth(int depth)
 430 {
 431     AllocExclusive();
 432 #warning "todo"
 433 }
 434
 435 wxIDirectFBSurfacePtr wxBitmap::GetDirectFBSurface() const
 436 {
 437     wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
 438
 439     return M_BITMAP->m_surface;
 440 }
 441
 442 wxObjectRefData *wxBitmap::CreateRefData() const
 443 {
 444     return new wxBitmapRefData;
 445 }
 446
 447 wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *data) const
 448 {
 449     return new wxBitmapRefData(*(wxBitmapRefData *)data);
 450 }
 451
 452
 453 /*static*/
 454 void wxBitmap::InitStandardHandlers()
 455 {
 456     // not wxBitmap handlers, we rely on wxImage
 457 }