Refactor Item::draw to use ICairoShim interface for testability

engine/cairoShimCairo.cc

@@ -1,91 +1,136 @@
-#include "cairoShim.h"
+#include "cairoShimCairo.h"
 #define CAIRO_WIN32_STATIC_BUILD
 #include <cairo.h>
 #undef CAIRO_WIN32_STATIC_BUILD
+#include <pango.h>
 
 using namespace std;
 
-namespace ravel
+namespace minsky
 {
-  void CairoShimCairo::moveTo(double x, double y) 
+  CairoShimCairo::CairoShimCairo(cairo_t* c) : cairo(c) {}
+
+  CairoShimCairo::~CairoShimCairo() = default;
+
+  // Drawing operations
+  void CairoShimCairo::moveTo(double x, double y) const
   {cairo_move_to(cairo,x,y);}
 
-  void CairoShimCairo::lineTo(double x, double y)
+  void CairoShimCairo::lineTo(double x, double y) const
   {cairo_line_to(cairo,x,y);}
 
-  void CairoShimCairo::relMoveTo(double x, double y)
+  void CairoShimCairo::relMoveTo(double x, double y) const
   {cairo_rel_move_to(cairo,x,y);}
 
-  void CairoShimCairo::relLineTo(double x, double y)
+  void CairoShimCairo::relLineTo(double x, double y) const
   {cairo_rel_line_to(cairo,x,y);}
 
-  void CairoShimCairo::arc
-  (double x, double y, double radius, double start, double end)
+  void CairoShimCairo::arc(double x, double y, double radius, double start, double end) const
   {cairo_arc(cairo,x,y,radius,start,end);}
 
-    // paths
-  void CairoShimCairo::newPath()
+  void CairoShimCairo::curveTo(double x1, double y1, double x2, double y2, double x3, double y3) const
+  {cairo_curve_to(cairo,x1,y1,x2,y2,x3,y3);}
+
+  void CairoShimCairo::rectangle(double x, double y, double width, double height) const
+  {cairo_rectangle(cairo,x,y,width,height);}
+
+  // Path operations
+  void CairoShimCairo::newPath() const
   {cairo_new_path(cairo);}
 
-  void CairoShimCairo::closePath()
+  void CairoShimCairo::newSubPath() const
+  {cairo_new_sub_path(cairo);}
+
+  void CairoShimCairo::closePath() const
   {cairo_close_path(cairo);}
 
-  void CairoShimCairo::fill()
+  void CairoShimCairo::getCurrentPoint(double& x, double& y) const
+  {cairo_get_current_point(cairo, &x, &y);}
+
+  // Fill and stroke operations
+  void CairoShimCairo::fill() const
   {cairo_fill(cairo);}
+
+  void CairoShimCairo::fillPreserve() const
+  {cairo_fill_preserve(cairo);}
 
-  void CairoShimCairo::clip()
+  void CairoShimCairo::clip() const
   {cairo_clip(cairo);}
 
-  void CairoShimCairo::stroke()
+  void CairoShimCairo::resetClip() const
+  {cairo_reset_clip(cairo);}
+
+  void CairoShimCairo::stroke() const
   {cairo_stroke(cairo);}
 
-   void CairoShimCairo::strokePreserve()
+  void CairoShimCairo::strokePreserve() const
   {cairo_stroke_preserve(cairo);}
 
-   void CairoShimCairo::setLineWidth(double w)
+  void CairoShimCairo::paint() const
+  {cairo_paint(cairo);}
+
+  // Line properties
+  void CairoShimCairo::setLineWidth(double w) const
   {cairo_set_line_width(cairo, w);}
 
-  // sources
-   void CairoShimCairo::setSourceRGB
-  (double r, double g, double b)
+  double CairoShimCairo::getLineWidth() const
+  {return cairo_get_line_width(cairo);}
+
+  void CairoShimCairo::setDash(const double* dashes, int num_dashes, double offset) const
+  {cairo_set_dash(cairo, dashes, num_dashes, offset);}
+
+  void CairoShimCairo::setFillRule(cairo_fill_rule_t fill_rule) const
+  {cairo_set_fill_rule(cairo, fill_rule);}
+
+  // Color operations
+  void CairoShimCairo::setSourceRGB(double r, double g, double b) const
   {cairo_set_source_rgb(cairo,r,g,b);}
 
-   void CairoShimCairo::setSourceRGBA
-  (double r, double g, double b, double a)
+  void CairoShimCairo::setSourceRGBA(double r, double g, double b, double a) const
   {cairo_set_source_rgba(cairo,r,g,b,a);}
 
-  // text. Argument is in UTF8 encoding
-   void CairoShimCairo::showText(const std::string& text)
+  // Text operations
+  void CairoShimCairo::showText(const std::string& text) const
   {cairo_show_text(cairo,text.c_str());}
 
-   void CairoShimCairo::setTextExtents(const std::string& text)
-  {cairo_text_extents(cairo,text.c_str(),&extents);}
-
-   double CairoShimCairo::textWidth() const
-  {return extents.width;}
+  void CairoShimCairo::setFontSize(double size) const
+  {cairo_set_font_size(cairo, size);}
 
-   double CairoShimCairo::textHeight() const
-  {return extents.height;}
+  void CairoShimCairo::textExtents(const std::string& text, cairo_text_extents_t& extents) const
+  {cairo_text_extents(cairo,text.c_str(),&extents);}
 
-  // matrix transformation
-   void CairoShimCairo::identityMatrix()
+  // Transformation operations
+  void CairoShimCairo::identityMatrix() const
   {cairo_identity_matrix(cairo);}
 
-   void CairoShimCairo::translate(double x, double y)
+  void CairoShimCairo::translate(double x, double y) const
   {cairo_translate(cairo,x,y);}
 
-   void CairoShimCairo::scale(double sx, double sy)
+  void CairoShimCairo::scale(double sx, double sy) const
   {cairo_scale(cairo,sx,sy);}
 
-   void CairoShimCairo::rotate(double angle)
+  void CairoShimCairo::rotate(double angle) const
   {cairo_rotate(cairo,angle);}
 
-    // context manipulation
-   void CairoShimCairo::save()
+  void CairoShimCairo::userToDevice(double& x, double& y) const
+  {cairo_user_to_device(cairo, &x, &y);}
+
+  // Context state operations
+  void CairoShimCairo::save() const
   {cairo_save(cairo);}
 
-   void CairoShimCairo::restore()
+  void CairoShimCairo::restore() const
   {cairo_restore(cairo);}
 
-
+  // Tolerance
+  void CairoShimCairo::setTolerance(double tolerance) const
+  {cairo_set_tolerance(cairo, tolerance);}
+
+  // Pango support
+  ecolab::Pango& CairoShimCairo::pango() const
+  {
+    if (!m_pango)
+      m_pango.reset(new ecolab::Pango(cairo));
+    return *m_pango;
+  }
 }

engine/cairoShimCairo.h

@@ -1,56 +1,83 @@
 #ifndef CAIROSHIMCAIRO_H
 #define CAIROSHIMCAIRO_H
-#include "cairoShim.h"
+#include "../model/ICairoShim.h"
 #include <cairo.h>
+#include <pango.h>
+#include <memory>
+
+namespace ecolab { class Pango; }
 
 namespace minsky
 {
+  /// Concrete implementation of ICairoShim using actual Cairo library
   class CairoShimCairo: public ICairoShim
   {
-    cairo_t* cairo; 
+    cairo_t* cairo;
+    mutable std::unique_ptr<ecolab::Pango> m_pango;
     CairoShimCairo(const CairoShimCairo&)=delete;
     void operator=(const CairoShimCairo&)=delete;
   public:
-    // template parameter G = cairo_t* or HDC
-    CairoShim(cairo_t*);
-    ~CairoShim();
-
-    void moveTo(double x, double y);
-    void lineTo(double x, double y);
-    void relMoveTo(double x, double y);
-    void relLineTo(double x, double y);
-    void arc(double x, double y, double radius, double start, double end);
-
-    void setLineWidth(double);
-
-    // paths
-    void newPath();
-    void closePath();
-    void fill();
-    void clip();
-    void stroke();
-    void strokePreserve();
-
-    // sources
-    void setSourceRGB(double r, double g, double b);
-    void setSourceRGBA(double r, double g, double b, double a);
-
-    // text. Argument is in UTF8 encoding
-    void showText(const std::string&);
-    void setTextExtents(const std::string&);
-    double textWidth() const;
-    double textHeight() const;
-
-    // matrix transformation
-    void identityMatrix();
-    void translate(double x, double y);
-    void scale(double sx, double sy);
-    void rotate(double angle); ///< angle in radians
-
-    // context manipulation
-    void save();
-    void restore();
+    CairoShimCairo(cairo_t* c);
+    ~CairoShimCairo() override;
+
+    // Drawing operations
+    void moveTo(double x, double y) const override;
+    void lineTo(double x, double y) const override;
+    void relMoveTo(double x, double y) const override;
+    void relLineTo(double x, double y) const override;
+    void arc(double x, double y, double radius, double start, double end) const override;
+    void curveTo(double x1, double y1, double x2, double y2, double x3, double y3) const override;
+    void rectangle(double x, double y, double width, double height) const override;
+
+    // Path operations
+    void newPath() const override;
+    void newSubPath() const override;
+    void closePath() const override;
+    void getCurrentPoint(double& x, double& y) const override;
+
+    // Fill and stroke operations
+    void fill() const override;
+    void fillPreserve() const override;
+    void stroke() const override;
+    void strokePreserve() const override;
+    void clip() const override;
+    void resetClip() const override;
+    void paint() const override;
+
+    // Line properties
+    void setLineWidth(double width) const override;
+    double getLineWidth() const override;
+    void setDash(const double* dashes, int num_dashes, double offset) const override;
+    void setFillRule(cairo_fill_rule_t fill_rule) const override;
+
+    // Color operations
+    void setSourceRGB(double r, double g, double b) const override;
+    void setSourceRGBA(double r, double g, double b, double a) const override;
+
+    // Text operations
+    void showText(const std::string& text) const override;
+    void setFontSize(double size) const override;
+    void textExtents(const std::string& text, cairo_text_extents_t& extents) const override;
+
+    // Transformation operations
+    void identityMatrix() const override;
+    void translate(double x, double y) const override;
+    void scale(double sx, double sy) const override;
+    void rotate(double angle) const override;
+    void userToDevice(double& x, double& y) const override;
+
+    // Context state operations
+    void save() const override;
+    void restore() const override;
+
+    // Tolerance
+    void setTolerance(double tolerance) const override;
+
+    // Pango support
+    ecolab::Pango& pango() const override;
 
+    // TEMPORARY: Internal accessor for migration - to be removed once all implementations are updated
+    cairo_t* _internalGetCairoContext() const { return cairo; }
   };
 
 }

model/ICairoShim.h

@@ -0,0 +1,95 @@
+/*
+  Abstract interface for Cairo operations to enable testing and mocking
+  @copyright Steve Keen 2012
+  @author Russell Standish
+  This file is part of Minsky.
+
+  Minsky is free software: you can redistribute it and/or modify it
+  under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  Minsky is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with Minsky.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef ICAIROSHIM_H
+#define ICAIROSHIM_H
+
+#include <string>
+#include <cairo.h>
+
+namespace minsky
+{
+  // Forward declarations for Pango
+  namespace ecolab { class Pango; }
+
+  /// Abstract interface for Cairo drawing operations
+  class ICairoShim
+  {
+  public:
+    virtual ~ICairoShim() = default;
+
+    // Drawing operations
+    virtual void moveTo(double x, double y) const = 0;
+    virtual void lineTo(double x, double y) const = 0;
+    virtual void relMoveTo(double x, double y) const = 0;
+    virtual void relLineTo(double x, double y) const = 0;
+    virtual void arc(double x, double y, double radius, double start, double end) const = 0;
+    virtual void curveTo(double x1, double y1, double x2, double y2, double x3, double y3) const = 0;
+    virtual void rectangle(double x, double y, double width, double height) const = 0;
+
+    // Path operations
+    virtual void newPath() const = 0;
+    virtual void newSubPath() const = 0;
+    virtual void closePath() const = 0;
+    virtual void getCurrentPoint(double& x, double& y) const = 0;
+
+    // Fill and stroke operations
+    virtual void fill() const = 0;
+    virtual void fillPreserve() const = 0;
+    virtual void stroke() const = 0;
+    virtual void strokePreserve() const = 0;
+    virtual void clip() const = 0;
+    virtual void resetClip() const = 0;
+    virtual void paint() const = 0;
+
+    // Line properties
+    virtual void setLineWidth(double width) const = 0;
+    virtual double getLineWidth() const = 0;
+    virtual void setDash(const double* dashes, int num_dashes, double offset) const = 0;
+    virtual void setFillRule(cairo_fill_rule_t fill_rule) const = 0;
+
+    // Color operations
+    virtual void setSourceRGB(double r, double g, double b) const = 0;
+    virtual void setSourceRGBA(double r, double g, double b, double a) const = 0;
+
+    // Text operations
+    virtual void showText(const std::string& text) const = 0;
+    virtual void setFontSize(double size) const = 0;
+    virtual void textExtents(const std::string& text, cairo_text_extents_t& extents) const = 0;
+
+    // Transformation operations
+    virtual void identityMatrix() const = 0;
+    virtual void translate(double x, double y) const = 0;
+    virtual void scale(double sx, double sy) const = 0;
+    virtual void rotate(double angle) const = 0;
+    virtual void userToDevice(double& x, double& y) const = 0;
+
+    // Context state operations
+    virtual void save() const = 0;
+    virtual void restore() const = 0;
+
+    // Tolerance
+    virtual void setTolerance(double tolerance) const = 0;
+
+    // Pango support for text rendering
+    virtual ecolab::Pango& pango() const = 0;
+  };
+}
+
+#endif // ICAIROSHIM_H