X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/9a83f860948059b0273b5cc6d9e43fadad3ebfca..7fbc727b20f39088ddd5e5cf4b6aed930da69119:/src/msw/dc.cpp diff --git a/src/msw/dc.cpp b/src/msw/dc.cpp index d25954bd32..e0e1ec6523 100644 --- a/src/msw/dc.cpp +++ b/src/msw/dc.cpp @@ -82,7 +82,7 @@ IMPLEMENT_ABSTRACT_CLASS(wxMSWDCImpl, wxDCImpl) // constants // --------------------------------------------------------------------------- -static const int VIEWPORT_EXTENT = 1000; +static const int VIEWPORT_EXTENT = 1024; // 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) @@ -273,6 +273,98 @@ private: 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 // =========================================================================== @@ -723,7 +815,7 @@ void wxMSWDCImpl::DoDrawArc(wxCoord x1, wxCoord y1, 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). @@ -931,7 +1023,7 @@ void wxMSWDCImpl::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord h // (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++; @@ -965,7 +1057,7 @@ void wxMSWDCImpl::DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wx // 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++; @@ -1048,11 +1140,11 @@ void wxMSWDCImpl::DoDrawSpline(const wxPointList *points) 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; @@ -1214,13 +1306,20 @@ void wxMSWDCImpl::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool #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()); @@ -1296,6 +1395,18 @@ void wxMSWDCImpl::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool 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); @@ -1543,15 +1654,22 @@ void wxMSWDCImpl::SetBrush(const wxBrush& brush) 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 ) ) { @@ -1696,6 +1814,31 @@ wxCoord wxMSWDCImpl::GetCharWidth() const 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 @@ -1758,17 +1901,15 @@ void wxMSWDCImpl::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y } #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 ) { @@ -1826,11 +1967,39 @@ void wxMSWDCImpl::RealizeScaleAndOrigin() #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 we more or less arbitrarily + // decide to use "base" VIEWPORT_EXTENT and adjust it depending on scale. + // + // To avoid rounding errors we prefer to multiply by the scale if it's > 1 + // and to divide by it if it's < 1. + int devExtX, devExtY, // Viewport, i.e. device space, extents. + logExtX, logExtY; // Window, i.e. logical coordinate space, extents. + if ( m_scaleX >= 1 ) + { + devExtX = VIEWPORT_EXTENT*m_scaleX; + logExtX = m_signX*VIEWPORT_EXTENT; + } + else + { + devExtX = VIEWPORT_EXTENT; + logExtX = m_signX*VIEWPORT_EXTENT/m_scaleX; + } + + if ( m_scaleY >= 1 ) + { + devExtY = VIEWPORT_EXTENT*m_scaleY; + logExtY = m_signY*VIEWPORT_EXTENT; + } + else + { + devExtY = VIEWPORT_EXTENT; + logExtY = m_signY*VIEWPORT_EXTENT/m_scaleY; + } - ::SetViewportExtEx(GetHdc(), VIEWPORT_EXTENT, VIEWPORT_EXTENT, NULL); - ::SetWindowExtEx(GetHdc(), width, height, NULL); + ::SetViewportExtEx(GetHdc(), devExtX, devExtY, NULL); + ::SetWindowExtEx(GetHdc(), logExtX, logExtY, NULL); ::SetViewportOrgEx(GetHdc(), m_deviceOriginX, m_deviceOriginY, NULL); ::SetWindowOrgEx(GetHdc(), m_logicalOriginX, m_logicalOriginY, NULL); @@ -1956,6 +2125,87 @@ void wxMSWDCImpl::SetDeviceOrigin(wxCoord x, wxCoord y) ::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 // ---------------------------------------------------------------------------