Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove GTK2 stuff from src/gtk1. Rename wx/gtk includes to wx/gtk1.

Browse Source 
57 files changed, 394 insertions(+), 6767 deletions(-)


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@37063 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Mart Raudsepp
2006-01-23 01:14:32 +00:00
parent 9fa72bd2a6
commit 3cbab64109
57 changed files with 403 additions and 6777 deletions
Download Patch File Download Diff File Expand all files Collapse all files

802
src/gtk1/bitmap.cpp
View File

@@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////////
// Name: src/gtk/bitmap.cpp
// Name: src/gtk1/bitmap.cpp
// Purpose:
// Author: Robert Roebling
// RCS-ID: $Id$
@@ -20,33 +20,24 @@
#include "wx/dcmemory.h"
#include "wx/app.h"
#ifdef __WXGTK20__
#include "wx/rawbmp.h"
// need this to get gdk_image_new_bitmap()
#define GDK_ENABLE_BROKEN
#endif
#include <gdk/gdk.h>
#include <gtk/gtk.h>
#include <gdk/gdkx.h>
#ifdef __WXGTK20__
#include <gdk/gdkimage.h>
#else // GTK+ 1.2
#include <gdk/gdkrgb.h>
#endif // GTK+ 2.0/1.2
#include <gdk/gdkrgb.h>
#include "wx/math.h"
extern void gdk_wx_draw_bitmap (GdkDrawable *drawable,
GdkGC *gc,
GdkDrawable *src,
gint xsrc,
gint ysrc,
gint xdest,
gint ydest,
gint width,
gint height);
extern
void gdk_wx_draw_bitmap (GdkDrawable *drawable,
GdkGC *gc,
GdkDrawable *src,
gint xsrc,
gint ysrc,
gint xdest,
gint ydest,
gint width,
gint height);
//-----------------------------------------------------------------------------
// data
@@ -240,9 +231,6 @@ public:
GdkPixmap *m_pixmap;
GdkBitmap *m_bitmap;
#ifdef __WXGTK20__
GdkPixbuf *m_pixbuf;
#endif
wxMask *m_mask;
int m_width;
int m_height;
@@ -254,9 +242,6 @@ wxBitmapRefData::wxBitmapRefData()
{
m_pixmap = (GdkPixmap *) NULL;
m_bitmap = (GdkBitmap *) NULL;
#ifdef __WXGTK20__
m_pixbuf = (GdkPixbuf *) NULL;
#endif
m_mask = (wxMask *) NULL;
m_width = 0;
m_height = 0;
@@ -270,10 +255,6 @@ wxBitmapRefData::~wxBitmapRefData()
gdk_pixmap_unref( m_pixmap );
if (m_bitmap)
gdk_bitmap_unref( m_bitmap );
#ifdef __WXGTK20__
if (m_pixbuf)
gdk_pixbuf_unref( m_pixbuf );
#endif
delete m_mask;
#if wxUSE_PALETTE
delete m_palette;
@@ -321,14 +302,6 @@ bool wxBitmap::Create( int width, int height, int depth )
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 );
@@ -381,77 +354,124 @@ wxBitmap wxBitmap::Rescale( int clipx, int clipy, int clipwidth, int clipheight,
wxBitmap bmp;
#ifdef __WXGTK20__
if (HasPixbuf())
{
bmp.SetWidth(width);
bmp.SetHeight(height);
bmp.SetDepth(GetDepth());
bmp.SetPixbuf(gdk_pixbuf_new(GDK_COLORSPACE_RGB,
gdk_pixbuf_get_has_alpha(GetPixbuf()),
8, width, height));
gdk_pixbuf_scale(GetPixbuf(), bmp.GetPixbuf(),
0, 0, width, height,
clipx, clipy,
(double)newx/GetWidth(), (double)newy/GetHeight(),
GDK_INTERP_BILINEAR);
}
GdkImage *img = (GdkImage*) NULL;
if (GetPixmap())
img = gdk_image_get( GetPixmap(), 0, 0, GetWidth(), GetHeight() );
else if (GetBitmap())
img = gdk_image_get( GetBitmap(), 0, 0, GetWidth(), GetHeight() );
else
#endif // __WXGTK20__
wxFAIL_MSG( wxT("Ill-formed bitmap") );
wxCHECK_MSG( img, wxNullBitmap, wxT("couldn't create image") );
int bpp = -1;
GdkGC *gc = NULL;
GdkPixmap *dstpix = NULL;
if (GetPixmap())
{
GdkImage *img = (GdkImage*) NULL;
if (GetPixmap())
img = gdk_image_get( GetPixmap(), 0, 0, GetWidth(), GetHeight() );
else if (GetBitmap())
img = gdk_image_get( GetBitmap(), 0, 0, GetWidth(), GetHeight() );
else
wxFAIL_MSG( wxT("Ill-formed bitmap") );
GdkVisual *visual = gdk_window_get_visual( GetPixmap() );
if (visual == NULL)
visual = wxTheApp->GetGdkVisual();
wxCHECK_MSG( img, wxNullBitmap, wxT("couldn't create image") );
bpp = visual->depth;
bmp = wxBitmap(width,height,bpp);
dstpix = bmp.GetPixmap();
gc = gdk_gc_new( dstpix );
}
int bpp = -1;
char *dst = NULL;
long dstbyteperline = 0;
if (GetBitmap())
{
bpp = 1;
dstbyteperline = width/8*M_BMPDATA->m_bpp;
if (width*M_BMPDATA->m_bpp % 8 != 0)
dstbyteperline++;
dst = (char*) malloc(dstbyteperline*height);
}
GdkGC *gc = NULL;
GdkPixmap *dstpix = NULL;
if (GetPixmap())
// 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;
// prepare accel-tables
int *tablex = (int *)calloc(width,sizeof(int));
int *tabley = (int *)calloc(height,sizeof(int));
// accel table filled with clipped values
for (int x = 0; x < width; x++)
tablex[x] = (int) (scx * (x+clipx));
for (int y = 0; y < height; y++)
tabley[y] = (int) (scy * (y+clipy));
// Main rescaling routine starts here
for (int h = 0; h < height; h++)
{
char outbyte = 0;
int old_x = -1;
guint32 old_pixval = 0;
for (int w = 0; w < width; w++)
{
GdkVisual *visual = gdk_window_get_visual( GetPixmap() );
if (visual == NULL)
visual = wxTheApp->GetGdkVisual();
guint32 pixval;
int x = tablex[w];
if (x == old_x)
pixval = old_pixval;
else
{
pixval = gdk_image_get_pixel( img, x, tabley[h] );
old_pixval = pixval;
old_x = x;
}
bpp = visual->depth;
bmp = wxBitmap(width,height,bpp);
dstpix = bmp.GetPixmap();
gc = gdk_gc_new( dstpix );
if (bpp == 1)
{
if (!pixval)
{
char bit=1;
char shift = bit << (w % 8);
outbyte |= shift;
}
if ((w+1)%8==0)
{
dst[h*dstbyteperline+w/8] = outbyte;
outbyte = 0;
}
}
else
{
GdkColor col;
col.pixel = pixval;
gdk_gc_set_foreground( gc, &col );
gdk_draw_point( dstpix, gc, w, h);
}
}
char *dst = NULL;
long dstbyteperline = 0;
// do not forget the last byte
if ((bpp == 1) && (width % 8 != 0))
dst[h*dstbyteperline+width/8] = outbyte;
}
if (GetBitmap())
{
bpp = 1;
dstbyteperline = width/8*M_BMPDATA->m_bpp;
if (width*M_BMPDATA->m_bpp % 8 != 0)
dstbyteperline++;
dst = (char*) malloc(dstbyteperline*height);
}
gdk_image_destroy( img );
if (gc) gdk_gc_unref( gc );
// 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;
// prepare accel-tables
int *tablex = (int *)calloc(width,sizeof(int));
int *tabley = (int *)calloc(height,sizeof(int));
if (bpp == 1)
{
bmp = wxBitmap( (const char *)dst, width, height, 1 );
free( dst );
}
// accel table filled with clipped values
for (int x = 0; x < width; x++)
tablex[x] = (int) (scx * (x+clipx));
for (int y = 0; y < height; y++)
tabley[y] = (int) (scy * (y+clipy));
if (GetMask())
{
dstbyteperline = width/8;
if (width % 8 != 0)
dstbyteperline++;
dst = (char*) malloc(dstbyteperline*height);
img = gdk_image_get( GetMask()->GetBitmap(), 0, 0, GetWidth(), GetHeight() );
// Main rescaling routine starts here
for (int h = 0; h < height; h++)
{
char outbyte = 0;
@@ -471,101 +491,35 @@ wxBitmap wxBitmap::Rescale( int clipx, int clipy, int clipwidth, int clipheight,
old_x = x;
}
if (bpp == 1)
if (pixval)
{
if (!pixval)
{
char bit=1;
char shift = bit << (w % 8);
outbyte |= shift;
}
if ((w+1)%8==0)
{
dst[h*dstbyteperline+w/8] = outbyte;
outbyte = 0;
}
char bit=1;
char shift = bit << (w % 8);
outbyte |= shift;
}
else
if ((w+1)%8 == 0)
{
GdkColor col;
col.pixel = pixval;
gdk_gc_set_foreground( gc, &col );
gdk_draw_point( dstpix, gc, w, h);
dst[h*dstbyteperline+w/8] = outbyte;
outbyte = 0;
}
}
// do not forget the last byte
if ((bpp == 1) && (width % 8 != 0))
if (width % 8 != 0)
dst[h*dstbyteperline+width/8] = outbyte;
}
wxMask* mask = new wxMask;
mask->m_bitmap = gdk_bitmap_create_from_data( wxGetRootWindow()->window, (gchar *) dst, width, height );
bmp.SetMask(mask);
free( dst );
gdk_image_destroy( img );
if (gc) gdk_gc_unref( gc );
if (bpp == 1)
{
bmp = wxBitmap( (const char *)dst, width, height, 1 );
free( dst );
}
if (GetMask())
{
dstbyteperline = width/8;
if (width % 8 != 0)
dstbyteperline++;
dst = (char*) malloc(dstbyteperline*height);
img = gdk_image_get( GetMask()->GetBitmap(), 0, 0, GetWidth(), GetHeight() );
for (int h = 0; h < height; h++)
{
char outbyte = 0;
int old_x = -1;
guint32 old_pixval = 0;
for (int w = 0; w < width; w++)
{
guint32 pixval;
int x = tablex[w];
if (x == old_x)
pixval = old_pixval;
else
{
pixval = gdk_image_get_pixel( img, x, tabley[h] );
old_pixval = pixval;
old_x = x;
}
if (pixval)
{
char bit=1;
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;
}
wxMask* mask = new wxMask;
mask->m_bitmap = gdk_bitmap_create_from_data( wxGetRootWindow()->window, (gchar *) dst, width, height );
bmp.SetMask(mask);
free( dst );
gdk_image_destroy( img );
}
free( tablex );
free( tabley );
}
free( tablex );
free( tabley );
return bmp;
}
@@ -587,10 +541,6 @@ bool wxBitmap::CreateFromImage(const wxImage& image, int depth)
}
else
{
#ifdef __WXGTK20__
if (image.HasAlpha())
return CreateFromImageAsPixbuf(image);
#endif
return CreateFromImageAsPixmap(image);
}
}
@@ -935,51 +885,6 @@ bool wxBitmap::CreateFromImageAsPixmap(const wxImage& img)
return true;
}
#ifdef __WXGTK20__
bool wxBitmap::CreateFromImageAsPixbuf(const wxImage& image)
{
int width = image.GetWidth();
int height = image.GetHeight();
GdkPixbuf *pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
image.HasAlpha(),
8 /* bits per sample */,
width, height);
if (!pixbuf)
return false;
wxASSERT( image.HasAlpha() ); // for now
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)
{
for (int x = 0; x < width; x++, alpha++, out += 4, in += 3)
{
out[0] = in[0];
out[1] = in[1];
out[2] = in[2];
out[3] = *alpha;
}
}
return true;
}
#endif // __WXGTK20__
wxImage wxBitmap::ConvertToImage() const
{
wxImage image;
@@ -995,172 +900,141 @@ wxImage wxBitmap::ConvertToImage() const
return wxNullImage;
}
#ifdef __WXGTK20__
if (HasPixbuf())
// the colour used as transparent one in wxImage and the one it is
// replaced with when it really occurs in the bitmap
static const int MASK_RED = 1;
static const int MASK_GREEN = 2;
static const int MASK_BLUE = 3;
static const int MASK_BLUE_REPLACEMENT = 2;
GdkImage *gdk_image = (GdkImage*) NULL;
if (HasPixmap())
{
GdkPixbuf *pixbuf = GetPixbuf();
wxASSERT( gdk_pixbuf_get_has_alpha(pixbuf) );
int w = GetWidth();
int h = GetHeight();
image.SetAlpha();
unsigned char *alpha = image.GetAlpha();
unsigned char *in = gdk_pixbuf_get_pixels(pixbuf);
unsigned char *out = data;
int rowinc = gdk_pixbuf_get_rowstride(pixbuf) - 4 * w;
for (int y = 0; y < h; y++, in += rowinc)
{
for (int x = 0; x < w; x++, in += 4, out += 3, alpha++)
{
out[0] = in[0];
out[1] = in[1];
out[2] = in[2];
*alpha = in[3];
}
}
gdk_image = gdk_image_get( GetPixmap(),
0, 0,
GetWidth(), GetHeight() );
}
else if (GetBitmap())
{
gdk_image = gdk_image_get( GetBitmap(),
0, 0,
GetWidth(), GetHeight() );
}
else
#endif // __WXGTK20__
{
// the colour used as transparent one in wxImage and the one it is
// replaced with when it really occurs in the bitmap
static const int MASK_RED = 1;
static const int MASK_GREEN = 2;
static const int MASK_BLUE = 3;
static const int MASK_BLUE_REPLACEMENT = 2;
wxFAIL_MSG( wxT("Ill-formed bitmap") );
}
GdkImage *gdk_image = (GdkImage*) NULL;
wxCHECK_MSG( gdk_image, wxNullImage, wxT("couldn't create image") );
if (HasPixmap())
GdkImage *gdk_image_mask = (GdkImage*) NULL;
if (GetMask())
{
gdk_image_mask = gdk_image_get( GetMask()->GetBitmap(),
0, 0,
GetWidth(), GetHeight() );
image.SetMaskColour( MASK_RED, MASK_GREEN, MASK_BLUE );
}
int bpp = -1;
int red_shift_right = 0;
int green_shift_right = 0;
int blue_shift_right = 0;
int red_shift_left = 0;
int green_shift_left = 0;
int blue_shift_left = 0;
bool use_shift = false;
if (GetPixmap())
{
GdkVisual *visual = gdk_window_get_visual( GetPixmap() );
if (visual == NULL)
visual = wxTheApp->GetGdkVisual();
bpp = visual->depth;
if (bpp == 16)
bpp = visual->red_prec + visual->green_prec + visual->blue_prec;
red_shift_right = visual->red_shift;
red_shift_left = 8-visual->red_prec;
green_shift_right = visual->green_shift;
green_shift_left = 8-visual->green_prec;
blue_shift_right = visual->blue_shift;
blue_shift_left = 8-visual->blue_prec;
use_shift = (visual->type == GDK_VISUAL_TRUE_COLOR) || (visual->type == GDK_VISUAL_DIRECT_COLOR);
}
if (GetBitmap())
{
bpp = 1;
}
GdkColormap *cmap = gtk_widget_get_default_colormap();
long pos = 0;
for (int j = 0; j < GetHeight(); j++)
{
for (int i = 0; i < GetWidth(); i++)
{
gdk_image = gdk_image_get( GetPixmap(),
0, 0,
GetWidth(), GetHeight() );
}
else if (GetBitmap())
{
gdk_image = gdk_image_get( GetBitmap(),
0, 0,
GetWidth(), GetHeight() );
}
else
{
wxFAIL_MSG( wxT("Ill-formed bitmap") );
}
wxCHECK_MSG( gdk_image, wxNullImage, wxT("couldn't create image") );
GdkImage *gdk_image_mask = (GdkImage*) NULL;
if (GetMask())
{
gdk_image_mask = gdk_image_get( GetMask()->GetBitmap(),
0, 0,
GetWidth(), GetHeight() );
image.SetMaskColour( MASK_RED, MASK_GREEN, MASK_BLUE );
}
int bpp = -1;
int red_shift_right = 0;
int green_shift_right = 0;
int blue_shift_right = 0;
int red_shift_left = 0;
int green_shift_left = 0;
int blue_shift_left = 0;
bool use_shift = false;
if (GetPixmap())
{
GdkVisual *visual = gdk_window_get_visual( GetPixmap() );
if (visual == NULL)
visual = wxTheApp->GetGdkVisual();
bpp = visual->depth;
if (bpp == 16)
bpp = visual->red_prec + visual->green_prec + visual->blue_prec;
red_shift_right = visual->red_shift;
red_shift_left = 8-visual->red_prec;
green_shift_right = visual->green_shift;
green_shift_left = 8-visual->green_prec;
blue_shift_right = visual->blue_shift;
blue_shift_left = 8-visual->blue_prec;
use_shift = (visual->type == GDK_VISUAL_TRUE_COLOR) || (visual->type == GDK_VISUAL_DIRECT_COLOR);
}
if (GetBitmap())
{
bpp = 1;
}
GdkColormap *cmap = gtk_widget_get_default_colormap();
long pos = 0;
for (int j = 0; j < GetHeight(); j++)
{
for (int i = 0; i < GetWidth(); i++)
wxUint32 pixel = gdk_image_get_pixel( gdk_image, i, j );
if (bpp == 1)
{
wxUint32 pixel = gdk_image_get_pixel( gdk_image, i, j );
if (bpp == 1)
if (pixel == 0)
{
if (pixel == 0)
{
data[pos] = 0;
data[pos+1] = 0;
data[pos+2] = 0;
}
else
{
data[pos] = 255;
data[pos+1] = 255;
data[pos+2] = 255;
}
}
else if (use_shift)
{
data[pos] = (pixel >> red_shift_right) << red_shift_left;
data[pos+1] = (pixel >> green_shift_right) << green_shift_left;
data[pos+2] = (pixel >> blue_shift_right) << blue_shift_left;
}
else if (cmap->colors)
{
data[pos] = cmap->colors[pixel].red >> 8;
data[pos+1] = cmap->colors[pixel].green >> 8;
data[pos+2] = cmap->colors[pixel].blue >> 8;
data[pos] = 0;
data[pos+1] = 0;
data[pos+2] = 0;
}
else
{
wxFAIL_MSG( wxT("Image conversion failed. Unknown visual type.") );
data[pos] = 255;
data[pos+1] = 255;
data[pos+2] = 255;
}
if (gdk_image_mask)
{
int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
if (mask_pixel == 0)
{
data[pos] = MASK_RED;
data[pos+1] = MASK_GREEN;
data[pos+2] = MASK_BLUE;
}
else if ( data[pos] == MASK_RED &&
data[pos+1] == MASK_GREEN &&
data[pos+2] == MASK_BLUE )
{
data[pos+2] = MASK_BLUE_REPLACEMENT;
}
}
pos += 3;
}
}
else if (use_shift)
{
data[pos] = (pixel >> red_shift_right) << red_shift_left;
data[pos+1] = (pixel >> green_shift_right) << green_shift_left;
data[pos+2] = (pixel >> blue_shift_right) << blue_shift_left;
}
else if (cmap->colors)
{
data[pos] = cmap->colors[pixel].red >> 8;
data[pos+1] = cmap->colors[pixel].green >> 8;
data[pos+2] = cmap->colors[pixel].blue >> 8;
}
else
{
wxFAIL_MSG( wxT("Image conversion failed. Unknown visual type.") );
}
gdk_image_destroy( gdk_image );
if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
if (gdk_image_mask)
{
int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
if (mask_pixel == 0)
{
data[pos] = MASK_RED;
data[pos+1] = MASK_GREEN;
data[pos+2] = MASK_BLUE;
}
else if ( data[pos] == MASK_RED &&
data[pos+1] == MASK_GREEN &&
data[pos+2] == MASK_BLUE )
{
data[pos+2] = MASK_BLUE_REPLACEMENT;
}
}
pos += 3;
}
}
gdk_image_destroy( gdk_image );
if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
return image;
}
@@ -1222,12 +1096,7 @@ bool wxBitmap::operator != ( const wxBitmap& bmp ) const
bool wxBitmap::Ok() const
{
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);
}
int wxBitmap::GetHeight() const
@@ -1283,37 +1152,22 @@ wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
wxBitmap ret( rect.width, rect.height, M_BMPDATA->m_bpp );
wxASSERT_MSG( ret.Ok(), wxT("GetSubBitmap error") );
#ifdef __WXGTK20__
if (HasPixbuf())
if (ret.GetPixmap())
{
GdkPixbuf *pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
gdk_pixbuf_get_has_alpha(GetPixbuf()),
8, rect.width, rect.height);
ret.SetPixbuf(pixbuf);
gdk_pixbuf_copy_area(GetPixbuf(),
rect.x, rect.y, rect.width, rect.height,
pixbuf, 0, 0);
GdkGC *gc = gdk_gc_new( ret.GetPixmap() );
gdk_draw_pixmap( ret.GetPixmap(), gc, GetPixmap(), rect.x, rect.y, 0, 0, rect.width, rect.height );
gdk_gc_destroy( gc );
}
else
#endif // __WXGTK20__
{
if (ret.GetPixmap())
{
GdkGC *gc = gdk_gc_new( ret.GetPixmap() );
gdk_draw_pixmap( ret.GetPixmap(), gc, GetPixmap(), rect.x, rect.y, 0, 0, rect.width, rect.height );
gdk_gc_destroy( gc );
}
else
{
GdkGC *gc = gdk_gc_new( ret.GetBitmap() );
GdkColor col;
col.pixel = 0xFFFFFF;
gdk_gc_set_foreground( gc, &col );
col.pixel = 0;
gdk_gc_set_background( gc, &col );
gdk_wx_draw_bitmap( ret.GetBitmap(), gc, GetBitmap(), rect.x, rect.y, 0, 0, rect.width, rect.height );
gdk_gc_destroy( gc );
}
GdkGC *gc = gdk_gc_new( ret.GetBitmap() );
GdkColor col;
col.pixel = 0xFFFFFF;
gdk_gc_set_foreground( gc, &col );
col.pixel = 0;
gdk_gc_set_background( gc, &col );
gdk_wx_draw_bitmap( ret.GetBitmap(), gc, GetBitmap(), rect.x, rect.y, 0, 0, rect.width, rect.height );
gdk_gc_destroy( gc );
}
if (GetMask())
@@ -1439,9 +1293,6 @@ void wxBitmap::SetPixmap( GdkPixmap *pixmap )
m_refData = new wxBitmapRefData();
M_BMPDATA->m_pixmap = pixmap;
#ifdef __WXGTK20__
PurgeOtherRepresentations(Pixmap);
#endif
}
void wxBitmap::SetBitmap( GdkPixmap *bitmap )
@@ -1450,28 +1301,12 @@ void wxBitmap::SetBitmap( GdkPixmap *bitmap )
m_refData = new wxBitmapRefData();
M_BMPDATA->m_bitmap = bitmap;
#ifdef __WXGTK20__
PurgeOtherRepresentations(Pixmap);
#endif
}
GdkPixmap *wxBitmap::GetPixmap() const
{
wxCHECK_MSG( Ok(), (GdkPixmap *) NULL, wxT("invalid bitmap") );
#ifdef __WXGTK20__
// create the pixmap on the fly if we use Pixbuf representation:
if (HasPixbuf() && !HasPixmap())
{
delete M_BMPDATA->m_mask;
M_BMPDATA->m_mask = new wxMask();
gdk_pixbuf_render_pixmap_and_mask(M_BMPDATA->m_pixbuf,
&M_BMPDATA->m_pixmap,
&M_BMPDATA->m_mask->m_bitmap,
128 /*threshold*/);
}
#endif // __WXGTK20__
return M_BMPDATA->m_pixmap;
}
@@ -1489,113 +1324,9 @@ GdkBitmap *wxBitmap::GetBitmap() const
return M_BMPDATA->m_bitmap;
}
#ifdef __WXGTK20__
GdkPixbuf *wxBitmap::GetPixbuf() const
{
wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
if (HasPixmap() && !HasPixbuf())
{
int width = GetWidth();
int height = GetHeight();
GdkPixbuf *pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
GetMask() != NULL,
8, width, height);
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 =
gdk_pixbuf_get_from_drawable(NULL,
M_BMPDATA->m_mask->GetBitmap(),
NULL,
0, 0, 0, 0, width, height);
if (pmask)
{
guchar *bmp = gdk_pixbuf_get_pixels(pixbuf);
guchar *mask = gdk_pixbuf_get_pixels(pmask);
int bmprowinc = gdk_pixbuf_get_rowstride(pixbuf) - 4 * width;
int maskrowinc = gdk_pixbuf_get_rowstride(pmask) - 3 * width;
for (int y = 0; y < height;
y++, bmp += bmprowinc, mask += maskrowinc)
{
for (int x = 0; x < width; x++, bmp += 4, mask += 3)
{
if (mask[0] == 0 /*black pixel*/)
bmp[3] = 0;
}
}
gdk_pixbuf_unref(pmask);
}
}
}
return M_BMPDATA->m_pixbuf;
}
bool wxBitmap::HasPixbuf() const
{
wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
return M_BMPDATA->m_pixbuf != NULL;
}
void wxBitmap::SetPixbuf( GdkPixbuf *pixbuf )
{
if (!m_refData)
m_refData = new wxBitmapRefData();
M_BMPDATA->m_pixbuf = pixbuf;
PurgeOtherRepresentations(Pixbuf);
}
void wxBitmap::PurgeOtherRepresentations(wxBitmap::Representation keep)
{
if (keep == Pixmap && HasPixbuf())
{
gdk_pixbuf_unref( M_BMPDATA->m_pixbuf );
M_BMPDATA->m_pixbuf = NULL;
}
if (keep == Pixbuf && HasPixmap())
{
gdk_pixmap_unref( M_BMPDATA->m_pixmap );
M_BMPDATA->m_pixmap = NULL;
}
}
#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& WXUNUSED(data))
@@ -1605,18 +1336,11 @@ void wxBitmap::UngetRawData(wxPixelDataBase& WXUNUSED(data))
bool wxBitmap::HasAlpha() const
{
#ifdef __WXGTK20__
return HasPixbuf();
#else
return false;
#endif
}
void wxBitmap::UseAlpha()
{
#ifdef __WXGTK20__
GetPixbuf();
#endif
}
//-----------------------------------------------------------------------------