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