better native types for carbon

[wxWidgets.git] / src / generic / graphicc.cpp

diff --git a/src/generic/graphicc.cpp b/src/generic/graphicc.cpp
index 67805459146d1ebed33ba278bf138d5a23446a7f..e2e63d632f66ca1b9a2552e327fc7df42022efc7 100644 (file)
--- a/src/generic/graphicc.cpp
+++ b/src/generic/graphicc.cpp
@@ -17,11 +17,11 @@
 
 #if wxUSE_GRAPHICS_CONTEXT
 
 
 #if wxUSE_GRAPHICS_CONTEXT
 

+#include "wx/graphics.h"
+

 #ifndef WX_PRECOMP
     #include "wx/bitmap.h"
     #include "wx/icon.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"
     #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/private/graphics.h"
 #include "wx/rawbmp.h"

+#include "wx/vector.h"

 
 using namespace std;
 
 
 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
 //
 //-----------------------------------------------------------------------------
 // device context implementation
 //


@@ -165,7 +138,7 @@ public :
     // gets the bounding box enclosing all points (possibly including control points)
     virtual void GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h) const;
 
     // gets the bounding box enclosing all points (possibly including control points)
     virtual void GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h) const;
 

-    virtual bool Contains( wxDouble x, wxDouble y, int fillStyle = wxWINDING_RULE) const;
+    virtual bool Contains( wxDouble x, wxDouble y, wxPolygonFillMode fillStyle = wxWINDING_RULE) const;

 
 private :
     cairo_t* m_pathContext;
 
 private :
     cairo_t* m_pathContext;


@@ -255,6 +228,8 @@ private :
     double *m_userLengths;
 
     wxPen m_pen;
     double *m_userLengths;
 
     wxPen m_pen;

+
+    wxDECLARE_NO_COPY_CLASS(wxCairoPenData);

 };
 
 class WXDLLIMPEXP_CORE wxCairoBrushData : public wxGraphicsObjectRefData
 };
 
 class WXDLLIMPEXP_CORE wxCairoBrushData : public wxGraphicsObjectRefData


@@ -291,9 +266,11 @@ public:
     virtual void Apply( wxGraphicsContext* context );
 #ifdef __WXGTK__
     const PangoFontDescription* GetFont() const { return m_font; }
     virtual void Apply( wxGraphicsContext* context );
 #ifdef __WXGTK__
     const PangoFontDescription* GetFont() const { return m_font; }

+    bool GetUnderlined() const { return m_underlined; }

 #endif
 private :
     double m_size;
 #endif
 private :
     double m_size;

+    bool m_underlined;

     double m_red;
     double m_green;
     double m_blue;
     double m_red;
     double m_green;
     double m_blue;


@@ -345,10 +322,16 @@ public:
 
     virtual void * GetNativeContext();
 
 
     virtual void * GetNativeContext();
 

-    virtual bool SetLogicalFunction( int 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 StrokePath( const wxGraphicsPath& p );

-    virtual void FillPath( const wxGraphicsPath& p , int fillStyle = wxWINDING_RULE );
+    virtual void FillPath( const wxGraphicsPath& p , wxPolygonFillMode fillStyle = wxWINDING_RULE );

 
     virtual void Translate( wxDouble dx , wxDouble dy );
     virtual void Scale( wxDouble xScale , wxDouble yScale );
 
     virtual void Translate( wxDouble dx , wxDouble dy );
     virtual void Scale( wxDouble xScale , wxDouble yScale );


@@ -372,14 +355,17 @@ public:
                                 wxDouble *descent, wxDouble *externalLeading ) const;
     virtual void GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const;
 
                                 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);
 
 private:
     void Init(cairo_t *context);
 

-    virtual void DoDrawText( const wxString &str, wxDouble x, wxDouble y );
-

     cairo_t* m_context;
     cairo_t* m_context;

+    
+    wxVector<float> m_layerOpacities;

 
 

-    DECLARE_NO_COPY_CLASS(wxCairoContext)
+    wxDECLARE_NO_COPY_CLASS(wxCairoContext);

 };
 
 //-----------------------------------------------------------------------------
 };
 
 //-----------------------------------------------------------------------------


@@ -532,7 +518,7 @@ wxCairoPenData::wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
         }
         break;
     default :
         }
         break;
     default :

-        if ( m_pen.GetStyle() >= wxPENSTYLE_FIRST_HATCH 
+        if ( m_pen.GetStyle() >= wxPENSTYLE_FIRST_HATCH

             && m_pen.GetStyle() <= wxPENSTYLE_LAST_HATCH )
         {
             /*
             && m_pen.GetStyle() <= wxPENSTYLE_LAST_HATCH )
         {
             /*


@@ -703,9 +689,10 @@ wxCairoFontData::wxCairoFontData( wxGraphicsRenderer* renderer, const wxFont &fo
     m_blue = col.Blue()/255.0;
     m_alpha = col.Alpha()/255.0;
     m_size = font.GetPointSize();
     m_blue = col.Blue()/255.0;
     m_alpha = col.Alpha()/255.0;
     m_size = font.GetPointSize();

+    m_underlined = font.GetUnderlined();

 
 #ifdef __WXMAC__
 
 #ifdef __WXMAC__

-    m_font = cairo_atsui_font_face_create_for_atsu_font_id( font.MacGetATSUFontID() );
+    m_font = cairo_quartz_font_face_create_for_cgfont( font.OSXGetCGFont() );

 #elif defined(__WXGTK__)
     m_font = pango_font_description_copy( font.GetNativeFontInfo()->description );
 #else
 #elif defined(__WXGTK__)
     m_font = pango_font_description_copy( font.GetNativeFontInfo()->description );
 #else


@@ -879,7 +866,7 @@ void wxCairoPathData::GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h)
     }
 }
 
     }
 }
 

-bool wxCairoPathData::Contains( wxDouble x, wxDouble y, int WXUNUSED(fillStyle) ) const
+bool wxCairoPathData::Contains( wxDouble x, wxDouble y, wxPolygonFillMode WXUNUSED(fillStyle) ) const

 {
     return cairo_in_stroke( m_pathContext, x, y) != 0;
 }
 {
     return cairo_in_stroke( m_pathContext, x, y) != 0;
 }


@@ -1223,7 +1210,7 @@ void wxCairoContext::StrokePath( const wxGraphicsPath& path )
     }
 }
 
     }
 }
 

-void wxCairoContext::FillPath( const wxGraphicsPath& path , int fillStyle )
+void wxCairoContext::FillPath( const wxGraphicsPath& path , wxPolygonFillMode fillStyle )

 {
     if ( !m_brush.IsNull() )
     {
 {
     if ( !m_brush.IsNull() )
     {


@@ -1409,8 +1396,19 @@ void wxCairoContext::DoDrawText(const wxString& str, wxDouble x, wxDouble y)
     size_t datalen = strlen(data);
 
     PangoLayout *layout = pango_cairo_create_layout (m_context);
     size_t datalen = strlen(data);
 
     PangoLayout *layout = pango_cairo_create_layout (m_context);

-    pango_layout_set_font_description( layout, ((wxCairoFontData*)m_font.GetRefData())->GetFont());
+    wxCairoFontData* font_data = (wxCairoFontData*) m_font.GetRefData();
+    pango_layout_set_font_description( layout, font_data->GetFont());

     pango_layout_set_text(layout, data, datalen);
     pango_layout_set_text(layout, data, datalen);

+    
+    if (font_data->GetUnderlined()) 
+    {
+        PangoAttrList *attrs = pango_attr_list_new();
+        PangoAttribute *attr = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
+        pango_attr_list_insert(attrs, attr);
+        pango_layout_set_attributes(layout, attrs);
+        pango_attr_list_unref(attrs);
+    }
+

     cairo_move_to(m_context, x, y);
     pango_cairo_show_layout (m_context, layout);
 
     cairo_move_to(m_context, x, y);
     pango_cairo_show_layout (m_context, layout);
 


@@ -1522,54 +1520,98 @@ void * wxCairoContext::GetNativeContext()
     return m_context;
 }
 
     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( int function )
+bool wxCairoContext::SetAntialiasMode(wxAntialiasMode antialias)

 {
 {

-    if (m_logicalFunction == function)
+    if (m_antialias == antialias)

         return true;
 
         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;
             break;

-        case wxOR:         // src OR dst
-            op = CAIRO_OPERATOR_ADD;
+        case wxCOMPOSITION_SOURCE:
+            cop = CAIRO_OPERATOR_SOURCE;

             break;
             break;

-        case wxNO_OP:      // dst
-            op = CAIRO_OPERATOR_DEST; // ignore the source
+        case wxCOMPOSITION_OVER:
+            cop = CAIRO_OPERATOR_OVER;

             break;
             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;
             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;
     }
         default:
             return false;
     }

-
-    m_logicalFunction = function;
-    cairo_set_operator(m_context, op);
+    cairo_set_operator(m_context, cop);

     return true;
 }
 
     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
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // wxCairoRenderer declaration
 //-----------------------------------------------------------------------------


@@ -1730,7 +1772,7 @@ wxGraphicsMatrix wxCairoRenderer::CreateMatrix( wxDouble a, wxDouble b, wxDouble
 
 wxGraphicsPen wxCairoRenderer::CreatePen(const wxPen& pen)
 {
 
 wxGraphicsPen wxCairoRenderer::CreatePen(const wxPen& pen)
 {

-    if ( !pen.Ok() || pen.GetStyle() == wxTRANSPARENT )
+    if ( !pen.Ok() || pen.GetStyle() == wxPENSTYLE_TRANSPARENT )

         return wxNullGraphicsPen;
     else
     {
         return wxNullGraphicsPen;
     else
     {


@@ -1742,7 +1784,7 @@ wxGraphicsPen wxCairoRenderer::CreatePen(const wxPen& pen)
 
 wxGraphicsBrush wxCairoRenderer::CreateBrush(const wxBrush& brush )
 {
 
 wxGraphicsBrush wxCairoRenderer::CreateBrush(const wxBrush& brush )
 {

-    if ( !brush.Ok() || brush.GetStyle() == wxTRANSPARENT )
+    if ( !brush.Ok() || brush.GetStyle() == wxBRUSHSTYLE_TRANSPARENT )

         return wxNullGraphicsBrush;
     else
     {
         return wxNullGraphicsBrush;
     else
     {