src/palmos/bitmap.cpp

   1 ////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/palmos/bitmap.cpp
   3 // Purpose:     wxBitmap
   4 // Author:      William Osborne - minimal working wxPalmOS port
   5 // Modified by:
   6 // Created:     10/08/04
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) William Osborne
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #include "wx/bitmap.h"
  28
  29 #ifndef WX_PRECOMP
  30     #include <stdio.h>
  31
  32     #include "wx/list.h"
  33     #include "wx/utils.h"
  34     #include "wx/app.h"
  35     #include "wx/palette.h"
  36     #include "wx/dcmemory.h"
  37     #include "wx/icon.h"
  38     #include "wx/log.h"
  39     #include "wx/image.h"
  40 #endif
  41
  42 #if wxUSE_WXDIB
  43 #include "wx/palmos/dib.h"
  44 #endif
  45
  46 #include "wx/xpmdecod.h"
  47
  48 // missing from mingw32 header
  49 #ifndef CLR_INVALID
  50     #define CLR_INVALID ((COLORREF)-1)
  51 #endif // no CLR_INVALID
  52
  53 // ----------------------------------------------------------------------------
  54 // Bitmap data
  55 // ----------------------------------------------------------------------------
  56
  57 class WXDLLEXPORT wxBitmapRefData : public wxGDIImageRefData
  58 {
  59 public:
  60     wxBitmapRefData();
  61     virtual ~wxBitmapRefData() { Free(); }
  62
  63     virtual void Free();
  64
  65     // set the mask object to use as the mask, we take ownership of it
  66     void SetMask(wxMask *mask)
  67     {
  68         delete m_bitmapMask;
  69         m_bitmapMask = mask;
  70     }
  71
  72     // return the mask
  73     wxMask *GetMask() const { return m_bitmapMask; }
  74
  75 public:
  76 #if wxUSE_PALETTE
  77     wxPalette     m_bitmapPalette;
  78 #endif // wxUSE_PALETTE
  79
  80 #ifdef __WXDEBUG__
  81     wxDC         *m_selectedInto;
  82 #endif // __WXDEBUG__
  83
  84 #if wxUSE_WXDIB
  85     wxDIB *m_dib;
  86 #endif
  87
  88     bool m_hasAlpha;
  89
  90     bool m_isDIB;
  91
  92 private:
  93     wxMask       *m_bitmapMask;
  94
  95     wxDECLARE_NO_COPY_CLASS(wxBitmapRefData);
  96 };
  97
  98 // ----------------------------------------------------------------------------
  99 // macros
 100 // ----------------------------------------------------------------------------
 101
 102 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
 103 IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
 104
 105 IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
 106
 107 // ============================================================================
 108 // implementation
 109 // ============================================================================
 110
 111 // ----------------------------------------------------------------------------
 112 // helper functions
 113 // ----------------------------------------------------------------------------
 114
 115 #if !wxUSE_WXDIB
 116     #define NEVER_USE_DIB
 117 #else
 118     static inline bool wxShouldCreateDIB(int w, int h, int d, WXHDC hdc)
 119     {
 120         // here is the logic:
 121         //
 122         //  (a) if hdc is specified, the caller explicitly wants DDB
 123         //  (b) otherwise, create a DIB if depth >= 24 (we don't support 16bpp
 124         //      or less DIBs anyhow)
 125         //  (c) finally, create DIBs under Win9x even if the depth hasn't been
 126         //      explicitly specified but the current display depth is 24 or
 127         //      more and the image is "big", i.e. > 16Mb which is the
 128         //      theoretical limit for DDBs under Win9x
 129         //
 130         // consequences (all of which seem to make sense):
 131         //
 132         //  (i)     by default, DDBs are created (depth == -1 usually)
 133         //  (ii)    DIBs can be created by explicitly specifying the depth
 134         //  (iii)   using a DC always forces creating a DDB
 135         return !hdc &&
 136                 (d >= 24 ||
 137                     (d == -1 &&
 138                         wxDIB::GetLineSize(w, wxDisplayDepth())*h > 16*1024*1024));
 139     }
 140
 141     #define SOMETIMES_USE_DIB
 142 #endif // different DIB usage scenarious
 143
 144 // ----------------------------------------------------------------------------
 145 // wxBitmapRefData
 146 // ----------------------------------------------------------------------------
 147
 148 wxBitmapRefData::wxBitmapRefData()
 149 {
 150 #ifdef __WXDEBUG__
 151     m_selectedInto = NULL;
 152 #endif
 153     m_bitmapMask = NULL;
 154
 155     m_hBitmap = (WXHBITMAP) NULL;
 156 #if wxUSE_WXDIB
 157     m_dib = NULL;
 158 #endif
 159
 160     m_isDIB =
 161     m_hasAlpha = false;
 162 }
 163
 164 void wxBitmapRefData::Free()
 165 {
 166 }
 167
 168 // ----------------------------------------------------------------------------
 169 // wxBitmap creation
 170 // ----------------------------------------------------------------------------
 171
 172 // this function should be called from all wxBitmap ctors
 173 void wxBitmap::Init()
 174 {
 175 }
 176
 177 wxGDIImageRefData *wxBitmap::CreateData() const
 178 {
 179     return NULL;
 180 }
 181
 182 bool wxBitmap::CopyFromCursor(const wxCursor& cursor)
 183 {
 184     return false;
 185 }
 186
 187 bool wxBitmap::CopyFromIcon(const wxIcon& icon)
 188 {
 189     return false;
 190 }
 191
 192 #ifndef NEVER_USE_DIB
 193
 194 bool wxBitmap::CopyFromDIB(const wxDIB& dib)
 195 {
 196     return false:
 197 }
 198
 199 #endif // NEVER_USE_DIB
 200
 201 wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
 202 {
 203     Init();
 204 }
 205
 206 wxBitmap::wxBitmap(int w, int h, const wxDC& dc)
 207 {
 208 }
 209
 210 wxBitmap::wxBitmap(const void* data, long type, int width, int height, int depth)
 211 {
 212 }
 213
 214 wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type)
 215 {
 216 }
 217
 218 bool wxBitmap::Create(int width, int height, int depth)
 219 {
 220     return false;
 221 }
 222
 223 bool wxBitmap::Create(int width, int height, const wxDC& dc)
 224 {
 225     return false;
 226 }
 227
 228 bool wxBitmap::DoCreate(int w, int h, int d, WXHDC hdc)
 229 {
 230     return false;
 231 }
 232
 233 #if wxUSE_IMAGE
 234
 235 // ----------------------------------------------------------------------------
 236 // wxImage to/from conversions
 237 // ----------------------------------------------------------------------------
 238
 239 #if wxUSE_WXDIB
 240
 241 bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
 242 {
 243     return false;
 244 }
 245
 246 bool wxBitmap::CreateFromImage(const wxImage& image, const wxDC& dc)
 247 {
 248     return false;
 249 }
 250
 251 bool wxBitmap::CreateFromImage(const wxImage& image, int depth, WXHDC hdc)
 252 {
 253     return false;
 254 }
 255
 256 wxImage wxBitmap::ConvertToImage() const
 257 {
 258     wxImage image;
 259     return image;
 260 }
 261
 262 #endif // wxUSE_WXDIB
 263
 264 #endif // wxUSE_IMAGE
 265
 266 // ----------------------------------------------------------------------------
 267 // loading and saving bitmaps
 268 // ----------------------------------------------------------------------------
 269
 270 bool wxBitmap::LoadFile(const wxString& filename, long type)
 271 {
 272     return false;
 273 }
 274
 275 bool wxBitmap::Create(const void* data, long type, int width, int height, int depth)
 276 {
 277     return false;
 278 }
 279
 280 bool wxBitmap::SaveFile(const wxString& filename,
 281                         int type,
 282                         const wxPalette *palette)
 283 {
 284     return false;
 285 }
 286
 287 // ----------------------------------------------------------------------------
 288 // sub bitmap extraction
 289 // ----------------------------------------------------------------------------
 290
 291 wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
 292 {
 293     wxBitmap ret( 0, 0 );
 294     return ret;
 295 }
 296
 297 // ----------------------------------------------------------------------------
 298 // wxBitmap accessors
 299 // ----------------------------------------------------------------------------
 300
 301 #if wxUSE_PALETTE
 302 wxPalette* wxBitmap::GetPalette() const
 303 {
 304     return NULL;
 305 }
 306 #endif
 307
 308 wxMask *wxBitmap::GetMask() const
 309 {
 310     return NULL;
 311 }
 312
 313 #ifdef __WXDEBUG__
 314
 315 wxDC *wxBitmap::GetSelectedInto() const
 316 {
 317     return NULL;
 318 }
 319
 320 #endif
 321
 322 bool wxBitmap::HasAlpha() const
 323 {
 324     return false;
 325 }
 326
 327 // ----------------------------------------------------------------------------
 328 // wxBitmap setters
 329 // ----------------------------------------------------------------------------
 330
 331 #ifdef __WXDEBUG__
 332
 333 void wxBitmap::SetSelectedInto(wxDC *dc)
 334 {
 335 }
 336
 337 #endif
 338
 339 #if wxUSE_PALETTE
 340
 341 void wxBitmap::SetPalette(const wxPalette& palette)
 342 {
 343 }
 344
 345 #endif // wxUSE_PALETTE
 346
 347 void wxBitmap::SetMask(wxMask *mask)
 348 {
 349 }
 350
 351 // ----------------------------------------------------------------------------
 352 // raw bitmap access support
 353 // ----------------------------------------------------------------------------
 354
 355 // ----------------------------------------------------------------------------
 356 // wxMask
 357 // ----------------------------------------------------------------------------
 358
 359 wxMask::wxMask()
 360 {
 361     m_maskBitmap = 0;
 362 }
 363
 364 // Construct a mask from a bitmap and a colour indicating
 365 // the transparent area
 366 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
 367 {
 368 }
 369
 370 // Construct a mask from a bitmap and a palette index indicating
 371 // the transparent area
 372 wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
 373 {
 374 }
 375
 376 // Construct a mask from a mono bitmap (copies the bitmap).
 377 wxMask::wxMask(const wxBitmap& bitmap)
 378 {
 379 }
 380
 381 wxMask::~wxMask()
 382 {
 383 }
 384
 385 // Create a mask from a mono bitmap (copies the bitmap).
 386 bool wxMask::Create(const wxBitmap& bitmap)
 387 {
 388     return false;
 389 }
 390
 391 // Create a mask from a bitmap and a palette index indicating
 392 // the transparent area
 393 bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
 394 {
 395     return false;
 396 }
 397
 398 // Create a mask from a bitmap and a colour indicating
 399 // the transparent area
 400 bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
 401 {
 402     return false;
 403 }
 404
 405 // ----------------------------------------------------------------------------
 406 // wxBitmapHandler
 407 // ----------------------------------------------------------------------------
 408
 409 bool wxBitmapHandler::Create(wxGDIImage *image,
 410                              const void* data,
 411                              long flags,
 412                              int width, int height, int depth)
 413 {
 414     return false;
 415 }
 416
 417 bool wxBitmapHandler::Load(wxGDIImage *image,
 418                            const wxString& name,
 419                            long flags,
 420                            int width, int height)
 421 {
 422     return false;
 423 }
 424
 425 bool wxBitmapHandler::Save(wxGDIImage *image,
 426                            const wxString& name,
 427                            int type)
 428 {
 429     return false;
 430 }
 431
 432 bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap),
 433                              const void* WXUNUSED(data),
 434                              long WXUNUSED(type),
 435                              int WXUNUSED(width),
 436                              int WXUNUSED(height),
 437                              int WXUNUSED(depth))
 438 {
 439     return false;
 440 }
 441
 442 bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap),
 443                                const wxString& WXUNUSED(name),
 444                                long WXUNUSED(type),
 445                                int WXUNUSED(desiredWidth),
 446                                int WXUNUSED(desiredHeight))
 447 {
 448     return false;
 449 }
 450
 451 bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap),
 452                                const wxString& WXUNUSED(name),
 453                                int WXUNUSED(type),
 454                                const wxPalette *WXUNUSED(palette))
 455 {
 456     return false;
 457 }