]> 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
don't compare invalid iterators/node pointers
[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 wxString &filename, wxBitmapType type )
906{
907 LoadFile( filename, type );
908}
909
910wxBitmap::wxBitmap( const char bits[], int width, int height, int depth )
911{
912 m_refData = new wxBitmapRefData;
913
914 (void) Create((void*) bits, wxBITMAP_TYPE_XBM_DATA, width, height, depth);
915}
916
917wxBitmap::~wxBitmap()
918{
919}
920
921bool wxBitmap::operator == ( const wxBitmap& bmp ) const
922{
923 return m_refData == bmp.m_refData;
924}
925
926bool wxBitmap::operator != ( const wxBitmap& bmp ) const
927{
928 return m_refData != bmp.m_refData;
929}
930
931bool wxBitmap::Ok() const
932{
933 return (m_refData != NULL);
934}
935
936int wxBitmap::GetHeight() const
937{
938 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
939
940 return M_BMPDATA->m_height;
941}
942
943int wxBitmap::GetWidth() const
944{
945 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
946
947 return M_BMPDATA->m_width;
948}
949
950int wxBitmap::GetDepth() const
951{
952 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
953
954 return M_BMPDATA->m_bpp;
955}
956
957wxMask *wxBitmap::GetMask() const
958{
959 wxCHECK_MSG( Ok(), (wxMask *) NULL, wxT("invalid bitmap") );
960
961 return M_BMPDATA->m_mask;
962}
963
964void wxBitmap::SetMask( wxMask *mask )
965{
966 wxCHECK_RET( Ok(), wxT("invalid bitmap") );
967
968 if (M_BMPDATA->m_mask) delete M_BMPDATA->m_mask;
969
970 M_BMPDATA->m_mask = mask;
971}
972
973bool wxBitmap::CopyFromIcon(const wxIcon& icon)
974{
975 *this = icon;
976 return true;
977}
978
979wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
980{
981 wxCHECK_MSG( Ok() &&
982 (rect.x >= 0) && (rect.y >= 0) &&
983 (rect.x+rect.width <= M_BMPDATA->m_width ) &&
984 (rect.y+rect.height <= M_BMPDATA->m_height),
985 wxNullBitmap, wxT("invalid bitmap or bitmap region") );
986
987 wxBitmap ret( rect.width, rect.height, M_BMPDATA->m_bpp );
988 wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
989
990 if( GetMask() )
991 {
992 wxMask* mask = new wxMask();
993 mask->SetDisplay( GetMask()->GetDisplay() );
994 mask->SetBitmap( wxGetSubPixmap( GetMask()->GetDisplay(),
995 GetMask()->GetBitmap(),
996 rect.x, rect.y,
997 rect.width, rect.height,
998 1 ) );
999
1000 ret.SetMask( mask );
1001 }
1002
1003 if( GetPixmap() )
1004 {
1005 ret.SetPixmap( wxGetSubPixmap( GetDisplay(),
1006 GetPixmap(),
1007 rect.x, rect.y,
1008 rect.width, rect.height,
1009 M_BMPDATA->m_bpp ) );
1010 }
1011
1012 if( GetBitmap() )
1013 {
1014 ret.SetBitmap( wxGetSubPixmap( GetDisplay(),
1015 GetBitmap(),
1016 rect.x, rect.y,
1017 rect.width, rect.height,
1018 1 ) );
1019 }
1020
1021 return ret;
1022}
1023
1024bool wxBitmap::SaveFile( const wxString &name, wxBitmapType type,
1025 const wxPalette *palette ) const
1026{
1027 wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
1028
1029 wxBitmapHandler *handler = FindHandler(type);
1030
1031 // Try to save the bitmap via wxImage handlers:
1032 if (handler == NULL)
1033 {
1034 wxImage image(this->ConvertToImage());
1035 if (image.Ok()) return image.SaveFile( name, type );
1036
1037 return false;
1038 }
1039
1040 return handler->SaveFile(this, name, type, palette);
1041}
1042
1043bool wxBitmap::LoadFile( const wxString &name, wxBitmapType type )
1044{
1045 UnRef();
1046
1047 if (!wxFileExists(name)) return false;
1048
1049 wxBitmapHandler *handler = FindHandler(type);
1050
1051 if (handler == NULL)
1052 {
1053 wxImage image;
1054 if (!image.LoadFile( name, type ))
1055 return false;
1056
1057 if (image.Ok())
1058 {
1059 *this = wxBitmap(image);
1060 return true;
1061 }
1062 else return false;
1063 }
1064
1065 return handler->LoadFile(this, name, type, -1, -1);
1066}
1067
1068void wxBitmap::SetPalette(const wxPalette& palette)
1069{
1070 wxCHECK_RET(Ok(), wxT("invalid bitmap"));
1071 wxCHECK_RET(GetDepth() > 1 && GetDepth() <= 8,
1072 wxT("cannot set palette for bitmap of this depth"));
1073
1074 delete M_BMPDATA->m_palette;
1075 M_BMPDATA->m_palette = NULL;
1076
1077 if (!palette.Ok()) return;
1078
1079 M_BMPDATA->m_palette = new wxPalette(palette);
1080}
1081
1082wxPalette *wxBitmap::GetPalette() const
1083{
1084 if (!Ok()) return (wxPalette *) NULL;
1085
1086 return M_BMPDATA->m_palette;
1087}
1088
1089void wxBitmap::SetHeight( int height )
1090{
1091 if (!m_refData) m_refData = new wxBitmapRefData();
1092
1093 M_BMPDATA->m_height = height;
1094}
1095
1096void wxBitmap::SetWidth( int width )
1097{
1098 if (!m_refData) m_refData = new wxBitmapRefData();
1099
1100 M_BMPDATA->m_width = width;
1101}
1102
1103void wxBitmap::SetDepth( int depth )
1104{
1105 if (!m_refData) m_refData = new wxBitmapRefData();
1106
1107 M_BMPDATA->m_bpp = depth;
1108}
1109
1110void wxBitmap::SetPixmap( WXPixmap pixmap )
1111{
1112 if (!m_refData) m_refData = new wxBitmapRefData();
1113
1114 M_BMPDATA->m_pixmap = pixmap;
1115}
1116
1117void wxBitmap::SetBitmap( WXPixmap bitmap )
1118{
1119 if (!m_refData) m_refData = new wxBitmapRefData();
1120
1121 M_BMPDATA->m_bitmap = bitmap;
1122}
1123
1124WXPixmap wxBitmap::GetPixmap() const
1125{
1126 wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") );
1127
1128 return M_BMPDATA->m_pixmap;
1129}
1130
1131WXPixmap wxBitmap::GetBitmap() const
1132{
1133 wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") );
1134
1135 return M_BMPDATA->m_bitmap;
1136}
1137
1138WXPixmap wxBitmap::GetDrawable() const
1139{
1140 wxCHECK_MSG( Ok(), (WXPixmap) NULL, wxT("invalid bitmap") );
1141
1142 return M_BMPDATA->m_bpp == 1 ? M_BMPDATA->m_bitmap : M_BMPDATA->m_pixmap;
1143}
1144
1145WXDisplay *wxBitmap::GetDisplay() const
1146{
1147 wxCHECK_MSG( Ok(), (WXDisplay*) NULL, wxT("invalid bitmap") );
1148
1149 return M_BMPDATA->m_display;
1150}
1151
1152#if wxUSE_NANOX
1153// Copy from the drawable to the wxImage
1154bool wxGetImageFromDrawable(GR_DRAW_ID drawable, int srcX, int srcY, int width, int height, wxImage& image)
1155{
1156 GR_SCREEN_INFO sinfo;
1157 int x, y;
1158 GR_PIXELVAL *pixels;
1159 GR_PALETTE* palette = NULL;
1160 unsigned char rgb[3], *pp;
1161
1162 GrGetScreenInfo(&sinfo);
1163
1164 if (sinfo.pixtype == MWPF_PALETTE) {
1165 if(!(palette = (GR_PALETTE*) malloc(sizeof(GR_PALETTE)))) {
1166 return false;
1167 }
1168 GrGetSystemPalette(palette);
1169 }
1170
1171 if(!(pixels = (GR_PIXELVAL*) malloc(sizeof(GR_PIXELVAL) * width * height)))
1172 {
1173 return false;
1174 }
1175
1176 image.Create(width, height);
1177
1178 GrReadArea(drawable, srcX, srcY, width, height,
1179 pixels);
1180
1181
1182 for(x = 0; x < sinfo.cols; x++) {
1183
1184 pp = (unsigned char *)pixels +
1185 ((x + (y * sinfo.cols)) *
1186 sizeof(GR_PIXELVAL));
1187
1188 switch(sinfo.pixtype) {
1189 /* FIXME: These may need modifying on big endian. */
1190 case MWPF_TRUECOLOR0888:
1191 case MWPF_TRUECOLOR888:
1192 rgb[0] = pp[2];
1193 rgb[1] = pp[1];
1194 rgb[2] = pp[0];
1195 break;
1196 case MWPF_PALETTE:
1197 rgb[0] = palette->palette[pp[0]].r;
1198 rgb[1] = palette->palette[pp[0]].g;
1199 rgb[2] = palette->palette[pp[0]].b;
1200 break;
1201 case MWPF_TRUECOLOR565:
1202 rgb[0] = pp[1] & 0xf8;
1203 rgb[1] = ((pp[1] & 0x07) << 5) |
1204 ((pp[0] & 0xe0) >> 3);
1205 rgb[2] = (pp[0] & 0x1f) << 3;
1206 break;
1207 case MWPF_TRUECOLOR555:
1208 rgb[0] = (pp[1] & 0x7c) << 1;
1209 rgb[1] = ((pp[1] & 0x03) << 6) |
1210 ((pp[0] & 0xe0) >> 2);
1211 rgb[2] = (pp[0] & 0x1f) << 3;
1212 break;
1213 case MWPF_TRUECOLOR332:
1214 rgb[0] = pp[0] & 0xe0;
1215 rgb[1] = (pp[0] & 0x1c) << 3;
1216 rgb[2] = (pp[0] & 0x03) << 6;
1217 break;
1218 default:
1219 fprintf(stderr, "Unsupported pixel "
1220 "format\n");
1221 return 1;
1222 }
1223
1224 image.SetRGB(x, y, rgb[0], rgb[1], rgb[2]);
1225
1226 }
1227
1228 free(pixels);
1229 if(palette) free(palette);
1230
1231 return true;
1232}
1233
1234#if 0
1235int GrGetPixelColor(GR_SCREEN_INFO* sinfo, GR_PALETTE* palette, GR_PIXELVAL pixel,
1236 unsigned char* red, unsigned char* green, unsigned char* blue)
1237{
1238 unsigned char rgb[3], *pp;
1239
1240 pp = (unsigned char*) & pixel ;
1241
1242 switch (sinfo.pixtype)
1243 {
1244 /* FIXME: These may need modifying on big endian. */
1245 case MWPF_TRUECOLOR0888:
1246 case MWPF_TRUECOLOR888:
1247 rgb[0] = pp[2];
1248 rgb[1] = pp[1];
1249 rgb[2] = pp[0];
1250 break;
1251 case MWPF_PALETTE:
1252 rgb[0] = palette->palette[pp[0]].r;
1253 rgb[1] = palette->palette[pp[0]].g;
1254 rgb[2] = palette->palette[pp[0]].b;
1255 break;
1256 case MWPF_TRUECOLOR565:
1257 rgb[0] = pp[1] & 0xf8;
1258 rgb[1] = ((pp[1] & 0x07) << 5) |
1259 ((pp[0] & 0xe0) >> 3);
1260 rgb[2] = (pp[0] & 0x1f) << 3;
1261 break;
1262 case MWPF_TRUECOLOR555:
1263 rgb[0] = (pp[1] & 0x7c) << 1;
1264 rgb[1] = ((pp[1] & 0x03) << 6) |
1265 ((pp[0] & 0xe0) >> 2);
1266 rgb[2] = (pp[0] & 0x1f) << 3;
1267 break;
1268 case MWPF_TRUECOLOR332:
1269 rgb[0] = pp[0] & 0xe0;
1270 rgb[1] = (pp[0] & 0x1c) << 3;
1271 rgb[2] = (pp[0] & 0x03) << 6;
1272 break;
1273 default:
1274 fprintf(stderr, "Unsupported pixel format\n");
1275 return 0;
1276 }
1277
1278
1279 *(red) = rgb[0];
1280 *(green) = rgb[1];
1281 *(blue) = rgb[2];
1282 return 1;
1283}
1284#endif
1285
1286#endif
1287 // wxUSE_NANOX
1288
1289// ============================================================================
1290// Bitmap handlers
1291// ============================================================================
1292
1293IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)
1294
1295#define M_BMPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData())
1296
1297#if wxUSE_XPM
1298
1299#if wxHAVE_LIB_XPM || wxUSE_STREAMS
1300
1301// ----------------------------------------------------------------------------
1302// wxXPMFileHandler
1303// ----------------------------------------------------------------------------
1304
1305class wxXPMFileHandler : public wxBitmapHandler
1306{
1307 DECLARE_DYNAMIC_CLASS(wxXPMFileHandler)
1308public:
1309 wxXPMFileHandler()
1310 {
1311 SetName( wxT("XPM file") );
1312 SetExtension( wxT("xpm") );
1313 SetType( wxBITMAP_TYPE_XPM );
1314 };
1315
1316 virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
1317 int desiredWidth, int desiredHeight);
1318
1319 virtual bool SaveFile(const wxBitmap *bitmap, const wxString& name,
1320 int type, const wxPalette *palette = NULL);
1321
1322 virtual bool Create(wxBitmap *WXUNUSED(bitmap), void *WXUNUSED(data), long WXUNUSED(flags),
1323 int WXUNUSED(width), int WXUNUSED(height), int WXUNUSED(depth) = 1)
1324 { return false; }
1325};
1326
1327IMPLEMENT_DYNAMIC_CLASS(wxXPMFileHandler, wxBitmapHandler)
1328
1329bool wxXPMFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name,
1330 long WXUNUSED(flags), int WXUNUSED(desiredWidth),
1331 int WXUNUSED(desiredHeight))
1332{
1333#if wxHAVE_LIB_XPM
1334 if (!bitmap->GetRefData())
1335 bitmap->SetRefData( new wxBitmapRefData() );
1336
1337 M_BMPHANDLERDATA->m_display = wxGlobalDisplay();
1338
1339 Display *xdisplay = (Display*) M_BMPHANDLERDATA->m_display;
1340
1341 int xscreen = DefaultScreen( xdisplay );
1342 Window xroot = RootWindow( xdisplay, xscreen );
1343
1344 int bpp = DefaultDepth( xdisplay, xscreen );
1345
1346 XpmAttributes xpmAttr;
1347 xpmAttr.valuemask = XpmReturnInfos; // nothing yet, but get infos back
1348
1349 Pixmap pixmap;
1350 Pixmap mask = 0;
1351
1352 int ErrorStatus = XpmReadFileToPixmap( xdisplay, xroot,
1353 (char*) name.c_str(),
1354 &pixmap, &mask, &xpmAttr);
1355
1356 if (ErrorStatus == XpmSuccess)
1357 {
1358 M_BMPHANDLERDATA->m_width = xpmAttr.width;
1359 M_BMPHANDLERDATA->m_height = xpmAttr.height;
1360
1361 M_BMPHANDLERDATA->m_bpp = bpp; // mono as well?
1362
1363 XpmFreeAttributes(&xpmAttr);
1364
1365 M_BMPHANDLERDATA->m_bitmap = (WXPixmap) pixmap;
1366
1367 if (mask)
1368 {
1369 M_BMPHANDLERDATA->m_mask = new wxMask;
1370 M_BMPHANDLERDATA->m_mask->SetBitmap( (WXPixmap) mask );
1371 M_BMPHANDLERDATA->m_mask->SetDisplay( xdisplay );
1372 }
1373 }
1374 else
1375 {
1376 UnRef();
1377
1378 return false;
1379 }
1380
1381 return true;
1382#elif wxUSE_STREAMS
1383 wxXPMDecoder decoder;
1384 wxFileInputStream stream(name);
1385 if (stream.Ok())
1386 {
1387 wxImage image(decoder.ReadFile(stream));
1388 return image.Ok() && bitmap->CreateFromImage(image);
1389 }
1390
1391 return false;
1392#else // !wxHAVE_LIB_XPM && !wxUSE_STREAMS
1393 return false;
1394#endif // wxHAVE_LIB_XPM / wxUSE_STREAMS
1395}
1396
1397bool wxXPMFileHandler::SaveFile(const wxBitmap *bitmap, const wxString& name,
1398 int type,
1399 const wxPalette *WXUNUSED(palette))
1400{
1401 wxImage image(bitmap->ConvertToImage());
1402 if (image.Ok()) return image.SaveFile( name, (wxBitmapType)type );
1403
1404 return false;
1405}
1406
1407#endif // wxHAVE_LIB_XPM || wxUSE_STREAMS
1408
1409// ----------------------------------------------------------------------------
1410// wxXPMDataHandler
1411// ----------------------------------------------------------------------------
1412
1413class wxXPMDataHandler : public wxBitmapHandler
1414{
1415 DECLARE_DYNAMIC_CLASS(wxXPMDataHandler)
1416public:
1417 wxXPMDataHandler()
1418 {
1419 SetName( wxT("XPM data") );
1420 SetExtension( wxT("xpm") );
1421 SetType( wxBITMAP_TYPE_XPM_DATA );
1422 };
1423
1424 virtual bool LoadFile(wxBitmap *WXUNUSED(bitmap),
1425 const wxString& WXUNUSED(name),
1426 long WXUNUSED(flags),
1427 int WXUNUSED(desiredWidth),
1428 int WXUNUSED(desiredHeight))
1429 { return false; }
1430
1431 virtual bool SaveFile(const wxBitmap *WXUNUSED(bitmap),
1432 const wxString& WXUNUSED(name),
1433 int WXUNUSED(type),
1434 const wxPalette *WXUNUSED(palette) = NULL)
1435 { return false; }
1436
1437 virtual bool Create(wxBitmap *bitmap, void *data, long flags,
1438 int width, int height, int depth = 1);
1439};
1440
1441IMPLEMENT_DYNAMIC_CLASS(wxXPMDataHandler, wxBitmapHandler)
1442
1443bool wxXPMDataHandler::Create(wxBitmap *bitmap, void *bits,
1444 long WXUNUSED(flags),
1445 int WXUNUSED(width), int WXUNUSED(height), int WXUNUSED(depth))
1446{
1447#if wxHAVE_LIB_XPM
1448 wxCHECK_MSG( bits != NULL, false, wxT("invalid bitmap data") );
1449
1450 if (!bitmap->GetRefData())
1451 bitmap->SetRefData( new wxBitmapRefData() );
1452
1453 M_BMPHANDLERDATA->m_display = wxGlobalDisplay();
1454
1455 Display *xdisplay = (Display*) M_BMPHANDLERDATA->m_display;
1456
1457 int xscreen = DefaultScreen( xdisplay );
1458 Window xroot = RootWindow( xdisplay, xscreen );
1459
1460 int bpp = DefaultDepth( xdisplay, xscreen );
1461
1462 XpmAttributes xpmAttr;
1463 xpmAttr.valuemask = XpmReturnInfos; // nothing yet, but get infos back
1464
1465 Pixmap pixmap = 0;
1466 Pixmap mask = 0;
1467
1468 int ErrorStatus = XpmCreatePixmapFromData( xdisplay, xroot, (char**) bits,
1469 &pixmap, &mask, &xpmAttr );
1470
1471 if (ErrorStatus == XpmSuccess)
1472 {
1473 M_BMPHANDLERDATA->m_width = xpmAttr.width;
1474 M_BMPHANDLERDATA->m_height = xpmAttr.height;
1475
1476 M_BMPHANDLERDATA->m_bpp = bpp; // mono as well?
1477
1478#if __WXDEBUG__
1479 unsigned int depthRet;
1480 int xRet, yRet;
1481 unsigned int widthRet, heightRet, borderWidthRet;
1482 XGetGeometry( xdisplay, pixmap, &xroot, &xRet, &yRet,
1483 &widthRet, &heightRet, &borderWidthRet, &depthRet);
1484
1485 wxASSERT_MSG( bpp == (int)depthRet, wxT("colour depth mismatch") );
1486#endif
1487
1488 XpmFreeAttributes(&xpmAttr);
1489
1490 M_BMPHANDLERDATA->m_pixmap = (WXPixmap) pixmap;
1491
1492 if (mask)
1493 {
1494 M_BMPHANDLERDATA->m_mask = new wxMask;
1495 M_BMPHANDLERDATA->m_mask->SetBitmap( (WXPixmap) mask );
1496 M_BMPHANDLERDATA->m_mask->SetDisplay( xdisplay );
1497 }
1498 return true;
1499 }
1500 else
1501 {
1502 bitmap->UnRef();
1503
1504 return false;
1505 }
1506#else // !wxHAVE_LIB_XPM
1507 wxXPMDecoder decoder;
1508 wxImage image(decoder.ReadData((const char **)bits));
1509 return image.Ok() && bitmap->CreateFromImage(image);
1510#endif // wxHAVE_LIB_XPM/!wxHAVE_LIB_XPM
1511}
1512
1513#endif // wxUSE_XPM
1514
1515// ----------------------------------------------------------------------------
1516// wxXBMDataHandler
1517// ----------------------------------------------------------------------------
1518
1519class WXDLLEXPORT wxXBMDataHandler: public wxBitmapHandler
1520{
1521 DECLARE_DYNAMIC_CLASS(wxXBMDataHandler)
1522public:
1523 inline wxXBMDataHandler()
1524 {
1525 SetName( wxT("XBM data") );
1526 SetExtension( wxT("xbm") );
1527 SetType( wxBITMAP_TYPE_XBM_DATA );
1528 };
1529
1530 virtual bool LoadFile(wxBitmap *WXUNUSED(bitmap),
1531 const wxString& WXUNUSED(name),
1532 long WXUNUSED(flags),
1533 int WXUNUSED(desiredWidth),
1534 int WXUNUSED(desiredHeight))
1535 { return false; }
1536
1537 virtual bool SaveFile(const wxBitmap *WXUNUSED(bitmap),
1538 const wxString& WXUNUSED(name),
1539 int WXUNUSED(type),
1540 const wxPalette *WXUNUSED(palette) = NULL)
1541 { return false; }
1542
1543 virtual bool Create(wxBitmap *bitmap, void *data, long flags,
1544 int width, int height, int depth = 1);
1545};
1546
1547IMPLEMENT_DYNAMIC_CLASS(wxXBMDataHandler, wxBitmapHandler)
1548
1549bool wxXBMDataHandler::Create( wxBitmap *bitmap, void *bits,
1550 long WXUNUSED(flags),
1551 int width, int height, int WXUNUSED(depth))
1552{
1553#if !wxUSE_NANOX
1554 if (!bitmap->GetRefData())
1555 bitmap->SetRefData( new wxBitmapRefData() );
1556
1557 M_BMPHANDLERDATA->m_display = wxGlobalDisplay();
1558
1559 Display *xdisplay = (Display*) M_BMPHANDLERDATA->m_display;
1560
1561 int xscreen = DefaultScreen( xdisplay );
1562 Window xroot = RootWindow( xdisplay, xscreen );
1563
1564 M_BMPHANDLERDATA->m_mask = (wxMask *) NULL;
1565 M_BMPHANDLERDATA->m_bitmap =
1566 (WXPixmap) XCreateBitmapFromData( xdisplay, xroot,
1567 (char *) bits, width, height );
1568 M_BMPHANDLERDATA->m_width = width;
1569 M_BMPHANDLERDATA->m_height = height;
1570 M_BMPHANDLERDATA->m_bpp = 1;
1571
1572 return true;
1573#else
1574 wxCHECK_MSG( M_BMPHANDLERDATA->m_bitmap, false,
1575 wxT("couldn't create bitmap") );
1576#endif
1577}
1578
1579void wxBitmap::InitStandardHandlers()
1580{
1581 AddHandler(new wxXBMDataHandler);
1582#if wxUSE_XPM
1583#if wxHAVE_LIB_XPM || wxUSE_STREAMS
1584 AddHandler(new wxXPMFileHandler);
1585#endif
1586 AddHandler(new wxXPMDataHandler);
1587#endif
1588}
wxWidgets (Impactor)