void wxQtDCImpl::DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
bool useMask )
{
QPixmap pix = *bmp.GetHandle();
if (pix.depth() == 1) {
//Monochrome bitmap, draw using text fore/background
//Save pen/brush
QBrush savedBrush = m_qtPainter->background();
QPen savedPen = m_qtPainter->pen();
//Use text colors
m_qtPainter->setBackground(QBrush(m_textBackgroundColour.GetQColor()));
m_qtPainter->setPen(QPen(m_textForegroundColour.GetQColor()));
//Draw
m_qtPainter->drawPixmap(x, y, pix);
//Restore saved settings
m_qtPainter->setBackground(savedBrush);
m_qtPainter->setPen(savedPen);
}
else
{
if ( useMask && bmp.GetMask() && bmp.GetMask()->GetHandle() )
pix.setMask(*bmp.GetMask()->GetHandle());
m_qtPainter->drawPixmap(x, y, pix);
}
}
void SetPixmap(const wxBitmap& bitmap)
{
if (bitmap.Ok())
{
GdkBitmap *mask = bitmap.GetMask() ? bitmap.GetMask()->GetBitmap()
: (GdkBitmap *)NULL;
gtk_pixmap_set( GTK_PIXMAP(m_pixmap), bitmap.GetPixmap(), mask );
}
}
// Create a drag image from a bitmap and optional cursor
bool wxDragImage::Create(const wxBitmap& image, const wxCursor& cursor)
{
if ( m_hImageList )
ImageList_Destroy(GetHimageList());
m_hImageList = 0;
#ifdef __WXWINCE__
UINT flags = ILC_COLOR;
#else
UINT flags wxDUMMY_INITIALIZE(0) ;
if (image.GetDepth() <= 4)
flags = ILC_COLOR4;
else if (image.GetDepth() <= 8)
flags = ILC_COLOR8;
else if (image.GetDepth() <= 16)
flags = ILC_COLOR16;
else if (image.GetDepth() <= 24)
flags = ILC_COLOR24;
else
flags = ILC_COLOR32;
#endif
bool mask = (image.GetMask() != 0);
// Curiously, even if the image doesn't have a mask,
// we still have to use ILC_MASK or the image won't show
// up when dragged.
// if ( mask )
flags |= ILC_MASK;
m_hImageList = (WXHIMAGELIST) ImageList_Create(image.GetWidth(), image.GetHeight(), flags, 1, 1);
int index;
if (!mask)
{
HBITMAP hBitmap1 = (HBITMAP) image.GetHBITMAP();
index = ImageList_Add(GetHimageList(), hBitmap1, 0);
}
else
{
HBITMAP hBitmap1 = (HBITMAP) image.GetHBITMAP();
HBITMAP hBitmap2 = (HBITMAP) image.GetMask()->GetMaskBitmap();
HBITMAP hbmpMask = wxInvertMask(hBitmap2);
index = ImageList_Add(GetHimageList(), hBitmap1, hbmpMask);
::DeleteObject(hbmpMask);
}
if ( index == -1 )
{
wxLogError(_("Couldn't add an image to the image list."));
}
m_cursor = cursor; // Can only combine with drag image after calling BeginDrag.
return (index != -1) ;
}
void wxGCDCImpl::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y,
bool useMask )
{
wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawBitmap - invalid DC") );
wxCHECK_RET( bmp.IsOk(), wxT("wxGCDC(cg)::DoDrawBitmap - invalid bitmap") );
int w = bmp.GetScaledWidth();
int h = bmp.GetScaledHeight();
if ( bmp.GetDepth() == 1 )
{
m_graphicContext->SetPen(*wxTRANSPARENT_PEN);
m_graphicContext->SetBrush(m_textBackgroundColour);
m_graphicContext->DrawRectangle( x, y, w, h );
m_graphicContext->SetBrush(m_textForegroundColour);
m_graphicContext->DrawBitmap( bmp, x, y, w, h );
m_graphicContext->SetBrush( m_graphicContext->CreateBrush(m_brush));
m_graphicContext->SetPen( m_graphicContext->CreatePen(m_pen));
}
else // not a monochrome bitmap, handle it normally
{
// make a copy in case we need to remove its mask, if we don't modify
// it the copy is cheap as bitmaps are reference-counted
wxBitmap bmpCopy(bmp);
if ( !useMask && bmp.GetMask() )
bmpCopy.SetMask(NULL);
m_graphicContext->DrawBitmap( bmpCopy, x, y, w, h );
}
CalcBoundingBox(x, y);
CalcBoundingBox(x + w, y + h);
}
void wxGenericBrush::SetStipple(const wxBitmap& stipple)
{
wxCHECK_RET(Ok(), wxT("Invalid generic brush"));
M_GBRUSHDATA->m_stipple = stipple;
M_GBRUSHDATA->m_style = stipple.GetMask() ? wxSTIPPLE_MASK_OPAQUE : wxSTIPPLE;
}
void wxMemoryDC::SelectObject( const wxBitmap& bitmap )
{
if ( m_selected.Ok() )
{
UnlockPixels( GetGWorldPixMap(MAC_WXHBITMAP(m_selected.GetHBITMAP())) );
}
m_selected = bitmap;
if (m_selected.Ok())
{
if ( m_selected.GetHBITMAP() )
{
m_macPort = (GrafPtr) m_selected.GetHBITMAP() ;
LockPixels( GetGWorldPixMap( (CGrafPtr) m_macPort ) ) ;
wxMask * mask = bitmap.GetMask() ;
if ( mask )
{
m_macMask = mask->GetMaskBitmap() ;
}
SetRectRgn( (RgnHandle) m_macBoundaryClipRgn , 0 , 0 , m_selected.GetWidth() , m_selected.GetHeight() ) ;
CopyRgn( (RgnHandle) m_macBoundaryClipRgn ,(RgnHandle) m_macCurrentClipRgn ) ;
m_ok = TRUE ;
}
else
{
m_ok = FALSE;
}
}
else
{
m_ok = FALSE;
}
}
void wxDC::DoDrawSubBitmap(const wxBitmap &bmp,
wxCoord x, wxCoord y, wxCoord w, wxCoord h,
wxCoord destx, wxCoord desty, int rop, bool useMask)
{
wxCHECK_RET( Ok(), wxT("invalid dc") );
wxCHECK_RET( bmp.Ok(), wxT("invalid bitmap") );
// NB: we could also support XOR here (via DSBLIT_XOR)
// and possibly others via SetSrc/DstBlendFunction()
wxCHECK_RET( rop == wxCOPY, _T("only wxCOPY function supported") );
if ( bmp.GetDepth() == 1 )
{
// Mono bitmaps are handled in special way -- all 1s are drawn in
// foreground colours, all 0s in background colour.
wxFAIL_MSG( _T("drawing mono bitmaps not implemented") );
return;
}
if ( useMask && bmp.GetMask() )
{
// FIXME_DFB: see MGL sources for a way to do it, but it's not directly
// applicable because DirectFB doesn't implement ROPs; OTOH,
// it has blitting modes that can be useful; finally, see
// DFB's SetSrcBlendFunction() and SetSrcColorKey()
wxFAIL_MSG( _T("drawing bitmaps with masks not implemented") );
return;
}
DoBlitFromSurface(bmp.GetDirectFBSurface(),
x, y,
w, h,
destx, desty);
}
wxBrush::wxBrush( const wxBitmap &stippleBitmap )
{
wxBrushStyle style = wxBRUSHSTYLE_STIPPLE;
if (stippleBitmap.GetMask())
style = wxBRUSHSTYLE_STIPPLE_MASK_OPAQUE;
m_refData = new wxBrushRefData(*wxBLACK, style);
M_BRUSHDATA->m_stipple = stippleBitmap;
}
void wxGenericBrush::Create( const wxBitmap &stipple )
{
UnRef();
wxCHECK_RET(stipple.Ok(), wxT("Invalid bitmap in wxGenericBrush::Create"));
int style = stipple.GetMask() ? wxSTIPPLE_MASK_OPAQUE : wxSTIPPLE;
m_refData = new wxGenericBrushRefData(wxNullGenericColour, style);
M_GBRUSHDATA->m_stipple = stipple;
}
void wxBitmapToPixPattern(const wxBitmap& bitmap,
pixpattern24_t *pix, pattern_t *mask)
{
wxMemoryDC mem;
MGLDevCtx *dc;
int x, y;
if ( pix != NULL )
{
mem.SelectObjectAsSource(bitmap);
dc = mem.GetMGLDC();
wxCurrentDCSwitcher curDC(dc);
dc->beginPixel();
for (y = 0; y < 8; y++)
for (x = 0; x < 8; x++)
dc->unpackColorFast(dc->getPixelFast(x, y),
pix->p[y][x][2],
pix->p[y][x][1],
pix->p[y][x][0]);
dc->endPixel();
}
if ( mask && bitmap.GetMask() )
{
mem.SelectObjectAsSource(bitmap.GetMask()->GetBitmap());
dc = mem.GetMGLDC();
wxCurrentDCSwitcher curDC(dc);
dc->beginPixel();
for (y = 0; y < 8; y++)
{
mask->p[y] = 0;
for (x = 0; x < 8; x++)
if ( dc->getPixelFast(x, y) != 0 )
mask->p[y] = (uchar)(mask->p[y] | (1 << (7 - x)));
}
dc->endPixel();
}
}
bool wxRegion::Union(const wxBitmap& bmp)
{
if (bmp.GetMask())
{
wxImage image = bmp.ConvertToImage();
wxASSERT_MSG( image.HasMask(), _T("wxBitmap::ConvertToImage doesn't preserve mask?") );
return DoRegionUnion(*this, image,
image.GetMaskRed(),
image.GetMaskGreen(),
image.GetMaskBlue(),
0);
}
else
{
return Union(0, 0, bmp.GetWidth(), bmp.GetHeight());
}
}
static HBITMAP GetMaskForImage(const wxBitmap& bitmap, const wxBitmap& mask)
{
#if wxUSE_IMAGE
wxBitmap bitmapWithMask;
#endif // wxUSE_IMAGE
HBITMAP hbmpMask;
wxMask *pMask;
bool deleteMask = false;
if ( mask.IsOk() )
{
hbmpMask = GetHbitmapOf(mask);
pMask = NULL;
}
else
{
pMask = bitmap.GetMask();
#if wxUSE_IMAGE
// check if we don't have alpha in this bitmap -- we can create a mask
// from it (and we need to do it for the older systems which don't
// support 32bpp bitmaps natively)
if ( !pMask )
{
wxImage img(bitmap.ConvertToImage());
if ( img.HasAlpha() )
{
img.ConvertAlphaToMask();
bitmapWithMask = wxBitmap(img);
pMask = bitmapWithMask.GetMask();
}
}
#endif // wxUSE_IMAGE
if ( !pMask )
{
// use the light grey count as transparent: the trouble here is
// that the light grey might have been changed by Windows behind
// our back, so use the standard colour map to get its real value
wxCOLORMAP *cmap = wxGetStdColourMap();
wxColour col;
wxRGBToColour(col, cmap[wxSTD_COL_BTNFACE].from);
pMask = new wxMask(bitmap, col);
deleteMask = true;
}
hbmpMask = (HBITMAP)pMask->GetMaskBitmap();
}
// windows mask convention is opposite to the wxWidgets one
HBITMAP hbmpMaskInv = wxInvertMask(hbmpMask);
if ( deleteMask )
{
delete pMask;
}
return hbmpMaskInv;
}
void wxIcon::CopyFromBitmap(
const wxBitmap& rBmp
)
{
wxMask* pMask = rBmp.GetMask();
HBITMAP hBmp = NULLHANDLE;
HBITMAP hBmpMask = NULLHANDLE;
HBITMAP hOldBitmap = NULLHANDLE;
ERRORID vError;
wxString sError;
LONG lHits;
if (!pMask)
{
//
// We must have a mask for an icon, so even if it's probably incorrect,
// do create it (grey is the "standard" transparent colour)
//
pMask = new wxMask( rBmp
,*wxLIGHT_GREY
);
}
BITMAPINFOHEADER2 vHeader;
SIZEL vSize = {0, 0};
DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
HDC hDCSrc = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
HDC hDCDst = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
HPS hPSSrc = ::GpiCreatePS(vHabmain, hDCSrc, &vSize, PU_PELS | GPIA_ASSOC);
HPS hPSDst = ::GpiCreatePS(vHabmain, hDCDst, &vSize, PU_PELS | GPIA_ASSOC);
POINTL vPoint[4] = { {0, 0}, {rBmp.GetWidth(), rBmp.GetHeight()},
{0, 0}, {rBmp.GetWidth(), rBmp.GetHeight()}
};
POINTL vPointMask[4] = { {0, 0}, {rBmp.GetWidth(), rBmp.GetHeight() * 2},
{0, 0}, {rBmp.GetWidth(), rBmp.GetHeight()}
};
POINTERINFO vIconInfo;
memset(&vIconInfo, '\0', sizeof(POINTERINFO));
vIconInfo.fPointer = FALSE; // we want an icon, not a pointer
memset(&vHeader, '\0', 16);
vHeader.cbFix = 16;
vHeader.cx = (ULONG)rBmp.GetWidth();
vHeader.cy = (ULONG)rBmp.GetHeight();
vHeader.cPlanes = 1L;
vHeader.cBitCount = 24;
hBmp = ::GpiCreateBitmap( hPSDst
,&vHeader
,0L
,NULL
,NULL
);
if ((hOldBitmap = ::GpiSetBitmap(hPSDst, hBmp)) == HBM_ERROR)
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
}
if ((hOldBitmap = ::GpiSetBitmap(hPSSrc, (HBITMAP)rBmp.GetHBITMAP())) == HBM_ERROR)
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
}
if ((lHits = ::GpiBitBlt( hPSDst
,hPSSrc
,4L
,vPoint
,ROP_SRCCOPY
,BBO_IGNORE
)) == GPI_ERROR)
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
}
if ((hOldBitmap = ::GpiSetBitmap(hPSDst, NULLHANDLE)) == HBM_ERROR)
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
}
if ((hOldBitmap = ::GpiSetBitmap(hPSSrc, NULLHANDLE)) == HBM_ERROR)
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
}
vIconInfo.hbmColor = hBmp;
vHeader.cy = (ULONG)rBmp.GetHeight() * 2;
hBmpMask = ::GpiCreateBitmap( hPSDst
,&vHeader
,0L
,NULL
,NULL
);
if ((hOldBitmap = ::GpiSetBitmap(hPSDst, hBmpMask)) == HBM_ERROR)
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
}
if ((hOldBitmap = ::GpiSetBitmap(hPSSrc, (HBITMAP)pMask->GetMaskBitmap())) == HBM_ERROR)
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
}
if ((lHits = ::GpiBitBlt( hPSDst
,hPSSrc
,4L
,vPointMask
,ROP_SRCCOPY
,BBO_IGNORE
)) == GPI_ERROR)
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
}
if ((hOldBitmap = ::GpiSetBitmap(hPSSrc, NULLHANDLE)) == HBM_ERROR)
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
}
if ((hOldBitmap = ::GpiSetBitmap(hPSDst, NULLHANDLE)) == HBM_ERROR)
{
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
}
vIconInfo.hbmPointer = hBmpMask;
HICON hIcon = ::WinCreatePointerIndirect( HWND_DESKTOP
,&vIconInfo
);
if (!hIcon)
{
wxLogLastError(wxT("WinCreatePointerIndirect"));
vError = ::WinGetLastError(vHabmain);
sError = wxPMErrorToStr(vError);
}
else
{
SetHICON((WXHICON)hIcon);
SetSize( rBmp.GetWidth()
,rBmp.GetHeight()
);
}
if (!rBmp.GetMask())
{
//
// We created the mask, now delete it
//
delete pMask;
}
::GpiSetBitmap(hPSSrc, NULL);
::GpiSetBitmap(hPSDst, NULL);
::GpiDestroyPS(hPSSrc);
::GpiDestroyPS(hPSDst);
::DevCloseDC(hDCSrc);
::DevCloseDC(hDCDst);
} // end of wxIcon::CopyFromBitmap
