#if wxUSE_GRAPHICS_CONTEXT
-#include "wx/graphics.h"
#include "wx/dcgraph.h"
#ifndef WX_PRECOMP
#include "wx/icon.h"
- #include "wx/bitmap.h"
+ #include "wx/dcclient.h"
#include "wx/dcmemory.h"
- #include "wx/region.h"
-#endif
-
-#include "wx/dcclient.h"
-
-#ifdef __WXOSX_OR_COCOA__
-#ifdef __WXOSX_IPHONE__
- #include <CoreGraphics/CoreGraphics.h>
-#else
- #include <ApplicationServices/ApplicationServices.h>
-#endif
#endif
//-----------------------------------------------------------------------------
return (deg * M_PI) / 180.0;
}
-static bool TranslateRasterOp(wxRasterOperationMode function, wxCompositionMode *op)
+static wxCompositionMode TranslateRasterOp(wxRasterOperationMode function)
{
switch ( function )
{
case wxCOPY: // src
// since we are supporting alpha, _OVER is closer to the intention than _SOURCE
// since the latter would overwrite even when alpha is not set to opaque
- *op = wxCOMPOSITION_OVER;
- break;
+ return wxCOMPOSITION_OVER;
+
case wxOR: // src OR dst
- *op = wxCOMPOSITION_ADD;
- break;
+ return wxCOMPOSITION_ADD;
+
case wxNO_OP: // dst
- *op = wxCOMPOSITION_DEST; // ignore the source
- break;
+ return wxCOMPOSITION_DEST; // ignore the source
+
case wxCLEAR: // 0
- *op = wxCOMPOSITION_CLEAR;// clear dst
- break;
+ return wxCOMPOSITION_CLEAR;// clear dst
+
case wxXOR: // src XOR dst
- *op = wxCOMPOSITION_XOR;
- break;
+ return wxCOMPOSITION_XOR;
case wxAND: // src AND dst
case wxAND_INVERT: // (NOT src) AND dst
case wxOR_REVERSE: // src OR (NOT dst)
case wxSET: // 1
case wxSRC_INVERT: // NOT src
- default:
- return false;
+ break;
}
- return true;
+
+ return wxCOMPOSITION_INVALID;
}
//-----------------------------------------------------------------------------
}
#endif
+#if defined(__WXMSW__) && wxUSE_ENH_METAFILE
+wxGCDC::wxGCDC(const wxEnhMetaFileDC& dc)
+ : wxDC(new wxGCDCImpl(this, dc))
+{
+}
+#endif
+
+wxGCDC::wxGCDC(wxGraphicsContext* context) :
+ wxDC( new wxGCDCImpl( this ) )
+{
+ SetGraphicsContext(context);
+}
+
wxGCDC::wxGCDC() :
wxDC( new wxGCDCImpl( this ) )
{
{
}
-wxGraphicsContext* wxGCDC::GetGraphicsContext()
+wxGraphicsContext* wxGCDC::GetGraphicsContext() const
{
if (!m_pimpl) return NULL;
wxGCDCImpl *gc_impl = (wxGCDCImpl*) m_pimpl;
wxGCDCImpl::wxGCDCImpl( wxDC *owner ) :
wxDCImpl( owner )
{
- Init();
+ Init(wxGraphicsContext::Create());
}
void wxGCDCImpl::SetGraphicsContext( wxGraphicsContext* ctx )
wxGCDCImpl::wxGCDCImpl( wxDC *owner, const wxWindowDC& dc ) :
wxDCImpl( owner )
{
- Init();
- SetGraphicsContext( wxGraphicsContext::Create(dc) );
+ Init(wxGraphicsContext::Create(dc));
m_window = dc.GetWindow();
}
wxGCDCImpl::wxGCDCImpl( wxDC *owner, const wxMemoryDC& dc ) :
wxDCImpl( owner )
{
- Init();
- wxGraphicsContext* context;
-#if wxUSE_CAIRO
- wxGraphicsRenderer* renderer = wxGraphicsRenderer::GetCairoRenderer();
- context = renderer->CreateContext(dc);
-#else
- context = wxGraphicsContext::Create(dc);
-#endif
-
- SetGraphicsContext( context );
+ Init(wxGraphicsContext::Create(dc));
}
#if wxUSE_PRINTING_ARCHITECTURE
wxGCDCImpl::wxGCDCImpl( wxDC *owner, const wxPrinterDC& dc ) :
wxDCImpl( owner )
{
- Init();
- SetGraphicsContext( wxGraphicsContext::Create(dc) );
+ Init(wxGraphicsContext::Create(dc));
+}
+#endif
+
+#if defined(__WXMSW__) && wxUSE_ENH_METAFILE
+wxGCDCImpl::wxGCDCImpl(wxDC *owner, const wxEnhMetaFileDC& dc)
+ : wxDCImpl(owner)
+{
+ Init(wxGraphicsContext::Create(dc));
}
#endif
-void wxGCDCImpl::Init()
+wxGCDCImpl::wxGCDCImpl(wxDC* owner, int)
+ : wxDCImpl(owner)
+{
+ // derived class will set a context
+ Init(NULL);
+}
+
+void wxGCDCImpl::Init(wxGraphicsContext* ctx)
{
m_ok = false;
m_colour = true;
m_font = *wxNORMAL_FONT;
m_brush = *wxWHITE_BRUSH;
- m_graphicContext = wxGraphicsContext::Create();
+ m_graphicContext = NULL;
+ if (ctx)
+ SetGraphicsContext(ctx);
+
m_logicalFunctionSupported = true;
}
-
wxGCDCImpl::~wxGCDCImpl()
{
delete m_graphicContext;
wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawBitmap - invalid DC") );
wxCHECK_RET( bmp.IsOk(), wxT("wxGCDC(cg)::DoDrawBitmap - invalid bitmap") );
- int w = bmp.GetWidth();
- int h = bmp.GetHeight();
+ int w = bmp.GetScaledWidth();
+ int h = bmp.GetScaledHeight();
if ( bmp.GetDepth() == 1 )
{
m_graphicContext->SetPen(*wxTRANSPARENT_PEN);
wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoSetClippingRegion - invalid DC") );
m_graphicContext->Clip( x, y, w, h );
- if ( m_clipping )
- {
- m_clipX1 = wxMax( m_clipX1, x );
- m_clipY1 = wxMax( m_clipY1, y );
- m_clipX2 = wxMin( m_clipX2, (x + w) );
- m_clipY2 = wxMin( m_clipY2, (y + h) );
- }
- else
- {
- m_clipping = true;
- m_clipX1 = x;
- m_clipY1 = y;
- m_clipX2 = x + w;
- m_clipY2 = y + h;
- }
+ wxDCImpl::DoSetClippingRegion(x, y, w, h);
}
void wxGCDCImpl::DoSetDeviceClippingRegion( const wxRegion ®ion )
{
wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::SetTextForeground - invalid DC") );
- if ( col != m_textForegroundColour )
+ // don't set m_textForegroundColour to an invalid colour as we'd crash
+ // later then (we use m_textForegroundColour.GetColor() without checking
+ // in a few places)
+ if ( col.IsOk() )
{
m_textForegroundColour = col;
m_graphicContext->SetFont( m_font, m_textForegroundColour );
m_textBackgroundColour = col;
}
-void wxGCDCImpl::SetMapMode( wxMappingMode mode )
-{
- switch (mode)
- {
- case wxMM_TWIPS:
- SetLogicalScale( twips2mm * m_mm_to_pix_x, twips2mm * m_mm_to_pix_y );
- break;
-
- case wxMM_POINTS:
- SetLogicalScale( pt2mm * m_mm_to_pix_x, pt2mm * m_mm_to_pix_y );
- break;
-
- case wxMM_METRIC:
- SetLogicalScale( m_mm_to_pix_x, m_mm_to_pix_y );
- break;
-
- case wxMM_LOMETRIC:
- SetLogicalScale( m_mm_to_pix_x / 10.0, m_mm_to_pix_y / 10.0 );
- break;
-
- case wxMM_TEXT:
- default:
- SetLogicalScale( 1.0, 1.0 );
- break;
- }
-
- ComputeScaleAndOrigin();
-}
-
wxSize wxGCDCImpl::GetPPI() const
{
return wxSize(72, 72);
// the logical origin sets the origin to have new coordinates
m_matrixCurrent.Translate( m_deviceOriginX - m_logicalOriginX * m_signX * m_scaleX,
- m_deviceOriginY-m_logicalOriginY * m_signY * m_scaleY);
+ m_deviceOriginY - m_logicalOriginY * m_signY * m_scaleY);
m_matrixCurrent.Scale( m_scaleX * m_signX, m_scaleY * m_signY );
}
}
+void* wxGCDCImpl::GetHandle() const
+{
+ void* cgctx = NULL;
+ wxGraphicsContext* gc = GetGraphicsContext();
+ if (gc) {
+ cgctx = gc->GetNativeContext();
+ }
+ return cgctx;
+}
+
void wxGCDCImpl::SetPalette( const wxPalette& WXUNUSED(palette) )
{
m_font = font;
if ( m_graphicContext )
{
- wxFont f = font;
- if ( f.IsOk() )
- f.SetPointSize( /*LogicalToDeviceYRel*/(font.GetPointSize()));
- m_graphicContext->SetFont( f, m_textForegroundColour );
+ m_graphicContext->SetFont(font, m_textForegroundColour);
}
}
void wxGCDCImpl::SetPen( const wxPen &pen )
{
- if ( m_pen == pen )
- return;
-
m_pen = pen;
if ( m_graphicContext )
{
void wxGCDCImpl::SetBrush( const wxBrush &brush )
{
- if (m_brush == brush)
- return;
-
m_brush = brush;
if ( m_graphicContext )
{
void wxGCDCImpl::SetBackground( const wxBrush &brush )
{
- if (m_backgroundBrush == brush)
- return;
-
m_backgroundBrush = brush;
if (!m_backgroundBrush.IsOk())
return;
void wxGCDCImpl::SetLogicalFunction( wxRasterOperationMode function )
{
- if (m_logicalFunction == function)
- return;
-
m_logicalFunction = function;
- wxCompositionMode mode;
- m_logicalFunctionSupported = TranslateRasterOp( function, &mode);
+ wxCompositionMode mode = TranslateRasterOp( function );
+ m_logicalFunctionSupported = mode != wxCOMPOSITION_INVALID;
if (m_logicalFunctionSupported)
m_logicalFunctionSupported = m_graphicContext->SetCompositionMode(mode);
DoDrawLine( x , y , x + 1 , y + 1 );
}
-void wxGCDCImpl::DoDrawLines(int n, wxPoint points[],
+void wxGCDCImpl::DoDrawLines(int n, const wxPoint points[],
wxCoord xoffset, wxCoord yoffset)
{
wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawLines - invalid DC") );
// empty list
return;
- wxPoint *p = node->GetData();
+ const wxPoint *p = node->GetData();
wxCoord x1 = p->x;
wxCoord y1 = p->y;
}
#endif // wxUSE_SPLINES
-void wxGCDCImpl::DoDrawPolygon( int n, wxPoint points[],
+void wxGCDCImpl::DoDrawPolygon( int n, const wxPoint points[],
wxCoord xoffset, wxCoord yoffset,
wxPolygonFillMode fillStyle )
{
}
void wxGCDCImpl::DoDrawPolyPolygon(int n,
- int count[],
- wxPoint points[],
+ const int count[],
+ const wxPoint points[],
wxCoord xoffset,
wxCoord yoffset,
wxPolygonFillMode fillStyle)
if ( logical_func == wxNO_OP )
return true;
- wxCompositionMode mode;
- if ( !TranslateRasterOp(logical_func, &mode) )
+ wxCompositionMode mode = TranslateRasterOp(logical_func);
+ if ( mode == wxCOMPOSITION_INVALID )
{
wxFAIL_MSG( wxT("Blitting is not supported with this logical operation.") );
return false;
}
+ wxRect subrect(source->LogicalToDeviceX(xsrc),
+ source->LogicalToDeviceY(ysrc),
+ source->LogicalToDeviceXRel(srcWidth),
+ source->LogicalToDeviceYRel(srcHeight));
+ const wxRect subrectOrig = subrect;
+ // clip the subrect down to the size of the source DC
+ wxRect clip;
+ source->GetSize(&clip.width, &clip.height);
+ subrect.Intersect(clip);
+ if (subrect.width == 0)
+ return true;
+
bool retval = true;
wxCompositionMode formerMode = m_graphicContext->GetCompositionMode();
ysrcMask = ysrc;
}
- wxRect subrect(source->LogicalToDeviceX(xsrc),
- source->LogicalToDeviceY(ysrc),
- source->LogicalToDeviceXRel(srcWidth),
- source->LogicalToDeviceYRel(srcHeight));
-
- // if needed clip the subrect down to the size of the source DC
- wxCoord sw, sh;
- source->GetSize(&sw, &sh);
- sw = source->LogicalToDeviceXRel(sw);
- sh = source->LogicalToDeviceYRel(sh);
- if (subrect.x + subrect.width > sw)
- subrect.width = sw - subrect.x;
- if (subrect.y + subrect.height > sh)
- subrect.height = sh - subrect.y;
-
wxBitmap blit = source->GetAsBitmap( &subrect );
if ( blit.IsOk() )
if ( !useMask && blit.GetMask() )
blit.SetMask(NULL);
- m_graphicContext->DrawBitmap( blit, xdest, ydest,
- dstWidth, dstHeight);
+ double x = xdest;
+ double y = ydest;
+ double w = dstWidth;
+ double h = dstHeight;
+ // adjust dest rect if source rect is clipped
+ if (subrect.width != subrectOrig.width || subrect.height != subrectOrig.height)
+ {
+ x += (subrect.x - subrectOrig.x) / double(subrectOrig.width) * dstWidth;
+ y += (subrect.y - subrectOrig.y) / double(subrectOrig.height) * dstHeight;
+ w *= double(subrect.width) / subrectOrig.width;
+ h *= double(subrect.height) / subrectOrig.height;
+ }
+ m_graphicContext->DrawBitmap(blit, x, y, w, h);
}
else
{
void wxGCDCImpl::DoDrawText(const wxString& str, 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 OSX 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 ( str.find('\n') != wxString::npos )
+ {
+ GetOwner()->DrawLabel(str, wxRect(x, y, 0, 0));
+ return;
+ }
+
wxCHECK_RET( IsOk(), wxT("wxGCDC(cg)::DoDrawText - invalid DC") );
if ( str.empty() )
m_graphicContext->SetPen( p );
wxCompositionMode formerMode = m_graphicContext->GetCompositionMode();
m_graphicContext->SetCompositionMode(wxCOMPOSITION_SOURCE);
- DoDrawRectangle( 0, 0, 32000 , 32000 );
+ // maximum positive coordinate Cairo can handle is 2^23 - 1
+ DoDrawRectangle(
+ DeviceToLogicalX(0), DeviceToLogicalY(0),
+ DeviceToLogicalXRel(0x007fffff), DeviceToLogicalYRel(0x007fffff));
m_graphicContext->SetCompositionMode(formerMode);
m_graphicContext->SetPen( m_pen );
m_graphicContext->SetBrush( m_brush );
m_graphicContext->SetPen(*wxTRANSPARENT_PEN);
m_graphicContext->DrawRectangle(rect.x,rect.y,rect.width,rect.height);
m_graphicContext->SetPen(m_pen);
+ m_graphicContext->SetBrush(m_brush);
}
void wxGCDCImpl::DoGradientFillConcentric(const wxRect& rect,
m_graphicContext->DrawRectangle(rect.x,rect.y,rect.width,rect.height);
m_graphicContext->SetPen(m_pen);
+ m_graphicContext->SetBrush(m_brush);
}
void wxGCDCImpl::DoDrawCheckMark(wxCoord x, wxCoord y,
wxDCImpl::DoDrawCheckMark(x,y,width,height);
}
+#ifdef __WXMSW__
+wxRect wxGCDCImpl::MSWApplyGDIPlusTransform(const wxRect& r) const
+{
+ wxGraphicsContext* const gc = GetGraphicsContext();
+ wxCHECK_MSG( gc, r, wxT("Invalid wxGCDC") );
+
+ double x = 0,
+ y = 0;
+ gc->GetTransform().TransformPoint(&x, &y);
+
+ wxRect rect(r);
+ rect.Offset(x, y);
+
+ return rect;
+}
+#endif // __WXMSW__
+
#endif // wxUSE_GRAPHICS_CONTEXT
projects / wxWidgets.git / blobdiff