1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/x11/bitmap.cpp
4 // Author: Julian Smart, Robert Roebling
8 // Copyright: (c) Julian Smart, Robert Roebling
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // for compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
15 #include "wx/bitmap.h"
21 #include "wx/dcmemory.h"
24 #include "wx/x11/private.h"
26 /* No point in using libXPM for NanoX */
29 #define wxHAVE_LIB_XPM 0
31 // Copy from the drawable to the wxImage
32 bool wxGetImageFromDrawable(GR_DRAW_ID drawable
, int srcX
, int srcY
, int width
, int height
, wxImage
& image
);
39 #include "wx/xpmdecod.h"
40 #include "wx/wfstream.h"
45 //-----------------------------------------------------------------------------
47 //-----------------------------------------------------------------------------
49 IMPLEMENT_DYNAMIC_CLASS(wxMask
,wxObject
)
57 wxMask::wxMask( const wxBitmap
& bitmap
, const wxColour
& colour
)
60 Create( bitmap
, colour
);
63 wxMask::wxMask( const wxBitmap
& bitmap
, int paletteIndex
)
66 Create( bitmap
, paletteIndex
);
69 wxMask::wxMask( const wxBitmap
& bitmap
)
78 XFreePixmap( (Display
*) m_display
, (Pixmap
) m_bitmap
);
81 bool wxMask::Create( const wxBitmap
& bitmap
,
82 const wxColour
& colour
)
87 XFreePixmap( (Display
*) m_display
, (Pixmap
) m_bitmap
);
91 m_display
= bitmap
.GetDisplay();
93 wxImage image
= bitmap
.ConvertToImage();
94 if (!image
.Ok()) return false;
96 m_display
= bitmap
.GetDisplay();
98 Display
*xdisplay
= (Display
*) m_display
;
99 int xscreen
= DefaultScreen( xdisplay
);
100 Window xroot
= RootWindow( xdisplay
, xscreen
);
102 m_bitmap
= (WXPixmap
) XCreatePixmap( xdisplay
, xroot
, image
.GetWidth(), image
.GetHeight(), 1 );
103 GC gc
= XCreateGC( xdisplay
, (Pixmap
) m_bitmap
, 0, NULL
);
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() );
109 unsigned char *data
= image
.GetData();
112 unsigned char red
= colour
.Red();
113 unsigned char green
= colour
.Green();
114 unsigned char blue
= colour
.Blue();
116 int bpp
= wxTheApp
->GetVisualInfo(m_display
)->m_visualDepth
;
137 XSetForeground( xdisplay
, gc
, BlackPixel(xdisplay
,xscreen
) );
139 int width
= image
.GetWidth();
140 int height
= image
.GetHeight();
141 for (int j
= 0; j
< height
; j
++)
145 for (i
= 0; i
< width
; i
++)
147 if ((data
[index
] == red
) &&
148 (data
[index
+1] == green
) &&
149 (data
[index
+2] == blue
))
158 XDrawLine( xdisplay
, (Pixmap
) m_bitmap
, gc
, start_x
, j
, i
-1, j
);
165 XDrawLine( xdisplay
, (Pixmap
) m_bitmap
, gc
, start_x
, j
, i
, j
);
168 XFreeGC( xdisplay
, gc
);
177 bool wxMask::Create( const wxBitmap
& bitmap
, int paletteIndex
)
180 wxPalette
*pal
= bitmap
.GetPalette();
182 wxCHECK_MSG( pal
, false, wxT("Cannot create mask from bitmap without palette") );
184 pal
->GetRGB(paletteIndex
, &r
, &g
, &b
);
186 return Create(bitmap
, wxColour(r
, g
, b
));
189 bool wxMask::Create( const wxBitmap
& bitmap
)
194 XFreePixmap( (Display
*) m_display
, (Pixmap
) m_bitmap
);
198 if (!bitmap
.Ok()) return false;
200 wxCHECK_MSG( bitmap
.GetBitmap(), false, wxT("Cannot create mask from colour bitmap") );
202 m_display
= bitmap
.GetDisplay();
204 int xscreen
= DefaultScreen( (Display
*) m_display
);
205 Window xroot
= RootWindow( (Display
*) m_display
, xscreen
);
207 m_bitmap
= (WXPixmap
) XCreatePixmap( (Display
*) m_display
, xroot
, bitmap
.GetWidth(), bitmap
.GetHeight(), 1 );
209 if (!m_bitmap
) return false;
211 GC gc
= XCreateGC( (Display
*) m_display
, (Pixmap
) m_bitmap
, 0, NULL
);
213 XCopyPlane( (Display
*) m_display
, (Pixmap
) bitmap
.GetBitmap(), (Pixmap
) m_bitmap
,
214 gc
, 0, 0, bitmap
.GetWidth(), bitmap
.GetHeight(), 0, 0, 1 );
216 XFreeGC( (Display
*) m_display
, gc
);
225 //-----------------------------------------------------------------------------
227 //-----------------------------------------------------------------------------
229 class wxBitmapRefData
: public wxObjectRefData
237 WXDisplay
*m_display
;
242 wxPalette
*m_palette
;
245 wxBitmapRefData::wxBitmapRefData()
250 m_mask
= (wxMask
*) NULL
;
254 m_palette
= (wxPalette
*) NULL
;
257 wxBitmapRefData::~wxBitmapRefData()
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
;
265 //-----------------------------------------------------------------------------
269 static WXPixmap
wxGetSubPixmap( WXDisplay
* xdisplay
, WXPixmap xpixmap
,
270 int x
, int y
, int width
, int height
,
273 Display
* const dpy
= (Display
*)xdisplay
;
275 int xscreen
= DefaultScreen( dpy
);
276 Window xroot
= RootWindow( dpy
, xscreen
);
277 Visual
* xvisual
= DefaultVisual( dpy
, xscreen
);
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
,
284 AllPlanes
, ZPixmap
, ximage
, 0, 0 );
286 GC gc
= XCreateGC( dpy
, (Pixmap
)xpixmap
, 0, NULL
);
287 Pixmap ret
= XCreatePixmap( dpy
, xroot
,
288 width
, height
, depth
);
290 XPutImage( dpy
, ret
, gc
, ximage
,
291 0, 0, 0, 0, width
, height
);
292 XDestroyImage( ximage
);
295 return (WXPixmap
)ret
;
298 #define M_BMPDATA ((wxBitmapRefData *)m_refData)
300 IMPLEMENT_DYNAMIC_CLASS(wxBitmap
,wxGDIObject
)
306 wxBitmap::wxBitmap( int width
, int height
, int depth
)
308 Create( width
, height
, depth
);
311 bool wxBitmap::Create( int width
, int height
, int depth
)
315 wxCHECK_MSG( (width
> 0) && (height
> 0), false, wxT("invalid bitmap size") );
317 m_refData
= new wxBitmapRefData();
319 M_BMPDATA
->m_display
= wxGlobalDisplay();
321 wxASSERT_MSG( M_BMPDATA
->m_display
, wxT("No display") );
323 int xscreen
= DefaultScreen( (Display
*) M_BMPDATA
->m_display
);
324 Window xroot
= RootWindow( (Display
*) M_BMPDATA
->m_display
, xscreen
);
326 int bpp
= DefaultDepth( (Display
*) M_BMPDATA
->m_display
, xscreen
);
327 if (depth
== -1) depth
= bpp
;
329 wxCHECK_MSG( (depth
== bpp
) ||
330 (depth
== 1), false, wxT("invalid bitmap depth") );
332 M_BMPDATA
->m_mask
= (wxMask
*) NULL
;
333 M_BMPDATA
->m_width
= width
;
334 M_BMPDATA
->m_height
= height
;
337 M_BMPDATA
->m_pixmap
= (WXPixmap
) GrNewPixmap(width
, height
, NULL
);
338 M_BMPDATA
->m_bpp
= bpp
;
340 wxASSERT_MSG( M_BMPDATA
->m_pixmap
, wxT("Bitmap creation failed") );
344 M_BMPDATA
->m_bitmap
= (WXPixmap
) XCreatePixmap( (Display
*) M_BMPDATA
->m_display
, xroot
, width
, height
, 1 );
346 wxASSERT_MSG( M_BMPDATA
->m_bitmap
, wxT("Bitmap creation failed") );
348 M_BMPDATA
->m_bpp
= 1;
352 M_BMPDATA
->m_pixmap
= (WXPixmap
) XCreatePixmap( (Display
*) M_BMPDATA
->m_display
, xroot
, width
, height
, depth
);
354 wxASSERT_MSG( M_BMPDATA
->m_pixmap
, wxT("Pixmap creation failed") );
356 M_BMPDATA
->m_bpp
= depth
;
362 bool wxBitmap::Create(void *data
, wxBitmapType type
,
363 int width
, int height
, int depth
)
367 wxBitmapHandler
*handler
= FindHandler(type
);
369 if ( handler
== NULL
) {
370 wxLogWarning(wxT("no data bitmap handler for type %ld defined."),
376 return handler
->Create(this, data
, type
, width
, height
, depth
);
379 bool wxBitmap::Create(WXPixmap pixmap
)
382 Pixmap xpixmap
= (Pixmap
)pixmap
;
383 Display
* xdisplay
= wxGlobalDisplay();
384 int xscreen
= DefaultScreen( xdisplay
);
385 Window xroot
= RootWindow( xdisplay
, xscreen
);
387 // make a copy of the Pixmap
391 unsigned width
, height
, border
, depth
;
393 XGetGeometry( xdisplay
, (Drawable
)xpixmap
, &root
, &x
, &y
,
394 &width
, &height
, &border
, &depth
);
395 copy
= XCreatePixmap( xdisplay
, xroot
, width
, height
, depth
);
397 GC gc
= XCreateGC( xdisplay
, copy
, 0, NULL
);
398 XCopyArea( xdisplay
, xpixmap
, copy
, gc
, 0, 0, width
, height
, 0, 0 );
399 XFreeGC( xdisplay
, gc
);
402 wxBitmapRefData
* ref
= new wxBitmapRefData();
405 ref
->m_bitmap
= (WXPixmap
)copy
;
407 ref
->m_pixmap
= (WXPixmap
)copy
;
409 ref
->m_display
= (WXDisplay
*)xdisplay
;
410 ref
->m_width
= width
;
411 ref
->m_height
= height
;
419 bool wxBitmap::CreateFromXpm( const char **bits
)
421 wxCHECK_MSG( bits
, false, wxT("NULL pointer in wxBitmap::CreateFromXpm") );
423 return Create(bits
, wxBITMAP_TYPE_XPM_DATA
, 0, 0, 0);
426 bool wxBitmap::CreateFromImage( const wxImage
& image
, int depth
)
431 wxASSERT_MSG(image
.Ok(), wxT("Invalid wxImage passed to wxBitmap::CreateFromImage."));
435 int w
= image
.GetWidth();
436 int h
= image
.GetHeight();
438 if (!Create(w
, h
, depth
))
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
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.
452 bool hasMask
= image
.HasMask();
454 GC pixmapGC
= GrNewGC();
455 Pixmap pixmap
= (Pixmap
) GetPixmap();
458 Pixmap maskPixmap
= 0;
460 unsigned char maskR
= 0;
461 unsigned char maskG
= 0;
462 unsigned char maskB
= 0;
466 maskR
= image
.GetMaskRed();
467 maskG
= image
.GetMaskGreen();
468 maskB
= image
.GetMaskBlue();
471 maskPixmap
= GrNewPixmap(w
, h
, 0);
476 wxMask
* mask
= new wxMask
;
477 mask
->SetBitmap((WXPixmap
) maskPixmap
);
482 GR_COLOR lastPixmapColour
= 0;
483 GR_COLOR lastMaskColour
= 0;
486 for (i
= 0; i
< w
; i
++)
488 for (j
= 0; j
< h
; j
++)
490 unsigned char red
= image
.GetRed(i
, j
);
491 unsigned char green
= image
.GetGreen(i
, j
);
492 unsigned char blue
= image
.GetBlue(i
, j
);
494 GR_COLOR colour
= GR_RGB(red
, green
, blue
);
496 // Efficiency measure
497 if (colour
!= lastPixmapColour
|| (i
== 0 && j
== 0))
499 GrSetGCForeground(pixmapGC
, colour
);
500 lastPixmapColour
= colour
;
503 GrPoint(pixmap
, pixmapGC
, i
, j
);
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
)
511 colour
= GR_RGB(0, 0, 0);
515 colour
= GR_RGB(255, 255, 255);
517 if (colour
!= lastMaskColour
|| (i
== 0 && j
== 0))
519 GrSetGCForeground(maskGC
, colour
);
520 lastMaskColour
= colour
;
522 GrPoint(maskPixmap
, maskGC
, i
, j
);
527 GrDestroyGC(pixmapGC
);
537 wxCHECK_MSG( image
.Ok(), false, wxT("invalid image") );
538 wxCHECK_MSG( depth
== -1, false, wxT("invalid bitmap depth") );
540 m_refData
= new wxBitmapRefData();
542 M_BMPDATA
->m_display
= wxGlobalDisplay();
544 Display
*xdisplay
= (Display
*) M_BMPDATA
->m_display
;
546 int xscreen
= DefaultScreen( xdisplay
);
547 Window xroot
= RootWindow( xdisplay
, xscreen
);
548 Visual
* xvisual
= DefaultVisual( xdisplay
, xscreen
);
550 int bpp
= wxTheApp
->GetVisualInfo(M_BMPDATA
->m_display
)->m_visualDepth
;
552 int width
= image
.GetWidth();
553 int height
= image
.GetHeight();
554 M_BMPDATA
->m_width
= width
;
555 M_BMPDATA
->m_height
= height
;
557 if (depth
!= 1) depth
= bpp
;
558 M_BMPDATA
->m_bpp
= depth
;
562 wxFAIL_MSG( wxT("mono images later") );
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
);
571 if (data_image
->data
== NULL
)
573 wxLogError( wxT("Out of memory.") ); // TODO clean
577 M_BMPDATA
->m_pixmap
= (WXPixmap
) XCreatePixmap( xdisplay
, xroot
, width
, height
, depth
);
581 XImage
*mask_image
= (XImage
*) NULL
;
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
);
587 if (mask_image
->data
== NULL
)
589 wxLogError( wxT("Out of memory.") ); // TODO clean
593 wxMask
*mask
= new wxMask();
594 mask
->SetDisplay( xdisplay
);
595 mask
->SetBitmap( (WXPixmap
) XCreatePixmap( xdisplay
, xroot
, width
, height
, 1 ) );
600 if (bpp
< 8) bpp
= 8;
604 enum byte_order
{ RGB
, RBG
, BRG
, BGR
, GRB
, GBR
};
605 byte_order b_o
= RGB
;
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
;
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
;
622 int r_mask
= image
.GetMaskRed();
623 int g_mask
= image
.GetMaskGreen();
624 int b_mask
= image
.GetMaskBlue();
626 unsigned char* data
= image
.GetData();
627 wxASSERT_MSG( data
, wxT("No image data") );
629 unsigned char *colorCube
=
630 wxTheApp
->GetVisualInfo(M_BMPDATA
->m_display
)->m_colorCube
;
632 bool hasMask
= image
.HasMask();
635 for (int y
= 0; y
< height
; y
++)
637 for (int x
= 0; x
< width
; x
++)
648 if ((r
== r_mask
) && (b
== b_mask
) && (g
== g_mask
))
649 XPutPixel( mask_image
, x
, y
, 0 );
651 XPutPixel( mask_image
, x
, y
, 1 );
659 pixel
= colorCube
[ ((r
& 0xf8) << 7) + ((g
& 0xf8) << 2) + ((b
& 0xf8) >> 3) ];
660 XPutPixel( data_image
, x
, y
, pixel
);
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;
675 XPutPixel( data_image
, x
, y
, pixel
);
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;
690 XPutPixel( data_image
, x
, y
, pixel
);
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.
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;
707 XPutPixel( data_image
, x
, y
, pixel
);
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;
723 XPutPixel( data_image
, x
, y
, pixel
);
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
);
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
);
744 XDestroyImage( mask_image
);
745 XFreeGC( xdisplay
, gc
);
754 wxImage
wxBitmap::ConvertToImage() const
758 wxCHECK_MSG( Ok(), wxNullImage
, wxT("invalid bitmap") );
760 Display
*xdisplay
= (Display
*) M_BMPDATA
->m_display
;
761 wxASSERT_MSG( xdisplay
, wxT("No display") );
764 //int bpp = DefaultDepth(xdisplay, xscreen);
765 wxGetImageFromDrawable((Pixmap
) GetPixmap(), 0, 0, GetWidth(), GetHeight(), image
);
769 int bpp
= wxTheApp
->GetVisualInfo(M_BMPDATA
->m_display
)->m_visualDepth
;
770 XImage
*x_image
= NULL
;
773 x_image
= XGetImage( xdisplay
, (Pixmap
) GetPixmap(),
775 GetWidth(), GetHeight(),
776 AllPlanes
, ZPixmap
);
780 x_image
= XGetImage( xdisplay
, (Pixmap
) GetBitmap(),
782 GetWidth(), GetHeight(),
783 AllPlanes
, ZPixmap
);
786 wxFAIL_MSG( wxT("Ill-formed bitmap") );
789 wxCHECK_MSG( x_image
, wxNullImage
, wxT("couldn't create image") );
791 image
.Create( GetWidth(), GetHeight() );
792 char unsigned *data
= image
.GetData();
796 XDestroyImage( x_image
);
797 wxFAIL_MSG( wxT("couldn't create image") );
801 XImage
*x_image_mask
= NULL
;
804 x_image_mask
= XGetImage( xdisplay
, (Pixmap
) GetMask()->GetBitmap(),
806 GetWidth(), GetHeight(),
807 AllPlanes
, ZPixmap
);
809 image
.SetMaskColour( 16, 16, 16 ); // anything unlikely and dividable
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;
822 wxXVisualInfo
* vi
= wxTheApp
->GetVisualInfo(M_BMPDATA
->m_display
);
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
;
831 use_shift
= (vi
->m_visualType
== GrayScale
) ||
832 (vi
->m_visualType
!= PseudoColor
);
840 XColor
*colors
= (XColor
*)wxTheApp
->
841 GetVisualInfo(M_BMPDATA
->m_display
)->m_visualColormap
;
843 int width
= GetWidth();
844 int height
= GetHeight();
846 for (int j
= 0; j
< height
; j
++)
848 for (int i
= 0; i
< width
; i
++)
850 unsigned long pixel
= XGetPixel( x_image
, i
, j
);
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
);
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);
880 wxFAIL_MSG( wxT("Image conversion failed. Unknown visual type.") );
885 int mask_pixel
= XGetPixel( x_image_mask
, i
, j
);
898 XDestroyImage( x_image
);
899 if (x_image_mask
) XDestroyImage( x_image_mask
);
905 wxBitmap::wxBitmap( const wxString
&filename
, wxBitmapType type
)
907 LoadFile( filename
, type
);
910 wxBitmap::wxBitmap( const char bits
[], int width
, int height
, int depth
)
912 m_refData
= new wxBitmapRefData
;
914 (void) Create((void*) bits
, wxBITMAP_TYPE_XBM_DATA
, width
, height
, depth
);
917 wxBitmap::~wxBitmap()
921 bool wxBitmap::operator == ( const wxBitmap
& bmp
) const
923 return m_refData
== bmp
.m_refData
;
926 bool wxBitmap::operator != ( const wxBitmap
& bmp
) const
928 return m_refData
!= bmp
.m_refData
;
931 bool wxBitmap::Ok() const
933 return (m_refData
!= NULL
);
936 int wxBitmap::GetHeight() const
938 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
940 return M_BMPDATA
->m_height
;
943 int wxBitmap::GetWidth() const
945 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
947 return M_BMPDATA
->m_width
;
950 int wxBitmap::GetDepth() const
952 wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
954 return M_BMPDATA
->m_bpp
;
957 wxMask
*wxBitmap::GetMask() const
959 wxCHECK_MSG( Ok(), (wxMask
*) NULL
, wxT("invalid bitmap") );
961 return M_BMPDATA
->m_mask
;
964 void wxBitmap::SetMask( wxMask
*mask
)
966 wxCHECK_RET( Ok(), wxT("invalid bitmap") );
968 if (M_BMPDATA
->m_mask
) delete M_BMPDATA
->m_mask
;
970 M_BMPDATA
->m_mask
= mask
;
973 bool wxBitmap::CopyFromIcon(const wxIcon
& icon
)
979 wxBitmap
wxBitmap::GetSubBitmap( const wxRect
& rect
) const
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") );
987 wxBitmap
ret( rect
.width
, rect
.height
, M_BMPDATA
->m_bpp
);
988 wxASSERT_MSG( ret
.Ok(), wxT("GetSubBitmap error") );
992 wxMask
* mask
= new wxMask();
993 mask
->SetDisplay( GetMask()->GetDisplay() );
994 mask
->SetBitmap( wxGetSubPixmap( GetMask()->GetDisplay(),
995 GetMask()->GetBitmap(),
997 rect
.width
, rect
.height
,
1000 ret
.SetMask( mask
);
1005 ret
.SetPixmap( wxGetSubPixmap( GetDisplay(),
1008 rect
.width
, rect
.height
,
1009 M_BMPDATA
->m_bpp
) );
1014 ret
.SetBitmap( wxGetSubPixmap( GetDisplay(),
1017 rect
.width
, rect
.height
,
1024 bool wxBitmap::SaveFile( const wxString
&name
, wxBitmapType type
,
1025 const wxPalette
*palette
) const
1027 wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
1029 wxBitmapHandler
*handler
= FindHandler(type
);
1031 // Try to save the bitmap via wxImage handlers:
1032 if (handler
== NULL
)
1034 wxImage
image(this->ConvertToImage());
1035 if (image
.Ok()) return image
.SaveFile( name
, type
);
1040 return handler
->SaveFile(this, name
, type
, palette
);
1043 bool wxBitmap::LoadFile( const wxString
&name
, wxBitmapType type
)
1047 if (!wxFileExists(name
)) return false;
1049 wxBitmapHandler
*handler
= FindHandler(type
);
1051 if (handler
== NULL
)
1054 if (!image
.LoadFile( name
, type
))
1059 *this = wxBitmap(image
);
1065 return handler
->LoadFile(this, name
, type
, -1, -1);
1068 void wxBitmap::SetPalette(const wxPalette
& palette
)
1070 wxCHECK_RET(Ok(), wxT("invalid bitmap"));
1071 wxCHECK_RET(GetDepth() > 1 && GetDepth() <= 8,
1072 wxT("cannot set palette for bitmap of this depth"));
1074 delete M_BMPDATA
->m_palette
;
1075 M_BMPDATA
->m_palette
= NULL
;
1077 if (!palette
.Ok()) return;
1079 M_BMPDATA
->m_palette
= new wxPalette(palette
);
1082 wxPalette
*wxBitmap::GetPalette() const
1084 if (!Ok()) return (wxPalette
*) NULL
;
1086 return M_BMPDATA
->m_palette
;
1089 void wxBitmap::SetHeight( int height
)
1091 if (!m_refData
) m_refData
= new wxBitmapRefData();
1093 M_BMPDATA
->m_height
= height
;
1096 void wxBitmap::SetWidth( int width
)
1098 if (!m_refData
) m_refData
= new wxBitmapRefData();
1100 M_BMPDATA
->m_width
= width
;
1103 void wxBitmap::SetDepth( int depth
)
1105 if (!m_refData
) m_refData
= new wxBitmapRefData();
1107 M_BMPDATA
->m_bpp
= depth
;
1110 void wxBitmap::SetPixmap( WXPixmap pixmap
)
1112 if (!m_refData
) m_refData
= new wxBitmapRefData();
1114 M_BMPDATA
->m_pixmap
= pixmap
;
1117 void wxBitmap::SetBitmap( WXPixmap bitmap
)
1119 if (!m_refData
) m_refData
= new wxBitmapRefData();
1121 M_BMPDATA
->m_bitmap
= bitmap
;
1124 WXPixmap
wxBitmap::GetPixmap() const
1126 wxCHECK_MSG( Ok(), (WXPixmap
) NULL
, wxT("invalid bitmap") );
1128 return M_BMPDATA
->m_pixmap
;
1131 WXPixmap
wxBitmap::GetBitmap() const
1133 wxCHECK_MSG( Ok(), (WXPixmap
) NULL
, wxT("invalid bitmap") );
1135 return M_BMPDATA
->m_bitmap
;
1138 WXPixmap
wxBitmap::GetDrawable() const
1140 wxCHECK_MSG( Ok(), (WXPixmap
) NULL
, wxT("invalid bitmap") );
1142 return M_BMPDATA
->m_bpp
== 1 ? M_BMPDATA
->m_bitmap
: M_BMPDATA
->m_pixmap
;
1145 WXDisplay
*wxBitmap::GetDisplay() const
1147 wxCHECK_MSG( Ok(), (WXDisplay
*) NULL
, wxT("invalid bitmap") );
1149 return M_BMPDATA
->m_display
;
1153 // Copy from the drawable to the wxImage
1154 bool wxGetImageFromDrawable(GR_DRAW_ID drawable
, int srcX
, int srcY
, int width
, int height
, wxImage
& image
)
1156 GR_SCREEN_INFO sinfo
;
1158 GR_PIXELVAL
*pixels
;
1159 GR_PALETTE
* palette
= NULL
;
1160 unsigned char rgb
[3], *pp
;
1162 GrGetScreenInfo(&sinfo
);
1164 if (sinfo
.pixtype
== MWPF_PALETTE
) {
1165 if(!(palette
= (GR_PALETTE
*) malloc(sizeof(GR_PALETTE
)))) {
1168 GrGetSystemPalette(palette
);
1171 if(!(pixels
= (GR_PIXELVAL
*) malloc(sizeof(GR_PIXELVAL
) * width
* height
)))
1176 image
.Create(width
, height
);
1178 GrReadArea(drawable
, srcX
, srcY
, width
, height
,
1182 for(x
= 0; x
< sinfo
.cols
; x
++) {
1184 pp
= (unsigned char *)pixels
+
1185 ((x
+ (y
* sinfo
.cols
)) *
1186 sizeof(GR_PIXELVAL
));
1188 switch(sinfo
.pixtype
) {
1189 /* FIXME: These may need modifying on big endian. */
1190 case MWPF_TRUECOLOR0888
:
1191 case MWPF_TRUECOLOR888
:
1197 rgb
[0] = palette
->palette
[pp
[0]].r
;
1198 rgb
[1] = palette
->palette
[pp
[0]].g
;
1199 rgb
[2] = palette
->palette
[pp
[0]].b
;
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;
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;
1213 case MWPF_TRUECOLOR332
:
1214 rgb
[0] = pp
[0] & 0xe0;
1215 rgb
[1] = (pp
[0] & 0x1c) << 3;
1216 rgb
[2] = (pp
[0] & 0x03) << 6;
1219 fprintf(stderr
, "Unsupported pixel "
1224 image
.SetRGB(x
, y
, rgb
[0], rgb
[1], rgb
[2]);
1229 if(palette
) free(palette
);
1235 int GrGetPixelColor(GR_SCREEN_INFO
* sinfo
, GR_PALETTE
* palette
, GR_PIXELVAL pixel
,
1236 unsigned char* red
, unsigned char* green
, unsigned char* blue
)
1238 unsigned char rgb
[3], *pp
;
1240 pp
= (unsigned char*) & pixel
;
1242 switch (sinfo
.pixtype
)
1244 /* FIXME: These may need modifying on big endian. */
1245 case MWPF_TRUECOLOR0888
:
1246 case MWPF_TRUECOLOR888
:
1252 rgb
[0] = palette
->palette
[pp
[0]].r
;
1253 rgb
[1] = palette
->palette
[pp
[0]].g
;
1254 rgb
[2] = palette
->palette
[pp
[0]].b
;
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;
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;
1268 case MWPF_TRUECOLOR332
:
1269 rgb
[0] = pp
[0] & 0xe0;
1270 rgb
[1] = (pp
[0] & 0x1c) << 3;
1271 rgb
[2] = (pp
[0] & 0x03) << 6;
1274 fprintf(stderr
, "Unsupported pixel format\n");
1289 // ============================================================================
1291 // ============================================================================
1293 IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler
, wxBitmapHandlerBase
)
1295 #define M_BMPHANDLERDATA ((wxBitmapRefData *)bitmap->GetRefData())
1299 #if wxHAVE_LIB_XPM || wxUSE_STREAMS
1301 // ----------------------------------------------------------------------------
1303 // ----------------------------------------------------------------------------
1305 class wxXPMFileHandler
: public wxBitmapHandler
1307 DECLARE_DYNAMIC_CLASS(wxXPMFileHandler
)
1311 SetName( wxT("XPM file") );
1312 SetExtension( wxT("xpm") );
1313 SetType( wxBITMAP_TYPE_XPM
);
1316 virtual bool LoadFile(wxBitmap
*bitmap
, const wxString
& name
, long flags
,
1317 int desiredWidth
, int desiredHeight
);
1319 virtual bool SaveFile(const wxBitmap
*bitmap
, const wxString
& name
,
1320 int type
, const wxPalette
*palette
= NULL
);
1322 virtual bool Create(wxBitmap
*WXUNUSED(bitmap
), void *WXUNUSED(data
), long WXUNUSED(flags
),
1323 int WXUNUSED(width
), int WXUNUSED(height
), int WXUNUSED(depth
) = 1)
1327 IMPLEMENT_DYNAMIC_CLASS(wxXPMFileHandler
, wxBitmapHandler
)
1329 bool wxXPMFileHandler::LoadFile(wxBitmap
*bitmap
, const wxString
& name
,
1330 long WXUNUSED(flags
), int WXUNUSED(desiredWidth
),
1331 int WXUNUSED(desiredHeight
))
1334 if (!bitmap
->GetRefData())
1335 bitmap
->SetRefData( new wxBitmapRefData() );
1337 M_BMPHANDLERDATA
->m_display
= wxGlobalDisplay();
1339 Display
*xdisplay
= (Display
*) M_BMPHANDLERDATA
->m_display
;
1341 int xscreen
= DefaultScreen( xdisplay
);
1342 Window xroot
= RootWindow( xdisplay
, xscreen
);
1344 int bpp
= DefaultDepth( xdisplay
, xscreen
);
1346 XpmAttributes xpmAttr
;
1347 xpmAttr
.valuemask
= XpmReturnInfos
; // nothing yet, but get infos back
1352 int ErrorStatus
= XpmReadFileToPixmap( xdisplay
, xroot
,
1353 (char*) name
.c_str(),
1354 &pixmap
, &mask
, &xpmAttr
);
1356 if (ErrorStatus
== XpmSuccess
)
1358 M_BMPHANDLERDATA
->m_width
= xpmAttr
.width
;
1359 M_BMPHANDLERDATA
->m_height
= xpmAttr
.height
;
1361 M_BMPHANDLERDATA
->m_bpp
= bpp
; // mono as well?
1363 XpmFreeAttributes(&xpmAttr
);
1365 M_BMPHANDLERDATA
->m_bitmap
= (WXPixmap
) pixmap
;
1369 M_BMPHANDLERDATA
->m_mask
= new wxMask
;
1370 M_BMPHANDLERDATA
->m_mask
->SetBitmap( (WXPixmap
) mask
);
1371 M_BMPHANDLERDATA
->m_mask
->SetDisplay( xdisplay
);
1383 wxXPMDecoder decoder
;
1384 wxFileInputStream
stream(name
);
1387 wxImage
image(decoder
.ReadFile(stream
));
1388 return image
.Ok() && bitmap
->CreateFromImage(image
);
1392 #else // !wxHAVE_LIB_XPM && !wxUSE_STREAMS
1394 #endif // wxHAVE_LIB_XPM / wxUSE_STREAMS
1397 bool wxXPMFileHandler::SaveFile(const wxBitmap
*bitmap
, const wxString
& name
,
1399 const wxPalette
*WXUNUSED(palette
))
1401 wxImage
image(bitmap
->ConvertToImage());
1402 if (image
.Ok()) return image
.SaveFile( name
, (wxBitmapType
)type
);
1407 #endif // wxHAVE_LIB_XPM || wxUSE_STREAMS
1409 // ----------------------------------------------------------------------------
1411 // ----------------------------------------------------------------------------
1413 class wxXPMDataHandler
: public wxBitmapHandler
1415 DECLARE_DYNAMIC_CLASS(wxXPMDataHandler
)
1419 SetName( wxT("XPM data") );
1420 SetExtension( wxT("xpm") );
1421 SetType( wxBITMAP_TYPE_XPM_DATA
);
1424 virtual bool LoadFile(wxBitmap
*WXUNUSED(bitmap
),
1425 const wxString
& WXUNUSED(name
),
1426 long WXUNUSED(flags
),
1427 int WXUNUSED(desiredWidth
),
1428 int WXUNUSED(desiredHeight
))
1431 virtual bool SaveFile(const wxBitmap
*WXUNUSED(bitmap
),
1432 const wxString
& WXUNUSED(name
),
1434 const wxPalette
*WXUNUSED(palette
) = NULL
)
1437 virtual bool Create(wxBitmap
*bitmap
, void *data
, long flags
,
1438 int width
, int height
, int depth
= 1);
1441 IMPLEMENT_DYNAMIC_CLASS(wxXPMDataHandler
, wxBitmapHandler
)
1443 bool wxXPMDataHandler::Create(wxBitmap
*bitmap
, void *bits
,
1444 long WXUNUSED(flags
),
1445 int WXUNUSED(width
), int WXUNUSED(height
), int WXUNUSED(depth
))
1448 wxCHECK_MSG( bits
!= NULL
, false, wxT("invalid bitmap data") );
1450 if (!bitmap
->GetRefData())
1451 bitmap
->SetRefData( new wxBitmapRefData() );
1453 M_BMPHANDLERDATA
->m_display
= wxGlobalDisplay();
1455 Display
*xdisplay
= (Display
*) M_BMPHANDLERDATA
->m_display
;
1457 int xscreen
= DefaultScreen( xdisplay
);
1458 Window xroot
= RootWindow( xdisplay
, xscreen
);
1460 int bpp
= DefaultDepth( xdisplay
, xscreen
);
1462 XpmAttributes xpmAttr
;
1463 xpmAttr
.valuemask
= XpmReturnInfos
; // nothing yet, but get infos back
1468 int ErrorStatus
= XpmCreatePixmapFromData( xdisplay
, xroot
, (char**) bits
,
1469 &pixmap
, &mask
, &xpmAttr
);
1471 if (ErrorStatus
== XpmSuccess
)
1473 M_BMPHANDLERDATA
->m_width
= xpmAttr
.width
;
1474 M_BMPHANDLERDATA
->m_height
= xpmAttr
.height
;
1476 M_BMPHANDLERDATA
->m_bpp
= bpp
; // mono as well?
1479 unsigned int depthRet
;
1481 unsigned int widthRet
, heightRet
, borderWidthRet
;
1482 XGetGeometry( xdisplay
, pixmap
, &xroot
, &xRet
, &yRet
,
1483 &widthRet
, &heightRet
, &borderWidthRet
, &depthRet
);
1485 wxASSERT_MSG( bpp
== (int)depthRet
, wxT("colour depth mismatch") );
1488 XpmFreeAttributes(&xpmAttr
);
1490 M_BMPHANDLERDATA
->m_pixmap
= (WXPixmap
) pixmap
;
1494 M_BMPHANDLERDATA
->m_mask
= new wxMask
;
1495 M_BMPHANDLERDATA
->m_mask
->SetBitmap( (WXPixmap
) mask
);
1496 M_BMPHANDLERDATA
->m_mask
->SetDisplay( xdisplay
);
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
1515 // ----------------------------------------------------------------------------
1517 // ----------------------------------------------------------------------------
1519 class WXDLLEXPORT wxXBMDataHandler
: public wxBitmapHandler
1521 DECLARE_DYNAMIC_CLASS(wxXBMDataHandler
)
1523 inline wxXBMDataHandler()
1525 SetName( wxT("XBM data") );
1526 SetExtension( wxT("xbm") );
1527 SetType( wxBITMAP_TYPE_XBM_DATA
);
1530 virtual bool LoadFile(wxBitmap
*WXUNUSED(bitmap
),
1531 const wxString
& WXUNUSED(name
),
1532 long WXUNUSED(flags
),
1533 int WXUNUSED(desiredWidth
),
1534 int WXUNUSED(desiredHeight
))
1537 virtual bool SaveFile(const wxBitmap
*WXUNUSED(bitmap
),
1538 const wxString
& WXUNUSED(name
),
1540 const wxPalette
*WXUNUSED(palette
) = NULL
)
1543 virtual bool Create(wxBitmap
*bitmap
, void *data
, long flags
,
1544 int width
, int height
, int depth
= 1);
1547 IMPLEMENT_DYNAMIC_CLASS(wxXBMDataHandler
, wxBitmapHandler
)
1549 bool wxXBMDataHandler::Create( wxBitmap
*bitmap
, void *bits
,
1550 long WXUNUSED(flags
),
1551 int width
, int height
, int WXUNUSED(depth
))
1554 if (!bitmap
->GetRefData())
1555 bitmap
->SetRefData( new wxBitmapRefData() );
1557 M_BMPHANDLERDATA
->m_display
= wxGlobalDisplay();
1559 Display
*xdisplay
= (Display
*) M_BMPHANDLERDATA
->m_display
;
1561 int xscreen
= DefaultScreen( xdisplay
);
1562 Window xroot
= RootWindow( xdisplay
, xscreen
);
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;
1574 wxCHECK_MSG( M_BMPHANDLERDATA
->m_bitmap
, false,
1575 wxT("couldn't create bitmap") );
1579 void wxBitmap::InitStandardHandlers()
1581 AddHandler(new wxXBMDataHandler
);
1583 #if wxHAVE_LIB_XPM || wxUSE_STREAMS
1584 AddHandler(new wxXPMFileHandler
);
1586 AddHandler(new wxXPMDataHandler
);