/////////////////////////////////////////////////////////////////////////////
-// Name: dc.cpp
-// Purpose: wxDC class
+// Name: src/msw/dc.cpp
+// Purpose: wxDC class for MSW port
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
// Copyright: (c) Julian Smart
-// Licence: wxWidgets licence
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ===========================================================================
// headers
// ---------------------------------------------------------------------------
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
- #pragma implementation "dc.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#endif
#ifndef WX_PRECOMP
+ #include "wx/msw/wrapcdlg.h"
+ #include "wx/image.h"
#include "wx/window.h"
#include "wx/dc.h"
#include "wx/utils.h"
#include "wx/dcmemory.h"
#include "wx/log.h"
#include "wx/icon.h"
+ #include "wx/dcprint.h"
+ #include "wx/module.h"
#endif
-#include "wx/msw/private.h" // needs to be before #include <commdlg.h>
-#include "wx/msw/missing.h" // needs to be before #include <commdlg.h>
-
#include "wx/sysopt.h"
-#include "wx/dcprint.h"
-#include "wx/module.h"
-#include "wx/dynload.h"
+#include "wx/dynlib.h"
#ifdef wxHAVE_RAW_BITMAP
#include "wx/rawbmp.h"
#endif
#include <string.h>
-#include <math.h>
-
-#if wxUSE_COMMON_DIALOGS && !defined(__WXMICROWIN__)
- #include <commdlg.h>
-#endif
#ifndef __WIN32__
#include <print.h>
#endif
#ifndef AC_SRC_ALPHA
-#define AC_SRC_ALPHA 1
+ #define AC_SRC_ALPHA 1
+#endif
+
+#ifndef LAYOUT_RTL
+ #define LAYOUT_RTL 1
#endif
/* Quaternary raster codes */
static const int MM_POINTS = 9;
static const int MM_METRIC = 10;
-// usually this is defined in math.h
-#ifndef M_PI
- static const double M_PI = 3.14159265358979323846;
-#endif // M_PI
-
// 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)
#define DSTCOPY 0x00AA0029 // a.k.a. NOP operation
*/
#ifdef __WXWINCE__
- #define XLOG2DEV(x) ((x-m_logicalOriginX)*m_signX+m_deviceOriginX)
- #define YLOG2DEV(y) ((y-m_logicalOriginY)*m_signY+m_deviceOriginY)
- #define XDEV2LOG(x) ((x-m_deviceOriginX)*m_signX+m_logicalOriginX)
- #define YDEV2LOG(y) ((y-m_deviceOriginY)*m_signY+m_logicalOriginY)
+ #define XLOG2DEV(x) ((x-m_logicalOriginX)*m_signX)
+ #define YLOG2DEV(y) ((y-m_logicalOriginY)*m_signY)
+ #define XDEV2LOG(x) ((x)*m_signX+m_logicalOriginX)
+ #define YDEV2LOG(y) ((y)*m_signY+m_logicalOriginY)
#else
#define XLOG2DEV(x) (x)
#define YLOG2DEV(y) (y)
// otherwise
static bool AlphaBlt(HDC hdcDst,
int x, int y, int w, int h,
- HDC hdcSrc,
+ int srcX, int srcY, HDC hdcSrc,
const wxBitmap& bmpSrc);
#ifdef wxHAVE_RAW_BITMAP
-// our (limited) AlphaBlend() replacement
+
+// our (limited) AlphaBlend() replacement for Windows versions not providing it
static void
-wxAlphaBlend(HDC hdcDst, int x, int y, int w, int h, const wxBitmap& bmp);
-#endif
+wxAlphaBlend(HDC hdcDst, int x, int y, int w, int h,
+ int srcX, int srcY, const wxBitmap& bmp);
+
+#endif // wxHAVE_RAW_BITMAP
// ----------------------------------------------------------------------------
// private classes
class StretchBltModeChanger
{
public:
- StretchBltModeChanger(HDC hdc, int mode)
+ StretchBltModeChanger(HDC hdc,
+ int WXUNUSED_IN_WINCE(mode))
: m_hdc(hdc)
{
#ifndef __WXWINCE__
DECLARE_NO_COPY_CLASS(StretchBltModeChanger)
};
+// helper class to cache dynamically loaded libraries and not attempt reloading
+// them if it fails
+class wxOnceOnlyDLLLoader
+{
+public:
+ // ctor argument must be a literal string as we don't make a copy of it!
+ wxOnceOnlyDLLLoader(const wxChar *dllName)
+ : m_dllName(dllName)
+ {
+ };
+
+
+ // return the symbol with the given name or NULL if the DLL not loaded
+ // or symbol not present
+ void *GetSymbol(const wxChar *name)
+ {
+ // we're prepared to handle errors here
+ wxLogNull noLog;
+
+ if ( m_dllName )
+ {
+ m_dll.Load(m_dllName);
+
+ // reset the name whether we succeeded or failed so that we don't
+ // try again the next time
+ m_dllName = NULL;
+ }
+
+ return m_dll.IsLoaded() ? m_dll.GetSymbol(name) : NULL;
+ }
+
+private:
+ wxDynamicLibrary m_dll;
+ const wxChar *m_dllName;
+};
+
+static wxOnceOnlyDLLLoader wxGDI32DLL(_T("gdi32"));
+static wxOnceOnlyDLLLoader wxMSIMG32DLL(_T("msimg32"));
+
// ===========================================================================
// implementation
// ===========================================================================
// wxDC
// ---------------------------------------------------------------------------
-// Default constructor
-wxDC::wxDC()
-{
- m_canvas = NULL;
-
- m_oldBitmap = 0;
- m_oldPen = 0;
- m_oldBrush = 0;
- m_oldFont = 0;
-#if wxUSE_PALETTE
- m_oldPalette = 0;
-#endif // wxUSE_PALETTE
-
- m_bOwnsDC = false;
- m_hDC = 0;
-}
-
wxDC::~wxDC()
{
if ( m_hDC != 0 )
if ( !::GetClipBox(GetHdc(), &rectClip) )
return;
+ // GetClipBox returns logical coordinates, so transform to device
+ rectClip.left = LogicalToDeviceX(rectClip.left);
+ rectClip.top = LogicalToDeviceY(rectClip.top);
+ rectClip.right = LogicalToDeviceX(rectClip.right);
+ rectClip.bottom = LogicalToDeviceY(rectClip.bottom);
+
HRGN hrgnDest = ::CreateRectRgn(0, 0, 0, 0);
HRGN hrgnClipOld = ::CreateRectRgn(rectClip.left, rectClip.top,
rectClip.right, rectClip.bottom);
if (m_clipping && m_hDC)
{
+#if 1
+ // On a PocketPC device (not necessarily emulator), resetting
+ // the clip region as per the old method causes bad display
+ // problems. In fact setting a null region is probably OK
+ // on desktop WIN32 also, since the WIN32 docs imply that the user
+ // clipping region is independent from the paint clipping region.
+ ::SelectClipRgn(GetHdc(), 0);
+#else
// TODO: this should restore the previous clipping region,
// so that OnPaint processing works correctly, and the update
// clipping region doesn't get destroyed after the first
HRGN rgn = CreateRectRgn(0, 0, 32000, 32000);
::SelectClipRgn(GetHdc(), rgn);
::DeleteObject(rgn);
+#endif
}
wxDCBase::DestroyClippingRegion();
if (!m_selectedBitmap.Ok())
return;
- rect.left = 0; rect.top = 0;
- rect.right = m_selectedBitmap.GetWidth();
- rect.bottom = m_selectedBitmap.GetHeight();
+ rect.left = -m_deviceOriginX; rect.top = -m_deviceOriginY;
+ rect.right = m_selectedBitmap.GetWidth()-m_deviceOriginX;
+ rect.bottom = m_selectedBitmap.GetHeight()-m_deviceOriginY;
}
#ifndef __WXWINCE__
::FillRect(GetHdc(), &rect, brush);
::DeleteObject(brush);
+#ifndef __WXWINCE__
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);
#endif
}
-bool wxDC::DoFloodFill(wxCoord x, wxCoord y, const wxColour& col, int style)
+bool wxDC::DoFloodFill(wxCoord WXUNUSED_IN_WINCE(x),
+ wxCoord WXUNUSED_IN_WINCE(y),
+ const wxColour& WXUNUSED_IN_WINCE(col),
+ int WXUNUSED_IN_WINCE(style))
{
#ifdef __WXWINCE__
return false;
#else
-
WXMICROWIN_CHECK_HDC_RET(false)
bool success = (0 != ::ExtFloodFill(GetHdc(), XLOG2DEV(x), YLOG2DEV(y),
void wxDC::DoDrawCheckMark(wxCoord x1, wxCoord y1,
wxCoord width, wxCoord height)
{
- WXMICROWIN_CHECK_HDC
-
+ // cases when we don't have DrawFrameControl()
+#if defined(__SYMANTEC__) || defined(__WXMICROWIN__)
+ return wxDCBase::DoDrawCheckMark(x1, y1, width, height);
+#else // normal case
wxCoord x2 = x1 + width,
y2 = y1 + height;
-#if defined(__WIN32__) && !defined(__SYMANTEC__) && !defined(__WXMICROWIN__)
RECT rect;
rect.left = x1;
rect.top = y1;
#else
DrawFrameControl(GetHdc(), &rect, DFC_MENU, DFCS_MENUCHECK);
#endif
-#else // Symantec-MicroWin
- // draw a cross
- HPEN blackPen = ::CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
- HPEN whiteBrush = (HPEN)::GetStockObject(WHITE_BRUSH);
- HPEN hPenOld = (HPEN)::SelectObject(GetHdc(), blackPen);
- HPEN hBrushOld = (HPEN)::SelectObject(GetHdc(), whiteBrush);
- ::SetROP2(GetHdc(), R2_COPYPEN);
- Rectangle(GetHdc(), x1, y1, x2, y2);
- MoveToEx(GetHdc(), x1, y1, NULL);
- LineTo(GetHdc(), x2, y2);
- MoveToEx(GetHdc(), x2, y1, NULL);
- LineTo(GetHdc(), x1, y2);
- ::SelectObject(GetHdc(), hPenOld);
- ::SelectObject(GetHdc(), hBrushOld);
- ::DeleteObject(blackPen);
-#endif // Win32/Symantec-MicroWin
CalcBoundingBox(x1, y1);
CalcBoundingBox(x2, y2);
+#endif // Microwin/Normal
}
void wxDC::DoDrawPoint(wxCoord x, wxCoord y)
CalcBoundingBox(x, y);
}
-void wxDC::DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset,int fillStyle)
+void wxDC::DoDrawPolygon(int n,
+ wxPoint points[],
+ wxCoord xoffset,
+ wxCoord yoffset,
+ int WXUNUSED_IN_WINCE(fillStyle))
{
WXMICROWIN_CHECK_HDC
{
#ifdef __WXWINCE__
wxDCBase::DoDrawPolyPolygon(n, count, points, xoffset, yoffset, fillStyle);
-#else
+#else
WXMICROWIN_CHECK_HDC
wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
}
#ifndef __WXWINCE__
int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
-#endif
+#endif
(void)PolyPolygon(GetHdc(), cpoints, count, n);
#ifndef __WXWINCE__
SetPolyFillMode(GetHdc(),prev);
-#endif
+#endif
delete[] cpoints;
}
else
#ifndef __WXWINCE__
int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
-#endif
+#endif
(void)PolyPolygon(GetHdc(), (POINT*) points, count, n);
#ifndef __WXWINCE__
SetPolyFillMode(GetHdc(),prev);
-#endif
+#endif
}
#endif
// __WXWINCE__
// transparent pen) one pixel smaller in both directions and we want them
// to have the same size regardless of which pen is used - adjust
- // I wonder if this shouldnยดt be done after the LOG2DEV() conversions. RR.
+ // I wonder if this shouldnt be done after the LOG2DEV() conversions. RR.
if ( m_pen.GetStyle() == wxTRANSPARENT )
{
+ // Apparently not needed for WinCE (see e.g. Life! demo)
+#ifndef __WXWINCE__
x2++;
y2++;
+#endif
}
(void)Rectangle(GetHdc(), XLOG2DEV(x), YLOG2DEV(y), XLOG2DEV(x2), YLOG2DEV(y2));
CalcBoundingBox(x2, y2);
}
+#if wxUSE_SPLINES
+void wxDC::DoDrawSpline(wxList *points)
+{
+#ifdef __WXWINCE__
+ // WinCE does not support ::PolyBezier so use generic version
+ wxDCBase::DoDrawSpline(points);
+#else
+ // quadratic b-spline to cubic bezier spline conversion
+ //
+ // quadratic spline with control points P0,P1,P2
+ // P(s) = P0*(1-s)^2 + P1*2*(1-s)*s + P2*s^2
+ //
+ // bezier spline with control points B0,B1,B2,B3
+ // B(s) = B0*(1-s)^3 + B1*3*(1-s)^2*s + B2*3*(1-s)*s^2 + B3*s^3
+ //
+ // control points of bezier spline calculated from b-spline
+ // B0 = P0
+ // B1 = (2*P1 + P0)/3
+ // B2 = (2*P1 + P2)/3
+ // B3 = P2
+
+ WXMICROWIN_CHECK_HDC
+
+ wxASSERT_MSG( points, wxT("NULL pointer to spline points?") );
+
+ const size_t n_points = points->GetCount();
+ wxASSERT_MSG( n_points > 2 , wxT("incomplete list of spline points?") );
+
+ const size_t n_bezier_points = n_points * 3 + 1;
+ POINT *lppt = (POINT *)malloc(n_bezier_points*sizeof(POINT));
+ size_t bezier_pos = 0;
+ wxCoord x1, y1, x2, y2, cx1, cy1, cx4, cy4;
+
+ wxList::compatibility_iterator node = points->GetFirst();
+ wxPoint *p = (wxPoint *)node->GetData();
+ lppt[ bezier_pos ].x = x1 = p->x;
+ lppt[ bezier_pos ].y = y1 = p->y;
+ bezier_pos++;
+ lppt[ bezier_pos ] = lppt[ bezier_pos-1 ];
+ bezier_pos++;
+
+ node = node->GetNext();
+ p = (wxPoint *)node->GetData();
+
+ x2 = p->x;
+ y2 = p->y;
+ cx1 = ( x1 + x2 ) / 2;
+ cy1 = ( y1 + y2 ) / 2;
+ lppt[ bezier_pos ].x = XLOG2DEV(cx1);
+ lppt[ bezier_pos ].y = YLOG2DEV(cy1);
+ bezier_pos++;
+ lppt[ bezier_pos ] = lppt[ bezier_pos-1 ];
+ bezier_pos++;
+
+#if !wxUSE_STL
+ while ((node = node->GetNext()) != NULL)
+#else
+ while ((node = node->GetNext()))
+#endif // !wxUSE_STL
+ {
+ p = (wxPoint *)node->GetData();
+ x1 = x2;
+ y1 = y2;
+ x2 = p->x;
+ y2 = p->y;
+ cx4 = (x1 + x2) / 2;
+ cy4 = (y1 + y2) / 2;
+ // B0 is B3 of previous segment
+ // B1:
+ lppt[ bezier_pos ].x = XLOG2DEV((x1*2+cx1)/3);
+ lppt[ bezier_pos ].y = YLOG2DEV((y1*2+cy1)/3);
+ bezier_pos++;
+ // B2:
+ lppt[ bezier_pos ].x = XLOG2DEV((x1*2+cx4)/3);
+ lppt[ bezier_pos ].y = YLOG2DEV((y1*2+cy4)/3);
+ bezier_pos++;
+ // B3:
+ lppt[ bezier_pos ].x = XLOG2DEV(cx4);
+ lppt[ bezier_pos ].y = YLOG2DEV(cy4);
+ bezier_pos++;
+ cx1 = cx4;
+ cy1 = cy4;
+ }
+
+ lppt[ bezier_pos ] = lppt[ bezier_pos-1 ];
+ bezier_pos++;
+ lppt[ bezier_pos ].x = XLOG2DEV(x2);
+ lppt[ bezier_pos ].y = YLOG2DEV(y2);
+ bezier_pos++;
+ lppt[ bezier_pos ] = lppt[ bezier_pos-1 ];
+ bezier_pos++;
+
+ ::PolyBezier( GetHdc(), lppt, bezier_pos );
+
+ free(lppt);
+#endif
+}
+#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)
{
MemoryHDC hdcMem;
SelectInHDC select(hdcMem, GetHbitmapOf(bmp));
- if ( AlphaBlt(GetHdc(), x, y, width, height, hdcMem, bmp) )
+ if ( AlphaBlt(GetHdc(), x, y, width, height, 0, 0, hdcMem, bmp) )
return;
}
// Rather than reproduce wxDC::Blit, let's do it at the wxWin API
// level
wxMemoryDC memDC;
- memDC.SelectObject(bmp);
+
+ memDC.SelectObjectAsSource(bmp);
Blit(x, y, width, height, &memDC, 0, 0, wxCOPY, useMask);
// "upper left" and "upper right"
CalcBoundingBox(x, y);
- CalcBoundingBox(x + wxCoord(w*cos(rad)), y - wxCoord(h*sin(rad)));
+ CalcBoundingBox(x + wxCoord(w*cos(rad)), y - wxCoord(w*sin(rad)));
// "bottom left" and "bottom right"
x += (wxCoord)(h*sin(rad));
y += (wxCoord)(h*cos(rad));
CalcBoundingBox(x, y);
- CalcBoundingBox(x + wxCoord(h*sin(rad)), y + wxCoord(h*cos(rad)));
+ CalcBoundingBox(x + wxCoord(w*cos(rad)), y - wxCoord(w*sin(rad)));
}
#endif
}
else // selected ok
{
if ( !m_oldFont )
- m_oldFont = (WXHPEN)hfont;
+ m_oldFont = (WXHFONT)hfont;
m_font = font;
}
else // selected ok
{
if ( !m_oldBrush )
- m_oldBrush = (WXHPEN)hbrush;
+ m_oldBrush = (WXHBRUSH)hbrush;
m_brush = brush;
}
}
SIZE sizeRect;
- TEXTMETRIC tm;
+ const size_t len = string.length();
+ if ( !::GetTextExtentPoint32(GetHdc(), string, len, &sizeRect) )
+ {
+ wxLogLastError(_T("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
- GetTextExtentPoint(GetHdc(), string, string.length(), &sizeRect);
- GetTextMetrics(GetHdc(), &tm);
+ 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;
static int maxWidth = -1;
int fit = 0;
SIZE sz = {0,0};
- int stlen = text.Length();
+ int stlen = text.length();
if (maxLenText == -1)
{
// Win9x and WinNT+ have different limits
int version = wxGetOsVersion();
- maxLenText = version == wxWINDOWS_NT ? 65535 : 8192;
- maxWidth = version == wxWINDOWS_NT ? INT_MAX : 32767;
+ maxLenText = version == wxOS_WINDOWS_NT ? 65535 : 8192;
+ maxWidth = version == wxOS_WINDOWS_NT ? INT_MAX : 32767;
}
widths.Empty();
widths.Add(0, stlen); // fill the array with zeros
+ if (stlen == 0)
+ return true;
if (!::GetTextExtentExPoint(GetHdc(),
text.c_str(), // string to check
{
WXMICROWIN_CHECK_HDC
-#ifndef __WXWINCE__
if ( x == m_userScaleX && y == m_userScaleY )
return;
m_userScaleX = x;
m_userScaleY = y;
- SetMapMode(m_mappingMode);
-#endif
+ this->SetMapMode(m_mappingMode);
}
-void wxDC::SetAxisOrientation(bool xLeftRight, bool yBottomUp)
+void wxDC::SetAxisOrientation(bool WXUNUSED_IN_WINCE(xLeftRight),
+ bool WXUNUSED_IN_WINCE(yBottomUp))
{
WXMICROWIN_CHECK_HDC
m_deviceOriginX = x;
m_deviceOriginY = y;
-#ifndef __WXWINCE__
::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
-#endif
}
// ---------------------------------------------------------------------------
WXMICROWIN_CHECK_HDC_RET(false)
+ // if either the source or destination has alpha channel, we must use
+ // AlphaBlt() as other function don't handle it correctly
const wxBitmap& bmpSrc = source->m_selectedBitmap;
- if ( bmpSrc.Ok() && bmpSrc.HasAlpha() )
+ if ( bmpSrc.Ok() && (bmpSrc.HasAlpha() ||
+ (m_selectedBitmap.Ok() && m_selectedBitmap.HasAlpha())) )
{
if ( AlphaBlt(GetHdc(), xdest, ydest, width, height,
- GetHdcOf(*source), bmpSrc) )
+ xsrc, ysrc, GetHdcOf(*source), bmpSrc) )
return true;
}
ds.dsBm.bmBits,
(LPBITMAPINFO)&ds.dsBmih,
DIB_RGB_COLORS,
- SRCCOPY
+ dwRop
) == (int)GDI_ERROR )
{
// On Win9x this API fails most (all?) of the time, so
// logging it becomes quite distracting. Since it falls
// back to the code below this is not really serious, so
- // don't log it.
+ // don't log it.
//wxLogLastError(wxT("StretchDIBits"));
}
else
return success;
}
-void wxDC::DoGetSize(int *w, int *h) const
+void wxDC::GetDeviceSize(int *width, int *height) const
{
WXMICROWIN_CHECK_HDC
- if ( w ) *w = ::GetDeviceCaps(GetHdc(), HORZRES);
- if ( h ) *h = ::GetDeviceCaps(GetHdc(), VERTRES);
+ if ( width )
+ *width = ::GetDeviceCaps(GetHdc(), HORZRES);
+ if ( height )
+ *height = ::GetDeviceCaps(GetHdc(), VERTRES);
}
void wxDC::DoGetSizeMM(int *w, int *h) const
wxSize wxDC::GetPPI() const
{
- WXMICROWIN_CHECK_HDC_RET(wxSize())
+ WXMICROWIN_CHECK_HDC_RET(wxSize(0,0))
int x = ::GetDeviceCaps(GetHdc(), LOGPIXELSX);
int y = ::GetDeviceCaps(GetHdc(), LOGPIXELSY);
static bool AlphaBlt(HDC hdcDst,
int x, int y, int width, int height,
- HDC hdcSrc,
+ int srcX, int srcY, HDC hdcSrc,
const wxBitmap& bmp)
{
wxASSERT_MSG( bmp.Ok() && bmp.HasAlpha(), _T("AlphaBlt(): invalid bitmap") );
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();
- }
- }
- }
-
+ static AlphaBlend_t
+ pfnAlphaBlend = (AlphaBlend_t)wxMSIMG32DLL.GetSymbol(_T("AlphaBlend"));
if ( pfnAlphaBlend )
{
BLENDFUNCTION bf;
bf.AlphaFormat = AC_SRC_ALPHA;
if ( pfnAlphaBlend(hdcDst, x, y, width, height,
- hdcSrc, 0, 0, width, height,
+ hdcSrc, srcX, srcY, width, height,
bf) )
{
// skip wxAlphaBlend() call below
wxLogLastError(_T("AlphaBlend"));
}
+#else
+ wxUnusedVar(hdcSrc);
#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);
+ wxAlphaBlend(hdcDst, x, y, width, height, srcX, srcY, 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)
+ wxUnusedVar(bmp);
return false;
#endif // wxHAVE_RAW_BITMAP
}
#ifdef wxHAVE_RAW_BITMAP
static void
-wxAlphaBlend(HDC hdcDst, int xDst, int yDst, int w, int h, const wxBitmap& bmpSrc)
+wxAlphaBlend(HDC hdcDst, int xDst, int yDst,
+ int w, int h,
+ int srcX, int srcY, 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, hdcDst, 0, 0, SRCCOPY) )
+ if ( !::BitBlt(hdcMem, 0, 0, w, h, hdcDst, xDst, yDst, SRCCOPY) )
{
wxLogLastError(_T("BitBlt"));
}
wxAlphaPixelData::Iterator pDst(dataDst),
pSrc(dataSrc);
+ pSrc.Offset(dataSrc, srcX, srcY);
+
for ( int y = 0; y < h; y++ )
{
wxAlphaPixelData::Iterator pDstRowStart = pDst,
}
#endif // #ifdef wxHAVE_RAW_BITMAP
+
+void wxDC::DoGradientFillLinear (const wxRect& rect,
+ const wxColour& initialColour,
+ const wxColour& destColour,
+ wxDirection nDirection)
+{
+ // use native function if we have compile-time support it and can load it
+ // during run-time (linking to it statically would make the program
+ // unusable on earlier Windows versions)
+#if defined(GRADIENT_FILL_RECT_H) && wxUSE_DYNLIB_CLASS
+ typedef BOOL
+ (WINAPI *GradientFill_t)(HDC, PTRIVERTEX, ULONG, PVOID, ULONG, ULONG);
+ static GradientFill_t pfnGradientFill =
+ (GradientFill_t)wxMSIMG32DLL.GetSymbol(_T("GradientFill"));
+
+ if ( pfnGradientFill )
+ {
+ GRADIENT_RECT grect;
+ grect.UpperLeft = 0;
+ grect.LowerRight = 1;
+
+ // invert colours direction if not filling from left-to-right or
+ // top-to-bottom
+ int firstVertex = nDirection == wxNORTH || nDirection == wxWEST ? 1 : 0;
+
+ // one vertex for upper left and one for upper-right
+ TRIVERTEX vertices[2];
+
+ vertices[0].x = rect.GetLeft();
+ vertices[0].y = rect.GetTop();
+ vertices[1].x = rect.GetRight();
+ vertices[1].y = rect.GetBottom();
+
+ vertices[firstVertex].Red = (COLOR16)(initialColour.Red() << 8);
+ vertices[firstVertex].Green = (COLOR16)(initialColour.Green() << 8);
+ vertices[firstVertex].Blue = (COLOR16)(initialColour.Blue() << 8);
+ vertices[firstVertex].Alpha = 0;
+ vertices[1 - firstVertex].Red = (COLOR16)(destColour.Red() << 8);
+ vertices[1 - firstVertex].Green = (COLOR16)(destColour.Green() << 8);
+ vertices[1 - firstVertex].Blue = (COLOR16)(destColour.Blue() << 8);
+ vertices[1 - firstVertex].Alpha = 0;
+
+ if ( (*pfnGradientFill)
+ (
+ GetHdc(),
+ vertices,
+ WXSIZEOF(vertices),
+ &grect,
+ 1,
+ nDirection == wxWEST || nDirection == wxEAST
+ ? GRADIENT_FILL_RECT_H
+ : GRADIENT_FILL_RECT_V
+ ) )
+ {
+ // skip call of the base class version below
+ return;
+ }
+
+ wxLogLastError(_T("GradientFill"));
+ }
+#endif // wxUSE_DYNLIB_CLASS
+
+ wxDCBase::DoGradientFillLinear(rect, initialColour, destColour, nDirection);
+}
+
+static DWORD wxGetDCLayout(HDC hdc)
+{
+ typedef DWORD (WINAPI *GetLayout_t)(HDC);
+ static GetLayout_t
+ pfnGetLayout = (GetLayout_t)wxGDI32DLL.GetSymbol(_T("GetLayout"));
+
+ return pfnGetLayout ? pfnGetLayout(hdc) : (DWORD)-1;
+}
+
+wxLayoutDirection wxDC::GetLayoutDirection() const
+{
+ DWORD layout = wxGetDCLayout(GetHdc());
+
+ if ( layout == (DWORD)-1 )
+ return wxLayout_Default;
+
+ return layout & LAYOUT_RTL ? wxLayout_RightToLeft : wxLayout_LeftToRight;
+}
+
+void wxDC::SetLayoutDirection(wxLayoutDirection dir)
+{
+ typedef DWORD (WINAPI *SetLayout_t)(HDC, DWORD);
+ static SetLayout_t
+ pfnSetLayout = (SetLayout_t)wxGDI32DLL.GetSymbol(_T("SetLayout"));
+ if ( !pfnSetLayout )
+ return;
+
+ if ( dir == wxLayout_Default )
+ {
+ dir = wxTheApp->GetLayoutDirection();
+ if ( dir == wxLayout_Default )
+ return;
+ }
+
+ DWORD layout = wxGetDCLayout(GetHdc());
+ if ( dir == wxLayout_RightToLeft )
+ layout |= LAYOUT_RTL;
+ else
+ layout &= ~LAYOUT_RTL;
+
+ pfnSetLayout(GetHdc(), layout);
+}
projects / wxWidgets.git / blobdiff