]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/x11/bitmap.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
fixed unreachable code warnings (occurred in MSVC6+Release mode)
[wxWidgets.git] / src / x11 / bitmap.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/x11/bitmap.cpp
3// Purpose: wxBitmap
4// Author: Julian Smart, Robert Roebling
5// Modified by:
6// Created: 17/09/98
7// RCS-ID: $Id$
8// Copyright: (c) Julian Smart, Robert Roebling
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12// for compilers that support precompilation, includes "wx.h".
13#include "wx/wxprec.h"
14
15#include "wx/bitmap.h"
16#include "wx/icon.h"
17#include "wx/log.h"
18#include "wx/image.h"
19#include "wx/app.h"
20#if wxUSE_NANOX
21#include "wx/dcmemory.h"
22#endif
23
24#include "wx/x11/private.h"
25
26/* No point in using libXPM for NanoX */
27#if wxUSE_NANOX
28#undef wxHAVE_LIB_XPM
29#define wxHAVE_LIB_XPM 0
30
31// Copy from the drawable to the wxImage
32bool wxGetImageFromDrawable(GR_DRAW_ID drawable, int srcX, int srcY, int width, int height, wxImage& image);
33#endif
34
35#if wxUSE_XPM
36#if wxHAVE_LIB_XPM
37#include <X11/xpm.h>
38#else
39#include "wx/xpmdecod.h"
40#include "wx/wfstream.h"
41#endif
42#endif
43#include "wx/math.h"
44
45//-----------------------------------------------------------------------------
46// wxMask
47//-----------------------------------------------------------------------------
48
49IMPLEMENT_DYNAMIC_CLASS(wxMask,wxObject)
50
51wxMask::wxMask()
52{
53 m_bitmap = NULL;
54 m_display = NULL;
55}
56
57wxMask::wxMask( const wxBitmap& bitmap, const wxColour& colour )
58{
59 m_bitmap = NULL;
60 Create( bitmap, colour );
61}
62
63wxMask::wxMask( const wxBitmap& bitmap, int paletteIndex )
64{
65 m_bitmap = NULL;
66 Create( bitmap, paletteIndex );
67}
68
69wxMask::wxMask( const wxBitmap& bitmap )
70{
71 m_bitmap = NULL;
72 Create( bitmap );
73}
74
75wxMask::~wxMask()
76{
77 if (m_bitmap)
78 XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap );
79}
80
81bool wxMask::Create( const wxBitmap& bitmap,
82 const wxColour& colour )
83{
84#if !wxUSE_NANOX
85 if (m_bitmap)
86 {
87 XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap );
88 m_bitmap = NULL;
89 }
90
91 m_display = bitmap.GetDisplay();
92
93 wxImage image = bitmap.ConvertToImage();
94 if (!image.Ok()) return false;
95
96 m_display = bitmap.GetDisplay();
97
98 Display *xdisplay = (Display*) m_display;
99 int xscreen = DefaultScreen( xdisplay );
100 Window xroot = RootWindow( xdisplay, xscreen );
101
102 m_bitmap = (WXPixmap) XCreatePixmap( xdisplay, xroot, image.GetWidth(), image.GetHeight(), 1 );
103 GC gc = XCreateGC( xdisplay, (Pixmap) m_bitmap, 0, NULL );
104
105 XSetForeground( xdisplay, gc, WhitePixel(xdisplay,xscreen) );
106 XSetFillStyle( xdisplay, gc, FillSolid );
107 XFillRectangle( xdisplay, (Pixmap) m_bitmap, gc, 0, 0, image.GetWidth(), image.GetHeight() );
108
109 unsigned char *data = image.GetData();
110 int index = 0;
111
112 unsigned char red = colour.Red();
113 unsigned char green = colour.Green();
114 unsigned char blue = colour.Blue();
115
116 int bpp = wxTheApp->GetVisualInfo(m_display)->m_visualDepth;
117
118 if (bpp == 15)
119 {
120 red &= 0xf8;
121 green &= 0xf8;
122 blue &= 0xf8;
123 } else
124 if (bpp == 16)
125 {
126 red &= 0xf8;
127 green &= 0xfc;
128 blue &= 0xf8;
129 } else
130 if (bpp == 12)
131 {
132 red &= 0xf0;
133 green &= 0xf0;
134 blue &= 0xf0;
135 }
136
137 XSetForeground( xdisplay, gc, BlackPixel(xdisplay,xscreen) );
138
139 int width = image.GetWidth();
140 int height = image.GetHeight();
141 for (int j = 0; j < height; j++)
142 {
143 int start_x = -1;
144 int i;
145 for (i = 0; i < width; i++)
146 {
147 if ((data[index] == red) &&
148 (data[index+1] == green) &&
149 (data[index+2] == blue))
150 {
151 if (start_x == -1)
152 start_x = i;
153 }
154 else
155 {
156 if (start_x != -1)
157 {
158 XDrawLine( xdisplay, (Pixmap) m_bitmap, gc, start_x, j, i-1, j );
159 start_x = -1;
160 }
161 }
162 index += 3;
163 }
164 if (start_x != -1)
165 XDrawLine( xdisplay, (Pixmap) m_bitmap, gc, start_x, j, i, j );
166 }
167
168 XFreeGC( xdisplay, gc );
169
170 return true;
171#else
172 return false;
173#endif
174 // wxUSE_NANOX
175}
176
177bool wxMask::Create( const wxBitmap& bitmap, int paletteIndex )
178{
179 unsigned char r,g,b;
180 wxPalette *pal = bitmap.GetPalette();
181
182 wxCHECK_MSG( pal, false, wxT("Cannot create mask from bitmap without palette") );
183
184 pal->GetRGB(paletteIndex, &r, &g, &b);
185
186 return Create(bitmap, wxColour(r, g, b));
187}
188
189bool wxMask::Create( const wxBitmap& bitmap )
190{
191#if !wxUSE_NANOX
192 if (m_bitmap)
193 {
194 XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap );
195 m_bitmap = NULL;
196 }
197
198 if (!bitmap.Ok()) return false;
199
200 wxCHECK_MSG( bitmap.GetBitmap(), false, wxT("Cannot create mask from colour bitmap") );
201
202 m_display = bitmap.GetDisplay();
203
204 int xscreen = DefaultScreen( (Display*) m_display );
205 Window xroot = RootWindow( (Display*) m_display, xscreen );
206
207 m_bitmap = (WXPixmap) XCreatePixmap( (Display*) m_display, xroot, bitmap.GetWidth(), bitmap.GetHeight(), 1 );
208
209 if (!m_bitmap) return false;
210
211 GC gc = XCreateGC( (Display*) m_display, (Pixmap) m_bitmap, 0, NULL );
212
213 XCopyPlane( (Display*) m_display, (Pixmap) bitmap.GetBitmap(), (Pixmap) m_bitmap,
214 gc, 0, 0, bitmap.GetWidth(), bitmap.GetHeight(), 0, 0, 1 );
215
216 XFreeGC( (Display*) m_display, gc );
217
218 return true;
219#else
220 return false;
221#endif
222 // wxUSE_NANOX
223}
224
225//-----------------------------------------------------------------------------
226// wxBitmap
227//-----------------------------------------------------------------------------
228
229class wxBitmapRefData: public wxObjectRefData
230{
231public:
232 wxBitmapRefData();
233 ~wxBitmapRefData();
234
235 WXPixmap m_pixmap;
236 WXPixmap m_bitmap;
237 WXDisplay *m_display;
238 wxMask *m_mask;
239 int m_width;
240 int m_height;
241 int m_bpp;
242 wxPalette *m_palette;
243};
244
245wxBitmapRefData::wxBitmapRefData()
246{
247 m_pixmap = NULL;
248 m_bitmap = NULL;
249 m_display = NULL;
250 m_mask = (wxMask *) NULL;
251 m_width = 0;
252 m_height = 0;
253 m_bpp = 0;
254 m_palette = (wxPalette *) NULL;
255}
256
257wxBitmapRefData::~wxBitmapRefData()
258{
259 if (m_pixmap) XFreePixmap( (Display*) m_display, (Pixmap) m_pixmap );
260 if (m_bitmap) XFreePixmap( (Display*) m_display, (Pixmap) m_bitmap );
261 if (m_mask) delete m_mask;
262 if (m_palette) delete m_palette;
263}
264
265//-----------------------------------------------------------------------------
266
267// helper function
268
269static WXPixmap wxGetSubPixmap( WXDisplay* xdisplay, WXPixmap xpixmap,
270 int x, int y, int width, int height,
271 int depth )
272{
273 Display * const dpy = (Display *)xdisplay;
274
275 int xscreen = DefaultScreen( dpy );
276 Window xroot = RootWindow( dpy, xscreen );
277 Visual* xvisual = DefaultVisual( dpy, xscreen );
278
279 XImage* ximage = XCreateImage( dpy, xvisual, depth,
280 ZPixmap, 0, 0, width, height, 32, 0 );
281 ximage->data = (char*)malloc( ximage->bytes_per_line * ximage->height );
282 ximage = XGetSubImage( dpy, (Pixmap)xpixmap,
283 x, y, width, height,
284 AllPlanes, ZPixmap, ximage, 0, 0 );
285
286 GC gc = XCreateGC( dpy, (Pixmap)xpixmap, 0, NULL );
287 Pixmap ret = XCreatePixmap( dpy, xroot,
288 width, height, depth );
289
290 XPutImage( dpy, ret, gc, ximage,
291 0, 0, 0, 0, width, height );
292 XDestroyImage( ximage );
293 XFreeGC( dpy, gc );
294
295 return (WXPixmap)ret;
296}
297
298#define M_BMPDATA ((wxBitmapRefData *)m_refData)
299
300IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxGDIObject)
301
302wxBitmap::wxBitmap()
303{
304}
305
306wxBitmap::wxBitmap( int width, int height, int depth )
307{
308 Create( width, height, depth );
309}
310
311bool wxBitmap::Create( int width, int height, int depth )
312{
313 UnRef();
314
315 wxCHECK_MSG( (width > 0) && (height > 0), false, wxT("invalid bitmap size") )
316
317 m_refData = new wxBitmapRefData();
318
319 M_BMPDATA->m_display = wxGlobalDisplay();
320
321 wxASSERT_MSG( M_BMPDATA->m_display, wxT("No display") );
322
323 int xscreen = DefaultScreen( (Display*) M_BMPDATA->m_display );
324 Window xroot = RootWindow( (Display*) M_BMPDATA->m_display, xscreen );
325
326 int bpp = DefaultDepth( (Display*) M_BMPDATA->m_display, xscreen );
327 if (depth == -1) depth = bpp;
328
329 wxCHECK_MSG( (depth == bpp) ||
330 (depth == 1), false, wxT("invalid bitmap depth") )
331
332 M_BMPDATA->m_mask = (wxMask *) NULL;
333 M_BMPDATA->m_width = width;
334 M_BMPDATA->m_height = height;
335
336#if wxUSE_NANOX
337 M_BMPDATA->m_pixmap = (WXPixmap) GrNewPixmap(width, height, NULL);
338 M_BMPDATA->m_bpp = bpp;
339
340 wxASSERT_MSG( M_BMPDATA->m_pixmap, wxT("Bitmap creation failed") );
341#else
342 if (depth == 1)
343 {
344 M_BMPDATA->m_bitmap = (WXPixmap) XCreatePixmap( (Display*) M_BMPDATA->m_display, xroot, width, height, 1 );
345
346 wxASSERT_MSG( M_BMPDATA->m_bitmap, wxT("Bitmap creation failed") );
347
348 M_BMPDATA->m_bpp = 1;
349 }
350 else
351 {
352 M_BMPDATA->m_pixmap = (WXPixmap) XCreatePixmap( (Display*) M_BMPDATA->m_display, xroot, width, height, depth );
353
354 wxASSERT_MSG( M_BMPDATA->m_pixmap, wxT("Pixmap creation failed") );
355
356 M_BMPDATA->m_bpp = depth;
357 }
358#endif
359 return Ok();
360}
361
362bool wxBitmap::Create(void *data, wxBitmapType type,
363 int width, int height, int depth)
364{
365 UnRef();
366
367 wxBitmapHandler *handler = FindHandler(type);
368
369 if ( handler == NULL ) {
370 wxLogWarning(wxT("no data bitmap handler for type %ld defined."),
371 (long)type);
372
373 return false;
374 }
375
376 return handler->Create(this, data, type, width, height, depth);
377}
378
379bool wxBitmap::Create(WXPixmap pixmap)
380{
381 UnRef();
382 Pixmap xpixmap = (Pixmap)pixmap;
383 Display* xdisplay = wxGlobalDisplay();
384 int xscreen = DefaultScreen( xdisplay );
385 Window xroot = RootWindow( xdisplay, xscreen );
386
387 // make a copy of the Pixmap
388 Window root;
389 Pixmap copy;
390 int x, y;
391 unsigned width, height, border, depth;
392
393 XGetGeometry( xdisplay, (Drawable)xpixmap, &root, &x, &y,
394 &width, &height, &border, &depth );
395 copy = XCreatePixmap( xdisplay, xroot, width, height, depth );
396
397 GC gc = XCreateGC( xdisplay, copy, 0, NULL );
398 XCopyArea( xdisplay, xpixmap, copy, gc, 0, 0, width, height, 0, 0 );
399 XFreeGC( xdisplay, gc );
400
401 // fill in ref data
402 wxBitmapRefData* ref = new wxBitmapRefData();
403
404 if( depth == 1 )
405 ref->m_bitmap = (WXPixmap)copy;
406 else
407 ref->m_pixmap = (WXPixmap)copy;
408
409 ref->m_display = (WXDisplay*)xdisplay;
410 ref->m_width = width;
411 ref->m_height = height;
412 ref->m_bpp = depth;
413
414 m_refData = ref;
415
416 return true;
417}
418
419bool wxBitmap::CreateFromXpm( const char **bits )
420{
421 wxCHECK_MSG( bits, false, wxT("NULL pointer in wxBitmap::CreateFromXpm") );
422
423 return Create(bits, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
424}
425
426bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
427{
428#if wxUSE_NANOX
429 if (!image.Ok())
430 {
431 wxASSERT_MSG(image.Ok(), wxT("Invalid wxImage passed to wxBitmap::CreateFromImage."));
432 return false;
433 }
434
435 int w = image.GetWidth();
436 int h = image.GetHeight();
437
438 if (!Create(w, h, depth))
439 return false;
440
441 // Unfortunately the mask has to be screen-depth since
442 // 1-bpp bitmaps don't seem to be supported
443 // TODO: implement transparent drawing, presumably
444 // by doing several blits as per the Windows
445 // implementation because Nano-X doesn't support
446 // XSetClipMask.
447 // TODO: could perhaps speed this function up
448 // by making a buffer of pixel values,
449 // and then calling GrArea to write that to the
450 // pixmap. See demos/nxroach.c.
451
452 bool hasMask = image.HasMask();
453
454 GC pixmapGC = GrNewGC();
455 Pixmap pixmap = (Pixmap) GetPixmap();
456
457 GC maskGC = 0;
458 Pixmap maskPixmap = 0;
459
460 unsigned char maskR = 0;
461 unsigned char maskG = 0;
462 unsigned char maskB = 0;
463
464 if (hasMask)
465 {
466 maskR = image.GetMaskRed();
467 maskG = image.GetMaskGreen();
468 maskB = image.GetMaskBlue();
469
470 maskGC = GrNewGC();
471 maskPixmap = GrNewPixmap(w, h, 0);
472 if (!maskPixmap)
473 hasMask = false;
474 else
475 {
476 wxMask* mask = new wxMask;
477 mask->SetBitmap((WXPixmap) maskPixmap);
478 SetMask(mask);
479 }
480 }
481
482 GR_COLOR lastPixmapColour = 0;
483 GR_COLOR lastMaskColour = 0;
484
485 int i, j;
486 for (i = 0; i < w; i++)
487 {
488 for (j = 0; j < h; j++)
489 {
490 unsigned char red = image.GetRed(i, j);
491 unsigned char green = image.GetGreen(i, j);
492 unsigned char blue = image.GetBlue(i, j);
493
494 GR_COLOR colour = GR_RGB(red, green, blue);
495
496 // Efficiency measure
497 if (colour != lastPixmapColour || (i == 0 && j == 0))
498 {
499 GrSetGCForeground(pixmapGC, colour);
500 lastPixmapColour = colour;
501 }
502
503 GrPoint(pixmap, pixmapGC, i, j);
504
505 if (hasMask)
506 {
507 // scan the bitmap for the transparent colour and set the corresponding
508 // pixels in the mask to BLACK and the rest to WHITE
509 if (maskR == red && maskG == green && maskB == blue)
510 {
511 colour = GR_RGB(0, 0, 0);
512 }
513 else
514 {
515 colour = GR_RGB(255, 255, 255);
516 }
517 if (colour != lastMaskColour || (i == 0 && j == 0))
518 {
519 GrSetGCForeground(maskGC, colour);
520 lastMaskColour = colour;
521 }
522 GrPoint(maskPixmap, maskGC, i, j);
523 }
524 }
525 }
526
527 GrDestroyGC(pixmapGC);
528 if (hasMask)
529 GrDestroyGC(maskGC);
530
531 return true;
532#else
533 // !wxUSE_NANOX
534
535 UnRef();
536
537 wxCHECK_MSG( image.Ok(), false, wxT("invalid image") )
538 wxCHECK_MSG( depth == -1, false, wxT("invalid bitmap depth") )
539
540 m_refData = new wxBitmapRefData();
541
542 M_BMPDATA->m_display = wxGlobalDisplay();
543
544 Display *xdisplay = (Display*) M_BMPDATA->m_display;
545
546 int xscreen = DefaultScreen( xdisplay );
547 Window xroot = RootWindow( xdisplay, xscreen );
548 Visual* xvisual = DefaultVisual( xdisplay, xscreen );
549
550 int bpp = wxTheApp->GetVisualInfo(M_BMPDATA->m_display)->m_visualDepth;
551
552 int width = image.GetWidth();
553 int height = image.GetHeight();
554 M_BMPDATA->m_width = width;
555 M_BMPDATA->m_height = height;
556
557 if (depth != 1) depth = bpp;
558 M_BMPDATA->m_bpp = depth;
559
560 if (depth == 1)
561 {
562 wxFAIL_MSG( wxT("mono images later") );
563 }
564 else
565 {
566 // Create image
567
568 XImage *data_image = XCreateImage( xdisplay, xvisual, bpp, ZPixmap, 0, 0, width, height, 32, 0 );
569 data_image->data = (char*) malloc( data_image->bytes_per_line * data_image->height );
570
571 if (data_image->data == NULL)
572 {
573 wxLogError( wxT("Out of memory.") ); // TODO clean
574 return false;
575 }
576
577 M_BMPDATA->m_pixmap = (WXPixmap) XCreatePixmap( xdisplay, xroot, width, height, depth );
578
579 // Create mask
580
581 XImage *mask_image = (XImage*) NULL;
582 if (image.HasMask())
583 {
584 mask_image = XCreateImage( xdisplay, xvisual, 1, ZPixmap, 0, 0, width, height, 32, 0 );
585 mask_image->data = (char*) malloc( mask_image->bytes_per_line * mask_image->height );
586
587 if (mask_image->data == NULL)
588 {
589 wxLogError( wxT("Out of memory.") ); // TODO clean
590 return false;
591 }
592
593 wxMask *mask = new wxMask();
594 mask->SetDisplay( xdisplay );
595 mask->SetBitmap( (WXPixmap) XCreatePixmap( xdisplay, xroot, width, height, 1 ) );
596
597 SetMask( mask );
598 }
599
600 if (bpp < 8) bpp = 8;
601
602 // Render
603
604 enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
605 byte_order b_o = RGB;
606
607 wxXVisualInfo* vi = wxTheApp->GetVisualInfo(M_BMPDATA->m_display);
608 unsigned long greenMask = vi->m_visualGreenMask,
609 redMask = vi->m_visualRedMask,
610 blueMask = vi->m_visualBlueMask;
611
612 if (bpp > 8)
613 {
614 if ((redMask > greenMask) && (greenMask > blueMask)) b_o = RGB;
615 else if ((redMask > blueMask) && (blueMask > greenMask)) b_o = RBG;
616 else if ((blueMask > redMask) && (redMask > greenMask)) b_o = BRG;
617 else if ((blueMask > greenMask) && (greenMask > redMask))b_o = BGR;
618 else if ((greenMask > redMask) && (redMask > blueMask)) b_o = GRB;
619 else if ((greenMask > blueMask) && (blueMask > redMask)) b_o = GBR;
620 }
621
622 int r_mask = image.GetMaskRed();
623 int g_mask = image.GetMaskGreen();
624 int b_mask = image.GetMaskBlue();
625
626 unsigned char* data = image.GetData();
627 wxASSERT_MSG( data, wxT("No image data") );
628
629 unsigned char *colorCube =
630 wxTheApp->GetVisualInfo(M_BMPDATA->m_display)->m_colorCube;
631
632 bool hasMask = image.HasMask();
633
634 int index = 0;
635 for (int y = 0; y < height; y++)
636 {
637 for (int x = 0; x < width; x++)
638 {
639 int r = data[index];
640 index++;
641 int g = data[index];
642 index++;
643 int b = data[index];
644 index++;
645
646 if (hasMask)
647 {
648 if ((r == r_mask) && (b == b_mask) && (g == g_mask))
649 XPutPixel( mask_image, x, y, 0 );
650 else
651 XPutPixel( mask_image, x, y, 1 );
652 }
653
654 switch (bpp)
655 {
656 case 8:
657 {
658 int pixel = 0;
659 pixel = colorCube[ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
660 XPutPixel( data_image, x, y, pixel );
661 break;
662 }
663 case 12: // SGI only
664 {
665 int pixel = 0;
666 switch (b_o)
667 {
668 case RGB: pixel = ((r & 0xf0) << 4) | (g & 0xf0) | ((b & 0xf0) >> 4); break;
669 case RBG: pixel = ((r & 0xf0) << 4) | (b & 0xf0) | ((g & 0xf0) >> 4); break;
670 case GRB: pixel = ((g & 0xf0) << 4) | (r & 0xf0) | ((b & 0xf0) >> 4); break;
671 case GBR: pixel = ((g & 0xf0) << 4) | (b & 0xf0) | ((r & 0xf0) >> 4); break;
672 case BRG: pixel = ((b & 0xf0) << 4) | (r & 0xf0) | ((g & 0xf0) >> 4); break;
673 case BGR: pixel = ((b & 0xf0) << 4) | (g & 0xf0) | ((r & 0xf0) >> 4); break;
674 }
675 XPutPixel( data_image, x, y, pixel );
676 break;
677 }
678 case 15:
679 {
680 int pixel = 0;
681 switch (b_o)
682 {
683 case RGB: pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3); break;
684 case RBG: pixel = ((r & 0xf8) << 7) | ((b & 0xf8) << 2) | ((g & 0xf8) >> 3); break;
685 case GRB: pixel = ((g & 0xf8) << 7) | ((r & 0xf8) << 2) | ((b & 0xf8) >> 3); break;
686 case GBR: pixel = ((g & 0xf8) << 7) | ((b & 0xf8) << 2) | ((r & 0xf8) >> 3); break;
687 case BRG: pixel = ((b & 0xf8) << 7) | ((r & 0xf8) << 2) | ((g & 0xf8) >> 3); break;
688 case BGR: pixel = ((b & 0xf8) << 7) | ((g & 0xf8) << 2) | ((r & 0xf8) >> 3); break;
689 }
690 XPutPixel( data_image, x, y, pixel );
691 break;
692 }
693 case 16:
694 {
695 // I actually don't know if for 16-bit displays, it is alway the green
696 // component or the second component which has 6 bits.
697 int pixel = 0;
698 switch (b_o)
699 {
700 case RGB: pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3); break;
701 case RBG: pixel = ((r & 0xf8) << 8) | ((b & 0xfc) << 3) | ((g & 0xf8) >> 3); break;
702 case GRB: pixel = ((g & 0xf8) << 8) | ((r & 0xfc) << 3) | ((b & 0xf8) >> 3); break;
703 case GBR: pixel = ((g & 0xf8) << 8) | ((b & 0xfc) << 3) | ((r & 0xf8) >> 3); break;
704 case BRG: pixel = ((b & 0xf8) << 8) | ((r & 0xfc) << 3) | ((g & 0xf8) >> 3); break;
705 case BGR: pixel = ((b & 0xf8) << 8) | ((g & 0xfc) << 3) | ((r & 0xf8) >> 3); break;
706 }
707 XPutPixel( data_image, x, y, pixel );
708 break;
709 }
710 case 32:
711 case 24:
712 {
713 int pixel = 0;
714 switch (b_o)
715 {
716 case RGB: pixel = (r << 16) | (g << 8) | b; break;
717 case RBG: pixel = (r << 16) | (b << 8) | g; break;
718 case BRG: pixel = (b << 16) | (r << 8) | g; break;
719 case BGR: pixel = (b << 16) | (g << 8) | r; break;
720 case GRB: pixel = (g << 16) | (r << 8) | b; break;
721 case GBR: pixel = (g << 16) | (b << 8) | r; break;
722 }
723 XPutPixel( data_image, x, y, pixel );
724 }
725 default: break;
726 }
727 } // for
728 } // for
729
730 // Blit picture
731
732 GC gc = XCreateGC( xdisplay, (Pixmap) M_BMPDATA->m_pixmap, 0, NULL );
733 XPutImage( xdisplay, (Pixmap) M_BMPDATA->m_pixmap, gc, data_image, 0, 0, 0, 0, width, height );
734 XDestroyImage( data_image );
735 XFreeGC( xdisplay, gc );
736
737 // Blit mask
738
739 if (image.HasMask())
740 {
741 GC gc = XCreateGC( xdisplay, (Pixmap) GetMask()->GetBitmap(), 0, NULL );
742 XPutImage( xdisplay, (Pixmap) GetMask()->GetBitmap(), gc, mask_image, 0, 0, 0, 0, width, height );
743
744 XDestroyImage( mask_image );
745 XFreeGC( xdisplay, gc );
746 }
747 }
748
749 return true;
750#endif
751 // wxUSE_NANOX
752}
753
754wxImage wxBitmap::ConvertToImage() const
755{
756 wxImage image;
757
758 wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
759
760 Display *xdisplay = (Display*) M_BMPDATA->m_display;
761 wxASSERT_MSG( xdisplay, wxT("No display") );
762
763#if wxUSE_NANOX
764 //int bpp = DefaultDepth(xdisplay, xscreen);
765 wxGetImageFromDrawable((Pixmap) GetPixmap(), 0, 0, GetWidth(), GetHeight(), image);
766 return image;
767#else
768 // !wxUSE_NANOX
769 int bpp = wxTheApp->GetVisualInfo(M_BMPDATA->m_display)->m_visualDepth;
770 XImage *x_image = NULL;
771 if (GetPixmap())
772 {
773 x_image = XGetImage( xdisplay, (Pixmap) GetPixmap(),
774 0, 0,
775 GetWidth(), GetHeight(),
776 AllPlanes, ZPixmap );
777 } else
778 if (GetBitmap())
779 {
780 x_image = XGetImage( xdisplay, (Pixmap) GetBitmap(),
781 0, 0,
782 GetWidth(), GetHeight(),
783 AllPlanes, ZPixmap );
784 } else
785 {
786 wxFAIL_MSG( wxT("Ill-formed bitmap") );
787 }
788
789 wxCHECK_MSG( x_image, wxNullImage, wxT("couldn't create image") );
790
791 image.Create( GetWidth(), GetHeight() );
792 char unsigned *data = image.GetData();
793
794 if (!data)
795 {
796 XDestroyImage( x_image );
797 wxFAIL_MSG( wxT("couldn't create image") );
798 return wxNullImage;
799 }
800
801 XImage *x_image_mask = NULL;
802 if (GetMask())
803 {
804 x_image_mask = XGetImage( xdisplay, (Pixmap) GetMask()->GetBitmap(),
805 0, 0,
806 GetWidth(), GetHeight(),
807 AllPlanes, ZPixmap );
808
809 image.SetMaskColour( 16, 16, 16 ); // anything unlikely and dividable
810 }
811
812 int red_shift_right = 0;
813 int green_shift_right = 0;
814 int blue_shift_right = 0;
815 int red_shift_left = 0;
816 int green_shift_left = 0;
817 int blue_shift_left = 0;
818 bool use_shift = false;
819
820 if (GetPixmap())
821 {
822 wxXVisualInfo* vi = wxTheApp->GetVisualInfo(M_BMPDATA->m_display);
823
824 red_shift_right = vi->m_visualRedShift;
825 red_shift_left = 8 - vi->m_visualRedPrec;
826 green_shift_right = vi->m_visualGreenShift;
827 green_shift_left = 8 - vi->m_visualGreenPrec;
828 blue_shift_right = vi->m_visualBlueShift;
829 blue_shift_left = 8 - vi->m_visualBluePrec;
830
831 use_shift = (vi->m_visualType == GrayScale) ||
832 (vi->m_visualType != PseudoColor);
833 }
834
835 if (GetBitmap())
836 {
837 bpp = 1;
838 }
839
840 XColor *colors = (XColor*)wxTheApp->
841 GetVisualInfo(M_BMPDATA->m_display)->m_visualColormap;
842
843 int width = GetWidth();
844 int height = GetHeight();
845 long pos = 0;
846 for (int j = 0; j < height; j++)
847 {
848 for (int i = 0; i < width; i++)
849 {
850 unsigned long pixel = XGetPixel( x_image, i, j );
851 if (bpp == 1)
852 {
853 if (pixel == 0)
854 {
855 data[pos] = 0;
856 data[pos+1] = 0;
857 data[pos+2] = 0;
858 }
859 else
860 {
861 data[pos] = 255;
862 data[pos+1] = 255;
863 data[pos+2] = 255;
864 }
865 }
866 else if (use_shift)
867 {
868 data[pos] = (unsigned char)((pixel >> red_shift_right) << red_shift_left);
869 data[pos+1] = (unsigned char)((pixel >> green_shift_right) << green_shift_left);
870 data[pos+2] = (unsigned char)((pixel >> blue_shift_right) << blue_shift_left);
871 }
872 else if (colors)
873 {
874 data[pos] = (unsigned char)(colors[pixel].red >> 8);
875 data[pos+1] = (unsigned char)(colors[pixel].green >> 8);
876 data[pos+2] = (unsigned char)(colors[pixel].blue >> 8);
877 }
878 else
879 {
880 wxFAIL_MSG( wxT("Image conversion failed. Unknown visual type.") );
881 }
882
883 if (x_image_mask)
884 {
885 int mask_pixel = XGetPixel( x_image_mask, i, j );
886 if (mask_pixel == 0)
887 {
888 data[pos] = 16;
889 data[pos+1] = 16;
890 data[pos+2] = 16;
891 }
892 }
893
894 pos += 3;
895 }
896 }
897
898 XDestroyImage( x_image );
899 if (x_image_mask) XDestroyImage( x_image_mask );
900 return image;
901#endif
902 // wxUSE_NANOX
903}
904
905wxBitmap::wxBitmap( const wxBitmap& bmp )
906{
907 Ref( bmp );
908}
909
910wxBitmap::wxBitmap( const wxString &filename, wxBitmapType type )
911{
912 LoadFile( filename, type );
913}
914
915wxBitmap::wxBitmap( const char bits[], int width, int height, int depth )
916{
917 m_refData = new wxBitmapRefData;
918
919 (void) Create((void*) bits, wxBITMAP_TYPE_XBM_DATA, width, height, depth);
920}
921
922wxBitmap::~wxBitmap()
923{
924}
925
926wxBitmap& wxBitmap::operator = ( const wxBitmap& bmp )
927{
928 if ( m_refData != bmp.m_refData )
929 Ref( bmp );
930
931 return *this;
932}
933
934bool wxBitmap::operator == ( const wxBitmap& bmp ) const
935{
936 return m_refData == bmp.m_refData;
937}
938
939bool wxBitmap::operator != ( const wxBitmap& bmp ) const
940{
941 return m_refData != bmp.m_refData;
942}
943
944bool wxBitmap::Ok() const
945{
946 return (m_refData != NULL);
947}
948
949int wxBitmap::GetHeight() const
950{
951 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
952
953 return M_BMPDATA->m_height;
954}
955
956int wxBitmap::GetWidth() const
957{
958 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
959
960 return M_BMPDATA->m_width;
961}
962
963int wxBitmap::GetDepth() const
964{
965 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
966
967 return M_BMPDATA->m_bpp;
968}
969
970wxMask *wxBitmap::GetMask() const
971{
972 wxCHECK_MSG( Ok(), (wxMask *) NULL, wxT("invalid bitmap") );
973
974 return M_BMPDATA->m_mask;
975}
976
977void wxBitmap::SetMask( wxMask *mask )
978{
979 wxCHECK_RET( Ok(), wxT("invalid bitmap") );
980
981 if (M_BMPDATA->m_mask) delete M_BMPDATA->m_mask;
982
983 M_BMPDATA->m_mask = mask;
984}
985
986bool wxBitmap::CopyFromIcon(const wxIcon& icon)
987{
988 *this = icon;
989 return true;
990}
991
992wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
993{
994 wxCHECK_MSG( Ok() &&
995 (rect.x >= 0) && (rect.y >= 0) &&
996 (rect.x+rect.width <= M_BMPDATA->m_width ) &&
997 (rect.y+rect.height <= M_BMPDATA->m_height),
998 wxNullBitmap, wxT("invalid bitmap or bitmap region") );
999
1000 wxBitmap ret( rect.width, rect.height, M_BMPDATA->m_bpp );
1001 wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
1002
1003 if( GetMask() )
1004 {
1005 wxMask* mask = new wxMask();
1006 mask->SetDisplay( GetMask()->GetDisplay() );
1007 mask->SetBitmap( wxGetSubPixmap( GetMask()->GetDisplay(),
1008 GetMask()->GetBitmap(),
1009 rect.x, rect.y,
1010 rect.width, rect.height,
1011 1 ) );
1012
1013 ret.SetMask( mask );
1014 }
1015
1016 if( GetPixmap() )
1017 {
1018 ret.SetPixmap( wxGetSubPixmap( GetDisplay(),
1019 GetPixmap(),
1020 rect.x, rect.y,
1021 rect.width, rect.height,
1022 M_BMPDATA->m_bpp ) );
1023 }
1024
1025 if( GetBitmap() )
1026 {
1027 ret.SetBitmap( wxGetSubPixmap( GetDisplay(),
1028 GetBitmap(),
1029 rect.x, rect.y,
1030 rect.width, rect.height,
1031 1 ) );
1032 }
1033
1034 return ret;
1035}
1036
1037bool wxBitmap::SaveFile( const wxString &name, wxBitmapType type,
1038 const wxPalette *palette ) const
1039{
1040 wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
1041
1042 wxBitmapHandler *handler = FindHandler(type);
1043
1044 // Try to save the bitmap via wxImage handlers:
1045 if (handler == NULL)
1046 {
1047 wxImage image(this->ConvertToImage());
1048 if (image.Ok()) return image.SaveFile( name, type );
1049
1050 return false;
1051 }
1052
1053 return handler->SaveFile(this, name, type, palette);
1054}
1055
1056bool wxBitmap::LoadFile( const wxString &name, wxBitmapType type )
1057{
1058 UnRef();
1059
1060 if (!wxFileExists(name)) return false;
1061
1062 wxBitmapHandler *handler = FindHandler(type);
1063
1064 if (handler == NULL)
1065 {
1066 wxImage image;
1067 if (!image.LoadFile( name, type ))
1068 return false;
1069
1070 if (image.Ok())
1071 {
1072 *this = wxBitmap(image);
1073 return true;
1074 }
1075 else return false;
1076 }
1077
1078 return handler->LoadFile(this, name, type, -1, -1);
1079}
1080
1081void wxBitmap::SetPalette(const wxPalette& palette)
1082{
1083 wxCHECK_RET(Ok(), wxT("invalid bitmap"));
1084 wxCHECK_RET(GetDepth() > 1 && GetDepth() <= 8,
1085 wxT("cannot set palette for bitmap of this depth"));
1086
1087 delete M_BMPDATA->m_palette;
1088 M_BMPDATA->m_palette = NULL;
1089
1090 if (!palette.Ok()) return;
1091
1092 M_BMPDATA->m_palette = new wxPalette(palette);
1093}
1094
1095wxPalette *wxBitmap::GetPalette() const
1096{
1097 if (!Ok()) return (wxPalette *) NULL;
1098
1099 return M_BMPDATA->m_palette;
1100}
1101
1102void wxBitmap::SetHeight( int height )
1103{
1104 if (!m_refData) m_refData = new wxBitmapRefData();
1105
1106 M_BMPDATA->m_height = height;
1107}
1108
1109void wxBitmap::SetWidth( int width )
1110{
1111 if (!m_refData) m_refData = new wxBitmapRefData();
1112
1113 M_BMPDATA->m_width = width;
1114}
1115
1116void wxBitmap::SetDepth( int depth )
1117{
1118 if (!m_refData) m_refData = new wxBitmapRefData();
1119
1120 M_BMPDATA->m_bpp = depth;
1121}
1122
1123void wxBitmap::SetPixmap( WXPixmap pixmap )
1124{
1125 if (!m_refData) m_refData = new wxBitmapRefData();
1126
1127 M_BMPDATA->m_pixmap = pixmap;
1128}
1129
1130void wxBitmap::SetBitmap( WXPixmap bitmap )
1131{
1132 if (!m_refData) m_refData = new wxBitmapRefData();
1133
1134 M_BMPDATA->m_bitmap = bitmap;
1135}
1136
1137WXPixmap wxBitmap::GetPixmap() const
1138{
1139 wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") );
1140
1141 return M_BMPDATA->m_pixmap;
1142}
1143
1144WXPixmap wxBitmap::GetBitmap() const
1145{
1146 wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") );
1147
1148 return M_BMPDATA->m_bitmap;
1149}
1150
1151WXPixmap wxBitmap::GetDrawable() const
1152{
1153 wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") );
1154
1155 return M_BMPDATA->m_bpp == 1 ? M_BMPDATA->m_bitmap : M_BMPDATA->m_pixmap;
1156}
1157
1158WXDisplay *wxBitmap::GetDisplay() const
1159{
1160 wxCHECK_MSG( Ok(), (WXDisplay*) NULL, wxT("invalid bitmap") );
1161
1162 return M_BMPDATA->m_display;
1163}
1164
1165#if wxUSE_NANOX
1166// Copy from the drawable to the wxImage
1167bool wxGetImageFromDrawable(GR_DRAW_ID drawable, int srcX, int srcY, int width, int height, wxImage& image)
1168{
1169 GR_SCREEN_INFO sinfo;
1170 int x, y;
1171 GR_PIXELVAL *pixels;
1172 GR_PALETTE* palette = NULL;
1173 unsigned char rgb[3], *pp;
1174
1175 GrGetScreenInfo(&sinfo);
1176
1177 if (sinfo.pixtype == MWPF_PALETTE) {
1178 if(!(palette = (GR_PALETTE*) malloc(sizeof(GR_PALETTE)))) {
1179 return false;
1180 }
1181 GrGetSystemPalette(palette);
1182 }
1183
1184 if(!(pixels = (GR_PIXELVAL*) malloc(sizeof(GR_PIXELVAL) * width * height)))
1185 {
1186 return false;
1187 }
1188
1189 image.Create(width, height);
1190
1191 GrReadArea(drawable, srcX, srcY, width, height,
1192 pixels);
1193
1194
1195 for(x = 0; x < sinfo.cols; x++) {
1196
1197 pp = (unsigned char *)pixels +
1198 ((x + (y * sinfo.cols)) *
1199 sizeof(GR_PIXELVAL));
1200
1201 switch(sinfo.pixtype) {
1202 /* FIXME: These may need modifying on big endian. */
1203 case MWPF_TRUECOLOR0888:
1204 case MWPF_TRUECOLOR888:
1205 rgb[0] = pp[2];
1206 rgb[1] = pp[1];
1207 rgb[2] = pp[0];
1208 break;
1209 case MWPF_PALETTE:
1210 rgb[0] = palette->palette[pp[0]].r;
1211 rgb[1] = palette->palette[pp[0]].g;
1212 rgb[2] = palette->palette[pp[0]].b;
1213 break;
1214 case MWPF_TRUECOLOR565:
1215 rgb[0] = pp[1] & 0xf8;
1216 rgb[1] = ((pp[1] & 0x07) << 5) |
1217 ((pp[0] & 0xe0) >> 3);
1218 rgb[2] = (pp[0] & 0x1f) << 3;
1219 break;
1220 case MWPF_TRUECOLOR555:
1221 rgb[0] = (pp[1] & 0x7c) << 1;
1222 rgb[1] = ((pp[1] & 0x03) << 6) |
1223 ((pp[0] & 0xe0) >> 2);
1224 rgb[2] = (pp[0] & 0x1f) << 3;
1225 break;
1226 case MWPF_TRUECOLOR332:
1227 rgb[0] = pp[0] & 0xe0;
1228 rgb[1] = (pp[0] & 0x1c) << 3;
1229 rgb[2] = (pp[0] & 0x03) << 6;
1230 break;
1231 default:
1232 fprintf(stderr, "Unsupported pixel "
1233 "format\n");
1234 return 1;
1235 }
1236
1237 image.SetRGB(x, y, rgb[0], rgb[1], rgb[2]);
1238
1239 }
1240
1241 free(pixels);
1242 if(palette) free(palette);
1243
1244 return true;
1245}
1246
1247#if 0
1248int GrGetPixelColor(GR_SCREEN_INFO* sinfo, GR_PALETTE* palette, GR_PIXELVAL pixel,
1249 unsigned char* red, unsigned char* green, unsigned char* blue)
1250{
1251 unsigned char rgb[3], *pp;
1252
1253 pp = (unsigned char*) & pixel ;
1254
1255 switch (sinfo.pixtype)
1256 {
1257 /* FIXME: These may need modifying on big endian. */
1258 case MWPF_TRUECOLOR0888:
1259 case MWPF_TRUECOLOR888:
1260 rgb[0] = pp[2];
1261 rgb[1] = pp[1];
1262 rgb[2] = pp[0];
1263 break;
1264 case MWPF_PALETTE:
1265 rgb[0] = palette->palette[pp[0]].r;
1266 rgb[1] = palette->palette[pp[0]].g;
1267 rgb[2] = palette->palette[pp[0]].b;
1268 break;
1269 case MWPF_TRUECOLOR565:
1270 rgb[0] = pp[1] & 0xf8;
1271 rgb[1] = ((pp[1] & 0x07) << 5) |
1272 ((pp[0] & 0xe0) >> 3);
1273 rgb[2] = (pp[0] & 0x1f) << 3;
1274 break;
1275 case MWPF_TRUECOLOR555:
1276 rgb[0] = (pp[1] & 0x7c) << 1;
1277 rgb[1] = ((pp[1] & 0x03) << 6) |
1278 ((pp[0] & 0xe0) >> 2);
1279 rgb[2] = (pp[0] & 0x1f) << 3;
1280 break;
1281 case MWPF_TRUECOLOR332:
1282 rgb[0] = pp[0] & 0xe0;
1283 rgb[1] = (pp[0] & 0x1c) << 3;
1284 rgb[2] = (pp[0] & 0x03) << 6;
1285 break;
1286 default:
1287 fprintf(stderr, "Unsupported pixel format\n");
1288 return 0;
1289 }
1290
1291
1292 *(red) = rgb[0];
1293 *(green) = rgb[1];
1294 *(blue) = rgb[2];
1295 return 1;
1296}
1297#endif
1298
1299#endif
1300 // wxUSE_NANOX
1301
1302// ============================================================================
1303// Bitmap handlers
1304// ============================================================================
1305
1306IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)
1307
1308#define M_BMPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData())
1309
1310#if wxUSE_XPM
1311
1312#if wxHAVE_LIB_XPM || wxUSE_STREAMS
1313
1314// ----------------------------------------------------------------------------
1315// wxXPMFileHandler
1316// ----------------------------------------------------------------------------
1317
1318class wxXPMFileHandler : public wxBitmapHandler
1319{
1320 DECLARE_DYNAMIC_CLASS(wxXPMFileHandler)
1321public:
1322 wxXPMFileHandler()
1323 {
1324 SetName( wxT("XPM file") );
1325 SetExtension( wxT("xpm") );
1326 SetType( wxBITMAP_TYPE_XPM );
1327 };
1328
1329 virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
1330 int desiredWidth, int desiredHeight);
1331
1332 virtual bool SaveFile(const wxBitmap *bitmap, const wxString& name,
1333 int type, const wxPalette *palette = NULL);
1334
1335 virtual bool Create(wxBitmap *WXUNUSED(bitmap), void *WXUNUSED(data), long WXUNUSED(flags),
1336 int WXUNUSED(width), int WXUNUSED(height), int WXUNUSED(depth) = 1)
1337 { return false; }
1338};
1339
1340IMPLEMENT_DYNAMIC_CLASS(wxXPMFileHandler, wxBitmapHandler)
1341
1342bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name,
1343 long WXUNUSED(flags), int WXUNUSED(desiredWidth),
1344 int WXUNUSED(desiredHeight))
1345{
1346#if wxHAVE_LIB_XPM
1347 if (!bitmap->GetRefData())
1348 bitmap->SetRefData( new wxBitmapRefData() );
1349
1350 M_BMPHANDLERDATA->m_display = wxGlobalDisplay();
1351
1352 Display *xdisplay = (Display*) M_BMPHANDLERDATA->m_display;
1353
1354 int xscreen = DefaultScreen( xdisplay );
1355 Window xroot = RootWindow( xdisplay, xscreen );
1356
1357 int bpp = DefaultDepth( xdisplay, xscreen );
1358
1359 XpmAttributes xpmAttr;
1360 xpmAttr.valuemask = XpmReturnInfos; // nothing yet, but get infos back
1361
1362 Pixmap pixmap;
1363 Pixmap mask = 0;
1364
1365 int ErrorStatus = XpmReadFileToPixmap( xdisplay, xroot,
1366 (char*) name.c_str(),
1367 &pixmap, &mask, &xpmAttr);
1368
1369 if (ErrorStatus == XpmSuccess)
1370 {
1371 M_BMPHANDLERDATA->m_width = xpmAttr.width;
1372 M_BMPHANDLERDATA->m_height = xpmAttr.height;
1373
1374 M_BMPHANDLERDATA->m_bpp = bpp; // mono as well?
1375
1376 XpmFreeAttributes(&xpmAttr);
1377
1378 M_BMPHANDLERDATA->m_bitmap = (WXPixmap) pixmap;
1379
1380 if (mask)
1381 {
1382 M_BMPHANDLERDATA->m_mask = new wxMask;
1383 M_BMPHANDLERDATA->m_mask->SetBitmap( (WXPixmap) mask );
1384 M_BMPHANDLERDATA->m_mask->SetDisplay( xdisplay );
1385 }
1386 }
1387 else
1388 {
1389 UnRef();
1390
1391 return false;
1392 }
1393
1394 return true;
1395#elif wxUSE_STREAMS
1396 wxXPMDecoder decoder;
1397 wxFileInputStream stream(name);
1398 if (stream.Ok())
1399 {
1400 wxImage image(decoder.ReadFile(stream));
1401 return image.Ok() && bitmap->CreateFromImage(image);
1402 }
1403
1404 return false;
1405#else // !wxHAVE_LIB_XPM && !wxUSE_STREAMS
1406 return false;
1407#endif // wxHAVE_LIB_XPM / wxUSE_STREAMS
1408}
1409
1410bool wxXPMFileHandler::SaveFile(const wxBitmap *bitmap, const wxString& name,
1411 int type,
1412 const wxPalette *WXUNUSED(palette))
1413{
1414 wxImage image(bitmap->ConvertToImage());
1415 if (image.Ok()) return image.SaveFile( name, (wxBitmapType)type );
1416
1417 return false;
1418}
1419
1420#endif // wxHAVE_LIB_XPM || wxUSE_STREAMS
1421
1422// ----------------------------------------------------------------------------
1423// wxXPMDataHandler
1424// ----------------------------------------------------------------------------
1425
1426class wxXPMDataHandler : public wxBitmapHandler
1427{
1428 DECLARE_DYNAMIC_CLASS(wxXPMDataHandler)
1429public:
1430 wxXPMDataHandler()
1431 {
1432 SetName( wxT("XPM data") );
1433 SetExtension( wxT("xpm") );
1434 SetType( wxBITMAP_TYPE_XPM_DATA );
1435 };
1436
1437 virtual bool LoadFile(wxBitmap *WXUNUSED(bitmap),
1438 const wxString& WXUNUSED(name),
1439 long WXUNUSED(flags),
1440 int WXUNUSED(desiredWidth),
1441 int WXUNUSED(desiredHeight))
1442 { return false; }
1443
1444 virtual bool SaveFile(const wxBitmap *WXUNUSED(bitmap),
1445 const wxString& WXUNUSED(name),
1446 int WXUNUSED(type),
1447 const wxPalette *WXUNUSED(palette) = NULL)
1448 { return false; }
1449
1450 virtual bool Create(wxBitmap *bitmap, void *data, long flags,
1451 int width, int height, int depth = 1);
1452};
1453
1454IMPLEMENT_DYNAMIC_CLASS(wxXPMDataHandler, wxBitmapHandler)
1455
1456bool wxXPMDataHandler::Create(wxBitmap *bitmap, void *bits,
1457 long WXUNUSED(flags),
1458 int WXUNUSED(width), int WXUNUSED(height), int WXUNUSED(depth))
1459{
1460#if wxHAVE_LIB_XPM
1461 wxCHECK_MSG( bits != NULL, false, wxT("invalid bitmap data") )
1462
1463 if (!bitmap->GetRefData())
1464 bitmap->SetRefData( new wxBitmapRefData() );
1465
1466 M_BMPHANDLERDATA->m_display = wxGlobalDisplay();
1467
1468 Display *xdisplay = (Display*) M_BMPHANDLERDATA->m_display;
1469
1470 int xscreen = DefaultScreen( xdisplay );
1471 Window xroot = RootWindow( xdisplay, xscreen );
1472
1473 int bpp = DefaultDepth( xdisplay, xscreen );
1474
1475 XpmAttributes xpmAttr;
1476 xpmAttr.valuemask = XpmReturnInfos; // nothing yet, but get infos back
1477
1478 Pixmap pixmap = 0;
1479 Pixmap mask = 0;
1480
1481 int ErrorStatus = XpmCreatePixmapFromData( xdisplay, xroot, (char**) bits,
1482 &pixmap, &mask, &xpmAttr );
1483
1484 if (ErrorStatus == XpmSuccess)
1485 {
1486 M_BMPHANDLERDATA->m_width = xpmAttr.width;
1487 M_BMPHANDLERDATA->m_height = xpmAttr.height;
1488
1489 M_BMPHANDLERDATA->m_bpp = bpp; // mono as well?
1490
1491#if __WXDEBUG__
1492 unsigned int depthRet;
1493 int xRet, yRet;
1494 unsigned int widthRet, heightRet, borderWidthRet;
1495 XGetGeometry( xdisplay, pixmap, &xroot, &xRet, &yRet,
1496 &widthRet, &heightRet, &borderWidthRet, &depthRet);
1497
1498 wxASSERT_MSG( bpp == (int)depthRet, wxT("colour depth mismatch") );
1499#endif
1500
1501 XpmFreeAttributes(&xpmAttr);
1502
1503 M_BMPHANDLERDATA->m_pixmap = (WXPixmap) pixmap;
1504
1505 if (mask)
1506 {
1507 M_BMPHANDLERDATA->m_mask = new wxMask;
1508 M_BMPHANDLERDATA->m_mask->SetBitmap( (WXPixmap) mask );
1509 M_BMPHANDLERDATA->m_mask->SetDisplay( xdisplay );
1510 }
1511 return true;
1512 }
1513 else
1514 {
1515 bitmap->UnRef();
1516
1517 return false;
1518 }
1519#else // !wxHAVE_LIB_XPM
1520 wxXPMDecoder decoder;
1521 wxImage image(decoder.ReadData((const char **)bits));
1522 return image.Ok() && bitmap->CreateFromImage(image);
1523#endif // wxHAVE_LIB_XPM/!wxHAVE_LIB_XPM
1524}
1525
1526#endif // wxUSE_XPM
1527
1528// ----------------------------------------------------------------------------
1529// wxXBMDataHandler
1530// ----------------------------------------------------------------------------
1531
1532class WXDLLEXPORT wxXBMDataHandler: public wxBitmapHandler
1533{
1534 DECLARE_DYNAMIC_CLASS(wxXBMDataHandler)
1535public:
1536 inline wxXBMDataHandler()
1537 {
1538 SetName( wxT("XBM data") );
1539 SetExtension( wxT("xbm") );
1540 SetType( wxBITMAP_TYPE_XBM_DATA );
1541 };
1542
1543 virtual bool LoadFile(wxBitmap *WXUNUSED(bitmap),
1544 const wxString& WXUNUSED(name),
1545 long WXUNUSED(flags),
1546 int WXUNUSED(desiredWidth),
1547 int WXUNUSED(desiredHeight))
1548 { return false; }
1549
1550 virtual bool SaveFile(const wxBitmap *WXUNUSED(bitmap),
1551 const wxString& WXUNUSED(name),
1552 int WXUNUSED(type),
1553 const wxPalette *WXUNUSED(palette) = NULL)
1554 { return false; }
1555
1556 virtual bool Create(wxBitmap *bitmap, void *data, long flags,
1557 int width, int height, int depth = 1);
1558};
1559
1560IMPLEMENT_DYNAMIC_CLASS(wxXBMDataHandler, wxBitmapHandler)
1561
1562bool wxXBMDataHandler::Create( wxBitmap *bitmap, void *bits,
1563 long WXUNUSED(flags),
1564 int width, int height, int WXUNUSED(depth))
1565{
1566#if !wxUSE_NANOX
1567 if (!bitmap->GetRefData())
1568 bitmap->SetRefData( new wxBitmapRefData() );
1569
1570 M_BMPHANDLERDATA->m_display = wxGlobalDisplay();
1571
1572 Display *xdisplay = (Display*) M_BMPHANDLERDATA->m_display;
1573
1574 int xscreen = DefaultScreen( xdisplay );
1575 Window xroot = RootWindow( xdisplay, xscreen );
1576
1577 M_BMPHANDLERDATA->m_mask = (wxMask *) NULL;
1578 M_BMPHANDLERDATA->m_bitmap =
1579 (WXPixmap) XCreateBitmapFromData( xdisplay, xroot,
1580 (char *) bits, width, height );
1581 M_BMPHANDLERDATA->m_width = width;
1582 M_BMPHANDLERDATA->m_height = height;
1583 M_BMPHANDLERDATA->m_bpp = 1;
1584
1585 return true;
1586#else
1587 wxCHECK_MSG( M_BMPHANDLERDATA->m_bitmap, false,
1588 wxT("couldn't create bitmap") );
1589#endif
1590}
1591
1592void wxBitmap::InitStandardHandlers()
1593{
1594 AddHandler(new wxXBMDataHandler);
1595#if wxUSE_XPM
1596#if wxHAVE_LIB_XPM || wxUSE_STREAMS
1597 AddHandler(new wxXPMFileHandler);
1598#endif
1599 AddHandler(new wxXPMDataHandler);
1600#endif
1601}
wxWidgets (Impactor)