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     wxCHECK_MSG( depth == -1, false, wxT("only default depth supported now") );
 216
 217     DFBSurfaceDescription desc;
 218     desc.flags = (DFBSurfaceDescriptionFlags)(
 219                         DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT);
 220     desc.caps = DSCAPS_NONE;
 221     desc.width = width;
 222     desc.height = height;
 223
 224     return Create(wxIDirectFB::Get()->CreateSurface(&desc));
 225 }
 226
 227 #warning "FIXME: move this to common code"
 228 bool wxBitmap::CreateFromXpm(const char **bits)
 229 {
 230     wxCHECK_MSG( bits != NULL, false, wxT("invalid bitmap data") );
 231
 232 #if wxUSE_IMAGE && wxUSE_XPM
 233     wxXPMDecoder decoder;
 234     wxImage img = decoder.ReadData(bits);
 235     wxCHECK_MSG( img.Ok(), false, wxT("invalid bitmap data") );
 236
 237     *this = wxBitmap(img);
 238
 239     return true;
 240 #else
 241     wxFAIL_MSG( _T("creating bitmaps from XPMs not supported") );
 242     return false;
 243 #endif // wxUSE_IMAGE && wxUSE_XPM
 244 }
 245
 246 #if wxUSE_IMAGE
 247 wxBitmap::wxBitmap(const wxImage& image, int depth)
 248 {
 249     wxCHECK_RET( image.Ok(), wxT("invalid image") );
 250 }
 251
 252 wxImage wxBitmap::ConvertToImage() const
 253 {
 254     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 255
 256     return wxNullImage; // FIXME
 257 }
 258 #endif // wxUSE_IMAGE
 259
 260 wxBitmap::wxBitmap(const wxString &filename, wxBitmapType type)
 261 {
 262     LoadFile(filename, type);
 263 }
 264
 265 wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
 266 {
 267     wxCHECK_RET( depth == 1, wxT("can only create mono bitmap from XBM data") );
 268
 269     wxFAIL_MSG( _T("not implemented") );
 270 }
 271
 272 bool wxBitmap::Ok() const
 273 {
 274     return (m_refData != NULL && M_BITMAP->m_surface);
 275 }
 276
 277 bool wxBitmap::operator==(const wxBitmap& bmp) const
 278 {
 279     // FIXME: is this the right way to compare bitmaps?
 280     return (m_refData == bmp.m_refData);
 281 }
 282
 283 int wxBitmap::GetHeight() const
 284 {
 285     wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 286
 287     int h = -1;
 288     M_BITMAP->m_surface->GetSize(NULL, &h);
 289     return h;
 290 }
 291
 292 int wxBitmap::GetWidth() const
 293 {
 294     wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 295
 296     int w = -1;
 297     M_BITMAP->m_surface->GetSize(&w, NULL);
 298     return w;
 299 }
 300
 301 int wxBitmap::GetDepth() const
 302 {
 303     wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 304
 305     return M_BITMAP->m_surface->GetDepth();
 306 }
 307
 308 wxMask *wxBitmap::GetMask() const
 309 {
 310     wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
 311
 312     return M_BITMAP->m_mask;
 313 }
 314
 315 void wxBitmap::SetMask(wxMask *mask)
 316 {
 317     wxCHECK_RET( Ok(), wxT("invalid bitmap") );
 318
 319     delete M_BITMAP->m_mask;
 320     M_BITMAP->m_mask = mask;
 321 }
 322
 323 bool wxBitmap::CopyFromIcon(const wxIcon& icon)
 324 {
 325     *this = *((wxBitmap*)(&icon));
 326     return true;
 327 }
 328
 329 wxBitmap wxBitmap::GetSubBitmap(const wxRect& rect) const
 330 {
 331     wxCHECK_MSG( Ok() &&
 332                  rect.x >= 0 && rect.y >= 0 &&
 333                  rect.x+rect.width <= GetWidth() &&
 334                  rect.y+rect.height <= GetHeight(),
 335                  wxNullBitmap,
 336                  wxT("invalid bitmap or bitmap region") );
 337
 338     // NB: DirectFB subsurfaces share the same pixels buffer, so we must
 339     //     clone the obtained subsurface
 340     DFBRectangle r = { rect.x, rect.y, rect.width, rect.height };
 341     return wxBitmap(M_BITMAP->m_surface->GetSubSurface(&r)->Clone());
 342 }
 343
 344 #warning "to common code"
 345 bool wxBitmap::LoadFile(const wxString &name, wxBitmapType type)
 346 {
 347     UnRef();
 348
 349     wxBitmapHandler *handler = FindHandler(type);
 350
 351     if ( handler == NULL )
 352     {
 353         wxImage image;
 354         if ( !image.LoadFile(name, type) || !image.Ok() )
 355         {
 356             wxLogError("no bitmap handler for type %d defined.", type);
 357             return false;
 358         }
 359         else
 360         {
 361             *this = wxBitmap(image);
 362             return true;
 363         }
 364     }
 365
 366     m_refData = new wxBitmapRefData();
 367
 368     return handler->LoadFile(this, name, type, -1, -1);
 369 }
 370
 371 #warning "to common code"
 372 bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type, const wxPalette *palette) const
 373 {
 374     wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
 375
 376     wxBitmapHandler *handler = FindHandler(type);
 377
 378     if ( handler == NULL )
 379     {
 380         wxImage image = ConvertToImage();
 381 #if wxUSE_PALETTE
 382         if ( palette )
 383             image.SetPalette(*palette);
 384 #endif // wxUSE_PALETTE
 385
 386         if ( image.Ok() )
 387             return image.SaveFile(filename, type);
 388         else
 389         {
 390             wxLogError("no bitmap handler for type %d defined.", type);
 391             return false;
 392         }
 393     }
 394
 395     return handler->SaveFile(this, filename, type, palette);
 396 }
 397
 398 #if wxUSE_PALETTE
 399 wxPalette *wxBitmap::GetPalette() const
 400 {
 401     wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
 402
 403     return M_BITMAP->m_palette;
 404 }
 405
 406 void wxBitmap::SetPalette(const wxPalette& palette)
 407 {
 408     wxCHECK_RET( Ok(), wxT("invalid bitmap") );
 409     wxCHECK_RET( GetDepth() > 1 && GetDepth() <= 8, wxT("cannot set palette for bitmap of this depth") );
 410
 411     delete M_BITMAP->m_palette;
 412     M_BITMAP->m_palette = NULL;
 413
 414     if ( !palette.Ok() ) return;
 415
 416     M_BITMAP->m_palette = new wxPalette(palette);
 417 }
 418 #endif // wxUSE_PALETTE
 419
 420 void wxBitmap::SetHeight(int height)
 421 {
 422     AllocExclusive();
 423 #warning "todo"
 424 }
 425
 426 void wxBitmap::SetWidth(int width)
 427 {
 428     AllocExclusive();
 429 #warning "todo"
 430 }
 431
 432 void wxBitmap::SetDepth(int depth)
 433 {
 434     AllocExclusive();
 435 #warning "todo"
 436 }
 437
 438 wxIDirectFBSurfacePtr wxBitmap::GetDirectFBSurface() const
 439 {
 440     wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
 441
 442     return M_BITMAP->m_surface;
 443 }
 444
 445 wxObjectRefData *wxBitmap::CreateRefData() const
 446 {
 447     return new wxBitmapRefData;
 448 }
 449
 450 wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *data) const
 451 {
 452     return new wxBitmapRefData(*(wxBitmapRefData *)data);
 453 }
 454
 455
 456 /*static*/
 457 void wxBitmap::InitStandardHandlers()
 458 {
 459     // not wxBitmap handlers, we rely on wxImage
 460 }