#include "wx/bitmap.h"
#include "wx/dcmemory.h"
#include "wx/log.h"
+ #include "wx/math.h"
#include "wx/icon.h"
#include "wx/dcprint.h"
#include "wx/module.h"
#include "wx/dynlib.h"
#ifdef wxHAS_RAW_BITMAP
-#include "wx/rawbmp.h"
+ #include "wx/rawbmp.h"
#endif
#include <string.h>
-#ifndef __WIN32__
- #include <print.h>
-#endif
+#include "wx/msw/private/dc.h"
+
+using namespace wxMSWImpl;
#ifndef AC_SRC_ALPHA
#define AC_SRC_ALPHA 1
// constants
// ---------------------------------------------------------------------------
-static const int VIEWPORT_EXTENT = 1000;
+// The device space in Win32 GDI measures 2^27*2^27 , so we use 2^27-1 as the
+// maximal possible view port extent.
+static const int VIEWPORT_EXTENT = 134217727;
// ROPs which don't have standard names (see "Ternary Raster Operations" in the
// MSDN docs for how this and other numbers in wxDC::Blit() are obtained)
// private classes
// ----------------------------------------------------------------------------
-// various classes to change some DC property temporarily
-
-// text background and foreground colours
-class wxTextColoursChanger
-{
-public:
- wxTextColoursChanger(HDC hdc, const wxMSWDCImpl& dc)
- : m_hdc(hdc)
- {
- Change(dc.GetTextForeground(), dc.GetTextBackground());
- }
-
- wxTextColoursChanger(HDC hdc, const wxColour& colFg, const wxColour& colBg)
- : m_hdc(hdc)
- {
- Change(colFg, colBg);
- }
-
- ~wxTextColoursChanger()
- {
- if ( m_oldColFg != CLR_INVALID )
- ::SetTextColor(m_hdc, m_oldColFg);
- if ( m_oldColBg != CLR_INVALID )
- ::SetBkColor(m_hdc, m_oldColBg);
- }
-
-protected:
- // this ctor doesn't change mode immediately, call Change() later to do it
- // only if needed
- wxTextColoursChanger(HDC hdc)
- : m_hdc(hdc)
- {
- m_oldColFg =
- m_oldColBg = CLR_INVALID;
- }
-
- void Change(const wxColour& colFg, const wxColour& colBg)
- {
- if ( colFg.IsOk() )
- {
- m_oldColFg = ::SetTextColor(m_hdc, colFg.GetPixel());
- if ( m_oldColFg == CLR_INVALID )
- {
- wxLogLastError(_T("SetTextColor"));
- }
- }
- else
- {
- m_oldColFg = CLR_INVALID;
- }
-
- if ( colBg.IsOk() )
- {
- m_oldColBg = ::SetBkColor(m_hdc, colBg.GetPixel());
- if ( m_oldColBg == CLR_INVALID )
- {
- wxLogLastError(_T("SetBkColor"));
- }
- }
- else
- {
- m_oldColBg = CLR_INVALID;
- }
- }
-
-private:
- const HDC m_hdc;
- COLORREF m_oldColFg,
- m_oldColBg;
-
- DECLARE_NO_COPY_CLASS(wxTextColoursChanger)
-};
-
-// background mode
-class wxBkModeChanger
-{
-public:
- // set background mode to opaque if mode != wxBRUSHSTYLE_TRANSPARENT
- wxBkModeChanger(HDC hdc, int mode)
- : m_hdc(hdc)
- {
- Change(mode);
- }
-
- ~wxBkModeChanger()
- {
- if ( m_oldMode )
- ::SetBkMode(m_hdc, m_oldMode);
- }
-
-protected:
- // this ctor doesn't change mode immediately, call Change() later to do it
- // only if needed
- wxBkModeChanger(HDC hdc) : m_hdc(hdc) { m_oldMode = 0; }
-
- void Change(int mode)
- {
- m_oldMode = ::SetBkMode(m_hdc, mode == wxBRUSHSTYLE_TRANSPARENT
- ? TRANSPARENT
- : OPAQUE);
- if ( !m_oldMode )
- {
- wxLogLastError(_T("SetBkMode"));
- }
- }
-
-private:
- const HDC m_hdc;
- int m_oldMode;
-
- DECLARE_NO_COPY_CLASS(wxBkModeChanger)
-};
-
// instead of duplicating the same code which sets and then restores text
// colours in each wxDC method working with wxSTIPPLE_MASK_OPAQUE brushes,
// encapsulate this in a small helper class
wxBrushAttrsSetter(wxMSWDCImpl& dc);
private:
- DECLARE_NO_COPY_CLASS(wxBrushAttrsSetter)
+ wxDECLARE_NO_COPY_CLASS(wxBrushAttrsSetter);
};
-// this class saves the old stretch blit mode during its life time
+#ifdef __WXWINCE__
+
+#define SET_STRETCH_BLT_MODE(hdc)
+
+#else // !__WXWINCE__
+
+// this class sets the stretch blit mode to COLORONCOLOR during its lifetime
+//
+// don't use it directly, use SET_STRETCH_BLT_MODE() macro instead as it
+// expands to nothing under WinCE which doesn't have SetStretchBltMode()
class StretchBltModeChanger
{
public:
- StretchBltModeChanger(HDC hdc,
- int WXUNUSED_IN_WINCE(mode))
+ StretchBltModeChanger(HDC hdc)
: m_hdc(hdc)
{
-#ifndef __WXWINCE__
- m_modeOld = ::SetStretchBltMode(m_hdc, mode);
+ m_modeOld = ::SetStretchBltMode(m_hdc, COLORONCOLOR);
if ( !m_modeOld )
- wxLogLastError(_T("SetStretchBltMode"));
-#endif
+ {
+ wxLogLastError(wxT("SetStretchBltMode"));
+ }
}
~StretchBltModeChanger()
{
-#ifndef __WXWINCE__
if ( !::SetStretchBltMode(m_hdc, m_modeOld) )
- wxLogLastError(_T("SetStretchBltMode"));
-#endif
+ {
+ wxLogLastError(wxT("SetStretchBltMode"));
+ }
}
private:
int m_modeOld;
- DECLARE_NO_COPY_CLASS(StretchBltModeChanger)
+ wxDECLARE_NO_COPY_CLASS(StretchBltModeChanger);
};
+#define SET_STRETCH_BLT_MODE(hdc) \
+ StretchBltModeChanger wxMAKE_UNIQUE_NAME(stretchModeChanger)(hdc)
+
+#endif // __WXWINCE__/!__WXWINCE__
+
#if wxUSE_DYNLIB_CLASS
// helper class to cache dynamically loaded libraries and not attempt reloading
const wxChar *m_dllName;
};
-static wxOnceOnlyDLLLoader wxMSIMG32DLL(_T("msimg32"));
+static wxOnceOnlyDLLLoader wxMSIMG32DLL(wxT("msimg32"));
// we must ensure that DLLs are unloaded before the static objects cleanup time
// because we may hit the notorious DllMain() dead lock in this case if wx is
IMPLEMENT_DYNAMIC_CLASS(wxGDIDLLsCleanupModule, wxModule)
+namespace
+{
+
+#if wxUSE_DC_TRANSFORM_MATRIX
+
+// Class used to dynamically load world transform related API functions.
+class GdiWorldTransformFuncs
+{
+public:
+ static bool IsOk()
+ {
+ if ( !ms_worldTransformSymbolsLoaded )
+ LoadWorldTransformSymbols();
+
+ return ms_pfnSetGraphicsMode &&
+ ms_pfnSetWorldTransform &&
+ ms_pfnGetWorldTransform &&
+ ms_pfnModifyWorldTransform;
+ }
+
+ typedef int (WINAPI *SetGraphicsMode_t)(HDC, int);
+ static SetGraphicsMode_t SetGraphicsMode()
+ {
+ if ( !ms_worldTransformSymbolsLoaded )
+ LoadWorldTransformSymbols();
+
+ return ms_pfnSetGraphicsMode;
+ }
+
+ typedef BOOL (WINAPI *SetWorldTransform_t)(HDC, const XFORM *);
+ static SetWorldTransform_t SetWorldTransform()
+ {
+ if ( !ms_worldTransformSymbolsLoaded )
+ LoadWorldTransformSymbols();
+
+ return ms_pfnSetWorldTransform;
+ }
+
+ typedef BOOL (WINAPI *GetWorldTransform_t)(HDC, LPXFORM);
+ static GetWorldTransform_t GetWorldTransform()
+ {
+ if ( !ms_worldTransformSymbolsLoaded )
+ LoadWorldTransformSymbols();
+
+ return ms_pfnGetWorldTransform;
+ }
+
+ typedef BOOL (WINAPI *ModifyWorldTransform_t)(HDC, const XFORM *, DWORD);
+ static ModifyWorldTransform_t ModifyWorldTransform()
+ {
+ if ( !ms_worldTransformSymbolsLoaded )
+ LoadWorldTransformSymbols();
+
+ return ms_pfnModifyWorldTransform;
+ }
+
+private:
+ static void LoadWorldTransformSymbols()
+ {
+ wxDynamicLibrary dll(wxT("gdi32.dll"));
+
+ wxDL_INIT_FUNC(ms_pfn, SetGraphicsMode, dll);
+ wxDL_INIT_FUNC(ms_pfn, SetWorldTransform, dll);
+ wxDL_INIT_FUNC(ms_pfn, GetWorldTransform, dll);
+ wxDL_INIT_FUNC(ms_pfn, ModifyWorldTransform, dll);
+
+ ms_worldTransformSymbolsLoaded = true;
+ }
+
+ static SetGraphicsMode_t ms_pfnSetGraphicsMode;
+ static SetWorldTransform_t ms_pfnSetWorldTransform;
+ static GetWorldTransform_t ms_pfnGetWorldTransform;
+ static ModifyWorldTransform_t ms_pfnModifyWorldTransform;
+
+ static bool ms_worldTransformSymbolsLoaded;
+};
+
+GdiWorldTransformFuncs::SetGraphicsMode_t
+ GdiWorldTransformFuncs::ms_pfnSetGraphicsMode = NULL;
+GdiWorldTransformFuncs::SetWorldTransform_t
+ GdiWorldTransformFuncs::ms_pfnSetWorldTransform = NULL;
+GdiWorldTransformFuncs::GetWorldTransform_t
+ GdiWorldTransformFuncs::ms_pfnGetWorldTransform = NULL;
+GdiWorldTransformFuncs::ModifyWorldTransform_t
+ GdiWorldTransformFuncs::ms_pfnModifyWorldTransform = NULL;
+
+bool GdiWorldTransformFuncs::ms_worldTransformSymbolsLoaded = false;
+
+#endif // wxUSE_DC_TRANSFORM_MATRIX
+
+} // anonymous namespace
+
#endif // wxUSE_DYNLIB_CLASS
// ===========================================================================
}
}
+// ----------------------------------------------------------------------------
+// wxDC MSW-specific methods
+// ----------------------------------------------------------------------------
+
+WXHDC wxDC::GetHDC() const
+{
+ wxMSWDCImpl * const impl = wxDynamicCast(GetImpl(), wxMSWDCImpl);
+ return impl ? impl->GetHDC() : 0;
+}
+
// ---------------------------------------------------------------------------
// wxMSWDCImpl
// ---------------------------------------------------------------------------
if (m_oldBitmap)
{
::SelectObject((HDC) dc, (HBITMAP) m_oldBitmap);
-#ifdef __WXDEBUG__
if (m_selectedBitmap.IsOk())
{
m_selectedBitmap.SetSelectedInto(NULL);
}
-#endif
}
m_oldBitmap = 0;
if (m_oldPen)
wxDCImpl::DoGetClippingBox(x, y, w, h);
}
-// common part of DoSetClippingRegion() and DoSetClippingRegionAsRegion()
+// common part of DoSetClippingRegion() and DoSetDeviceClippingRegion()
void wxMSWDCImpl::SetClippingHrgn(WXHRGN hrgn)
{
wxCHECK_RET( hrgn, wxT("invalid clipping region") );
#else // !WinCE
if ( ::ExtSelectClipRgn(GetHdc(), (HRGN)hrgn, RGN_AND) == ERROR )
{
- wxLogLastError(_T("ExtSelectClipRgn"));
+ wxLogLastError(wxT("ExtSelectClipRgn"));
return;
}
LogicalToDeviceY(y + h));
if ( !hrgn )
{
- wxLogLastError(_T("CreateRectRgn"));
+ wxLogLastError(wxT("CreateRectRgn"));
}
else
{
}
}
-void wxMSWDCImpl::DoSetClippingRegionAsRegion(const wxRegion& region)
+void wxMSWDCImpl::DoSetDeviceClippingRegion(const wxRegion& region)
{
SetClippingHrgn(region.GetHRGN());
}
bool wxMSWDCImpl::DoFloodFill(wxCoord WXUNUSED_IN_WINCE(x),
wxCoord WXUNUSED_IN_WINCE(y),
const wxColour& WXUNUSED_IN_WINCE(col),
- int WXUNUSED_IN_WINCE(style))
+ wxFloodFillStyle WXUNUSED_IN_WINCE(style))
{
#ifdef __WXWINCE__
return false;
{
WXMICROWIN_CHECK_HDC_RET(false)
- wxCHECK_MSG( col, false, _T("NULL colour parameter in wxMSWDCImpl::GetPixel") );
+ wxCHECK_MSG( col, false, wxT("NULL colour parameter in wxMSWDCImpl::GetPixel") );
// get the color of the pixel
COLORREF pixelcolor = ::GetPixel(GetHdc(), XLOG2DEV(x), YLOG2DEV(y));
wxCoord x2, wxCoord y2,
wxCoord xc, wxCoord yc)
{
+ double dx = xc - x1;
+ double dy = yc - y1;
+ wxCoord r = (wxCoord)sqrt(dx*dx + dy*dy);
+
+
#ifdef __WXWINCE__
// Slower emulation since WinCE doesn't support Pie and Arc
- double r = sqrt( (x1-xc)*(x1-xc) + (y1-yc)*(y1-yc) );
double sa = acos((x1-xc)/r)/M_PI*180; // between 0 and 180
- if( y1>yc ) sa = -sa; // below center
+ if( y1>yc )
+ sa = -sa; // below center
double ea = atan2(yc-y2, x2-xc)/M_PI*180;
DoDrawEllipticArcRot( xc-r, yc-r, 2*r, 2*r, sa, ea );
#else
wxBrushAttrsSetter cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
- double dx = xc - x1;
- double dy = yc - y1;
- double radius = (double)sqrt(dx*dx+dy*dy);
- wxCoord r = (wxCoord)radius;
-
// treat the special case of full circle separately
if ( x1 == x2 && y1 == y2 )
{
wxCoord yy2 = YLOG2DEV(y2);
wxCoord xxc = XLOG2DEV(xc);
wxCoord yyc = YLOG2DEV(yc);
- wxCoord ray = (wxCoord) sqrt(double((xxc-xx1)*(xxc-xx1)+(yyc-yy1)*(yyc-yy1)));
+ dx = xxc - xx1;
+ dy = yyc - yy1;
+ wxCoord ray = (wxCoord)sqrt(dx*dx + dy*dy);
wxCoord xxx1 = (wxCoord) (xxc-ray);
wxCoord yyy1 = (wxCoord) (yyc-ray);
wxCoord xxx2 = (wxCoord) (xxc+ray);
wxCoord yyy2 = (wxCoord) (yyc+ray);
- if ( m_brush.IsOk() && m_brush.GetStyle() != wxBRUSHSTYLE_TRANSPARENT )
+ if ( m_brush.IsNonTransparent() )
{
// Have to add 1 to bottom-right corner of rectangle
// to make semi-circles look right (crooked line otherwise).
wxPoint points[],
wxCoord xoffset,
wxCoord yoffset,
- int WXUNUSED_IN_WINCE(fillStyle))
+ wxPolygonFillMode WXUNUSED_IN_WINCE(fillStyle))
{
WXMICROWIN_CHECK_HDC
wxPoint points[],
wxCoord xoffset,
wxCoord yoffset,
- int fillStyle)
+ wxPolygonFillMode fillStyle)
{
#ifdef __WXWINCE__
wxDCImpl::DoDrawPolyPolygon(n, count, points, xoffset, yoffset, fillStyle);
// (i.e. drawn with a transparent pen) one pixel smaller in both directions
// and we want them to have the same size regardless of which pen is used
#ifndef __WXWINCE__
- if ( m_pen.IsOk() && m_pen.GetStyle() == wxPENSTYLE_TRANSPARENT )
+ if ( m_pen.IsTransparent() )
{
x2dev++;
y2dev++;
// Windows draws the filled rectangles without outline (i.e. drawn with a
// transparent pen) one pixel smaller in both directions and we want them
// to have the same size regardless of which pen is used - adjust
- if ( m_pen.GetStyle() == wxPENSTYLE_TRANSPARENT )
+ if ( m_pen.IsTransparent() )
{
x2++;
y2++;
wxBrushAttrsSetter cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
- wxCoord x2 = (x+width);
- wxCoord y2 = (y+height);
+ // +1 below makes the ellipse more similar to other platforms.
+ // In particular, DoDrawEllipse(x,y,1,1) should draw one point.
+ wxCoord x2 = x + width + 1;
+ wxCoord y2 = y + height + 1;
+
+ // Problem: Windows GDI Ellipse() with x2-x == y2-y == 3 and transparent
+ // pen doesn't draw anything. Should we provide a workaround?
- (void)Ellipse(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
+ ::Ellipse(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
CalcBoundingBox(x, y);
CalcBoundingBox(x2, y2);
lppt[ bezier_pos ] = lppt[ bezier_pos-1 ];
bezier_pos++;
-#if !wxUSE_STL
+#if !wxUSE_STD_CONTAINERS
while ((node = node->GetNext()) != NULL)
#else
while ((node = node->GetNext()))
-#endif // !wxUSE_STL
+#endif // !wxUSE_STD_CONTAINERS
{
p = (wxPoint *)node->GetData();
x1 = x2;
{
WXMICROWIN_CHECK_HDC
- wxCHECK_RET( bmp.IsOk(), _T("invalid bitmap in wxMSWDCImpl::DrawBitmap") );
+ wxCHECK_RET( bmp.IsOk(), wxT("invalid bitmap in wxMSWDCImpl::DrawBitmap") );
int width = bmp.GetWidth(),
height = bmp.GetHeight();
return;
}
+ SET_STRETCH_BLT_MODE(GetHdc());
+
if ( useMask )
{
wxMask *mask = bmp.GetMask();
#ifdef __WIN32__
// use MaskBlt() with ROP which doesn't do anything to dst in the mask
// points
+ bool ok = false;
+
+#if wxUSE_SYSTEM_OPTIONS
// On some systems, MaskBlt succeeds yet is much much slower
// than the wxWidgets fall-back implementation. So we need
// to be able to switch this on and off at runtime.
- bool ok = false;
-#if wxUSE_SYSTEM_OPTIONS
- if (wxSystemOptions::GetOptionInt(wxT("no-maskblt")) == 0)
-#endif
+ //
+ // NB: don't query the value of the option every time but do it only
+ // once as otherwise it can have real (and bad) performance
+ // implications (see #11172)
+ static bool
+ s_maskBltAllowed = wxSystemOptions::GetOptionInt("no-maskblt") == 0;
+ if ( s_maskBltAllowed )
+#endif // wxUSE_SYSTEM_OPTIONS
{
HDC cdc = GetHdc();
HDC hdcMem = ::CreateCompatibleDC(GetHdc());
void wxMSWDCImpl::DoDrawText(const wxString& text, wxCoord x, wxCoord y)
{
+ // For compatibility with other ports (notably wxGTK) and because it's
+ // genuinely useful, we allow passing multiline strings to DrawText().
+ // However there is no native MSW function to draw them directly so we
+ // instead reuse the generic DrawLabel() method to render them. Of course,
+ // DrawLabel() itself will call back to us but with single line strings
+ // only so there won't be any infinite recursion here.
+ if ( text.find('\n') != wxString::npos )
+ {
+ GetOwner()->DrawLabel(text, wxRect(x, y, 0, 0));
+ return;
+ }
+
WXMICROWIN_CHECK_HDC
DrawAnyText(text, x, y);
HGDIOBJ hfont = ::SelectObject(GetHdc(), GetHfontOf(font));
if ( hfont == HGDI_ERROR )
{
- wxLogLastError(_T("SelectObject(font)"));
+ wxLogLastError(wxT("SelectObject(font)"));
}
else // selected ok
{
{
if ( ::SelectObject(GetHdc(), (HPEN) m_oldFont) == HGDI_ERROR )
{
- wxLogLastError(_T("SelectObject(old font)"));
+ wxLogLastError(wxT("SelectObject(old font)"));
}
m_oldFont = 0;
HGDIOBJ hpen = ::SelectObject(GetHdc(), GetHpenOf(pen));
if ( hpen == HGDI_ERROR )
{
- wxLogLastError(_T("SelectObject(pen)"));
+ wxLogLastError(wxT("SelectObject(pen)"));
}
else // selected ok
{
{
if ( ::SelectObject(GetHdc(), (HPEN) m_oldPen) == HGDI_ERROR )
{
- wxLogLastError(_T("SelectObject(old pen)"));
+ wxLogLastError(wxT("SelectObject(old pen)"));
}
m_oldPen = 0;
if ( brush.IsOk() )
{
// we must make sure the brush is aligned with the logical coordinates
- // before selecting it
+ // before selecting it or using the same brush for the background of
+ // different windows would result in discontinuities
+ wxSize sizeBrushBitmap = wxDefaultSize;
wxBitmap *stipple = brush.GetStipple();
if ( stipple && stipple->IsOk() )
+ sizeBrushBitmap = stipple->GetSize();
+ else if ( brush.IsHatch() )
+ sizeBrushBitmap = wxSize(8, 8);
+
+ if ( sizeBrushBitmap.IsFullySpecified() )
{
if ( !::SetBrushOrgEx
(
GetHdc(),
- m_deviceOriginX % stipple->GetWidth(),
- m_deviceOriginY % stipple->GetHeight(),
+ m_deviceOriginX % sizeBrushBitmap.x,
+ m_deviceOriginY % sizeBrushBitmap.y,
NULL // [out] previous brush origin
) )
{
- wxLogLastError(_T("SetBrushOrgEx()"));
+ wxLogLastError(wxT("SetBrushOrgEx()"));
}
}
HGDIOBJ hbrush = ::SelectObject(GetHdc(), GetHbrushOf(brush));
if ( hbrush == HGDI_ERROR )
{
- wxLogLastError(_T("SelectObject(brush)"));
+ wxLogLastError(wxT("SelectObject(brush)"));
}
else // selected ok
{
{
if ( ::SelectObject(GetHdc(), (HPEN) m_oldBrush) == HGDI_ERROR )
{
- wxLogLastError(_T("SelectObject(old brush)"));
+ wxLogLastError(wxT("SelectObject(old brush)"));
}
m_oldBrush = 0;
// and m_backgroundMode is used there
}
-void wxMSWDCImpl::SetLogicalFunction(int function)
+void wxMSWDCImpl::SetLogicalFunction(wxRasterOperationMode function)
{
WXMICROWIN_CHECK_HDC
case wxNAND: rop = R2_NOTMASKPEN; break;
case wxOR: rop = R2_MERGEPEN; break;
case wxSET: rop = R2_WHITE; break;
-
default:
- wxFAIL_MSG( wxT("unsupported logical function") );
- return;
+ wxFAIL_MSG( wxS("unknown logical function") );
+ return;
}
SetROP2(GetHdc(), rop);
return lpTextMetric.tmAveCharWidth;
}
+void wxMSWDCImpl::DoGetFontMetrics(int *height,
+ int *ascent,
+ int *descent,
+ int *internalLeading,
+ int *externalLeading,
+ int *averageWidth) const
+{
+ TEXTMETRIC tm;
+
+ GetTextMetrics(GetHdc(), &tm);
+
+ if ( height )
+ *height = tm.tmHeight;
+ if ( ascent )
+ *ascent = tm.tmAscent;
+ if ( descent )
+ *descent = tm.tmDescent;
+ if ( internalLeading )
+ *internalLeading = tm.tmInternalLeading;
+ if ( externalLeading )
+ *externalLeading = tm.tmExternalLeading;
+ if ( averageWidth )
+ *averageWidth = tm.tmAveCharWidth;
+}
+
void wxMSWDCImpl::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,
wxCoord *descent, wxCoord *externalLeading,
const wxFont *font) const
HFONT hfontOld;
if ( font )
{
- wxASSERT_MSG( font->IsOk(), _T("invalid font in wxMSWDCImpl::GetTextExtent") );
+ wxASSERT_MSG( font->IsOk(), wxT("invalid font in wxMSWDCImpl::GetTextExtent") );
hfontOld = (HFONT)::SelectObject(GetHdc(), GetHfontOf(*font));
}
const size_t len = string.length();
if ( !::GetTextExtentPoint32(GetHdc(), string.wx_str(), len, &sizeRect) )
{
- wxLogLastError(_T("GetTextExtentPoint32()"));
+ wxLogLastError(wxT("GetTextExtentPoint32()"));
}
#if !defined(_WIN32_WCE) || (_WIN32_WCE >= 400)
}
#endif // !defined(_WIN32_WCE) || (_WIN32_WCE >= 400)
- TEXTMETRIC tm;
- ::GetTextMetrics(GetHdc(), &tm);
-
if (x)
*x = sizeRect.cx;
if (y)
*y = sizeRect.cy;
- if (descent)
- *descent = tm.tmDescent;
- if (externalLeading)
- *externalLeading = tm.tmExternalLeading;
+
+ if ( descent || externalLeading )
+ {
+ DoGetFontMetrics(NULL, NULL, descent, NULL, externalLeading, NULL);
+ }
if ( hfontOld )
{
return true;
}
+namespace
+{
+
+void ApplyEffectiveScale(double scale, int sign, int *device, int *logical)
+{
+ // To reduce rounding errors as much as possible, we try to use the largest
+ // possible extent (2^27-1) for the device space but we must also avoid
+ // overflowing the int range i.e. ensure that logical extents are less than
+ // 2^31 in magnitude. So the minimal scale we can use is 1/16 as for
+ // anything smaller VIEWPORT_EXTENT/scale would overflow the int range.
+ static const double MIN_LOGICAL_SCALE = 1./16;
+
+ double physExtent = VIEWPORT_EXTENT;
+ if ( scale < MIN_LOGICAL_SCALE )
+ {
+ physExtent *= scale/MIN_LOGICAL_SCALE;
+ scale = MIN_LOGICAL_SCALE;
+ }
+
+ *device = wxRound(physExtent);
+ *logical = sign*wxRound(VIEWPORT_EXTENT/scale);
+}
+
+} // anonymous namespace
+
void wxMSWDCImpl::RealizeScaleAndOrigin()
{
// although it may seem wasteful to always use MM_ANISOTROPIC here instead
#ifndef __WXWINCE__
::SetMapMode(GetHdc(), MM_ANISOTROPIC);
- int width = DeviceToLogicalXRel(VIEWPORT_EXTENT)*m_signX,
- height = DeviceToLogicalYRel(VIEWPORT_EXTENT)*m_signY;
+ // wxWidgets API assumes that the coordinate space is "infinite" (i.e. only
+ // limited by 2^32 range of the integer coordinates) but in MSW API we must
+ // actually specify the extents that we use so compute them here.
+
+ int devExtX, devExtY, // Viewport, i.e. device space, extents.
+ logExtX, logExtY; // Window, i.e. logical coordinate space, extents.
- ::SetViewportExtEx(GetHdc(), VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL);
- ::SetWindowExtEx(GetHdc(), width, height, NULL);
+ ApplyEffectiveScale(m_scaleX, m_signX, &devExtX, &logExtX);
+ ApplyEffectiveScale(m_scaleY, m_signY, &devExtY, &logExtY);
+
+ ::SetViewportExtEx(GetHdc(), devExtX, devExtY, NULL);
+ ::SetWindowExtEx(GetHdc(), logExtX, logExtY, NULL);
::SetViewportOrgEx(GetHdc(), m_deviceOriginX, m_deviceOriginY, NULL);
::SetWindowOrgEx(GetHdc(), m_logicalOriginX, m_logicalOriginY, NULL);
#endif
}
-void wxMSWDCImpl::SetMapMode(int mode)
+void wxMSWDCImpl::SetMapMode(wxMappingMode mode)
{
WXMICROWIN_CHECK_HDC
break;
default:
- wxFAIL_MSG( _T("unknown mapping mode in SetMapMode") );
+ wxFAIL_MSG( wxT("unknown mapping mode in SetMapMode") );
}
}
::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
}
+// ----------------------------------------------------------------------------
+// Transform matrix
+// ----------------------------------------------------------------------------
+
+#if wxUSE_DC_TRANSFORM_MATRIX
+
+bool wxMSWDCImpl::CanUseTransformMatrix() const
+{
+ return GdiWorldTransformFuncs::IsOk();
+}
+
+bool wxMSWDCImpl::SetTransformMatrix(const wxAffineMatrix2D &matrix)
+{
+ if ( !GdiWorldTransformFuncs::IsOk() )
+ return false;
+
+ if ( matrix.IsIdentity() )
+ {
+ ResetTransformMatrix();
+ return true;
+ }
+
+ if ( !GdiWorldTransformFuncs::SetGraphicsMode()(GetHdc(), GM_ADVANCED) )
+ {
+ wxLogLastError(wxT("SetGraphicsMode"));
+ return false;
+ }
+
+ wxMatrix2D mat;
+ wxPoint2DDouble tr;
+ matrix.Get(&mat, &tr);
+
+ XFORM xform;
+ xform.eM11 = mat.m_11;
+ xform.eM12 = mat.m_12;
+ xform.eM21 = mat.m_21;
+ xform.eM22 = mat.m_22;
+ xform.eDx = tr.m_x;
+ xform.eDy = tr.m_y;
+
+ if ( !GdiWorldTransformFuncs::SetWorldTransform()(GetHdc(), &xform) )
+ {
+ wxLogLastError(wxT("SetWorldTransform"));
+ return false;
+ }
+
+ return true;
+}
+
+wxAffineMatrix2D wxMSWDCImpl::GetTransformMatrix() const
+{
+ wxAffineMatrix2D transform;
+
+ if ( !GdiWorldTransformFuncs::IsOk() )
+ return transform;
+
+ XFORM xform;
+ if ( !GdiWorldTransformFuncs::GetWorldTransform()(GetHdc(), &xform) )
+ {
+ wxLogLastError(wxT("GetWorldTransform"));
+ return transform;
+ }
+
+ wxMatrix2D m(xform.eM11, xform.eM12, xform.eM21, xform.eM22);
+ wxPoint2DDouble p(xform.eDx, xform.eDy);
+ transform.Set(m, p);
+
+ return transform;
+}
+
+void wxMSWDCImpl::ResetTransformMatrix()
+{
+ if ( GdiWorldTransformFuncs::IsOk() )
+ {
+ GdiWorldTransformFuncs::ModifyWorldTransform()(GetHdc(), NULL, MWT_IDENTITY);
+ GdiWorldTransformFuncs::SetGraphicsMode()(GetHdc(), GM_COMPATIBLE);
+ }
+}
+
+#endif // wxUSE_DC_TRANSFORM_MATRIX
+
// ---------------------------------------------------------------------------
// bit blit
// ---------------------------------------------------------------------------
wxCoord dstWidth, wxCoord dstHeight,
wxDC *source,
wxCoord srcX, wxCoord srcY,
- int rop, bool useMask,
+ wxRasterOperationMode rop, bool useMask,
wxCoord srcMaskX, wxCoord srcMaskY)
{
return DoStretchBlit(dstX, dstY, dstWidth, dstHeight, source, srcX, srcY, dstWidth, dstHeight, rop, useMask, srcMaskX, srcMaskY);
wxDC *source,
wxCoord xsrc, wxCoord ysrc,
wxCoord srcWidth, wxCoord srcHeight,
- int rop, bool useMask,
+ wxRasterOperationMode rop, bool useMask,
wxCoord xsrcMask, wxCoord ysrcMask)
{
- wxCHECK_MSG( source, false, _T("wxMSWDCImpl::Blit(): NULL wxDC pointer") );
+ wxCHECK_MSG( source, false, wxT("wxMSWDCImpl::Blit(): NULL wxDC pointer") );
WXMICROWIN_CHECK_HDC_RET(false)
// than the wxWidgets fall-back implementation. So we need
// to be able to switch this on and off at runtime.
#if wxUSE_SYSTEM_OPTIONS
- if (wxSystemOptions::GetOptionInt(wxT("no-maskblt")) == 0)
+ static bool s_maskBltAllowed = wxSystemOptions::GetOptionInt("no-maskblt") == 0;
+ if ( s_maskBltAllowed )
#endif
{
if ( dstWidth == srcWidth && dstHeight == srcHeight )
wxLogLastError(wxT("BitBlt"));
}
-#ifndef __WXWINCE__
- StretchBltModeChanger changeMode(dc_buffer, COLORONCOLOR);
-#endif
+ SET_STRETCH_BLT_MODE(GetHdc());
// copy src to buffer using selected raster op
if ( !::StretchBlt(dc_buffer, 0, 0, dstWidth, dstHeight,
sizeof(ds),
&ds) == sizeof(ds) )
{
- StretchBltModeChanger changeMode(GetHdc(), COLORONCOLOR);
+ SET_STRETCH_BLT_MODE(GetHdc());
// Figure out what co-ordinate system we're supposed to specify
// ysrc in.
if ( hDIB > 0 )
{
// reflect ysrc
- ysrc = hDIB - (ysrc + dstHeight);
+ ysrc = hDIB - (ysrc + srcHeight);
}
if ( ::StretchDIBits(GetHdc(),
#endif
// __WXWINCE__
{
-#ifndef __WXWINCE__
- StretchBltModeChanger changeMode(GetHdc(), COLORONCOLOR);
-#endif
+ SET_STRETCH_BLT_MODE(GetHdc());
if ( !::StretchBlt
(
dwRop
) )
{
- wxLogLastError(_T("StretchBlt"));
+ wxLogLastError(wxT("StretchBlt"));
}
else
{
if ( !::BitBlt(GetHdc(), xdest, ydest, dstWidth, dstHeight,
hdcSrc, xsrc, ysrc, dwRop) )
{
- wxLogLastError(_T("BitBlt"));
+ wxLogLastError(wxT("BitBlt"));
}
else
{
{
int wTotal = ::GetDeviceCaps(GetHdc(), HORZRES);
- wxCHECK_RET( wTotal, _T("0 width device?") );
+ wxCHECK_RET( wTotal, wxT("0 width device?") );
*w = (wPixels * ::GetDeviceCaps(GetHdc(), HORZSIZE)) / wTotal;
}
{
int hTotal = ::GetDeviceCaps(GetHdc(), VERTRES);
- wxCHECK_RET( hTotal, _T("0 height device?") );
+ wxCHECK_RET( hTotal, wxT("0 height device?") );
*h = (hPixels * ::GetDeviceCaps(GetHdc(), VERTSIZE)) / hTotal;
}
HDC hdcSrc,
const wxBitmap& bmp)
{
- wxASSERT_MSG( bmp.IsOk() && bmp.HasAlpha(), _T("AlphaBlt(): invalid bitmap") );
- wxASSERT_MSG( hdcDst && hdcSrc, _T("AlphaBlt(): invalid HDC") );
+ wxASSERT_MSG( bmp.IsOk() && bmp.HasAlpha(), wxT("AlphaBlt(): invalid bitmap") );
+ wxASSERT_MSG( hdcDst && hdcSrc, wxT("AlphaBlt(): invalid HDC") );
// do we have AlphaBlend() and company in the headers?
#if defined(AC_SRC_OVER) && wxUSE_DYNLIB_CLASS
BLENDFUNCTION);
static AlphaBlend_t
- pfnAlphaBlend = (AlphaBlend_t)wxMSIMG32DLL.GetSymbol(_T("AlphaBlend"));
+ pfnAlphaBlend = (AlphaBlend_t)wxMSIMG32DLL.GetSymbol(wxT("AlphaBlend"));
if ( pfnAlphaBlend )
{
BLENDFUNCTION bf;
return true;
}
- wxLogLastError(_T("AlphaBlend"));
+ wxLogLastError(wxT("AlphaBlend"));
}
#else
wxUnusedVar(hdcSrc);
if ( !::BitBlt(hdcMem, 0, 0, dstWidth, dstHeight, hdcDst, xDst, yDst, SRCCOPY) )
{
- wxLogLastError(_T("BitBlt"));
+ wxLogLastError(wxT("BitBlt"));
}
// combine them with the source bitmap using alpha
dataSrc((wxBitmap &)bmpSrc);
wxCHECK_RET( dataDst && dataSrc,
- _T("failed to get raw data in wxAlphaBlend") );
+ wxT("failed to get raw data in wxAlphaBlend") );
wxAlphaPixelData::Iterator pDst(dataDst),
pSrc(dataSrc);
// and finally blit them back to the destination DC
if ( !::BitBlt(hdcDst, xDst, yDst, dstWidth, dstHeight, hdcMem, 0, 0, SRCCOPY) )
{
- wxLogLastError(_T("BitBlt"));
+ wxLogLastError(wxT("BitBlt"));
}
}
typedef BOOL
(WINAPI *GradientFill_t)(HDC, PTRIVERTEX, ULONG, PVOID, ULONG, ULONG);
static GradientFill_t pfnGradientFill =
- (GradientFill_t)wxMSIMG32DLL.GetSymbol(_T("GradientFill"));
+ (GradientFill_t)wxMSIMG32DLL.GetSymbol(wxT("GradientFill"));
if ( pfnGradientFill )
{
return;
}
- wxLogLastError(_T("GradientFill"));
+ wxLogLastError(wxT("GradientFill"));
}
#endif // wxUSE_DYNLIB_CLASS
{
typedef DWORD (WINAPI *GetLayout_t)(HDC);
static GetLayout_t
- wxDL_INIT_FUNC(s_pfn, GetLayout, wxDynamicLibrary(_T("gdi32.dll")));
+ wxDL_INIT_FUNC(s_pfn, GetLayout, wxDynamicLibrary(wxT("gdi32.dll")));
return s_pfnGetLayout ? s_pfnGetLayout(hdc) : (DWORD)-1;
}
{
typedef DWORD (WINAPI *SetLayout_t)(HDC, DWORD);
static SetLayout_t
- wxDL_INIT_FUNC(s_pfn, SetLayout, wxDynamicLibrary(_T("gdi32.dll")));
+ wxDL_INIT_FUNC(s_pfn, SetLayout, wxDynamicLibrary(wxT("gdi32.dll")));
if ( !s_pfnSetLayout )
return;
projects / wxWidgets.git / blobdiff