#include "wx/icon.h"
#endif
+#include "wx/msw/private.h" // needs to be before #include <commdlg.h>
+
#include "wx/sysopt.h"
#include "wx/dcprint.h"
#include "wx/module.h"
#include "wx/dynload.h"
+
+#ifdef wxHAVE_RAW_BITMAP
#include "wx/rawbmp.h"
+#endif
#include <string.h>
#include <math.h>
-#include "wx/msw/private.h" // needs to be before #include <commdlg.h>
-
#if wxUSE_COMMON_DIALOGS && !defined(__WXMICROWIN__)
#include <commdlg.h>
#endif
// convert degrees to radians
static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
+// call AlphaBlend() to blit contents of hdcSrc to hdcDst using alpha
+//
+// NB: bmpSrc is the bitmap selected in hdcSrc, it is not really needed
+// to pass it to this function but as we already have it at the point
+// of call anyhow we do
+//
+// return true if we could draw the bitmap in one way or the other, false
+// otherwise
+static bool AlphaBlt(HDC hdcDst,
+ int x, int y, int w, int h,
+ HDC hdcSrc,
+ const wxBitmap& bmpSrc);
+
+#ifdef wxHAVE_RAW_BITMAP
// our (limited) AlphaBlend() replacement
static void
-wxAlphaBlend(wxDC& dc, int x, int y, int w, int h, const wxBitmap& bmp);
+wxAlphaBlend(HDC hdcDst, int x, int y, int w, int h, const wxBitmap& bmp);
+#endif
// ----------------------------------------------------------------------------
// private classes
StretchBltModeChanger(HDC hdc, int mode)
: m_hdc(hdc)
{
+#ifndef __WXWINCE__
m_modeOld = ::SetStretchBltMode(m_hdc, mode);
if ( !m_modeOld )
wxLogLastError(_T("SetStretchBltMode"));
+#endif
}
~StretchBltModeChanger()
{
+#ifndef __WXWINCE__
if ( !::SetStretchBltMode(m_hdc, m_modeOld) )
wxLogLastError(_T("SetStretchBltMode"));
+#endif
}
private:
// note that we combine the new clipping region with the existing one: this
// is compatible with what the other ports do and is the documented
// behaviour now (starting with 2.3.3)
-#ifdef __WIN16__
+#if defined(__WIN16__) || defined(__WXWINCE__)
RECT rectClip;
if ( !::GetClipBox(GetHdc(), &rectClip) )
return;
rect.bottom = m_selectedBitmap.GetHeight();
}
+#ifndef __WXWINCE__
(void) ::SetMapMode(GetHdc(), MM_TEXT);
+#endif
DWORD colour = ::GetBkColor(GetHdc());
HBRUSH brush = ::CreateSolidBrush(colour);
int width = DeviceToLogicalXRel(VIEWPORT_EXTENT)*m_signX,
height = DeviceToLogicalYRel(VIEWPORT_EXTENT)*m_signY;
+#ifndef __WXWINCE__
::SetMapMode(GetHdc(), MM_ANISOTROPIC);
+
::SetViewportExtEx(GetHdc(), VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL);
::SetWindowExtEx(GetHdc(), width, height, NULL);
::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
+#endif
}
bool wxDC::DoFloodFill(wxCoord x, wxCoord y, const wxColour& col, int style)
{
+#ifdef __WXWINCE__
+ return FALSE;
+#else
+
#ifdef __WXMICROWIN__
if (!GetHDC()) return FALSE;
#endif
CalcBoundingBox(x, y);
return success;
+#endif
}
bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
wxCoord x2 = x+VIEWPORT_EXTENT;
wxCoord y2 = y+VIEWPORT_EXTENT;
- (void)MoveToEx(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y), NULL);
- (void)LineTo(GetHdc(), XLOG2DEV(x2), YLOG2DEV(y));
-
- (void)MoveToEx(GetHdc(), XLOG2DEV(x), YLOG2DEV(y1), NULL);
- (void)LineTo(GetHdc(), XLOG2DEV(x), YLOG2DEV(y2));
+ wxDrawLine(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y));
+ wxDrawLine(GetHdc(), XLOG2DEV(x), YLOG2DEV(y1), XLOG2DEV(x), YLOG2DEV(y2));
CalcBoundingBox(x1, y1);
CalcBoundingBox(x2, y2);
if (!GetHDC()) return;
#endif
- (void)MoveToEx(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y1), NULL);
- (void)LineTo(GetHdc(), XLOG2DEV(x2), YLOG2DEV(y2));
+ wxDrawLine(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2));
CalcBoundingBox(x1, y1);
CalcBoundingBox(x2, y2);
wxCoord x2, wxCoord y2,
wxCoord xc, wxCoord yc)
{
+#ifdef __WXWINCE__
+ // FIXME: emulate Arc
+#else
+
#ifdef __WXMICROWIN__
if (!GetHDC()) return;
#endif
CalcBoundingBox(xc - r, yc - r);
CalcBoundingBox(xc + r, yc + r);
+#endif
}
void wxDC::DoDrawCheckMark(wxCoord x1, wxCoord y1,
wxCoord x2 = x1 + width,
y2 = y1 + height;
-#if defined(__WIN32__) && !defined(__SC__) && !defined(__WXMICROWIN__)
+#if defined(__WIN32__) && !defined(__SYMANTEC__) && !defined(__WXMICROWIN__)
RECT rect;
rect.left = x1;
rect.top = y1;
rect.right = x2;
rect.bottom = y2;
+#ifdef __WXWINCE__
+ DrawFrameControl(GetHdc(), &rect, DFC_BUTTON, DFCS_BUTTONCHECK);
+#else
DrawFrameControl(GetHdc(), &rect, DFC_MENU, DFCS_MENUCHECK);
+#endif
#else // Win16
// In WIN16, draw a cross
HPEN blackPen = ::CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
CalcBoundingBox(cpoints[i].x, cpoints[i].y);
}
+#ifndef __WXWINCE__
int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
+#endif
(void)Polygon(GetHdc(), cpoints, n);
+#ifndef __WXWINCE__
SetPolyFillMode(GetHdc(),prev);
+#endif
delete[] cpoints;
}
else
for (i = 0; i < n; i++)
CalcBoundingBox(points[i].x, points[i].y);
+#ifndef __WXWINCE__
int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
+#endif
(void)Polygon(GetHdc(), (POINT*) points, n);
+#ifndef __WXWINCE__
SetPolyFillMode(GetHdc(),prev);
+#endif
}
}
// Chris Breeze 20/5/98: first implementation of DrawEllipticArc on Windows
void wxDC::DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,double ea)
{
+#ifdef __WXWINCE__
+ // FIXME
+#else
+
#ifdef __WXMICROWIN__
if (!GetHDC()) return;
#endif
CalcBoundingBox(x, y);
CalcBoundingBox(x2, y2);
+#endif
}
void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
HPALETTE oldPal = 0;
#endif // wxUSE_PALETTE
- // do we have AlphaBlend() and company in the headers?
-#ifdef AC_SRC_OVER
if ( bmp.HasAlpha() )
{
- // yes, now try to see if we have it during run-time
-
- typedef BOOL (WINAPI *AlphaBlend_t)(HDC,int,int,int,int,
- HDC,int,int,int,int,
- BLENDFUNCTION);
-
- // bitmaps can be drawn only from GUI thread so there is no need to
- // protect this static variable from multiple threads
- static bool s_triedToLoad = FALSE;
- static AlphaBlend_t pfnAlphaBlend = NULL;
- if ( !s_triedToLoad )
- {
- s_triedToLoad = TRUE;
-
- // don't give errors about the DLL being unavailable, we're
- // prepared to handle this
- wxLogNull nolog;
-
- wxDynamicLibrary dll(_T("msimg32.dll"));
- if ( dll.IsLoaded() )
- {
- pfnAlphaBlend = (AlphaBlend_t)dll.GetSymbol(_T("AlphaBlend"));
- if ( pfnAlphaBlend )
- {
- // we must keep the DLL loaded if we want to be able to
- // call AlphaBlend() so just never unload it at all, not a
- // big deal
- dll.Detach();
- }
- }
- }
+ MemoryHDC hdcMem;
+ SelectInHDC select(hdcMem, GetHbitmapOf(bmp));
- if ( pfnAlphaBlend )
- {
- MemoryHDC hdcMem;
- SelectInHDC select(hdcMem, GetHbitmapOf(bmp));
-
- BLENDFUNCTION bf;
- bf.BlendOp = AC_SRC_OVER;
- bf.BlendFlags = 0;
- bf.SourceConstantAlpha = 0xff;
- bf.AlphaFormat = AC_SRC_ALPHA;
-
- if ( !pfnAlphaBlend(GetHdc(), x, y, width, height,
- hdcMem, 0, 0, width, height,
- bf) )
- {
- wxLogLastError(_T("AlphaBlend"));
- }
- }
- else // use our own (probably much slower) implementation
- {
- wxAlphaBlend(*this, x, y, width, height, bmp);
- }
-
- return;
+ if ( AlphaBlt(GetHdc(), x, y, width, height, hdcMem, bmp) )
+ return;
}
-#endif // defined(AC_SRC_OVER)
if ( useMask )
{
SetBkMode(GetHdc(), m_backgroundMode == wxTRANSPARENT ? TRANSPARENT
: OPAQUE);
+#ifdef __WXWINCE__
+ if ( ::ExtTextOut(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), 0, NULL,
+ text.c_str(), text.length(), NULL) == 0 )
+ {
+ wxLogLastError(wxT("TextOut"));
+ }
+#else
if ( ::TextOut(GetHdc(), XLOG2DEV(x), YLOG2DEV(y),
text.c_str(), text.length()) == 0 )
{
wxLogLastError(wxT("TextOut"));
}
+#endif
// restore the old parameters (text foreground colour may be left because
// it never is set to anything else, but background should remain
m_backgroundBrush = brush;
- if (!m_backgroundBrush.Ok())
- return;
-
- if (m_canvas)
- {
- bool customColours = TRUE;
- // If we haven't specified wxUSER_COLOURS, don't allow the panel/dialog box to
- // change background colours from the control-panel specified colours.
- if (m_canvas->IsKindOf(CLASSINFO(wxWindow)) && ((m_canvas->GetWindowStyleFlag() & wxUSER_COLOURS) != wxUSER_COLOURS))
- customColours = FALSE;
-
- if (customColours)
- {
- if (m_backgroundBrush.GetStyle()==wxTRANSPARENT)
- {
- m_canvas->SetTransparent(TRUE);
- }
- else
- {
- // New behaviour, 10/2/99: setting the background brush of a DC
- // doesn't affect the window background colour. However,
- // I'm leaving in the transparency setting because it's needed by
- // various controls (e.g. wxStaticText) to determine whether to draw
- // transparently or not. TODO: maybe this should be a new function
- // wxWindow::SetTransparency(). Should that apply to the child itself, or the
- // parent?
- // m_canvas->SetBackgroundColour(m_backgroundBrush.GetColour());
- m_canvas->SetTransparent(FALSE);
- }
- }
- }
- COLORREF new_color = m_backgroundBrush.GetColour().GetPixel();
+ if ( m_backgroundBrush.Ok() )
{
- (void)SetBkColor(GetHdc(), new_color);
+ (void)SetBkColor(GetHdc(), m_backgroundBrush.GetColour().GetPixel());
}
}
return;
}
- double mm2pixelsX = pixel_width / mm_width,
- mm2pixelsY = pixel_height / mm_height;
+ double mm2pixelsX = (double)pixel_width / mm_width,
+ mm2pixelsY = (double)pixel_height / mm_height;
switch (mode)
{
// VZ: it seems very wasteful to always use MM_ANISOTROPIC when in 99% of
// cases we could do with MM_TEXT and in the remaining 0.9% with
// MM_ISOTROPIC (TODO!)
+#ifndef __WXWINCE__
::SetMapMode(GetHdc(), MM_ANISOTROPIC);
int width = DeviceToLogicalXRel(VIEWPORT_EXTENT)*m_signX,
::SetViewportOrgEx(GetHdc(), m_deviceOriginX, m_deviceOriginY, NULL);
::SetWindowOrgEx(GetHdc(), m_logicalOriginX, m_logicalOriginY, NULL);
+#endif
}
void wxDC::SetUserScale(double x, double y)
if (!GetHDC()) return;
#endif
+#ifndef __WXWINCE__
if ( x == m_userScaleX && y == m_userScaleY )
return;
m_userScaleY = y;
SetMapMode(m_mappingMode);
+#endif
}
void wxDC::SetAxisOrientation(bool xLeftRight, bool yBottomUp)
if (!GetHDC()) return;
#endif
+#ifndef __WXWINCE__
int signX = xLeftRight ? 1 : -1,
signY = yBottomUp ? -1 : 1;
SetMapMode(m_mappingMode);
}
+#endif
}
void wxDC::SetSystemScale(double x, double y)
if (!GetHDC()) return;
#endif
+#ifndef __WXWINCE__
if ( x == m_scaleX && y == m_scaleY )
return;
m_scaleY = y;
SetMapMode(m_mappingMode);
+#endif
}
void wxDC::SetLogicalOrigin(wxCoord x, wxCoord y)
if (!GetHDC()) return;
#endif
+#ifndef __WXWINCE__
if ( x == m_logicalOriginX && y == m_logicalOriginY )
return;
m_logicalOriginY = y;
::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
+#endif
}
void wxDC::SetDeviceOrigin(wxCoord x, wxCoord y)
if (!GetHDC()) return;
#endif
+#ifndef __WXWINCE__
if ( x == m_deviceOriginX && y == m_deviceOriginY )
return;
m_deviceOriginY = y;
::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
+#endif
}
// ---------------------------------------------------------------------------
int rop, bool useMask,
wxCoord xsrcMask, wxCoord ysrcMask)
{
+ wxCHECK_MSG( source, FALSE, _T("wxDC::Blit(): NULL wxDC pointer") );
+
#ifdef __WXMICROWIN__
if (!GetHDC()) return FALSE;
#endif
const wxBitmap& bmpSrc = source->m_selectedBitmap;
+ if ( bmpSrc.Ok() && bmpSrc.HasAlpha() )
+ {
+ if ( AlphaBlt(GetHdc(), xdest, ydest, width, height,
+ GetHdcOf(*source), bmpSrc) )
+ return TRUE;
+ }
wxMask *mask = NULL;
if ( useMask )
{
// if we already have a DIB, draw it using StretchDIBits(), otherwise
// use StretchBlt() if available and finally fall back to BitBlt()
+
+ // FIXME: use appropriate WinCE functions
+#ifndef __WXWINCE__
const int caps = ::GetDeviceCaps(GetHdc(), RASTERCAPS);
if ( bmpSrc.Ok() && (caps & RC_STRETCHDIB) )
{
success = TRUE;
}
}
+#endif
+ // __WXWINCE__
}
::SetTextColor(GetHdc(), old_textground);
wxDCCacheEntry* wxDC::FindBitmapInCache(WXHDC dc, int w, int h)
{
int depth = ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
- wxNode* node = sm_bitmapCache.GetFirst();
+ wxList::compatibility_iterator node = sm_bitmapCache.GetFirst();
while (node)
{
wxDCCacheEntry* entry = (wxDCCacheEntry*) node->GetData();
wxDCCacheEntry* wxDC::FindDCInCache(wxDCCacheEntry* notThis, WXHDC dc)
{
int depth = ::GetDeviceCaps((HDC) dc, PLANES) * ::GetDeviceCaps((HDC) dc, BITSPIXEL);
- wxNode* node = sm_dcCache.GetFirst();
+ wxList::compatibility_iterator node = sm_dcCache.GetFirst();
while (node)
{
wxDCCacheEntry* entry = (wxDCCacheEntry*) node->GetData();
void wxDC::ClearCache()
{
- sm_dcCache.DeleteContents(TRUE);
- sm_dcCache.Clear();
- sm_dcCache.DeleteContents(FALSE);
- sm_bitmapCache.DeleteContents(TRUE);
- sm_bitmapCache.Clear();
- sm_bitmapCache.DeleteContents(FALSE);
+ WX_CLEAR_LIST(wxList, sm_dcCache);
+ WX_CLEAR_LIST(wxList, sm_bitmapCache);
}
// Clean up cache at app exit
#endif // wxUSE_DC_CACHEING
// ----------------------------------------------------------------------------
-// wxAlphaBlend: our fallback if ::AlphaBlend() is unavailable
+// alpha channel support
// ----------------------------------------------------------------------------
+static bool AlphaBlt(HDC hdcDst,
+ int x, int y, int width, int height,
+ HDC hdcSrc,
+ const wxBitmap& bmp)
+{
+ wxASSERT_MSG( bmp.Ok() && bmp.HasAlpha(), _T("AlphaBlt(): invalid bitmap") );
+ wxASSERT_MSG( hdcDst && hdcSrc, _T("AlphaBlt(): invalid HDC") );
+
+ // do we have AlphaBlend() and company in the headers?
+#if defined(AC_SRC_OVER) && wxUSE_DYNLIB_CLASS
+ // yes, now try to see if we have it during run-time
+ typedef BOOL (WINAPI *AlphaBlend_t)(HDC,int,int,int,int,
+ HDC,int,int,int,int,
+ BLENDFUNCTION);
+
+ // bitmaps can be drawn only from GUI thread so there is no need to
+ // protect this static variable from multiple threads
+ static bool s_triedToLoad = FALSE;
+ static AlphaBlend_t pfnAlphaBlend = NULL;
+ if ( !s_triedToLoad )
+ {
+ s_triedToLoad = TRUE;
+
+ // don't give errors about the DLL being unavailable, we're
+ // prepared to handle this
+ wxLogNull nolog;
+
+ wxDynamicLibrary dll(_T("msimg32.dll"));
+ if ( dll.IsLoaded() )
+ {
+ pfnAlphaBlend = (AlphaBlend_t)dll.GetSymbol(_T("AlphaBlend"));
+ if ( pfnAlphaBlend )
+ {
+ // we must keep the DLL loaded if we want to be able to
+ // call AlphaBlend() so just never unload it at all, not a
+ // big deal
+ dll.Detach();
+ }
+ }
+ }
+
+ if ( pfnAlphaBlend )
+ {
+ BLENDFUNCTION bf;
+ bf.BlendOp = AC_SRC_OVER;
+ bf.BlendFlags = 0;
+ bf.SourceConstantAlpha = 0xff;
+ bf.AlphaFormat = AC_SRC_ALPHA;
+
+ if ( pfnAlphaBlend(hdcDst, x, y, width, height,
+ hdcSrc, 0, 0, width, height,
+ bf) )
+ {
+ // skip wxAlphaBlend() call below
+ return TRUE;
+ }
+
+ wxLogLastError(_T("AlphaBlend"));
+ }
+#endif // defined(AC_SRC_OVER)
+
+ // AlphaBlend() unavailable of failed: use our own (probably much slower)
+ // implementation
+#ifdef wxHAVE_RAW_BITMAP
+ wxAlphaBlend(hdcDst, x, y, width, height, bmp);
+
+ return TRUE;
+#else // !wxHAVE_RAW_BITMAP
+ // no wxAlphaBlend() neither, fall back to using simple BitBlt() (we lose
+ // alpha but at least something will be shown like this)
+ return FALSE;
+#endif // wxHAVE_RAW_BITMAP
+}
+
+
+// wxAlphaBlend: our fallback if ::AlphaBlend() is unavailable
+#ifdef wxHAVE_RAW_BITMAP
+
static void
-wxAlphaBlend(wxDC& dc, int xDst, int yDst, int w, int h, const wxBitmap& bmpSrc)
+wxAlphaBlend(HDC hdcDst, int xDst, int yDst, int w, int h, const wxBitmap& bmpSrc)
{
// get the destination DC pixels
wxBitmap bmpDst(w, h, 32 /* force creating RGBA DIB */);
MemoryHDC hdcMem;
SelectInHDC select(hdcMem, GetHbitmapOf(bmpDst));
- if ( !::BitBlt(hdcMem, 0, 0, w, h, GetHdcOf(dc), 0, 0, SRCCOPY) )
+ if ( !::BitBlt(hdcMem, 0, 0, w, h, hdcDst, 0, 0, SRCCOPY) )
{
wxLogLastError(_T("BitBlt"));
}
// combine them with the source bitmap using alpha
- wxRawBitmapData dataDst(bmpDst),
- dataSrc(bmpSrc);
+ wxAlphaPixelData dataDst(bmpDst),
+ dataSrc((wxBitmap &)bmpSrc);
wxCHECK_RET( dataDst && dataSrc,
_T("failed to get raw data in wxAlphaBlend") );
- wxRawBitmapIterator pDst(dataDst),
- pSrc(dataSrc);
+ wxAlphaPixelData::Iterator pDst(dataDst),
+ pSrc(dataSrc);
for ( int y = 0; y < h; y++ )
{
- wxRawBitmapIterator pDstRowStart = pDst,
- pSrcRowStart = pSrc;
+ wxAlphaPixelData::Iterator pDstRowStart = pDst,
+ pSrcRowStart = pSrc;
for ( int x = 0; x < w; x++ )
{
pDst = pDstRowStart;
pSrc = pSrcRowStart;
- pDst.OffsetY(1);
- pSrc.OffsetY(1);
+ pDst.OffsetY(dataDst, 1);
+ pSrc.OffsetY(dataSrc, 1);
}
// and finally blit them back to the destination DC
- if ( !::BitBlt(GetHdcOf(dc), xDst, yDst, w, h, hdcMem, 0, 0, SRCCOPY) )
+ if ( !::BitBlt(hdcDst, xDst, yDst, w, h, hdcMem, 0, 0, SRCCOPY) )
{
wxLogLastError(_T("BitBlt"));
}
}
+#endif // #ifdef wxHAVE_RAW_BITMAP
projects / wxWidgets.git / blobdiff