// headers
// ---------------------------------------------------------------------------
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "dc.h"
#endif
#endif
#ifndef WX_PRECOMP
+ #include "wx/image.h"
#include "wx/window.h"
#include "wx/dc.h"
#include "wx/utils.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"
#define MAKEROP4(fore,back) (DWORD)((((back) << 8) & 0xFF000000) | (fore))
#endif
+// apparently with MicroWindows it is possible that HDC is 0 so we have to
+// check for this ourselves
+#ifdef __WXMICROWIN__
+ #define WXMICROWIN_CHECK_HDC if ( !GetHDC() ) return;
+ #define WXMICROWIN_CHECK_HDC_RET(x) if ( !GetHDC() ) return x;
+#else
+ #define WXMICROWIN_CHECK_HDC
+ #define WXMICROWIN_CHECK_HDC_RET(x)
+#endif
+
IMPLEMENT_ABSTRACT_CLASS(wxDC, wxDCBase)
// ---------------------------------------------------------------------------
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+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)
+#else
+ #define XLOG2DEV(x) (x)
+ #define YLOG2DEV(y) (y)
+ #define XDEV2LOG(x) (x)
+ #define YDEV2LOG(y) (y)
+#endif
// ---------------------------------------------------------------------------
// private functions
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() )
: OPAQUE);
// flag which telsl us to undo changes in the dtor
- m_changed = TRUE;
+ m_changed = true;
}
else
{
// nothing done, nothing to undo
- m_changed = FALSE;
+ m_changed = false;
}
}
m_oldPalette = 0;
#endif // wxUSE_PALETTE
- m_bOwnsDC = FALSE;
+ m_bOwnsDC = false;
m_hDC = 0;
}
void wxDC::UpdateClipBox()
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
RECT rect;
::GetClipBox(GetHdc(), &rect);
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)
{
wxCHECK_RET( hrgn, wxT("invalid clipping region") );
-#ifdef __WXMICROWIN__
- if (!GetHdc()) return;
-#endif // __WXMICROWIN__
+ WXMICROWIN_CHECK_HDC
// 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;
::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;
+ m_clipping = true;
UpdateClipBox();
}
void wxDC::DestroyClippingRegion()
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
if (m_clipping && m_hDC)
{
::DeleteObject(rgn);
}
- m_clipping = FALSE;
+ wxDCBase::DestroyClippingRegion();
}
// ---------------------------------------------------------------------------
bool wxDC::CanDrawBitmap() const
{
- return TRUE;
+ return true;
}
bool wxDC::CanGetTextExtent() const
{
#ifdef __WXMICROWIN__
// TODO Extend MicroWindows' GetDeviceCaps function
- return TRUE;
+ return true;
#else
// What sort of display is it?
int technology = ::GetDeviceCaps(GetHdc(), TECHNOLOGY);
int wxDC::GetDepth() const
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return 16;
-#endif
+ WXMICROWIN_CHECK_HDC_RET(16)
return (int)::GetDeviceCaps(GetHdc(), BITSPIXEL);
}
void wxDC::Clear()
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
RECT rect;
if ( m_canvas )
bool wxDC::DoFloodFill(wxCoord x, wxCoord y, const wxColour& col, int style)
{
#ifdef __WXWINCE__
- return FALSE;
+ return false;
#else
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return FALSE;
-#endif
+ WXMICROWIN_CHECK_HDC_RET(false)
bool success = (0 != ::ExtFloodFill(GetHdc(), XLOG2DEV(x), YLOG2DEV(y),
col.GetPixel(),
}
CalcBoundingBox(x, y);
-
+
return success;
#endif
}
bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return FALSE;
-#endif
+ WXMICROWIN_CHECK_HDC_RET(false)
- wxCHECK_MSG( col, FALSE, _T("NULL colour parameter in wxDC::GetPixel") );
+ wxCHECK_MSG( col, false, _T("NULL colour parameter in wxDC::GetPixel") );
// get the color of the pixel
COLORREF pixelcolor = ::GetPixel(GetHdc(), XLOG2DEV(x), YLOG2DEV(y));
wxRGBToColour(*col, pixelcolor);
- return TRUE;
+ return true;
}
void wxDC::DoCrossHair(wxCoord x, wxCoord y)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
wxCoord x1 = x-VIEWPORT_EXTENT;
wxCoord y1 = y-VIEWPORT_EXTENT;
void wxDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
wxDrawLine(GetHdc(), XLOG2DEV(x1), YLOG2DEV(y1), XLOG2DEV(x2), YLOG2DEV(y2));
wxCoord xc, wxCoord yc)
{
#ifdef __WXWINCE__
- // FIXME: emulate Arc
+ // 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
+ double ea = atan2(yc-y2, x2-xc)/M_PI*180;
+ DoDrawEllipticArcRot( xc-r, yc-r, 2*r, 2*r, sa, ea );
#else
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
void wxDC::DoDrawCheckMark(wxCoord x1, wxCoord y1,
wxCoord width, wxCoord height)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
wxCoord x2 = x1 + width,
y2 = y1 + height;
#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);
void wxDC::DoDrawPoint(wxCoord x, wxCoord y)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
COLORREF color = 0x00ffffff;
if (m_pen.Ok())
void wxDC::DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset,int fillStyle)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
}
}
-void wxDC::DoDrawLines(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset)
+void
+wxDC::DoDrawPolyPolygon(int n,
+ int count[],
+ wxPoint points[],
+ wxCoord xoffset,
+ wxCoord yoffset,
+ int fillStyle)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
+#ifdef __WXWINCE__
+ wxDCBase::DoDrawPolyPolygon(n, count, points, xoffset, yoffset, fillStyle);
+#else
+ WXMICROWIN_CHECK_HDC
+
+ wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
+ int i, cnt;
+ for (i = cnt = 0; i < n; i++)
+ cnt += count[i];
+
+ // Do things less efficiently if we have offsets
+ if (xoffset != 0 || yoffset != 0)
+ {
+ POINT *cpoints = new POINT[cnt];
+ for (i = 0; i < cnt; i++)
+ {
+ cpoints[i].x = (int)(points[i].x + xoffset);
+ cpoints[i].y = (int)(points[i].y + yoffset);
+
+ CalcBoundingBox(cpoints[i].x, cpoints[i].y);
+ }
+#ifndef __WXWINCE__
+ int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
+#endif
+ (void)PolyPolygon(GetHdc(), cpoints, count, n);
+#ifndef __WXWINCE__
+ SetPolyFillMode(GetHdc(),prev);
+#endif
+ delete[] cpoints;
+ }
+ else
+ {
+ for (i = 0; i < cnt; i++)
+ CalcBoundingBox(points[i].x, points[i].y);
+
+#ifndef __WXWINCE__
+ int prev = SetPolyFillMode(GetHdc(),fillStyle==wxODDEVEN_RULE?ALTERNATE:WINDING);
+#endif
+ (void)PolyPolygon(GetHdc(), (POINT*) points, count, n);
+#ifndef __WXWINCE__
+ SetPolyFillMode(GetHdc(),prev);
+#endif
+ }
#endif
+ // __WXWINCE__
+}
+
+void wxDC::DoDrawLines(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset)
+{
+ WXMICROWIN_CHECK_HDC
// Do things less efficiently if we have offsets
if (xoffset != 0 || yoffset != 0)
void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
void wxDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
if (radius < 0.0)
{
- double smallest = 0.0;
- if (width < height)
- smallest = width;
- else
- smallest = height;
+ double smallest = (width < height) ? width : height;
radius = (- radius * smallest);
}
void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
void wxDC::DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,double ea)
{
#ifdef __WXWINCE__
- // FIXME
+ DoDrawEllipticArcRot( x, y, w, h, sa, ea );
#else
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
wxColourChanger cc(*this); // needed for wxSTIPPLE_MASK_OPAQUE handling
void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
wxCHECK_RET( icon.Ok(), wxT("invalid icon in DrawIcon") );
void wxDC::DoDrawBitmap( const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask )
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
wxCHECK_RET( bmp.Ok(), _T("invalid bitmap in wxDC::DrawBitmap") );
{
// don't give assert here because this would break existing
// programs - just silently ignore useMask parameter
- useMask = FALSE;
+ useMask = false;
}
}
if ( useMask )
// 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;
+ bool ok = false;
#if wxUSE_SYSTEM_OPTIONS
if (wxSystemOptions::GetOptionInt(wxT("no-maskblt")) == 0)
#endif
void wxDC::DoDrawText(const wxString& text, wxCoord x, wxCoord y)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
DrawAnyText(text, x, y);
void wxDC::DrawAnyText(const wxString& text, wxCoord x, wxCoord y)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
// prepare for drawing the text
if ( m_textForegroundColour.Ok() )
wxCoord x, wxCoord y,
double angle)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
// we test that we have some font because otherwise we should still use the
// "else" part below to avoid that DrawRotatedText(angle = 180) and
// "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
}
void wxDC::DoSelectPalette(bool realize)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
// Set the old object temporarily, in case the assignment deletes an object
// that's not yet selected out.
{
HPALETTE oldPal = ::SelectPalette(GetHdc(),
GetHpaletteOf(m_palette),
- FALSE);
+ false);
if (!m_oldPalette)
m_oldPalette = (WXHPALETTE) oldPal;
if ( palette.Ok() )
{
m_palette = palette;
- DoSelectPalette(TRUE);
+ DoSelectPalette(true);
}
}
#endif // wxUSE_PALETTE
-void wxDC::SetFont(const wxFont& the_font)
-{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+// SetFont/Pen/Brush() really ask to be implemented as a single template
+// function... but doing it is not worth breaking OpenWatcom build <sigh>
- // Set the old object temporarily, in case the assignment deletes an object
- // that's not yet selected out.
- if (m_oldFont)
- {
- ::SelectObject(GetHdc(), (HFONT) m_oldFont);
- m_oldFont = 0;
- }
+void wxDC::SetFont(const wxFont& font)
+{
+ WXMICROWIN_CHECK_HDC
- m_font = the_font;
+ if ( font == m_font )
+ return;
- if (!the_font.Ok())
+ if ( font.Ok() )
{
- if (m_oldFont)
- ::SelectObject(GetHdc(), (HFONT) m_oldFont);
- m_oldFont = 0;
- }
+ HGDIOBJ hfont = ::SelectObject(GetHdc(), GetHfontOf(font));
+ if ( hfont == HGDI_ERROR )
+ {
+ wxLogLastError(_T("SelectObject(font)"));
+ }
+ else // selected ok
+ {
+ if ( !m_oldFont )
+ m_oldFont = (WXHPEN)hfont;
- if (m_font.Ok() && m_font.GetResourceHandle())
+ m_font = font;
+ }
+ }
+ else // invalid font, reset the current font
{
- HFONT f = (HFONT) ::SelectObject(GetHdc(), (HFONT) m_font.GetResourceHandle());
- if (f == (HFONT) NULL)
+ if ( m_oldFont )
{
- wxLogDebug(wxT("::SelectObject failed in wxDC::SetFont."));
+ if ( ::SelectObject(GetHdc(), (HPEN) m_oldFont) == HGDI_ERROR )
+ {
+ wxLogLastError(_T("SelectObject(old font)"));
+ }
+
+ m_oldFont = 0;
}
- if (!m_oldFont)
- m_oldFont = (WXHFONT) f;
+
+ m_font = wxNullFont;
}
}
void wxDC::SetPen(const wxPen& pen)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
-
- // Set the old object temporarily, in case the assignment deletes an object
- // that's not yet selected out.
- if (m_oldPen)
- {
- ::SelectObject(GetHdc(), (HPEN) m_oldPen);
- m_oldPen = 0;
- }
+ WXMICROWIN_CHECK_HDC
- m_pen = pen;
+ if ( pen == m_pen )
+ return;
- if (!m_pen.Ok())
+ if ( pen.Ok() )
{
- if (m_oldPen)
- ::SelectObject(GetHdc(), (HPEN) m_oldPen);
- m_oldPen = 0;
- }
+ HGDIOBJ hpen = ::SelectObject(GetHdc(), GetHpenOf(pen));
+ if ( hpen == HGDI_ERROR )
+ {
+ wxLogLastError(_T("SelectObject(pen)"));
+ }
+ else // selected ok
+ {
+ if ( !m_oldPen )
+ m_oldPen = (WXHPEN)hpen;
- if (m_pen.Ok())
+ m_pen = pen;
+ }
+ }
+ else // invalid pen, reset the current pen
{
- if (m_pen.GetResourceHandle())
+ if ( m_oldPen )
{
- HPEN p = (HPEN) ::SelectObject(GetHdc(), (HPEN)m_pen.GetResourceHandle());
- if (!m_oldPen)
- m_oldPen = (WXHPEN) p;
+ if ( ::SelectObject(GetHdc(), (HPEN) m_oldPen) == HGDI_ERROR )
+ {
+ wxLogLastError(_T("SelectObject(old pen)"));
+ }
+
+ m_oldPen = 0;
}
+
+ m_pen = wxNullPen;
}
}
void wxDC::SetBrush(const wxBrush& brush)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
-
- // Set the old object temporarily, in case the assignment deletes an object
- // that's not yet selected out.
- if (m_oldBrush)
- {
- ::SelectObject(GetHdc(), (HBRUSH) m_oldBrush);
- m_oldBrush = 0;
- }
-
- m_brush = brush;
+ WXMICROWIN_CHECK_HDC
- if (!m_brush.Ok())
- {
- if (m_oldBrush)
- ::SelectObject(GetHdc(), (HBRUSH) m_oldBrush);
- m_oldBrush = 0;
- }
+ if ( brush == m_brush )
+ return;
- if (m_brush.Ok())
+ if ( brush.Ok() )
{
- // to make sure the brush is alligned with the logical coordinates
- wxBitmap *stipple = m_brush.GetStipple();
+ // we must make sure the brush is aligned with the logical coordinates
+ // before selecting it
+ wxBitmap *stipple = brush.GetStipple();
if ( stipple && stipple->Ok() )
{
-#ifdef __WIN32__
- ::SetBrushOrgEx(GetHdc(),
- m_deviceOriginX % stipple->GetWidth(),
- m_deviceOriginY % stipple->GetHeight(),
- NULL); // don't need previous brush origin
-#else
- ::SetBrushOrg(GetHdc(),
- m_deviceOriginX % stipple->GetWidth(),
- m_deviceOriginY % stipple->GetHeight());
-#endif
+ if ( !::SetBrushOrgEx
+ (
+ GetHdc(),
+ m_deviceOriginX % stipple->GetWidth(),
+ m_deviceOriginY % stipple->GetHeight(),
+ NULL // [out] previous brush origin
+ ) )
+ {
+ wxLogLastError(_T("SetBrushOrgEx()"));
+ }
+ }
+
+ HGDIOBJ hbrush = ::SelectObject(GetHdc(), GetHbrushOf(brush));
+ if ( hbrush == HGDI_ERROR )
+ {
+ wxLogLastError(_T("SelectObject(brush)"));
}
+ else // selected ok
+ {
+ if ( !m_oldBrush )
+ m_oldBrush = (WXHPEN)hbrush;
- if ( m_brush.GetResourceHandle() )
+ m_brush = brush;
+ }
+ }
+ else // invalid brush, reset the current brush
+ {
+ if ( m_oldBrush )
{
- HBRUSH b = 0;
- b = (HBRUSH) ::SelectObject(GetHdc(), (HBRUSH)m_brush.GetResourceHandle());
- if (!m_oldBrush)
- m_oldBrush = (WXHBRUSH) b;
+ if ( ::SelectObject(GetHdc(), (HPEN) m_oldBrush) == HGDI_ERROR )
+ {
+ wxLogLastError(_T("SelectObject(old brush)"));
+ }
+
+ m_oldBrush = 0;
}
+
+ m_brush = wxNullBrush;
}
}
void wxDC::SetBackground(const wxBrush& brush)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
m_backgroundBrush = brush;
void wxDC::SetBackgroundMode(int mode)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
m_backgroundMode = mode;
void wxDC::SetLogicalFunction(int function)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
m_logicalFunction = function;
bool wxDC::StartDoc(const wxString& WXUNUSED(message))
{
- // We might be previewing, so return TRUE to let it continue.
- return TRUE;
+ // We might be previewing, so return true to let it continue.
+ return true;
}
void wxDC::EndDoc()
wxCoord wxDC::GetCharHeight() const
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return 0;
-#endif
+ WXMICROWIN_CHECK_HDC_RET(0)
TEXTMETRIC lpTextMetric;
wxCoord wxDC::GetCharWidth() const
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return 0;
-#endif
+ WXMICROWIN_CHECK_HDC_RET(0)
TEXTMETRIC lpTextMetric;
}
}
+
+// Each element of the array will be the width of the string up to and
+// including the coresoponding character in text.
+
+bool wxDC::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();
+
+ 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;
+ }
+
+ widths.Empty();
+ widths.Add(0, stlen); // fill the array with zeros
+
+ 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;
+ }
+
+ return true;
+}
+
+
+
+
void wxDC::SetMapMode(int mode)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
m_mappingMode = mode;
void wxDC::SetUserScale(double x, double y)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ 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)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
#ifndef __WXWINCE__
int signX = xLeftRight ? 1 : -1,
void wxDC::SetSystemScale(double x, double y)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#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
}
void wxDC::SetLogicalOrigin(wxCoord x, wxCoord y)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#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
}
void wxDC::SetDeviceOrigin(wxCoord x, wxCoord y)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
-#ifndef __WXWINCE__
if ( x == m_deviceOriginX && y == m_deviceOriginY )
return;
m_deviceOriginX = x;
m_deviceOriginY = y;
+#ifndef __WXWINCE__
::SetViewportOrgEx(GetHdc(), (int)m_deviceOriginX, (int)m_deviceOriginY, NULL);
#endif
}
int rop, bool useMask,
wxCoord xsrcMask, wxCoord ysrcMask)
{
- wxCHECK_MSG( source, FALSE, _T("wxDC::Blit(): NULL wxDC pointer") );
+ wxCHECK_MSG( source, false, _T("wxDC::Blit(): NULL wxDC pointer") );
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return FALSE;
-#endif
+ WXMICROWIN_CHECK_HDC_RET(false)
const wxBitmap& bmpSrc = source->m_selectedBitmap;
if ( bmpSrc.Ok() && bmpSrc.HasAlpha() )
{
if ( AlphaBlt(GetHdc(), xdest, ydest, width, height,
GetHdcOf(*source), bmpSrc) )
- return TRUE;
+ return true;
}
wxMask *mask = NULL;
{
// don't give assert here because this would break existing
// programs - just silently ignore useMask parameter
- useMask = FALSE;
+ useMask = false;
}
}
::SetBkColor(GetHdc(), m_textBackgroundColour.GetPixel() );
}
- DWORD dwRop = SRCCOPY;
+ DWORD dwRop;
switch (rop)
{
case wxXOR: dwRop = SRCINVERT; break;
case wxNOR: dwRop = NOTSRCCOPY; break;
default:
wxFAIL_MSG( wxT("unsupported logical function") );
- return FALSE;
+ return false;
}
- bool success = FALSE;
+ bool success = false;
if (useMask)
{
// 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)
{
StretchBltModeChanger changeMode(GetHdc(), COLORONCOLOR);
+ // Figure out what co-ordinate system we're supposed to specify
+ // ysrc in.
+ const LONG hDIB = ds.dsBmih.biHeight;
+ if ( hDIB > 0 )
+ {
+ // reflect ysrc
+ ysrc = hDIB - (ysrc + height);
+ }
+
if ( ::StretchDIBits(GetHdc(),
xdest, ydest,
width, height,
- 0, 0,
+ xsrc, ysrc,
width, height,
ds.dsBm.bmBits,
(LPBITMAPINFO)&ds.dsBmih,
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
{
- success = TRUE;
+ success = true;
}
}
}
if ( !success && (caps & RC_STRETCHBLT) )
+#endif
+ // __WXWINCE__
{
+#ifndef __WXWINCE__
StretchBltModeChanger changeMode(GetHdc(), COLORONCOLOR);
+#endif
if ( !::StretchBlt
(
}
else
{
- success = TRUE;
+ success = true;
}
}
}
else
{
- success = TRUE;
+ success = true;
}
}
-#endif
- // __WXWINCE__
}
::SetTextColor(GetHdc(), old_textground);
void wxDC::DoGetSize(int *w, int *h) const
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
if ( w ) *w = ::GetDeviceCaps(GetHdc(), HORZRES);
if ( h ) *h = ::GetDeviceCaps(GetHdc(), VERTRES);
void wxDC::DoGetSizeMM(int *w, int *h) const
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
// if we implement it in terms of DoGetSize() instead of directly using the
// results returned by GetDeviceCaps(HORZ/VERTSIZE) as was done before, it
wxSize wxDC::GetPPI() const
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return wxSize();
-#endif
+ WXMICROWIN_CHECK_HDC_RET(wxSize())
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)
{
-#ifdef __WXMICROWIN__
- if (!GetHDC()) return;
-#endif
+ WXMICROWIN_CHECK_HDC
m_logicalScaleX = x;
m_logicalScaleY = y;
class wxDCModule : public wxModule
{
public:
- virtual bool OnInit() { return TRUE; }
+ virtual bool OnInit() { return true; }
virtual void OnExit() { wxDC::ClearCache(); }
private:
// 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 bool s_triedToLoad = false;
static AlphaBlend_t pfnAlphaBlend = NULL;
if ( !s_triedToLoad )
{
- s_triedToLoad = TRUE;
+ s_triedToLoad = true;
// don't give errors about the DLL being unavailable, we're
// prepared to handle this
bf) )
{
// skip wxAlphaBlend() call below
- return TRUE;
+ return true;
}
wxLogLastError(_T("AlphaBlend"));
#ifdef wxHAVE_RAW_BITMAP
wxAlphaBlend(hdcDst, x, y, width, height, bmp);
- return TRUE;
+ 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)
- return FALSE;
+ return false;
#endif // wxHAVE_RAW_BITMAP
}
projects / wxWidgets.git / blobdiff