// wxMask
//-----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxMask,wxObject)
+IMPLEMENT_DYNAMIC_CLASS(wxMask, wxMaskBase)
wxMask::wxMask()
{
- m_bitmap = (GdkBitmap *) NULL;
+ m_bitmap = NULL;
}
wxMask::wxMask( const wxBitmap& bitmap, const wxColour& colour )
{
- m_bitmap = (GdkBitmap *) NULL;
- Create( bitmap, colour );
+ m_bitmap = NULL;
+ InitFromColour(bitmap, colour);
}
#if wxUSE_PALETTE
wxMask::wxMask( const wxBitmap& bitmap, int paletteIndex )
{
- m_bitmap = (GdkBitmap *) NULL;
+ m_bitmap = NULL;
Create( bitmap, paletteIndex );
}
#endif // wxUSE_PALETTE
wxMask::wxMask( const wxBitmap& bitmap )
{
- m_bitmap = (GdkBitmap *) NULL;
- Create( bitmap );
+ m_bitmap = NULL;
+ InitFromMonoBitmap(bitmap);
}
wxMask::~wxMask()
g_object_unref (m_bitmap);
}
-bool wxMask::Create( const wxBitmap& bitmap,
- const wxColour& colour )
+void wxMask::FreeData()
{
if (m_bitmap)
{
g_object_unref (m_bitmap);
- m_bitmap = (GdkBitmap*) NULL;
+ m_bitmap = NULL;
}
+}
+bool wxMask::InitFromColour(const wxBitmap& bitmap, const wxColour& colour)
+{
const int w = bitmap.GetWidth();
const int h = bitmap.GetHeight();
return true;
}
-#if wxUSE_PALETTE
-bool wxMask::Create( const wxBitmap& bitmap, int paletteIndex )
+bool wxMask::InitFromMonoBitmap(const wxBitmap& bitmap)
{
- unsigned char r,g,b;
- wxPalette *pal = bitmap.GetPalette();
-
- wxCHECK_MSG( pal, false, wxT("Cannot create mask from bitmap without palette") );
-
- pal->GetRGB(paletteIndex, &r, &g, &b);
-
- return Create(bitmap, wxColour(r, g, b));
-}
-#endif // wxUSE_PALETTE
-
-bool wxMask::Create( const wxBitmap& bitmap )
-{
- if (m_bitmap)
- {
- g_object_unref (m_bitmap);
- m_bitmap = (GdkBitmap*) NULL;
- }
-
- if (!bitmap.Ok()) return false;
+ if (!bitmap.IsOk()) return false;
wxCHECK_MSG( bitmap.GetDepth() == 1, false, wxT("Cannot create mask from colour bitmap") );
}
//-----------------------------------------------------------------------------
-// wxBitmap
+// wxBitmapRefData
//-----------------------------------------------------------------------------
class wxBitmapRefData: public wxGDIRefData
wxBitmapRefData::wxBitmapRefData()
{
- m_pixmap = (GdkPixmap *) NULL;
- m_pixbuf = (GdkPixbuf *) NULL;
- m_mask = (wxMask *) NULL;
+ m_pixmap = NULL;
+ m_pixbuf = NULL;
+ m_mask = NULL;
m_width = 0;
m_height = 0;
m_bpp = 0;
#if wxUSE_PALETTE
- m_palette = (wxPalette *) NULL;
+ m_palette = NULL;
#endif // wxUSE_PALETTE
}
#endif // wxUSE_PALETTE
}
+
+//-----------------------------------------------------------------------------
+// wxBitmap
//-----------------------------------------------------------------------------
#define M_BMPDATA static_cast<wxBitmapRefData*>(m_refData)
IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxGDIObject)
-wxBitmap::wxBitmap(int width, int height, int depth)
-{
- Create(width, height, depth);
-}
-
wxBitmap::wxBitmap(const wxString &filename, wxBitmapType type)
{
LoadFile(filename, type);
if (width > 0 && height > 0 && depth == 1)
{
SetPixmap(gdk_bitmap_create_from_data(wxGetRootWindow()->window, bits, width, height));
-
- wxASSERT_MSG( M_BMPDATA->m_pixmap, wxT("couldn't create bitmap") );
}
}
GdkBitmap* mask = NULL;
SetPixmap(gdk_pixmap_create_from_xpm_d(wxGetRootWindow()->window, &mask, NULL, const_cast<char**>(bits)));
+ if (!M_BMPDATA)
+ return;
if (M_BMPDATA->m_pixmap != NULL && mask != NULL)
{
}
const GdkVisual* visual = wxTheApp->GetGdkVisual();
-
+
if (depth == 32)
{
SetPixbuf(gdk_pixbuf_new(GDK_COLORSPACE_RGB, true, 8, width, height), 32);
- } else
- if (depth == 24)
+
+ if (!M_BMPDATA)
+ return false;
+
+ // must initialize alpha, otherwise GetPixmap()
+ // will create a mask out of garbage
+ gdk_pixbuf_fill(M_BMPDATA->m_pixbuf, 0x000000ff);
+ }
+ else if (depth == 24)
{
if (visual->depth == depth)
SetPixmap(gdk_pixmap_new(wxGetRootWindow()->window, width, height, depth));
SetPixmap(gdk_pixmap_new(wxGetRootWindow()->window, width, height, depth));
}
- return Ok();
-}
-
-wxBitmap wxBitmap::Rescale(int clipx, int clipy, int clipwidth, int clipheight,
- int width, int height) const
-{
- wxBitmap bmp;
-
- wxCHECK_MSG(Ok(), bmp, wxT("invalid bitmap"));
-
- width = wxMax(width, 1);
- height = wxMax(height, 1);
-
- const double scale_x = double(width) / clipwidth;
- const double scale_y = double(height) / clipheight;
-
- // Converting to pixbuf, scaling with gdk_pixbuf_scale, and converting
- // back, is faster than scaling pixmap ourselves.
-
- // use pixbuf if already available,
- // otherwise create temporary pixbuf from pixmap
- GdkPixbuf* pixbuf = M_BMPDATA->m_pixbuf;
- if (pixbuf)
- g_object_ref(pixbuf);
- else
- pixbuf = gdk_pixbuf_get_from_drawable(
- NULL, M_BMPDATA->m_pixmap, NULL,
- 0, 0, 0, 0, M_BMPDATA->m_width, M_BMPDATA->m_height);
-
- // new pixbuf for scaled wxBitmap
- GdkPixbuf* pixbuf_scaled = gdk_pixbuf_new(
- GDK_COLORSPACE_RGB, gdk_pixbuf_get_has_alpha(pixbuf), 8, width, height);
-
- // GDK_INTERP_NEAREST is the lowest-quality method for continuous-tone
- // images, but the only one which preserves sharp edges
- gdk_pixbuf_scale(
- pixbuf, pixbuf_scaled,
- 0, 0, width, height, -clipx*scale_x, -clipy*scale_y, scale_x, scale_y,
- GDK_INTERP_NEAREST);
-
- g_object_unref(pixbuf);
- bmp.SetPixbuf(pixbuf_scaled, M_BMPDATA->m_bpp);
-
- if (M_BMPDATA->m_mask)
- {
- pixbuf = gdk_pixbuf_get_from_drawable(
- NULL, M_BMPDATA->m_mask->m_bitmap, NULL,
- 0, 0, 0, 0, M_BMPDATA->m_width, M_BMPDATA->m_height);
-
- pixbuf_scaled = gdk_pixbuf_new(
- GDK_COLORSPACE_RGB, false, 8, width, height);
-
- gdk_pixbuf_scale(
- pixbuf, pixbuf_scaled,
- 0, 0, width, height, -clipx, -clipy, scale_x, scale_y,
- GDK_INTERP_NEAREST);
-
- g_object_unref(pixbuf);
-
- // use existing functionality to create mask from scaled pixbuf
- wxBitmap maskbmp;
- maskbmp.SetPixbuf(pixbuf_scaled);
- bmp.SetMask(new wxMask(maskbmp, *wxBLACK));
- }
- return bmp;
+ return IsOk();
}
#if wxUSE_IMAGE
{
UnRef();
- wxCHECK_MSG( image.Ok(), false, wxT("invalid image") );
+ wxCHECK_MSG( image.IsOk(), false, wxT("invalid image") );
wxCHECK_MSG( depth == -1 || depth == 1, false, wxT("invalid bitmap depth") );
if (image.GetWidth() <= 0 || image.GetHeight() <= 0)
}
SetPixmap(gdk_bitmap_create_from_data(wxGetRootWindow()->window, (char*)out, w, h));
delete[] out;
+
+ if (!M_BMPDATA) // SetPixmap may have failed
+ return false;
}
else
{
SetPixmap(gdk_pixmap_new(wxGetRootWindow()->window, w, h, depth));
+ if (!M_BMPDATA)
+ return false;
+
wxGtkObject<GdkGC> gc(gdk_gc_new(M_BMPDATA->m_pixmap));
gdk_draw_rgb_image(
M_BMPDATA->m_pixmap, gc,
SetMask(mask);
delete[] out;
}
- return true;
+ return IsOk();
}
bool wxBitmap::CreateFromImageAsPixbuf(const wxImage& image)
wxImage wxBitmap::ConvertToImage() const
{
- wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
+ wxCHECK_MSG( IsOk(), wxNullImage, wxT("invalid bitmap") );
const int w = GetWidth();
const int h = GetHeight();
int wxBitmap::GetHeight() const
{
- wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
+ wxCHECK_MSG( IsOk(), -1, wxT("invalid bitmap") );
return M_BMPDATA->m_height;
}
int wxBitmap::GetWidth() const
{
- wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
+ wxCHECK_MSG( IsOk(), -1, wxT("invalid bitmap") );
return M_BMPDATA->m_width;
}
int wxBitmap::GetDepth() const
{
- wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
+ wxCHECK_MSG( IsOk(), -1, wxT("invalid bitmap") );
return M_BMPDATA->m_bpp;
}
wxMask *wxBitmap::GetMask() const
{
- wxCHECK_MSG( Ok(), (wxMask *) NULL, wxT("invalid bitmap") );
+ wxCHECK_MSG( IsOk(), NULL, wxT("invalid bitmap") );
return M_BMPDATA->m_mask;
}
void wxBitmap::SetMask( wxMask *mask )
{
- wxCHECK_RET( Ok(), wxT("invalid bitmap") );
+ wxCHECK_RET( IsOk(), wxT("invalid bitmap") );
AllocExclusive();
delete M_BMPDATA->m_mask;
bool wxBitmap::CopyFromIcon(const wxIcon& icon)
{
*this = icon;
- return Ok();
+ return IsOk();
}
wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
{
wxBitmap ret;
- wxCHECK_MSG(Ok(), ret, wxT("invalid bitmap"));
+ wxCHECK_MSG(IsOk(), ret, wxT("invalid bitmap"));
wxCHECK_MSG(rect.x >= 0 && rect.y >= 0 &&
rect.x + rect.width <= M_BMPDATA->m_width &&
rect.y + rect.height <= M_BMPDATA->m_height,
GdkPixbuf *pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
gdk_pixbuf_get_has_alpha(GetPixbuf()),
8, rect.width, rect.height);
+ if (!pixbuf)
+ return ret;
+
ret.SetPixbuf(pixbuf, M_BMPDATA->m_bpp);
gdk_pixbuf_copy_area(GetPixbuf(),
rect.x, rect.y, rect.width, rect.height,
bool wxBitmap::SaveFile( const wxString &name, wxBitmapType type, const wxPalette *WXUNUSED(palette) ) const
{
- wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
+ wxCHECK_MSG( IsOk(), false, wxT("invalid bitmap") );
#if wxUSE_IMAGE
// Try to save the bitmap via wxImage handlers:
if (type == wxBITMAP_TYPE_XPM)
{
- GdkBitmap *mask = (GdkBitmap*) NULL;
+ GdkBitmap *mask = NULL;
SetPixmap(gdk_pixmap_create_from_xpm(wxGetRootWindow()->window, &mask, NULL, name.fn_str()));
+ if (!M_BMPDATA)
+ return false; // do not set the mask
if (mask)
{
}
#endif // wxUSE_IMAGE
- return Ok();
+ return IsOk();
}
#if wxUSE_PALETTE
wxPalette *wxBitmap::GetPalette() const
{
- wxCHECK_MSG(Ok(), NULL, wxT("invalid bitmap"));
+ wxCHECK_MSG(IsOk(), NULL, wxT("invalid bitmap"));
return M_BMPDATA->m_palette;
}
void wxBitmap::SetPixmap( GdkPixmap *pixmap )
{
+ if (!pixmap)
+ return;
+
if (!m_refData)
m_refData = new wxBitmapRefData;
GdkPixmap *wxBitmap::GetPixmap() const
{
- wxCHECK_MSG( Ok(), (GdkPixmap *) NULL, wxT("invalid bitmap") );
+ wxCHECK_MSG( IsOk(), NULL, wxT("invalid bitmap") );
// create the pixmap on the fly if we use Pixbuf representation:
if (M_BMPDATA->m_pixmap == NULL)
bool wxBitmap::HasPixmap() const
{
- wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
+ wxCHECK_MSG( IsOk(), false, wxT("invalid bitmap") );
return M_BMPDATA->m_pixmap != NULL;
}
GdkPixbuf *wxBitmap::GetPixbuf() const
{
- wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
+ wxCHECK_MSG( IsOk(), NULL, wxT("invalid bitmap") );
if (M_BMPDATA->m_pixbuf == NULL)
{
-
+
int width = GetWidth();
int height = GetHeight();
bool wxBitmap::HasPixbuf() const
{
- wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
+ wxCHECK_MSG( IsOk(), false, wxT("invalid bitmap") );
return M_BMPDATA->m_pixbuf != NULL;
}
void wxBitmap::SetPixbuf(GdkPixbuf* pixbuf, int depth)
{
+ if (!pixbuf)
+ return;
+
if (!m_refData)
m_refData = new wxBitmapRefData;
}
}
+#ifdef wxHAS_RAW_BITMAP
void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
{
void* bits = NULL;
GdkPixbuf *pixbuf = GetPixbuf();
const bool hasAlpha = HasAlpha();
-
+
// allow access if bpp is valid and matches existence of alpha
if ( pixbuf && ((bpp == 24 && !hasAlpha) || (bpp == 32 && hasAlpha)) )
{
void wxBitmap::UngetRawData(wxPixelDataBase& WXUNUSED(data))
{
}
+#endif // wxHAS_RAW_BITMAP
bool wxBitmap::HasAlpha() const
{
projects / wxWidgets.git / blobdiff