X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/248802d0100093c48f67a60a6463d7765f14d5f0..d949570b6673dadd764686213afb89bddb6f19da:/src/generic/graphicc.cpp

diff --git a/src/generic/graphicc.cpp b/src/generic/graphicc.cpp
old mode 100755
new mode 100644
index 7ab1b5cdaf..df232c1db3
--- a/src/generic/graphicc.cpp
+++ b/src/generic/graphicc.cpp
@@ -11,12 +11,14 @@
 
 #include "wx/wxprec.h"
 
-#include "wx/dc.h"
-
 #ifdef __BORLANDC__
 #pragma hdrstop
 #endif
 
+#if wxUSE_GRAPHICS_CONTEXT
+
+#include "wx/dc.h"
+
 #ifndef WX_PRECOMP
 #include "wx/image.h"
 #include "wx/window.h"
@@ -32,13 +34,8 @@
 #include "wx/module.h"
 #endif
 
-#ifdef __WXGTK__
-#include "wx/gtk/win_gtk.h"
-#endif
-
 #include "wx/graphics.h"
-
-#if wxUSE_GRAPHICS_CONTEXT
+#include "wx/rawbmp.h"
 
 #include <vector>
 
@@ -101,6 +98,17 @@ static inline double RadToDeg(double deg)
 #include <cairo.h>
 #ifdef __WXGTK__
 #include <gtk/gtk.h>
+#include "wx/fontutil.h"
+#endif
+
+#ifdef __WXMSW__
+#include <cairo-win32.h>
+#endif
+
+#ifdef __WXMAC__
+#include "wx/mac/private.h"
+#include <cairo-quartz.h>
+#include <cairo-atsui.h>
 #endif
 
 class WXDLLIMPEXP_CORE wxCairoPathData : public wxGraphicsPathData
@@ -289,15 +297,24 @@ public:
     ~wxCairoFontData();
 
     virtual void Apply( wxGraphicsContext* context );
+#ifdef __WXGTK__
+    const PangoFontDescription* GetFont() const { return m_font; }
+#endif
 private :
-    wxCharBuffer m_fontName;
     double m_size;
-    cairo_font_slant_t m_slant;
-    cairo_font_weight_t m_weight;
     double m_red;
     double m_green;
     double m_blue;
     double m_alpha;
+#ifdef __WXMAC__
+    cairo_font_face_t *m_font;
+#elif defined(__WXGTK__)
+    PangoFontDescription* m_font;
+#else
+    wxCharBuffer m_fontName;
+    cairo_font_slant_t m_slant;
+    cairo_font_weight_t m_weight;
+#endif
 };
 
 class WXDLLIMPEXP_CORE wxCairoContext : public wxGraphicsContext
@@ -314,6 +331,18 @@ public:
     wxCairoContext();
     virtual ~wxCairoContext();
 
+    virtual bool ShouldOffset() const
+    {     
+        int penwidth = 0 ;
+        if ( !m_pen.IsNull() )
+        {
+            penwidth = (int)((wxCairoPenData*)m_pen.GetRefData())->GetWidth();
+            if ( penwidth == 0 )
+                penwidth = 1;
+        }
+        return ( penwidth % 2 ) == 1;
+    }
+
     virtual void Clip( const wxRegion &region );
 
     // clips drawings to the rect
@@ -351,6 +380,8 @@ public:
     virtual void GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const;
 
 private:
+    void Init(cairo_t *context);
+    
     cairo_t* m_context;
 };
 
@@ -454,17 +485,17 @@ wxCairoPenData::wxCairoPenData( wxGraphicsRenderer* renderer, const wxPen &pen )
         break;
 
     case wxLONG_DASH :
-        m_lengths = dotted ;
+        m_lengths = dashed ;
         m_count = WXSIZEOF(dashed);
         break;
 
     case wxSHORT_DASH :
-        m_lengths = dotted ;
+        m_lengths = short_dashed ;
         m_count = WXSIZEOF(short_dashed);
         break;
 
     case wxDOT_DASH :
-        m_lengths = dotted ;
+        m_lengths = dotted_dashed ;
         m_count = WXSIZEOF(dotted_dashed);
         break;
 
@@ -673,25 +704,42 @@ wxCairoFontData::wxCairoFontData( wxGraphicsRenderer* renderer, const wxFont &fo
     m_green = col.Green()/255.0; 
     m_blue = col.Blue()/255.0;
     m_alpha = col.Alpha()/255.0;
-
     m_size = font.GetPointSize();
+
+#ifdef __WXMAC__
+    m_font = cairo_atsui_font_face_create_for_atsu_font_id( font.MacGetATSUFontID() );
+#elif defined(__WXGTK__)
+    m_font = pango_font_description_copy( font.GetNativeFontInfo()->description );
+#else
     m_fontName = font.GetFaceName().mb_str(wxConvUTF8);
     m_slant = font.GetStyle() == wxFONTSTYLE_ITALIC ? CAIRO_FONT_SLANT_ITALIC:CAIRO_FONT_SLANT_NORMAL;
     m_weight = font.GetWeight() == wxFONTWEIGHT_BOLD ? CAIRO_FONT_WEIGHT_BOLD:CAIRO_FONT_WEIGHT_NORMAL;
+#endif
 }
 
 wxCairoFontData::~wxCairoFontData()
 {
+#ifdef __WXMAC__
+    cairo_font_face_destroy( m_font );
+#elif defined(__WXGTK__)
+    pango_font_description_free( m_font );
+#else
+#endif
 }
 
 void wxCairoFontData::Apply( wxGraphicsContext* context )
 {
     cairo_t * ctext = (cairo_t*) context->GetNativeContext();
     cairo_set_source_rgba(ctext,m_red,m_green, m_blue,m_alpha);
-    cairo_select_font_face(ctext,m_fontName,m_slant,m_weight);
-    cairo_set_font_size(ctext,m_size);
-    // TODO UNDERLINE
-    // TODO FIX SIZE
+#ifdef __WXGTK__
+    // the rest is done using Pango layouts
+#elif defined(__WXMAC__)
+    cairo_set_font_face(ctext, m_font);
+    cairo_set_font_size(ctext, m_size );
+#else
+    cairo_select_font_face(ctext, m_fontName, m_slant, m_weights );
+    cairo_set_font_size(ctext, m_size );
+#endif
 }
 
 //-----------------------------------------------------------------------------
@@ -757,7 +805,9 @@ void wxCairoPathData::AddLineToPoint( wxDouble x , wxDouble y )
 
 void wxCairoPathData::AddPath( const wxGraphicsPathData* path )
 {
-    // TODO
+    cairo_path_t* p = (cairo_path_t*)path->GetNativePath();
+    cairo_append_path(m_pathContext, p);
+    UnGetNativePath(p);
 }
 
 void wxCairoPathData::CloseSubpath()
@@ -831,7 +881,7 @@ void wxCairoPathData::GetBox(wxDouble *x, wxDouble *y, wxDouble *w, wxDouble *h)
     }
 }
 
-bool wxCairoPathData::Contains( wxDouble x, wxDouble y, int fillStyle ) const
+bool wxCairoPathData::Contains( wxDouble x, wxDouble y, int WXUNUSED(fillStyle) ) const
 {
     return cairo_in_stroke( m_pathContext, x, y) != 0;
 }
@@ -962,32 +1012,59 @@ void * wxCairoMatrixData::GetNativeMatrix() const
 // wxCairoContext implementation
 //-----------------------------------------------------------------------------
 
+class wxCairoOffsetHelper
+{
+public :
+    wxCairoOffsetHelper( cairo_t* ctx , bool offset )
+    {
+        m_ctx = ctx;
+        m_offset = offset;
+        if ( m_offset )
+             cairo_translate( m_ctx, 0.5, 0.5 );
+    }
+    ~wxCairoOffsetHelper( )
+    {
+        if ( m_offset )
+            cairo_translate( m_ctx, -0.5, -0.5 );
+    }
+public :
+    cairo_t* m_ctx;
+    bool m_offset;
+} ;
+
 wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, const wxWindowDC& dc )
 : wxGraphicsContext(renderer)
 {
 #ifdef __WXGTK__
-    m_context = gdk_cairo_create( dc.m_window ) ;
+#if wxUSE_NEW_DC
+    wxGTKImplDC *impldc = (wxGTKImplDC*) dc.GetImpl();
+    Init( gdk_cairo_create( impldc->GetGDKWindow() ) );
+#else  
+    Init( gdk_cairo_create( dc.m_window ) );
+#endif
+#endif
+#ifdef __WXMAC__
+    int width, height;
+    dc.GetSize( &width, &height );
+    CGContextRef cgcontext = (CGContextRef)dc.GetWindow()->MacGetCGContextRef();
+    cairo_surface_t* surface = cairo_quartz_surface_create_for_cg_context(cgcontext, width, height);
+    Init( cairo_create( surface ) );
+    cairo_surface_destroy( surface );
 #endif
-    PushState();
-    PushState();
 }
 
 #ifdef __WXGTK__
 wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, GdkDrawable *drawable )
 : wxGraphicsContext(renderer)
 {
-    m_context = gdk_cairo_create( drawable ) ;
-    PushState();
-    PushState();
+    Init( gdk_cairo_create( drawable ) );
 }
 #endif
 
 wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, cairo_t *context )
 : wxGraphicsContext(renderer)
 {
-    m_context = context ;
-    PushState();
-    PushState();
+    Init( context );
 }
 
 wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, wxWindow *window)
@@ -996,25 +1073,18 @@ wxCairoContext::wxCairoContext( wxGraphicsRenderer* renderer, wxWindow *window)
 #ifdef __WXGTK__
     // something along these lines (copied from dcclient)
 
-    GtkWidget *widget = window->m_wxwindow;
-
     // Some controls don't have m_wxwindow - like wxStaticBox, but the user
     // code should still be able to create wxClientDCs for them, so we will
     // use the parent window here then.
-    if ( !widget )
+    if (window->m_wxwindow == NULL)
     {
         window = window->GetParent();
-        widget = window->m_wxwindow;
     }
 
-    wxASSERT_MSG( widget, wxT("wxCairoContext needs a widget") );
+    wxASSERT_MSG( window->m_wxwindow, wxT("wxCairoContext needs a widget") );
 
-    GtkPizza *pizza = GTK_PIZZA( widget );
-    GdkDrawable* drawable = pizza->bin_window;
-    m_context = gdk_cairo_create( drawable ) ;
+    Init(gdk_cairo_create(window->GTKGetDrawingWindow()));
 #endif
-    PushState();
-    PushState();
 }
 
 wxCairoContext::~wxCairoContext()
@@ -1027,20 +1097,52 @@ wxCairoContext::~wxCairoContext()
     }
 }
 
+void wxCairoContext::Init(cairo_t *context)
+{
+    m_context = context ;
+    PushState();
+    PushState();
+}
+
 
-void wxCairoContext::Clip( const wxRegion & WXUNUSED(region) )
+void wxCairoContext::Clip( const wxRegion& region )
 {
-// TODO
+    // Create a path with all the rectangles in the region
+    wxGraphicsPath path = GetRenderer()->CreatePath();
+    wxRegionIterator ri(region);
+    while (ri)
+    {
+        path.AddRectangle(ri.GetX(), ri.GetY(), ri.GetW(), ri.GetH());
+        ++ri;
+    }
+    
+    // Put it in the context
+    cairo_path_t* cp = (cairo_path_t*) path.GetNativePath() ;
+    cairo_append_path(m_context, cp);
+
+    // clip to that path
+    cairo_clip(m_context);
+    path.UnGetNativePath(cp);  
 }
 
 void wxCairoContext::Clip( wxDouble x, wxDouble y, wxDouble w, wxDouble h )
 {
-// TODO
+    // Create a path with this rectangle
+    wxGraphicsPath path = GetRenderer()->CreatePath();
+    path.AddRectangle(x,y,w,h);
+
+    // Put it in the context
+    cairo_path_t* cp = (cairo_path_t*) path.GetNativePath() ;
+    cairo_append_path(m_context, cp);
+
+    // clip to that path
+    cairo_clip(m_context);
+    path.UnGetNativePath(cp);  
 }
 
 void wxCairoContext::ResetClip()
 {
-// TODO
+    cairo_reset_clip(m_context);
 }
 
 
@@ -1048,6 +1150,7 @@ void wxCairoContext::StrokePath( const wxGraphicsPath& path )
 {
     if ( !m_pen.IsNull() )
     {   
+        wxCairoOffsetHelper helper( m_context, ShouldOffset() ) ;       
         cairo_path_t* cp = (cairo_path_t*) path.GetNativePath() ;
         cairo_append_path(m_context,cp);
         ((wxCairoPenData*)m_pen.GetRefData())->Apply(this);
@@ -1060,6 +1163,7 @@ void wxCairoContext::FillPath( const wxGraphicsPath& path , int fillStyle )
 {
     if ( !m_brush.IsNull() )
     {
+        wxCairoOffsetHelper helper( m_context, ShouldOffset() ) ;
         cairo_path_t* cp = (cairo_path_t*) path.GetNativePath() ;
         cairo_append_path(m_context,cp);
         ((wxCairoBrushData*)m_brush.GetRefData())->Apply(this);
@@ -1118,37 +1222,217 @@ void wxCairoContext::PopState()
 
 void wxCairoContext::DrawBitmap( const wxBitmap &bmp, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
 {
-    /*
-        Bitmap* image = Bitmap::FromHBITMAP((HBITMAP)bmp.GetHBITMAP(),(HPALETTE)bmp.GetPalette()->GetHPALETTE());
-        m_context->DrawImage(image,(REAL) x,(REAL) y,(REAL) w,(REAL) h) ;
-        delete image ;
-    */
+    wxCHECK_RET( bmp.IsOk(), wxT("Invalid bitmap in wxCairoContext::DrawBitmap"));
+
+    cairo_surface_t* surface;
+    int bw = bmp.GetWidth();
+    int bh = bmp.GetHeight();
+    wxBitmap bmpSource = bmp;  // we need a non-const instance
+    unsigned char* buffer = new unsigned char[bw*bh*4];
+    wxUint32* data = (wxUint32*)buffer;
+    
+    // Create a surface object and copy the bitmap pixel data to it.  if the
+    // image has alpha (or a mask represented as alpha) then we'll use a
+    // different format and iterator than if it doesn't...
+    if (bmpSource.HasAlpha() || bmpSource.GetMask())
+    {
+        surface = cairo_image_surface_create_for_data(
+            buffer, CAIRO_FORMAT_ARGB32, bw, bh, bw*4);
+        wxAlphaPixelData pixData(bmpSource, wxPoint(0,0), wxSize(bw, bh));
+        wxCHECK_RET( pixData, wxT("Failed to gain raw access to bitmap data."));
+        
+        wxAlphaPixelData::Iterator p(pixData);
+        for (int y=0; y<bh; y++)
+        {
+            wxAlphaPixelData::Iterator rowStart = p;
+            for (int x=0; x<bw; x++)
+            {
+                // Each pixel in CAIRO_FORMAT_ARGB32 is a 32-bit quantity,
+                // with alpha in the upper 8 bits, then red, then green, then
+                // blue. The 32-bit quantities are stored native-endian.
+                // Pre-multiplied alpha is used.
+                unsigned char alpha = p.Alpha();
+                if (alpha == 0)
+                    *data = 0;
+                else
+                    *data = ( alpha                      << 24 
+                              | (p.Red() * alpha/255)    << 16 
+                              | (p.Green() * alpha/255)  <<  8 
+                              | (p.Blue() * alpha/255) );
+                ++data;
+                ++p;
+            }
+            p = rowStart;
+            p.OffsetY(pixData, 1);
+        }        
+    }
+    else  // no alpha
+    {
+        surface = cairo_image_surface_create_for_data(
+            buffer, CAIRO_FORMAT_RGB24, bw, bh, bw*4);
+        wxNativePixelData pixData(bmpSource, wxPoint(0,0), wxSize(bw, bh));
+        wxCHECK_RET( pixData, wxT("Failed to gain raw access to bitmap data."));
+        
+        wxNativePixelData::Iterator p(pixData);
+        for (int y=0; y<bh; y++)
+        {
+            wxNativePixelData::Iterator rowStart = p;
+            for (int x=0; x<bw; x++)
+            {
+                // Each pixel in CAIRO_FORMAT_RGB24 is a 32-bit quantity, with
+                // the upper 8 bits unused. Red, Green, and Blue are stored in
+                // the remaining 24 bits in that order.  The 32-bit quantities
+                // are stored native-endian.
+                *data = ( p.Red() << 16 | p.Green() << 8 | p.Blue() );
+                ++data;
+                ++p;
+            }
+            p = rowStart;
+            p.OffsetY(pixData, 1);
+        }        
+    }
+
+    
+    PushState();
+    
+    // In case we're scaling the image by using a width and height different
+    // than the bitmap's size create a pattern transformation on the surface and
+    // draw the transformed pattern.
+    cairo_pattern_t* pattern = cairo_pattern_create_for_surface(surface);
+    wxDouble scaleX = w / bw;
+    wxDouble scaleY = h / bh;
+    cairo_scale(m_context, scaleX, scaleY);
+
+    // prepare to draw the image
+    cairo_translate(m_context, x, y);
+    cairo_set_source(m_context, pattern);
+    // use the original size here since the context is scaled already...
+    cairo_rectangle(m_context, 0, 0, bw, bh);
+    // fill the rectangle using the pattern
+    cairo_fill(m_context);
+
+    // clean up
+    cairo_pattern_destroy(pattern);
+    cairo_surface_destroy(surface);
+    delete [] buffer;
+    PopState();
 }
 
 void wxCairoContext::DrawIcon( const wxIcon &icon, wxDouble x, wxDouble y, wxDouble w, wxDouble h )
 {
-    /*
-        Bitmap* image = Bitmap::FromHICON((HICON)icon.GetHICON());
-        m_context->DrawImage(image,(REAL) x,(REAL) y,(REAL) w,(REAL) h) ;
-        delete image ;
-    */
+    // An icon is a bitmap on wxGTK, so do this the easy way.  When we want to
+    // start using the Cairo backend on other platforms then we may need to
+    // fiddle with this...
+    DrawBitmap(icon, x, y, w, h);
 }
 
 
 void wxCairoContext::DrawText( const wxString &str, wxDouble x, wxDouble y )
 {
-    if ( m_font.IsNull() || str.IsEmpty())
-        return ;
-    cairo_move_to(m_context,x,y);
-    const wxWX2MBbuf buf(str.mb_str(wxConvUTF8));
+    if ( m_font.IsNull() || str.empty())
+        return;
+
+#ifdef __WXGTK__
+    const wxCharBuffer data = str.utf8_str();
+    if ( !data )
+        return;
+    size_t datalen = strlen(data);
+    ((wxCairoFontData*)m_font.GetRefData())->Apply(this);
+
+    PangoLayout *layout = pango_cairo_create_layout (m_context);
+    pango_layout_set_font_description( layout, ((wxCairoFontData*)m_font.GetRefData())->GetFont());
+    pango_layout_set_text(layout, data, datalen);
+    cairo_move_to(m_context, x, y);
+    pango_cairo_show_layout (m_context, layout);
+
+    g_object_unref (layout);
+#else
     ((wxCairoFontData*)m_font.GetRefData())->Apply(this);
+    // Cairo's x,y for drawing text is at the baseline, so we need to adjust
+    // the position we move to by the ascent.
+    cairo_font_extents_t fe;
+    cairo_font_extents(m_context, &fe);
+    cairo_move_to(m_context, x, y+fe.ascent);
+    
+    const wxWX2MBbuf buf(str.mb_str(wxConvUTF8));
     cairo_show_text(m_context,buf);
+#endif
 }
 
 void wxCairoContext::GetTextExtent( const wxString &str, wxDouble *width, wxDouble *height,
                                     wxDouble *descent, wxDouble *externalLeading ) const
 {
-    // TODO
+    if ( width )
+        *width = 0;
+    if ( height )
+        *height = 0;
+    if ( descent )
+        *descent = 0;
+    if ( externalLeading )
+        *externalLeading = 0;
+
+    if ( m_font.IsNull() || str.empty())
+        return;
+
+#ifdef __WXGTK__
+    int w, h;
+  
+    PangoLayout *layout = pango_cairo_create_layout (m_context);
+    pango_layout_set_font_description( layout, ((wxCairoFontData*)m_font.GetRefData())->GetFont());
+    const wxCharBuffer data = str.utf8_str();
+    if ( !data )
+    {
+        return;
+    }
+    pango_layout_set_text( layout, data, strlen(data) );
+    pango_layout_get_pixel_size (layout, &w, &h);
+    if ( width )
+        *width = w;
+    if ( height )
+        *height = h;
+    if (descent)
+    {
+        PangoLayoutIter *iter = pango_layout_get_iter(layout);
+        int baseline = pango_layout_iter_get_baseline(iter);
+        pango_layout_iter_free(iter);
+        *descent = h - PANGO_PIXELS(baseline);
+    }
+    g_object_unref (layout);
+#else
+    ((wxCairoFontData*)m_font.GetRefData())->Apply((wxCairoContext*)this);
+
+    if (width)
+    {
+        const wxWX2MBbuf buf(str.mb_str(wxConvUTF8));
+        cairo_text_extents_t te;
+        cairo_text_extents(m_context, buf, &te);
+        *width = te.width;
+    }
+
+    if (height || descent || externalLeading)
+    {
+        cairo_font_extents_t fe;
+        cairo_font_extents(m_context, &fe);
+        
+        // some backends have negative descents
+        
+        if ( fe.descent < 0 )
+            fe.descent = -fe.descent;
+    
+        if ( fe.height < (fe.ascent + fe.descent ) )
+        {
+            // some backends are broken re height ... (eg currently ATSUI)
+            fe.height = fe.ascent + fe.descent;
+        }
+    
+        if (height)
+            *height = fe.height;
+        if ( descent )
+            *descent = fe.descent;
+        if ( externalLeading )
+            *externalLeading = wxMax(0, fe.height - (fe.ascent + fe.descent));
+    }
+#endif
 }
 
 void wxCairoContext::GetPartialTextExtents(const wxString& text, wxArrayDouble& widths) const
@@ -1231,6 +1515,9 @@ private :
 IMPLEMENT_DYNAMIC_CLASS(wxCairoRenderer,wxGraphicsRenderer)
 
 static wxCairoRenderer gs_cairoGraphicsRenderer;
+// temporary hack to allow creating a cairo context on any platform
+extern wxGraphicsRenderer* gCairoRenderer;
+wxGraphicsRenderer* gCairoRenderer = &gs_cairoGraphicsRenderer;
 
 #ifdef __WXGTK__
 wxGraphicsRenderer* wxGraphicsRenderer::GetDefaultRenderer()