#include "wx/app.h"
#ifdef __WXGTK20__
+#include "wx/rawbmp.h"
// need this to get gdk_image_new_bitmap()
#define GDK_ENABLE_BROKEN
#endif
}
wxImage image = bitmap.ConvertToImage();
- if (!image.Ok()) return FALSE;
+ if (!image.Ok()) return false;
m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, image.GetWidth(), image.GetHeight(), 1 );
GdkGC *gc = gdk_gc_new( m_bitmap );
gdk_gc_unref( gc );
- return TRUE;
+ return true;
}
bool wxMask::Create( const wxBitmap& bitmap, int paletteIndex )
unsigned char r,g,b;
wxPalette *pal = bitmap.GetPalette();
- wxCHECK_MSG( pal, FALSE, wxT("Cannot create mask from bitmap without palette") );
+ wxCHECK_MSG( pal, false, wxT("Cannot create mask from bitmap without palette") );
pal->GetRGB(paletteIndex, &r, &g, &b);
m_bitmap = (GdkBitmap*) NULL;
}
- if (!bitmap.Ok()) return FALSE;
+ if (!bitmap.Ok()) return false;
- wxCHECK_MSG( bitmap.GetBitmap(), FALSE, wxT("Cannot create mask from colour bitmap") );
+ wxCHECK_MSG( bitmap.GetBitmap(), false, wxT("Cannot create mask from colour bitmap") );
m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, bitmap.GetWidth(), bitmap.GetHeight(), 1 );
- if (!m_bitmap) return FALSE;
+ if (!m_bitmap) return false;
GdkGC *gc = gdk_gc_new( m_bitmap );
gdk_gc_unref( gc );
- return TRUE;
+ return true;
}
GdkBitmap *wxMask::GetBitmap() const
if (depth == -1)
depth = visual->depth;
- wxCHECK_MSG( (depth == visual->depth) || (depth == 1), FALSE,
+ wxCHECK_MSG( (depth == visual->depth) || (depth == 1) || (depth == 32), false,
wxT("invalid bitmap depth") )
m_refData = new wxBitmapRefData();
M_BMPDATA->m_bitmap = gdk_pixmap_new( wxGetRootWindow()->window, width, height, 1 );
M_BMPDATA->m_bpp = 1;
}
+#ifdef __WXGTK20__
+ else if (depth == 32)
+ {
+ M_BMPDATA->m_pixbuf = gdk_pixbuf_new( GDK_COLORSPACE_RGB, true,
+ 8, width, height);
+ M_BMPDATA->m_bpp = 32;
+ }
+#endif
else
{
M_BMPDATA->m_pixmap = gdk_pixmap_new( wxGetRootWindow()->window, width, height, depth );
{
UnRef();
- wxCHECK_MSG( bits != NULL, FALSE, wxT("invalid bitmap data") )
+ wxCHECK_MSG( bits != NULL, false, wxT("invalid bitmap data") )
GdkVisual *visual = wxTheApp->GetGdkVisual();
M_BMPDATA->m_pixmap = gdk_pixmap_create_from_xpm_d( wxGetRootWindow()->window, &mask, NULL, (gchar **) bits );
- wxCHECK_MSG( M_BMPDATA->m_pixmap, FALSE, wxT("couldn't create pixmap") );
+ wxCHECK_MSG( M_BMPDATA->m_pixmap, false, wxT("couldn't create pixmap") );
if (mask)
{
M_BMPDATA->m_bpp = visual->depth; // Can we get a different depth from create_from_xpm_d() ?
- return TRUE;
+ return true;
}
wxBitmap wxBitmap::Rescale( int clipx, int clipy, int clipwidth, int clipheight, int newx, int newy )
if (newy==M_BMPDATA->m_width && newy==M_BMPDATA->m_height)
return *this;
-
+
int width = wxMax(newx, 1);
int height = wxMax(newy, 1);
width = wxMin(width, clipwidth);
height = wxMin(height, clipheight);
-
+
wxBitmap bmp;
#ifdef __WXGTK20__
8, width, height));
gdk_pixbuf_scale(GetPixbuf(), bmp.GetPixbuf(),
0, 0, width, height,
- clipx, clipy,
+ clipx, clipy,
(double)newx/GetWidth(), (double)newy/GetHeight(),
GDK_INTERP_BILINEAR);
}
int bpp = -1;
-
+
GdkGC *gc = NULL;
GdkPixmap *dstpix = NULL;
if (GetPixmap())
char *dst = NULL;
long dstbyteperline = 0;
-
+
if (GetBitmap())
{
bpp = 1;
dstbyteperline++;
dst = (char*) malloc(dstbyteperline*height);
}
-
+
// be careful to use the right scaling factor
float scx = (float)M_BMPDATA->m_width/(float)newx;
float scy = (float)M_BMPDATA->m_height/(float)newy;
old_pixval = pixval;
old_x = x;
}
-
+
if (bpp == 1)
{
if (!pixval)
{
char bit=1;
- char shift = bit << w % 8;
+ char shift = bit << (w % 8);
outbyte |= shift;
}
-
+
if ((w+1)%8==0)
{
dst[h*dstbyteperline+w/8] = outbyte;
gdk_draw_point( dstpix, gc, w, h);
}
}
-
+
// do not forget the last byte
if ((bpp == 1) && (width % 8 != 0))
dst[h*dstbyteperline+width/8] = outbyte;
}
-
+
gdk_image_destroy( img );
if (gc) gdk_gc_unref( gc );
bmp = wxBitmap( (const char *)dst, width, height, 1 );
free( dst );
}
-
+
if (GetMask())
{
dstbyteperline = width/8;
char outbyte = 0;
int old_x = -1;
guint32 old_pixval = 0;
-
+
for (int w = 0; w < width; w++)
{
guint32 pixval;
old_pixval = pixval;
old_x = x;
}
-
+
if (pixval)
{
char bit=1;
- char shift = bit << w % 8;
+ char shift = bit << (w % 8);
outbyte |= shift;
}
-
+
if ((w+1)%8 == 0)
{
dst[h*dstbyteperline+w/8] = outbyte;
outbyte = 0;
}
}
-
+
// do not forget the last byte
if (width % 8 != 0)
dst[h*dstbyteperline+width/8] = outbyte;
free( tablex );
free( tabley );
}
-
- return bmp;
+
+ return bmp;
}
bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
{
UnRef();
- wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
- wxCHECK_MSG( depth == -1 || depth == 1, FALSE, wxT("invalid bitmap depth") )
+ wxCHECK_MSG( image.Ok(), false, wxT("invalid image") )
+ wxCHECK_MSG( depth == -1 || depth == 1, false, wxT("invalid bitmap depth") )
if (image.GetWidth() <= 0 || image.GetHeight() <= 0)
return false;
-
+
m_refData = new wxBitmapRefData();
if (depth == 1)
// convert alpha channel to mask, if it is present:
wxImage image(img);
image.ConvertAlphaToMask();
-
+
int width = image.GetWidth();
int height = image.GetHeight();
return true;
}
-
+
// conversion to colour bitmap:
bool wxBitmap::CreateFromImageAsPixmap(const wxImage& img)
{
// convert alpha channel to mask, if it is present:
wxImage image(img);
image.ConvertAlphaToMask();
-
+
int width = image.GetWidth();
int height = image.GetHeight();
if (!image.HasMask() && (bpp > 12))
#endif
{
- static bool s_hasInitialized = FALSE;
+ static bool s_hasInitialized = false;
if (!s_hasInitialized)
{
gdk_rgb_init();
- s_hasInitialized = TRUE;
+ s_hasInitialized = true;
}
GdkGC *gc = gdk_gc_new( GetPixmap() );
width*3 );
gdk_gc_unref( gc );
- return TRUE;
+ return true;
}
// Create picture image
case GBR: pixel = (g << 16) | (b << 8) | r; break;
}
gdk_image_put_pixel( data_image, x, y, pixel );
+ break;
}
default: break;
}
wxASSERT( gdk_pixbuf_get_n_channels(pixbuf) == 4 );
wxASSERT( gdk_pixbuf_get_width(pixbuf) == width );
wxASSERT( gdk_pixbuf_get_height(pixbuf) == height );
-
+
M_BMPDATA->m_pixbuf = pixbuf;
SetHeight(height);
SetWidth(width);
SetDepth(wxTheApp->GetGdkVisual()->depth);
-
+
// Copy the data:
unsigned char *in = image.GetData();
unsigned char *out = gdk_pixbuf_get_pixels(pixbuf);
unsigned char *alpha = image.GetAlpha();
-
+
int rowinc = gdk_pixbuf_get_rowstride(pixbuf) - 4 * width;
for (int y = 0; y < height; y++, out += rowinc)
out[3] = *alpha;
}
}
-
+
return true;
}
#endif // __WXGTK20__
wxImage image;
wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
-
+
image.Create(GetWidth(), GetHeight());
unsigned char *data = image.GetData();
{
GdkPixbuf *pixbuf = GetPixbuf();
wxASSERT( gdk_pixbuf_get_has_alpha(pixbuf) );
-
+
int w = GetWidth();
int h = GetHeight();
-
+
image.SetAlpha();
unsigned char *alpha = image.GetAlpha();
int red_shift_left = 0;
int green_shift_left = 0;
int blue_shift_left = 0;
- bool use_shift = FALSE;
+ bool use_shift = false;
if (GetPixmap())
{
bool wxBitmap::Ok() const
{
- return (m_refData != NULL) &&
+ return (m_refData != NULL) &&
(
#ifdef __WXGTK20__
M_BMPDATA->m_pixbuf ||
#endif
- M_BMPDATA->m_bitmap || M_BMPDATA->m_pixmap
+ M_BMPDATA->m_bitmap || M_BMPDATA->m_pixmap
);
}
bool wxBitmap::CopyFromIcon(const wxIcon& icon)
{
*this = icon;
- return TRUE;
+ return true;
}
wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
bool wxBitmap::SaveFile( const wxString &name, wxBitmapType type, const wxPalette *WXUNUSED(palette) ) const
{
- wxCHECK_MSG( Ok(), FALSE, wxT("invalid bitmap") );
+ wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
// Try to save the bitmap via wxImage handlers:
{
if (image.Ok()) return image.SaveFile( name, type );
}
- return FALSE;
+ return false;
}
bool wxBitmap::LoadFile( const wxString &name, wxBitmapType type )
UnRef();
if (!wxFileExists(name))
- return FALSE;
+ return false;
GdkVisual *visual = wxTheApp->GetGdkVisual();
{
wxImage image;
if ( !image.LoadFile( name, type ) || !image.Ok() )
- return FALSE;
+ return false;
*this = wxBitmap(image);
}
- return TRUE;
+ return true;
}
wxPalette *wxBitmap::GetPalette() const
{
int width = GetWidth();
int height = GetHeight();
-
+
GdkPixbuf *pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
GetMask() != NULL,
8, width, height);
- M_BMPDATA->m_pixbuf =
+ M_BMPDATA->m_pixbuf =
gdk_pixbuf_get_from_drawable(pixbuf, M_BMPDATA->m_pixmap, NULL,
0, 0, 0, 0, width, height);
-
+
// apply the mask to created pixbuf:
if (M_BMPDATA->m_pixbuf && M_BMPDATA->m_mask)
{
- GdkPixbuf *pmask =
+ GdkPixbuf *pmask =
gdk_pixbuf_get_from_drawable(NULL,
M_BMPDATA->m_mask->GetBitmap(),
NULL,
bmp[3] = 0;
}
}
-
+
gdk_pixbuf_unref(pmask);
}
}
}
}
+#endif // __WXGTK20__
+
+void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
+{
+#ifdef __WXGTK20__
+ if (bpp != 32)
+ return NULL;
+
+ GdkPixbuf *pixbuf = GetPixbuf();
+ if (!pixbuf)
+ return NULL;
+
+#if 0
+ if (gdk_pixbuf_get_has_alpha( pixbuf ))
+ wxPrintf( wxT("Has alpha\n") );
+ else
+ wxPrintf( wxT("No alpha.\n") );
+#endif
+
+ data.m_height = gdk_pixbuf_get_height( pixbuf );
+ data.m_width = gdk_pixbuf_get_width( pixbuf );
+ data.m_stride = gdk_pixbuf_get_rowstride( pixbuf );
+
+ return gdk_pixbuf_get_pixels( pixbuf );
+#else
+ return NULL;
+#endif
+}
+
+void wxBitmap::UngetRawData(wxPixelDataBase& data)
+{
+}
+
+
+bool wxBitmap::HasAlpha() const
+{
+#ifdef __WXGTK20__
+ return HasPixbuf();
+#else
+ return false;
+#endif
+}
+
+void wxBitmap::UseAlpha()
+{
+#ifdef __WXGTK20__
+ GetPixbuf();
+#endif
+}
+
//-----------------------------------------------------------------------------
// wxBitmapHandler
//-----------------------------------------------------------------------------
bool wxBitmapHandler::Create(wxBitmap *bitmap, void *data, long type, int width, int height, int depth)
{
- return FALSE;
+ return false;
}
bool wxBitmapHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
int desiredWidth, int desiredHeight)
{
- return FALSE;
+ return false;
}
bool wxBitmapHandler::SaveFile(const wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette)
{
- return FALSE;
+ return false;
}
/* static */ void wxBitmap::InitStandardHandlers()
}
-#endif // __WXGTK20__