X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/0d19936d71032ba7658616faed3b63d4c930e5b4..826da45133baecd8a8a13af301a00bc00a1c8013:/src/generic/graphicc.cpp?ds=sidebyside

diff --git a/src/generic/graphicc.cpp b/src/generic/graphicc.cpp
index 6b29c3a902..6642ea5a45 100644
--- a/src/generic/graphicc.cpp
+++ b/src/generic/graphicc.cpp
@@ -17,11 +17,11 @@
 
 #if wxUSE_GRAPHICS_CONTEXT
 
+#include "wx/graphics.h"
+
 #ifndef WX_PRECOMP
     #include "wx/bitmap.h"
     #include "wx/icon.h"
-
-    #include "wx/dc.h"
     #include "wx/dcclient.h"
     #include "wx/dcmemory.h"
     #include "wx/dcprint.h"
@@ -29,37 +29,10 @@
 
 #include "wx/private/graphics.h"
 #include "wx/rawbmp.h"
+#include "wx/vector.h"
 
 using namespace std;
 
-//-----------------------------------------------------------------------------
-// constants
-//-----------------------------------------------------------------------------
-
-const double RAD2DEG = 180.0 / M_PI;
-
-//-----------------------------------------------------------------------------
-// Local functions
-//-----------------------------------------------------------------------------
-
-static inline double dmin(double a, double b)
-{
-    return a < b ? a : b;
-}
-static inline double dmax(double a, double b)
-{
-    return a > b ? a : b;
-}
-
-static inline double DegToRad(double deg)
-{
-    return (deg * M_PI) / 180.0;
-}
-static inline double RadToDeg(double deg)
-{
-    return (deg * 180.0) / M_PI;
-}
-
 //-----------------------------------------------------------------------------
 // device context implementation
 //
@@ -255,6 +228,8 @@ private :
     double *m_userLengths;
 
     wxPen m_pen;
+
+    wxDECLARE_NO_COPY_CLASS(wxCairoPenData);
 };
 
 class WXDLLIMPEXP_CORE wxCairoBrushData : public wxGraphicsObjectRefData
@@ -347,8 +322,14 @@ public:
 
     virtual void * GetNativeContext();
 
-    virtual bool SetLogicalFunction( wxRasterOperationMode function );
+    virtual bool SetAntialiasMode(wxAntialiasMode antialias);
+
+    virtual bool SetCompositionMode(wxCompositionMode op);
 
+    virtual void BeginLayer(wxDouble opacity);
+
+    virtual void EndLayer();
+    
     virtual void StrokePath( const wxGraphicsPath& p );
     virtual void FillPath( const wxGraphicsPath& p , wxPolygonFillMode fillStyle = wxWINDING_RULE );
 
@@ -374,14 +355,17 @@ public:
                                 wxDouble *descent, wxDouble *externalLeading ) const;
     virtual void GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const;
 
+protected:
+    virtual void DoDrawText( const wxString &str, wxDouble x, wxDouble y );
+
 private:
     void Init(cairo_t *context);
 
-    virtual void DoDrawText( const wxString &str, wxDouble x, wxDouble y );
-
     cairo_t* m_context;
+    
+    wxVector<float> m_layerOpacities;
 
-    DECLARE_NO_COPY_CLASS(wxCairoContext)
+    wxDECLARE_NO_COPY_CLASS(wxCairoContext);
 };
 
 //-----------------------------------------------------------------------------
@@ -1536,54 +1520,98 @@ void * wxCairoContext::GetNativeContext()
     return m_context;
 }
 
-// Cairo doesn't support bitwise logical function (a.k.a. ROP, raster output
-// mode). Cairo supports Porter-Duff compositing operators, but they are quite
-// different, although in some cases have similar names.
-bool wxCairoContext::SetLogicalFunction( wxRasterOperationMode function )
+bool wxCairoContext::SetAntialiasMode(wxAntialiasMode antialias)
 {
-    if (m_logicalFunction == function)
+    if (m_antialias == antialias)
         return true;
 
-    cairo_operator_t op;
+    m_antialias = antialias;
+    
+    cairo_antialias_t antialiasMode;
+    switch (antialias)
+    {
+        case wxANTIALIAS_DEFAULT:
+            antialiasMode = CAIRO_ANTIALIAS_DEFAULT;
+            break;
+        case wxANTIALIAS_NONE:
+            antialiasMode = CAIRO_ANTIALIAS_NONE;
+            break;
+        default:
+            return false;
+    }
+    cairo_set_antialias(m_context, antialiasMode);
+    return true;
+}
 
-    switch ( function )
+bool wxCairoContext::SetCompositionMode(wxCompositionMode op)
+{
+    if ( m_composition == op )
+        return true;
+        
+    m_composition = op;
+    cairo_operator_t cop;
+    switch (op)
     {
-        case wxCOPY:       // (default) src
-            op = CAIRO_OPERATOR_OVER; // (also default)
+        case wxCOMPOSITION_CLEAR:
+            cop = CAIRO_OPERATOR_CLEAR;
             break;
-        case wxOR:         // src OR dst
-            op = CAIRO_OPERATOR_ADD;
+        case wxCOMPOSITION_SOURCE:
+            cop = CAIRO_OPERATOR_SOURCE;
             break;
-        case wxNO_OP:      // dst
-            op = CAIRO_OPERATOR_DEST; // ignore the source
+        case wxCOMPOSITION_OVER:
+            cop = CAIRO_OPERATOR_OVER;
             break;
-        case wxCLEAR:      // 0
-            op = CAIRO_OPERATOR_CLEAR;// clear dst
+        case wxCOMPOSITION_IN:
+            cop = CAIRO_OPERATOR_IN;
+            break;
+        case wxCOMPOSITION_OUT:
+            cop = CAIRO_OPERATOR_OUT;
+            break;
+        case wxCOMPOSITION_ATOP:
+            cop = CAIRO_OPERATOR_ATOP;
+            break;
+        case wxCOMPOSITION_DEST:
+            cop = CAIRO_OPERATOR_DEST;
+            break;
+        case wxCOMPOSITION_DEST_OVER:
+            cop = CAIRO_OPERATOR_DEST_OVER;
+            break;
+        case wxCOMPOSITION_DEST_IN:
+            cop = CAIRO_OPERATOR_DEST_IN;
+            break;
+        case wxCOMPOSITION_DEST_OUT:
+            cop = CAIRO_OPERATOR_DEST_OUT;
+            break;
+        case wxCOMPOSITION_DEST_ATOP:
+            cop = CAIRO_OPERATOR_DEST_ATOP;
+            break;
+        case wxCOMPOSITION_XOR:
+            cop = CAIRO_OPERATOR_XOR;
+            break;
+        case wxCOMPOSITION_ADD:
+            cop = CAIRO_OPERATOR_ADD;
             break;
-
-        case wxAND:        // src AND dst
-        case wxAND_INVERT: // (NOT src) AND dst
-        case wxAND_REVERSE:// src AND (NOT dst)
-        case wxEQUIV:      // (NOT src) XOR dst
-        case wxINVERT:     // NOT dst
-        case wxNAND:       // (NOT src) OR (NOT dst)
-        case wxNOR:        // (NOT src) AND (NOT dst)
-        case wxOR_INVERT:  // (NOT src) OR dst
-        case wxOR_REVERSE: // src OR (NOT dst)
-        case wxSET:        // 1
-        case wxSRC_INVERT: // NOT src
-        //wxXOR does _not_ correspond to CAIRO_OPERATOR_XOR
-        case wxXOR:        // src XOR dst
         default:
             return false;
     }
-
-    m_logicalFunction = function;
-    cairo_set_operator(m_context, op);
+    cairo_set_operator(m_context, cop);
     return true;
 }
 
+void wxCairoContext::BeginLayer(wxDouble opacity)
+{
+    m_layerOpacities.push_back(opacity);
+    cairo_push_group(m_context);
+}
 
+void wxCairoContext::EndLayer()
+{
+    float opacity = m_layerOpacities.back();
+    m_layerOpacities.pop_back();
+    cairo_pop_group_to_source(m_context);
+    cairo_paint_with_alpha(m_context,opacity);
+}
+    
 //-----------------------------------------------------------------------------
 // wxCairoRenderer declaration
 //-----------------------------------------------------------------------------
@@ -1744,7 +1772,7 @@ wxGraphicsMatrix wxCairoRenderer::CreateMatrix( wxDouble a, wxDouble b, wxDouble
 
 wxGraphicsPen wxCairoRenderer::CreatePen(const wxPen& pen)
 {
-    if ( !pen.Ok() || pen.GetStyle() == wxTRANSPARENT )
+    if ( !pen.Ok() || pen.GetStyle() == wxPENSTYLE_TRANSPARENT )
         return wxNullGraphicsPen;
     else
     {
@@ -1756,7 +1784,7 @@ wxGraphicsPen wxCairoRenderer::CreatePen(const wxPen& pen)
 
 wxGraphicsBrush wxCairoRenderer::CreateBrush(const wxBrush& brush )
 {
-    if ( !brush.Ok() || brush.GetStyle() == wxTRANSPARENT )
+    if ( !brush.Ok() || brush.GetStyle() == wxBRUSHSTYLE_TRANSPARENT )
         return wxNullGraphicsBrush;
     else
     {