#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 <string.h>
#include "wx/msw/private/dc.h"
+#include "wx/private/textmeasure.h"
using namespace wxMSWImpl;
// 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)
#endif // wxHAS_RAW_BITMAP
+namespace wxMSW
+{
+
+// Wrappers for the dynamically loaded {Set,Get}Layout() functions. They work
+// in exactly the same way as the standard functions and return GDI_ERROR if
+// they're not actually available.
+DWORD GetLayout(HDC hdc);
+DWORD SetLayout(HDC hdc, DWORD dwLayout);
+
+// Create a compatible HDC and copy the layout of the source DC to it. This is
+// necessary in order to draw bitmaps (which are usually blitted from a
+// temporary compatible memory DC to the real target DC) using the same layout.
+HDC CreateCompatibleDCWithLayout(HDC hdc);
+
+} // namespace wxMSW
+
// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------
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
// ===========================================================================
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).
}
void wxMSWDCImpl::DoDrawPolygon(int n,
- wxPoint points[],
+ const wxPoint points[],
wxCoord xoffset,
wxCoord yoffset,
wxPolygonFillMode WXUNUSED_IN_WINCE(fillStyle))
void
wxMSWDCImpl::DoDrawPolyPolygon(int n,
- int count[],
- wxPoint points[],
+ const int count[],
+ const wxPoint points[],
wxCoord xoffset,
wxCoord yoffset,
wxPolygonFillMode fillStyle)
// __WXWINCE__
}
-void wxMSWDCImpl::DoDrawLines(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset)
+void wxMSWDCImpl::DoDrawLines(int n, const wxPoint points[], wxCoord xoffset, wxCoord yoffset)
{
WXMICROWIN_CHECK_HDC
// (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++;
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;
#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());
+ HDC hdcMem = wxMSW::CreateCompatibleDCWithLayout(cdc);
HGDIOBJ hOldBitmap = ::SelectObject(hdcMem, GetHbitmapOf(bmp));
#if wxUSE_PALETTE
wxPalette *pal = bmp.GetPalette();
// level
wxMemoryDC memDC;
+ memDC.SetLayoutDirection(GetLayoutDirection());
memDC.SelectObjectAsSource(bmp);
GetOwner()->Blit(x, y, width, height, &memDC, 0, 0, wxCOPY, useMask);
-
- memDC.SelectObject(wxNullBitmap);
}
}
else // no mask, just use BitBlt()
{
HDC cdc = GetHdc();
- HDC memdc = ::CreateCompatibleDC( cdc );
+ HDC memdc = wxMSW::CreateCompatibleDCWithLayout( cdc );
HBITMAP hbitmap = (HBITMAP) bmp.GetHBITMAP( );
wxASSERT_MSG( hbitmap, wxT("bitmap is ok but HBITMAP is NULL?") );
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);
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
) )
{
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
}
#endif // __WXMICROWIN__
- HFONT hfontOld;
- if ( font )
- {
- wxASSERT_MSG( font->IsOk(), wxT("invalid font in wxMSWDCImpl::GetTextExtent") );
+ wxASSERT_MSG( !font || font->IsOk(), wxT("invalid font in wxMSWDCImpl::GetTextExtent") );
- hfontOld = (HFONT)::SelectObject(GetHdc(), GetHfontOf(*font));
- }
- else // don't change the font
- {
- hfontOld = 0;
- }
-
- SIZE sizeRect;
- const size_t len = string.length();
- if ( !::GetTextExtentPoint32(GetHdc(), string.wx_str(), len, &sizeRect) )
- {
- wxLogLastError(wxT("GetTextExtentPoint32()"));
- }
-
-#if !defined(_WIN32_WCE) || (_WIN32_WCE >= 400)
- // the result computed by GetTextExtentPoint32() may be too small as it
- // accounts for under/overhang of the first/last character while we want
- // just the bounding rect for this string so adjust the width as needed
- // (using API not available in 2002 SDKs of WinCE)
- if ( len > 0 )
- {
- ABC width;
- const wxChar chFirst = *string.begin();
- if ( ::GetCharABCWidths(GetHdc(), chFirst, chFirst, &width) )
- {
- if ( width.abcA < 0 )
- sizeRect.cx -= width.abcA;
-
- if ( len > 1 )
- {
- const wxChar chLast = *string.rbegin();
- ::GetCharABCWidths(GetHdc(), chLast, chLast, &width);
- }
- //else: we already have the width of the last character
-
- if ( width.abcC < 0 )
- sizeRect.cx -= width.abcC;
- }
- //else: GetCharABCWidths() failed, not a TrueType font?
- }
-#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 ( hfontOld )
- {
- ::SelectObject(GetHdc(), hfontOld);
- }
+ wxTextMeasure txm(GetOwner(), font);
+ txm.GetTextExtent(string, x, y, descent, externalLeading);
}
-// Each element of the array will be the width of the string up to and
-// including the coresoponding character in text.
-
bool wxMSWDCImpl::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
{
- static int maxLenText = -1;
- static int maxWidth = -1;
- int fit = 0;
- SIZE sz = {0,0};
- int stlen = text.length();
+ wxTextMeasure txm(GetOwner(), NULL); // don't change the font
+ return txm.GetPartialTextExtents(text, widths, 1.0);
+}
- if (maxLenText == -1)
- {
- // Win9x and WinNT+ have different limits
- int version = wxGetOsVersion();
- maxLenText = version == wxOS_WINDOWS_NT ? 65535 : 8192;
- maxWidth = version == wxOS_WINDOWS_NT ? INT_MAX : 32767;
- }
+namespace
+{
- widths.Empty();
- widths.Add(0, stlen); // fill the array with zeros
- if (stlen == 0)
- return true;
+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;
- if (!::GetTextExtentExPoint(GetHdc(),
- text.c_str(), // string to check
- wxMin(stlen, maxLenText),
- maxWidth,
- &fit, // [out] count of chars
- // that will fit
- &widths[0], // array to fill
- &sz))
- {
- // API failed
- wxLogLastError(wxT("GetTextExtentExPoint"));
- return false;
+ double physExtent = VIEWPORT_EXTENT;
+ if ( scale < MIN_LOGICAL_SCALE )
+ {
+ physExtent *= scale/MIN_LOGICAL_SCALE;
+ scale = MIN_LOGICAL_SCALE;
}
- return true;
+ *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.
+
+ ApplyEffectiveScale(m_scaleX, m_signX, &devExtX, &logExtX);
+ ApplyEffectiveScale(m_scaleY, m_signY, &devExtY, &logExtY);
- ::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);
::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
// ---------------------------------------------------------------------------
// 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 )
buffer_bmap = (HBITMAP) bitmapCacheEntry->m_bitmap;
#else // !wxUSE_DC_CACHEING
// create a temp buffer bitmap and DCs to access it and the mask
- dc_mask = ::CreateCompatibleDC(hdcSrc);
- dc_buffer = ::CreateCompatibleDC(GetHdc());
+ dc_mask = wxMSW::CreateCompatibleDCWithLayout(hdcSrc);
+ dc_buffer = wxMSW::CreateCompatibleDCWithLayout(GetHdc());
buffer_bmap = ::CreateCompatibleBitmap(GetHdc(), dstWidth, dstHeight);
#endif // wxUSE_DC_CACHEING/!wxUSE_DC_CACHEING
HGDIOBJ hOldMaskBitmap = ::SelectObject(dc_mask, (HBITMAP) mask->GetMaskBitmap());
{
SET_STRETCH_BLT_MODE(GetHdc());
+ // Unlike all the other functions used here (i.e. AlphaBlt(),
+ // MaskBlt(), BitBlt() and StretchBlt()), StretchDIBits() does
+ // not take into account the source DC logical coordinates
+ // automatically as it doesn't even work with the source HDC.
+ // So do this manually to ensure that the coordinates are
+ // interpreted in the same way here as in all the other cases.
+ xsrc = source->LogicalToDeviceX(xsrc);
+ ysrc = source->LogicalToDeviceY(ysrc);
+ srcWidth = source->LogicalToDeviceXRel(srcWidth);
+ srcHeight = source->LogicalToDeviceYRel(srcHeight);
+
// Figure out what co-ordinate system we're supposed to specify
// ysrc in.
const LONG hDIB = ds.dsBmih.biHeight;
node = node->GetNext();
}
- WXHDC hDC = (WXHDC) ::CreateCompatibleDC((HDC) dc);
+ WXHDC hDC = (WXHDC) wxMSW::CreateCompatibleDCWithLayout((HDC) dc);
if ( !hDC)
{
wxLogLastError(wxT("CreateCompatibleDC"));
#if wxUSE_DYNLIB_CLASS
-static DWORD wxGetDCLayout(HDC hdc)
+namespace wxMSW
+{
+
+DWORD GetLayout(HDC hdc)
{
typedef DWORD (WINAPI *GetLayout_t)(HDC);
static GetLayout_t
wxDL_INIT_FUNC(s_pfn, GetLayout, wxDynamicLibrary(wxT("gdi32.dll")));
- return s_pfnGetLayout ? s_pfnGetLayout(hdc) : (DWORD)-1;
+ return s_pfnGetLayout ? s_pfnGetLayout(hdc) : GDI_ERROR;
}
+DWORD SetLayout(HDC hdc, DWORD dwLayout)
+{
+ typedef DWORD (WINAPI *SetLayout_t)(HDC, DWORD);
+ static SetLayout_t
+ wxDL_INIT_FUNC(s_pfn, SetLayout, wxDynamicLibrary(wxT("gdi32.dll")));
+
+ return s_pfnSetLayout ? s_pfnSetLayout(hdc, dwLayout) : GDI_ERROR;
+}
+
+HDC CreateCompatibleDCWithLayout(HDC hdc)
+{
+ HDC hdcNew = ::CreateCompatibleDC(hdc);
+ if ( hdcNew )
+ {
+ DWORD dwLayout = wxMSW::GetLayout(hdc);
+ if ( dwLayout != GDI_ERROR )
+ wxMSW::SetLayout(hdcNew, dwLayout);
+ }
+
+ return hdcNew;
+}
+
+} // namespace wxMSW
+
wxLayoutDirection wxMSWDCImpl::GetLayoutDirection() const
{
- DWORD layout = wxGetDCLayout(GetHdc());
+ DWORD layout = wxMSW::GetLayout(GetHdc());
- if ( layout == (DWORD)-1 )
+ if ( layout == GDI_ERROR )
return wxLayout_Default;
return layout & LAYOUT_RTL ? wxLayout_RightToLeft : wxLayout_LeftToRight;
void wxMSWDCImpl::SetLayoutDirection(wxLayoutDirection dir)
{
- typedef DWORD (WINAPI *SetLayout_t)(HDC, DWORD);
- static SetLayout_t
- wxDL_INIT_FUNC(s_pfn, SetLayout, wxDynamicLibrary(wxT("gdi32.dll")));
- if ( !s_pfnSetLayout )
- return;
-
if ( dir == wxLayout_Default )
{
dir = wxTheApp->GetLayoutDirection();
return;
}
- DWORD layout = wxGetDCLayout(GetHdc());
+ DWORD layout = GetLayout(GetHdc());
+ if ( layout == GDI_ERROR )
+ return;
+
if ( dir == wxLayout_RightToLeft )
layout |= LAYOUT_RTL;
else
layout &= ~LAYOUT_RTL;
- s_pfnSetLayout(GetHdc(), layout);
+ wxMSW::SetLayout(GetHdc(), layout);
}
#else // !wxUSE_DYNLIB_CLASS
+// Provide stubs to avoid ifdefs in the code using these functions.
+namespace wxMSW
+{
+
+DWORD GetLayout(HDC WXUNUSED(hdc))
+{
+ return GDI_ERROR;
+}
+
+DWORD SetLayout(HDC WXUNUSED(hdc), DWORD WXUNUSED(dwLayout))
+{
+ return GDI_ERROR;
+}
+
+HDC CreateCompatibleDCWithLayout(HDC hdc)
+{
+ return ::CreateCompatibleDC(hdc);
+}
+
+} // namespace wxMSW
+
// we can't provide RTL support without dynamic loading, so stub it out
wxLayoutDirection wxMSWDCImpl::GetLayoutDirection() const
{
projects / wxWidgets.git / blobdiff