#endif
#ifndef WX_PRECOMP
+ #include "wx/image.h"
#include "wx/window.h"
#include "wx/dc.h"
#include "wx/utils.h"
#include "wx/icon.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"
#endif
#include <string.h>
-#include <math.h>
-
-#if wxUSE_COMMON_DIALOGS && !defined(__WXMICROWIN__)
- #include <commdlg.h>
-#endif
+#include "wx/msw/wrapcdlg.h"
#ifndef __WIN32__
#include <print.h>
#endif
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
coordinates used.
*/
-// logical to device
-#define XLOG2DEV(x) (x)
-#define YLOG2DEV(y) (y)
-
-// device to logical
-#define XDEV2LOG(x) (x)
-#define YDEV2LOG(y) (y)
+#ifdef __WXWINCE__
+ #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)
+ #define XDEV2LOG(x) (x)
+ #define YDEV2LOG(y) (y)
+#endif
// ---------------------------------------------------------------------------
// private functions
// 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
static void
-wxAlphaBlend(HDC hdcDst, int x, int y, int w, int h, const wxBitmap& bmp);
+wxAlphaBlend(HDC hdcDst, int x, int y, int w, int h, int srcX, int srcY, const wxBitmap& bmp);
#endif
// ----------------------------------------------------------------------------
m_modeOld = ::SetStretchBltMode(m_hdc, mode);
if ( !m_modeOld )
wxLogLastError(_T("SetStretchBltMode"));
+#else
+ wxUnusedVar(mode);
#endif
}
m_colFgOld = ::GetTextColor(hdc);
m_colBgOld = ::GetBkColor(hdc);
- // note that Windows convention is opposite to wxWindows one, this is
+ // note that Windows convention is opposite to wxWidgets one, this is
// why text colour becomes the background one and vice versa
const wxColour& colFg = dc.GetTextForeground();
if ( colFg.Ok() )
m_clipY2 = (wxCoord) YDEV2LOG(rect.bottom);
}
+void
+wxDC::DoGetClippingBox(wxCoord *x, wxCoord *y, wxCoord *w, wxCoord *h) const
+{
+ // check if we should try to retrieve the clipping region possibly not set
+ // by our SetClippingRegion() but preset by Windows:this can only happen
+ // when we're associated with an existing HDC usign SetHDC(), see there
+ if ( m_clipping && !m_clipX1 && !m_clipX2 )
+ {
+ wxDC *self = wxConstCast(this, wxDC);
+ self->UpdateClipBox();
+
+ if ( !m_clipX1 && !m_clipX2 )
+ self->m_clipping = false;
+ }
+
+ wxDCBase::DoGetClippingBox(x, y, w, h);
+}
+
// common part of DoSetClippingRegion() and DoSetClippingRegionAsRegion()
void wxDC::SetClippingHrgn(WXHRGN hrgn)
{
// 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)
-#if defined(__WIN16__) || defined(__WXWINCE__)
+#if defined(__WXWINCE__)
RECT rectClip;
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);
::DeleteObject(hrgnClipOld);
::DeleteObject(hrgnDest);
-#else // Win32
+#else // !WinCE
if ( ::ExtSelectClipRgn(GetHdc(), (HRGN)hrgn, RGN_AND) == ERROR )
{
wxLogLastError(_T("ExtSelectClipRgn"));
return;
}
-#endif // Win16/32
+#endif // WinCE/!WinCE
m_clipping = true;
::DeleteObject(rgn);
}
- m_clipping = false;
+ wxDCBase::DestroyClippingRegion();
}
// ---------------------------------------------------------------------------
::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);
bool wxDC::DoFloodFill(wxCoord x, wxCoord y, const wxColour& col, int style)
{
#ifdef __WXWINCE__
+ wxUnusedVar(x);
+ wxUnusedVar(y);
+ wxUnusedVar(col);
+ wxUnusedVar(style);
return false;
#else
#else
DrawFrameControl(GetHdc(), &rect, DFC_MENU, DFCS_MENUCHECK);
#endif
-#else // Win16
- // In WIN16, draw a cross
+#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);
::SelectObject(GetHdc(), hPenOld);
::SelectObject(GetHdc(), hBrushOld);
::DeleteObject(blackPen);
-#endif // Win32/16
+#endif // Win32/Symantec-MicroWin
CalcBoundingBox(x1, y1);
CalcBoundingBox(x2, y2);
}
#ifndef __WXWINCE__
int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
+#else
+ wxUnusedVar(fillStyle);
#endif
(void)Polygon(GetHdc(), cpoints, n);
#ifndef __WXWINCE__
{
#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__
// I wonder if this shouldn´t 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));
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;
}
// use MaskBlt() with ROP which doesn't do anything to dst in the mask
// points
// On some systems, MaskBlt succeeds yet is much much slower
- // than the wxWindows fall-back implementation. So we need
+ // 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
// "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
}
SIZE sizeRect;
TEXTMETRIC tm;
- GetTextExtentPoint(GetHdc(), string, string.length(), &sizeRect);
+ ::GetTextExtentPoint32(GetHdc(), string, string.length(), &sizeRect);
GetTextMetrics(GetHdc(), &tm);
if (x)
{
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)
SetMapMode(m_mappingMode);
}
+#else
+ wxUnusedVar(xLeftRight);
+ wxUnusedVar(yBottomUp);
#endif
}
{
WXMICROWIN_CHECK_HDC
-#ifndef __WXWINCE__
if ( x == m_scaleX && y == m_scaleY )
return;
m_scaleX = x;
m_scaleY = y;
+#ifndef __WXWINCE__
SetMapMode(m_mappingMode);
#endif
}
{
WXMICROWIN_CHECK_HDC
-#ifndef __WXWINCE__
if ( x == m_logicalOriginX && y == m_logicalOriginY )
return;
m_logicalOriginX = x;
m_logicalOriginY = y;
+#ifndef __WXWINCE__
::SetWindowOrgEx(GetHdc(), (int)m_logicalOriginX, (int)m_logicalOriginY, NULL);
#endif
}
{
WXMICROWIN_CHECK_HDC
-#ifndef __WXWINCE__
if ( x == m_deviceOriginX && y == m_deviceOriginY )
return;
m_deviceOriginY = y;
::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;
}
// of the mask which is also contrary to the Windows one)
// On some systems, MaskBlt succeeds yet is much much slower
- // than the wxWindows fall-back implementation. So we need
+ // 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)
SRCCOPY
) == (int)GDI_ERROR )
{
- wxLogLastError(wxT("StretchDIBits"));
+ // 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.
+ //wxLogLastError(wxT("StretchDIBits"));
}
else
{
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);
return wxSize(x, y);
}
-// For use by wxWindows only, unless custom units are required.
+// For use by wxWidgets only, unless custom units are required.
void wxDC::SetLogicalScale(double x, double y)
{
WXMICROWIN_CHECK_HDC
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") );
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
// 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 */);
wxAlphaPixelData::Iterator pDst(dataDst),
pSrc(dataSrc);
+ pSrc.Offset(dataSrc, srcX, srcY);
+
for ( int y = 0; y < h; y++ )
{
wxAlphaPixelData::Iterator pDstRowStart = pDst,
pSrcRowStart = pSrc;
-
+
for ( int x = 0; x < w; x++ )
{
// note that source bitmap uses premultiplied alpha (as required by
projects / wxWidgets.git / blobdiff