Port the code from Cairo to Cairo--.

See the TODO files for bugs and things that require attention.
The nasty bug that prevents visualization has been around for a while now, since Gtk+ reached 2.12, I think. Must be fixed.


git-svn-id: svn://svn.gna.org/svn/sgpemv2/trunk@1349 3ecf2c5c-341e-0410-92b4-d18e462d057c

Makefile.am

@@ -352,7 +352,7 @@ sgpemv2_CPPFLAGS = \
 		-DLOCALEDIR="\"$(localedir)\"" \
 		-DSHAREDIR="\"$(sharedir)\"" \
 		-DUIDIR="\"$(uidir)\"" \
-		$(CAIRO_CFLAGS) \
+		$(CAIROMM_CFLAGS) \
 		$(GTKMM_CFLAGS) \
 		$(LIBGLADEMM_CFLAGS) \
 		$(GTHREAD_CFLAGS)
@@ -362,7 +362,7 @@ sgpemv2_LDFLAGS = \
 		-Wl,-rpath -Wl,"$(pkglibdir)"
 sgpemv2_LDADD = \
 		src/backend/libbackend.la \
-		$(CAIRO_LIBS) \
+		$(CAIROMM_LIBS) \
 		$(GTKMM_LIBS) \
 		$(GTHREAD_LIBS)
 
@@ -530,11 +530,11 @@ src_testsuite_test_key_file_SOURCES = \
 src_testsuite_test_cairo_widget_CPPFLAGS = \
 		-I@top_srcdir@/src \
 		-I@top_srcdir@/src/backend \
-		$(CAIRO_CFLAGS) \
+		$(CAIROMM_CFLAGS) \
 		$(GTKMM_CFLAGS) \
 		$(GLIBMM_CFLAGS)
 src_testsuite_test_cairo_widget_LDFLAGS = \
-		$(CAIRO_LIBS) \
+		$(CAIROMM_LIBS) \
 		$(GTKMM_LIBS) \
 		$(GLIBMM_LIBS)
 src_testsuite_test_cairo_widget_SOURCES = \
@@ -545,14 +545,14 @@ src_testsuite_test_cairo_widget_SOURCES = \
 src_testsuite_test_simulation_widget_CPPFLAGS = \
 		-I@top_srcdir@/src \
 		-I@top_srcdir@/src/backend \
-		$(CAIRO_CFLAGS) \
+		$(CAIROMM_CFLAGS) \
 		$(GTKMM_CFLAGS) \
 		$(GLIBMM_CFLAGS) \
 		$(GTHREAD_CFLAGS)
 src_testsuite_test_simulation_widget_LDFLAGS = \
 		src/backend/libbackend.la \
     -Wl,-rpath -Wl,"$(pkglibdir)" \
-		$(CAIRO_LIBS) \
+		$(CAIROMM_LIBS) \
 		$(GTKMM_LIBS) \
 		$(GLIBMM_LIBS) \
 		$(GTHREAD_LIBS)
@@ -565,14 +565,14 @@ src_testsuite_test_simulation_widget_SOURCES = \
 src_testsuite_test_holt_widget_CPPFLAGS = \
 		-I@top_srcdir@/src \
 		-I@top_srcdir@/src/backend \
-		$(CAIRO_CFLAGS) \
+		$(CAIROMM_CFLAGS) \
 		$(GTKMM_CFLAGS) \
 		$(GLIBMM_CFLAGS) \
 		$(GTHREAD_CFLAGS)
 src_testsuite_test_holt_widget_LDFLAGS = \
 		src/backend/libbackend.la \
 		-Wl,-rpath -Wl,"$(pkglibdir)" \
-		$(CAIRO_LIBS) \
+		$(CAIROMM_LIBS) \
 		$(GTKMM_LIBS) \
 		$(GLIBMM_LIBS) \
 		$(GTHREAD_LIBS)

TODO

@@ -0,0 +1,4 @@
+- fix nasty bug that prevents all cairowidgets from showing up
+- Check for simulationwidget deprecat. meth.
+- check headers for #includes with <> instead of ""
+- Report bug for presence of PKG, VERSION, etc. macros inside cairomm-config.h

configure.ac

@@ -57,9 +57,10 @@ AM_GNU_GETTEXT([external])
 AM_GNU_GETTEXT_VERSION([0.17])
 
 dnl various requisites
-SIGCPP_VERSION=2.0.10
+SIGCPP_VERSION=2.0.18
-GTKMM_VERSION=2.12.1
+GLIBMM_VERSION=2.22.0
-CAIRO_VERSION=1.0.0
+GTKMM_VERSION=2.18.0
+CAIROMM_VERSION=1.8.0
 
 dnl c++ compiler and flags
 AC_PROG_CXX
@@ -109,9 +110,9 @@ if test -z "$PKG_CONFIG"; then
    AC_MSG_ERROR([You may need to update your pkg-config installation])
 fi
 
-PKG_CHECK_MODULES([CAIRO], 
+PKG_CHECK_MODULES([CAIROMM], 
-		[cairo >= $CAIRO_VERSION],
+		[cairomm-1.0 >= $CAIROMM_VERSION],
-		:, AC_MSG_ERROR([$CAIRO_PKG_ERRORS]))
+		:, AC_MSG_ERROR([$CAIROMM_PKG_ERRORS]))
 PKG_CHECK_MODULES([GTHREAD], 
 		[gthread-2.0 >= $GTKMM_VERSION],
 		:, AC_MSG_ERROR([$GTHREAD_PKG_ERRORS]))
@@ -119,7 +120,7 @@ PKG_CHECK_MODULES([SIGCPP],
 		[sigc++-2.0 >= $SIGCPP_VERSION],
 		:, AC_MSG_ERROR([$SIGCPP_PKG_ERRORS]))
 PKG_CHECK_MODULES([GLIBMM], 
-		[glibmm-2.4 >= $GTKMM_VERSION],
+		[glibmm-2.4 >= $GLIBMM_VERSION],
 		:, AC_MSG_ERROR([$GLIBMM_PKG_ERRORS]))
 PKG_CHECK_MODULES([GTKMM], 
 		[gtkmm-2.4 >= $GTKMM_VERSION],

src/cairo_elements.cc

@@ -29,7 +29,7 @@
 using namespace sgpem;
 
 
-CairoElements::CairoElements(cairo_t* const ctx)
+CairoElements::CairoElements(const Cairo::RefPtr<Cairo::Context>& ctx)
     : _ctx(ctx)
 {
 }
@@ -38,7 +38,8 @@ CairoElements::CairoElements(cairo_t* const ctx)
 void
 CairoElements::draw_3dsphere(const Point& center, float radius, const Color& cl)
 {
-  cairo_t*& cr = _ctx;
+  using namespace Cairo;
+
   const float& x = center.x;
   const float& y = center.y;
   const float& r = cl.r;
@@ -46,52 +47,52 @@ CairoElements::draw_3dsphere(const Point& center, float radius, const Color& cl)
   const float& b = cl.b;
 
   // Draw initial sphere perimeter
-  cairo_save(cr);
+  _ctx->save();
-  cairo_new_path(cr);
+  _ctx->begin_new_path();
-  cairo_arc(cr, x, y, radius, 0, 2*M_PI);
+  _ctx->arc(x, y, radius, 0, 2*M_PI);
-  cairo_pattern_t* grad = cairo_pattern_create_radial(x, y, radius, x, y, radius - .15);
+  
-  cairo_pattern_add_color_stop_rgba(grad,  0, r - .2, g - .2, b - .2, 1);
+  RefPtr<Gradient> grad = RadialGradient::create(x, y, radius, x, y, radius - .15);
-  cairo_pattern_add_color_stop_rgba(grad,  1,      r,      g,      b, 1);
+  grad->add_color_stop_rgba(0, r - .2, g - .2, b - .2, 1);
-  cairo_set_source(cr, grad);
+  grad->add_color_stop_rgba(1,      r,      g,      b, 1);
-  cairo_fill_preserve(cr);
+  _ctx->set_source(grad);
-  cairo_pattern_destroy(grad);
+  _ctx->fill_preserve();
-  cairo_set_source_rgba(cr, 0, 0, 0, 1);
+
-  cairo_set_line_width(cr, radius * .01);
+  _ctx->set_source_rgba(0, 0, 0, 1);
-  cairo_stroke(cr);
+  _ctx->set_line_width(radius * .01);
-  cairo_restore(cr);
+  _ctx->stroke();
+  _ctx->restore();
 
   // Internal gradient
-  cairo_save(cr);
+  _ctx->save();
-  grad = cairo_pattern_create_linear(x, y, x, y + radius);
+  grad = LinearGradient::create(x, y, x, y + radius);
-  cairo_pattern_add_color_stop_rgba(grad, 1, r - .4, g - .4, b - .4,  1);
+  grad->add_color_stop_rgba(1, r - .4, g - .4, b - .4,  1);
-  cairo_pattern_add_color_stop_rgba(grad, 0,      r,      g,      b, .7);
+  grad->add_color_stop_rgba(0,      r,      g,      b, .7);
-  cairo_set_source(cr, grad);
+  _ctx->set_source(grad);
-  cairo_translate(cr, x*.2, (y + radius*8 / 9) * 1 / 3);
+  _ctx->translate(x*.2, (y + radius*8 / 9) * 1 / 3);
-  cairo_scale(cr, .8, 2. / 3);
+  _ctx->scale(.8, 2. / 3);
-  cairo_arc(cr, x, y, radius, 0, 2*M_PI);
+  _ctx->arc(x, y, radius, 0, 2*M_PI);
-  cairo_fill(cr);
+  _ctx->fill();
-  cairo_pattern_destroy(grad);
+  _ctx->restore();
-  cairo_restore(cr);
 
   // Internal glow
-  cairo_save(cr);
+  _ctx->save();
-  grad = cairo_pattern_create_linear(x, y - radius, x, y);
+  grad = LinearGradient::create(x, y - radius, x, y);
-  cairo_pattern_add_color_stop_rgba(grad,  0, 1, 1, 1, .9);
+  grad->add_color_stop_rgba(0, 1, 1, 1, .9);
-  cairo_pattern_add_color_stop_rgba(grad,  1, 1, 1, 1, .2);
+  grad->add_color_stop_rgba(1, 1, 1, 1, .2);
-  cairo_set_source(cr, grad);
+  _ctx->set_source(grad);
-  cairo_translate(cr, x * .2, (y - radius*8 / 9) * 1 / 3);
+  _ctx->translate(x * .2, (y - radius*8 / 9) * 1 / 3);
-  cairo_scale(cr, .8, 2. / 3);
+  _ctx->scale(.8, 2. / 3);
-  cairo_arc(cr, x, y, radius, 0, 2*M_PI);
+  _ctx->arc(x, y, radius, 0, 2*M_PI);
-  cairo_fill(cr);
+  _ctx->fill();
-  cairo_pattern_destroy(grad);
+  _ctx->restore();
-  cairo_restore(cr);
 }
 
 void
 CairoElements::draw_3dcube(const Rectangle& area, const Color& cl,
                            const float x_percent, const float y_percent)
 {
-  cairo_t*& cr = _ctx;
+  using namespace Cairo;
+
   const float& x0 = area.x0;
   const float& y0 = area.y0;
   const float& w = area.w;
@@ -100,54 +101,53 @@ CairoElements::draw_3dcube(const Rectangle& area, const Color& cl,
   const float& g = cl.b;
   const float& b = cl.b;
 
-  cairo_save(cr);
+  _ctx->save();
-  cairo_set_line_join(cr, CAIRO_LINE_JOIN_ROUND);
+  _ctx->set_line_join(LINE_JOIN_ROUND);
 
   // Front side of the cube:
-  cairo_rectangle(cr, 
+  _ctx->rectangle(x0,               y0 + (1 - y_percent) * h,
-                  x0,               y0 + (1 - y_percent) * h,
                   w * x_percent,    h * y_percent);
                   
-  cairo_set_source_rgb(cr, r, g, b);
+  _ctx->set_source_rgb(r, g, b);
-  cairo_fill_preserve(cr);
+  _ctx->fill_preserve();
-  cairo_set_source_rgb(cr, 0, 0, 0);
+  _ctx->set_source_rgb(0, 0, 0);
-  cairo_stroke(cr);
+  _ctx->stroke();
 
   // ``Upper'' visible cube side:
-  cairo_new_path(cr);
+  _ctx->begin_new_path();
-  cairo_move_to(cr, x0, y0 + (1 - y_percent) * h);
+  _ctx->move_to(x0, y0 + (1 - y_percent) * h);
-  cairo_line_to(cr, x0 + (1 - x_percent) * w, y0);
+  _ctx->line_to(x0 + (1 - x_percent) * w, y0);
-  cairo_line_to(cr, x0 + w, y0);
+  _ctx->line_to(x0 + w, y0);
-  cairo_line_to(cr, x0 + w * x_percent, y0 + (1 - y_percent) * h);
+  _ctx->line_to(x0 + w * x_percent, y0 + (1 - y_percent) * h);
-  cairo_close_path(cr);
+  _ctx->close_path();
-
-  cairo_set_source_rgb(cr, r - 0.2, g - 0.2, b - 0.2);
-  cairo_fill_preserve(cr);
-  cairo_set_source_rgb(cr, 0, 0, 0);
-  cairo_stroke(cr);
 
+  _ctx->set_source_rgb(r - 0.2, g - 0.2, b - 0.2);
+  _ctx->fill_preserve();
+  _ctx->set_source_rgb(0, 0, 0);
+  _ctx->stroke();
   
   // ``Right'' visible cube side:
-  cairo_new_path(cr);
+  _ctx->begin_new_path();
-  cairo_move_to(cr, x0 + w * x_percent, y0 + (1 - y_percent) * h);
+  _ctx->move_to(x0 + w * x_percent, y0 + (1 - y_percent) * h);
-  cairo_line_to(cr, x0 + w, y0);
+  _ctx->line_to(x0 + w, y0);
-  cairo_line_to(cr, x0 + w, y0 + y_percent * h);
+  _ctx->line_to(x0 + w, y0 + y_percent * h);
-  cairo_line_to(cr, x0 + w * x_percent, y0 + h);
+  _ctx->line_to(x0 + w * x_percent, y0 + h);
-  cairo_close_path(cr);
+  _ctx->close_path();
 
-  cairo_set_source_rgb(cr, r - 0.4, g - 0.4, b - 0.4);
+  _ctx->set_source_rgb(r - 0.4, g - 0.4, b - 0.4);
-  cairo_fill_preserve(cr);
+  _ctx->fill_preserve();
-  cairo_set_source_rgb(cr, 0, 0, 0);
+  _ctx->set_source_rgb(0, 0, 0);
-  cairo_stroke(cr);
+  _ctx->stroke();
 
-  cairo_restore(cr);
+  _ctx->restore();
 }
 
 
 void
 CairoElements::draw_container(const Rectangle& area)
 {
-  cairo_t*& cr = _ctx;
+  using namespace Cairo;
+
   const float& x0 = area.x0;
   const float& y0 = area.y0;
   const float& w = area.w;
@@ -155,67 +155,68 @@ CairoElements::draw_container(const Rectangle& area)
 
   const double corner_radius = 0.05;
 
-  cairo_save(cr);
+  _ctx->save();
-  cairo_new_path(cr);
+  _ctx->begin_new_path();
-  cairo_move_to(cr, x0 + corner_radius, y0);
+  _ctx->move_to(x0 + corner_radius, y0);
 
   // NW -> NE
-  cairo_line_to(cr, x0 + w - corner_radius, y0);
+  _ctx->line_to(x0 + w - corner_radius, y0);
-  cairo_curve_to(cr, x0 + w, y0, x0 + w, y0, x0 + w, y0 + corner_radius);
+  _ctx->curve_to(x0 + w, y0, x0 + w, y0, x0 + w, y0 + corner_radius);
   // NE -> SE
-  cairo_line_to(cr, x0 + w, y0 + h - corner_radius);
+  _ctx->line_to(x0 + w, y0 + h - corner_radius);
-  cairo_curve_to(cr, x0 + w, y0 + h, x0 + w, y0 + h, x0 + w - corner_radius, y0 + h);
+  _ctx->curve_to(x0 + w, y0 + h, x0 + w, y0 + h, x0 + w - corner_radius, y0 + h);
   // SE -> SW
-  cairo_line_to(cr, x0 + corner_radius, y0 + h);
+  _ctx->line_to(x0 + corner_radius, y0 + h);
-  cairo_curve_to(cr, x0, y0 + h, x0, y0 + h, x0, y0 + h - corner_radius);
+  _ctx->curve_to(x0, y0 + h, x0, y0 + h, x0, y0 + h - corner_radius);
   // SW -> NW
-  cairo_line_to(cr, x0, y0 + corner_radius);
+  _ctx->line_to(x0, y0 + corner_radius);
-  cairo_curve_to(cr, x0, y0, x0, y0, x0 + corner_radius, y0);
+  _ctx->curve_to(x0, y0, x0, y0, x0 + corner_radius, y0);
-  cairo_close_path(cr);
+  _ctx->close_path();
 
-  cairo_set_source_rgb(cr, 1, 1, 0.9);
+  _ctx->set_source_rgb(1, 1, 0.9);
-  cairo_fill_preserve(cr);
+  _ctx->fill_preserve();
 
-  cairo_set_line_width(cr, .005);
+  _ctx->set_line_width(.005);
-  cairo_set_source_rgb(cr, 0, 0, 0);
+  _ctx->set_source_rgb(0, 0, 0);
 
-  cairo_stroke(cr);
+  _ctx->stroke();
-  cairo_restore(cr);
+  _ctx->restore();
 }
 
 
 void
 CairoElements::draw_expandable(const Rectangle& area, bool expanded)
 {
-  cairo_t*& cr = _ctx;
+  using namespace Cairo;
+  
   const float& x0 = area.x0;
   const float& y0 = area.y0;
   const float& w = area.w;
   const float& h = area.h;
 
-  cairo_save(cr);
+  _ctx->save();
 
-  cairo_set_line_width(cr, .005);
+  _ctx->set_line_width(.005);
-  cairo_set_source_rgb(cr, 1, 1, 1);
+  _ctx->set_source_rgb(1, 1, 1);
 
-  cairo_new_path(cr);
+  _ctx->begin_new_path();
-  cairo_rectangle(cr, x0, y0, w, h);
+  _ctx->rectangle(x0, y0, w, h);
-  cairo_set_source_rgb(cr, 1, 1, 1);
+  _ctx->set_source_rgb(1, 1, 1);
-  cairo_fill_preserve(cr);
+  _ctx->fill_preserve();
-  cairo_set_source_rgb(cr, 0, 0, 0);
+  _ctx->set_source_rgb(0, 0, 0);
-  cairo_stroke(cr);
+  _ctx->stroke();
 
-  cairo_move_to(cr, x0 + w / 10, y0 + h / 2);
+  _ctx->move_to(x0 + w / 10, y0 + h / 2);
-  cairo_line_to(cr, x0 + w*9 / 10, y0 + h / 2);
+  _ctx->line_to(x0 + w*9 / 10, y0 + h / 2);
-  cairo_stroke(cr);
+  _ctx->stroke();
 
-  if (!expanded)
+  if (!expanded) // The "-" becomes a "+"
   {
-    cairo_move_to(cr, x0 + w / 2, y0 + h / 10);
+    _ctx->move_to(x0 + w / 2, y0 + h / 10);
-    cairo_line_to(cr, x0 + w / 2, y0 + h*9 / 10);
+    _ctx->line_to(x0 + w / 2, y0 + h*9 / 10);
-    cairo_stroke(cr);
+    _ctx->stroke();
   }
 
-  cairo_restore(cr);
+  _ctx->restore();
 }
 

src/cairo_elements.hh

@@ -21,11 +21,7 @@
 #ifndef CAIRO_ELEMENTS_HH
 #define CAIRO_ELEMENTS_HH 1
 
-
+#include <cairomm/context.h>
-#include <sgpemv2/thread.hh>
-#include <sgpemv2/process.hh>
-
-#include <cairo.h>
 
 namespace sgpem
 {
@@ -61,7 +57,7 @@ namespace sgpem
   class CairoElements
   {
   public:
-    CairoElements(cairo_t* const ctx);
+    CairoElements(const Cairo::RefPtr<Cairo::Context>& ctx);
 
     void draw_3dsphere(const Point& center, float radius, const Color& cl);
     void draw_3dcube(const Rectangle& area, const Color& cl, const float x_percent, const float y_percent);
@@ -69,7 +65,7 @@ namespace sgpem
     void draw_expandable(const Rectangle& area, bool expanded = false);
 
   private:
-    cairo_t*  _ctx;
+    Cairo::RefPtr<Cairo::Context> _ctx;
   };
 
 } //~ namespace sgpem

src/cairo_widget.cc

@@ -75,11 +75,11 @@ CairoWidget::get_scaling_mode() const
 void
 CairoWidget::on_realize()
 {
-  if (is_realized()) return;
-
   Gtk::Widget::on_realize();
   ensure_style();
 
+  if (!_ref_gdk_window) return;
+
   GdkWindowAttr attributes;
   memset(&attributes, 0, sizeof(attributes));
 
@@ -90,30 +90,29 @@ CairoWidget::on_realize()
   attributes.width = alloc.get_width();
   attributes.height = alloc.get_height();
   attributes.wclass = GDK_INPUT_OUTPUT;
-  attributes.event_mask = get_events() | GDK_EXPOSURE_MASK | GDK_ALL_EVENTS_MASK;
+  attributes.event_mask = get_events() | GDK_EXPOSURE_MASK;
   attributes.window_type = GDK_WINDOW_CHILD;
-  attributes.visual = get_visual()->gobj();
-  attributes.colormap = get_colormap()->gobj();
   
   _client_w = alloc.get_width();
   _client_h = alloc.get_height();
   
 
-  static const gint attributes_mask = Gdk::WA_X | Gdk::WA_Y | Gdk::WA_WMCLASS
+  static const gint attributes_mask = Gdk::WA_X | Gdk::WA_Y;
-                                      | Gdk::WA_VISUAL | Gdk::WA_COLORMAP;
 
-  Glib::RefPtr<Gdk::Window> window = Gdk::Window::create(get_parent_window(),
+  _ref_gdk_window = Gdk::Window::create(get_window(),
                                         &attributes,
                                         attributes_mask);
 
   unset_flags(Gtk::NO_WINDOW);
-  set_window(window);
+  set_window(_ref_gdk_window);
-  window->set_user_data(gobj());
+  _ref_gdk_window->set_user_data(gobj());
+}
 
-
+void
-  Glib::RefPtr<Gtk::Style> style = get_style ();
+CairoWidget::on_unrealize()
-  style = style->attach (window);
+{
-  style->set_background(window, Gtk::STATE_ACTIVE);
+  _ref_gdk_window.clear();
+  Gtk::Widget::on_unrealize();
 }
 
 /*
@@ -124,8 +123,8 @@ CairoWidget::on_size_allocate(const Gtk::Allocation& allocation)
 {
   set_allocation(allocation);
 
-  if (is_realized())
+  if (!_ref_gdk_window) return;
-  {
+  
   get_window()->move_resize(allocation.get_x(), allocation.get_y(),
                             allocation.get_width(), allocation.get_height());
 
@@ -137,8 +136,6 @@ CairoWidget::on_size_allocate(const Gtk::Allocation& allocation)
   _need_redraw = true;
 }
 
-}
-
 /*
   This method is called by Gtk to get the widget desired size.
  */
@@ -163,6 +160,8 @@ CairoWidget::on_size_request(Gtk::Requisition* requisition)
 bool
 CairoWidget::on_expose_event(GdkEventExpose* event)
 {
+  if (!_ref_gdk_window) return true;
+
   if (event == NULL || event->count > 0)
     return false;
 
@@ -180,7 +179,7 @@ CairoWidget::on_expose_event(GdkEventExpose* event)
     _client_w = actual_w;
     _client_h = actual_h;
 
-    // The pixmap must be crated or no?
+    // The pixmap must be crated or not?
     // If the pixmap buffer size isn't enough
     // it must be allocated or reallocated.
     // Here is used a lazy technique:
@@ -195,7 +194,7 @@ CairoWidget::on_expose_event(GdkEventExpose* event)
       _pixmap_h = (size_t) (_client_h*1.2);
 
       // allocate the pixmap
-      _buf = Gdk::Pixmap::create(get_window(), _pixmap_w, _pixmap_h);
+      _buf = Gdk::Pixmap::create(_ref_gdk_window, _pixmap_w, _pixmap_h);
     }
 
   
@@ -208,8 +207,8 @@ CairoWidget::on_expose_event(GdkEventExpose* event)
                   NULL, (GtkWidget*)this->gobj(), "through",
                   0, 0, _client_w, _client_h);
 
-    // here the cairo context is creted
+    // here the cairo context is created
-    cairo_t* ctx = gdk_cairo_create(_buf->gobj());
+    Cairo::RefPtr<Cairo::Context> ctx = _buf->create_cairo_context();
 
     // Determine the final drawing dimensions
     // before to start drawing
@@ -218,13 +217,11 @@ CairoWidget::on_expose_event(GdkEventExpose* event)
 
     // calculate and apply scale factors
     calc_scale_factors();
-    cairo_scale(ctx, _scale_x, _scale_y);
+    ctx->scale(_scale_x, _scale_y);
 
     // do the drawing...
     draw_widget(ctx);
 
-    // bye bye context
-    cairo_destroy(ctx);
   } // ~ if(_need_redraw || actual_w!=_client_w || actual_h!=_client_h)
 
   // Now the in-memory picture is placed on screen
@@ -233,7 +230,7 @@ CairoWidget::on_expose_event(GdkEventExpose* event)
   // Use double buffering or we're CPU-dead
   // Copy from the buffer to the screen
   if (_buf)
-    get_window()->draw_drawable(get_style()->get_black_gc(), _buf,
+    _ref_gdk_window->draw_drawable(get_style()->get_black_gc(), _buf,
                                 event->area.x, event->area.y,
                                 event->area.x, event->area.y,
                                 event->area.width, event->area.height);
@@ -265,6 +262,7 @@ CairoWidget::calc_scale_factors()
         // doesn't scale 
         _scale_x = _scale_y = 1.0;
         break;
+        
       case scaling_to_w:
         // scale to fit in width
         // x and y take the same x value
@@ -335,14 +333,14 @@ CairoWidget::resize_redraw()
 
   if(_buf)
   {
-    cairo_t* ctx = gdk_cairo_create(_buf->gobj());
+    Cairo::RefPtr<Cairo::Context> ctx = _buf->create_cairo_context();
 
     if(ctx)
     {
       // Determine the final drawing dimensions before to start drawing
       _draw_w = _draw_h = 0; // default no scaling
       calc_drawing_size(ctx, _draw_w, _draw_h);
-      cairo_destroy(ctx);
+      ctx.clear();
 
       calc_scale_factors();
 
@@ -367,7 +365,7 @@ CairoWidget::resize_redraw()
   Derived classes can reimplement it or not as desired.
  */
 void
-CairoWidget::calc_drawing_size(cairo_t* /* ctx */, size_t& /* width */, size_t& /*height*/)
+CairoWidget::calc_drawing_size(Cairo::RefPtr<Cairo::Context>& /* ctx */, size_t& /* width */, size_t& /*height*/)
 {
 }
 

src/cairo_widget.hh

@@ -21,8 +21,7 @@
 #ifndef CAIRO_WIDGET_HH
 #define CAIRO_WIDGET_HH 1
 
-#include <cairo.h>
+#include <cairomm/context.h>
-#include <gtkmm/drawingarea.h>
 #include <gtkmm/widget.h>
 #include <gdkmm/pixmap.h>
 
@@ -141,7 +140,7 @@ namespace sgpem
     /**
      * \brief Widgets size type.
      */
-    typedef unsigned int    size_t;
+    typedef guint    size_t;
 
     // implementation of fundamental widget's method
     /**
@@ -152,6 +151,7 @@ namespace sgpem
      * See gtkmm documentation for more informations.
      */
     virtual void on_realize();
+    virtual void on_unrealize(); // doesn't need to be documented.   
  
     /**
      * \brief Implements standard widget's on_size_allocate() mehtod.
@@ -193,7 +193,7 @@ namespace sgpem
      * draw in the widgets client area.
      * See cairo documentation for more informations.
      */
-    virtual void draw_widget(cairo_t* ctx) = 0;
+    virtual void draw_widget(Cairo::RefPtr<Cairo::Context>& ctx) = 0;
 
     /**
      * \brief Method to calculate widget dimensions.
@@ -201,7 +201,7 @@ namespace sgpem
      * The user should implement this method to allow scaling factors calculation.
      * Is necessary if scaling is needed/used.
      */
-    virtual void calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height);
+    virtual void calc_drawing_size(Cairo::RefPtr<Cairo::Context>& ctx, size_t& width, size_t& height);
 
     // with this method CairoWidget tells the needed widget dimensions
     /**
@@ -232,48 +232,48 @@ namespace sgpem
     /**
      * \brief Calculated width of drawing.
      */
-    mutable size_t      _draw_w;
+    size_t      _draw_w;
 
     /**
      * \brief Calculated height of drawing.
      */
-    mutable size_t      _draw_h;
+    size_t      _draw_h;
 
   private:
     /**
      * \brief Client area width of widget.
      */
-    mutable size_t      _client_w;
+    size_t      _client_w;
 
     /**
      * \brief Client area height of widget.
      */
-    mutable size_t      _client_h;
+    size_t      _client_h;
 
     /**
      * \brief Client area width of pixmap.
      */
-    mutable size_t      _pixmap_w;
+    size_t      _pixmap_w;
 
     /**
      * \brief Client area width of pixmap.
      */
-    mutable size_t      _pixmap_h;
+    size_t      _pixmap_h;
 
     /**
      * \brief Cairo x scale factor.
      */
-    mutable double      _scale_x;
+    double      _scale_x;
 
     /**
      * \brief Cairo y scale factor.
      */
-    mutable double      _scale_y;
+    double      _scale_y;
 
     /**
      * \brief Flag to signal require redrawing.
      */
-    mutable bool        _need_redraw;
+    bool        _need_redraw;
 
     /**
      * \brief Actual scaling mode.
@@ -284,6 +284,11 @@ namespace sgpem
      * \brief Offscreen pixmap used for double-buffering.
      */
     Glib::RefPtr<Gdk::Pixmap>  _buf;
+
+   /**
+    *
+    */
+    Glib::RefPtr<Gdk::Window> _ref_gdk_window;
   };
 
 } //~ namespace sgpem

src/holt_widget.cc

@@ -21,20 +21,22 @@
 
 #include "cairo_elements.hh"
 
-#include <sgpemv2/history.hh>
+#include "sgpemv2/history.hh"
-#include <sgpemv2/schedulable.hh>
+#include "sgpemv2/schedulable.hh"
-#include <sgpemv2/resource.hh>
+#include "sgpemv2/process.hh"
-#include <sgpemv2/simulation.hh>
+#include "sgpemv2/resource.hh"
-#include <sgpemv2/string_utils.hh>
+#include "sgpemv2/simulation.hh"
-#include <sgpemv2/thread.hh>
+#include "sgpemv2/string_utils.hh"
+#include "sgpemv2/thread.hh"
 
 #include "holt_widget.hh"
 
-#include <sgpemv2/templates/deletor.tcc>
+#include "sgpemv2/templates/deletor.tcc"
-#include <sgpemv2/templates/sequences.tcc>
+#include "sgpemv2/templates/sequences.tcc"
 
-#include <math.h>
+#include <cairomm/cairomm.h>
 
+#include <cmath>
 #include <cassert>
 
 #ifndef NDEBUG
@@ -104,7 +106,7 @@ HoltResource::~HoltResource()
 {
 }
 
-void HoltResource::draw(cairo_t *cr)
+void HoltResource::draw(Cairo::RefPtr<Cairo::Context>& cr)
 {
   static const Color white(1, 1, 1);
 
@@ -114,43 +116,31 @@ void HoltResource::draw(cairo_t *cr)
   CairoElements ce(cr);
  
   // outline
-  cairo_set_source_rgb (cr, 0, 0, 0);
+  cr->set_source_rgb (0, 0, 0);
 
   // draw rectangle
   Rectangle area(_pos.real() - _radius,  _pos.imag() - _radius, 2*_radius, 2*_radius);
   ce.draw_3dcube(area, white, x_percent, y_percent);
+  cr->save();
   
-  cairo_save(cr);
   // clip text outside region
-  /*
+  cr->rectangle(_pos.real() - _radius,
-  cairo_rectangle(cr,
-    _pos.real() - _radius,
-    _pos.imag() - _radius, // _pos.imag() + _radius  (1 - 2.0 * y_percent)
-    2 * _radius * x_percent,
-    2 * _radius * y_percent);
-  */
-
-  cairo_rectangle(cr,
-    _pos.real() - _radius,
                 _pos.imag() + _radius * (1 - 2.0 * y_percent),
                 2 * _radius * x_percent,
                 2 * _radius * y_percent);
+  cr->clip(); 
   
-  cairo_clip(cr); 
   // draw text
-  cairo_text_extents_t extents;
+  Cairo::TextExtents extents;
-  cairo_text_extents(cr, _resource->get_name().c_str(), &extents);
+  cr->get_text_extents(_resource->get_name(), extents);
   double xpos = _pos.real() + _radius * (x_percent-1) - extents.width/2.0;
   double ypos = _pos.imag() + _radius * (1 - y_percent); // + extents.height/2;
-  // _pos.imag() + extents.height * ((1 - y_percent) / 2 + 0.5)
 
   // left aligned if too large
   if(xpos<_pos.real() - _radius)
     xpos = _pos.real() - _radius;
-  cairo_move_to(cr, 
+  cr->move_to(xpos, ypos );
-                xpos,
+  cr->show_text(_resource->get_name());
-                ypos );
-  cairo_show_text(cr, _resource->get_name().c_str());
 
   // show used/total places
   Glib::ustring used;
@@ -159,18 +149,16 @@ void HoltResource::draw(cairo_t *cr)
   to_string<int>((int)_resource->get_places(), total);
 
   Glib::ustring msg = used + "/" + total;
-  cairo_text_extents(cr, msg.c_str(), &extents);
+  cr->get_text_extents(msg, extents);
   xpos = _pos.real() + _radius * (x_percent-1) - extents.width/2.0;
   ypos = _pos.imag() + _radius * (1 - y_percent) + extents.height*2;
-  cairo_move_to(cr,
+  cr->move_to(xpos, ypos);
-                xpos,
+  cr->show_text(msg);
-                ypos );
-  cairo_show_text(cr, msg.c_str());
 
   // stroke all
-  cairo_stroke (cr);
+  cr->stroke();
 
-  cairo_restore(cr);
+  cr->restore();
 }
 
 Vec2 HoltResource::get_intersection_to(Vec2 pt)
@@ -224,14 +212,13 @@ HoltSchedulable::~HoltSchedulable()
 {
 }
 
-void HoltSchedulable::draw(cairo_t *cr)
+void HoltSchedulable::draw(Cairo::RefPtr<Cairo::Context>& cr)
 {
   static const Color red(1, 0, 0);
   static const Color yellow(1, 0.8, 0);
   static const Color green(0, 1, 0);
 
-
+  cr->save(); // save context state
-  cairo_save(cr); // save context state
 
   const Point center(_pos.real(), _pos.imag());
   const Color* color = &red; 
@@ -259,22 +246,21 @@ void HoltSchedulable::draw(cairo_t *cr)
   cel.draw_3dsphere(center, _radius, *color);
 
   // clip text outside region
-  cairo_arc(cr, _pos.real(), _pos.imag(), _radius, 0, 2*M_PI);
+  cr->arc(_pos.real(), _pos.imag(), _radius, 0, 2*M_PI);
-  cairo_clip(cr);
+  cr->clip();
 
   // draw text
-  cairo_text_extents_t extents;
+  Cairo::TextExtents extents;
-  cairo_text_extents(cr, _schedulable->get_name().c_str(), &extents);
+  cr->get_text_extents(_schedulable->get_name(), extents);
   double text_width = extents.width;
-  if(text_width>_radius*2.0)
+  if(text_width>_radius*2.0) text_width=_radius*2.0;
-    text_width=_radius*2.0;
+  cr->move_to(_pos.real() - text_width/2, _pos.imag() + extents.height/2);
-  cairo_move_to(cr, _pos.real() - text_width/2, _pos.imag() + extents.height/2);
+  cr->show_text(_schedulable->get_name());
-  cairo_show_text(cr, _schedulable->get_name().c_str());
 
   // stroke all
-  cairo_stroke (cr);
+  cr->stroke();
 
-  cairo_restore(cr); // restore context state
+  cr->restore(); // restore context state
 }
 
 Vec2 HoltSchedulable::get_intersection_to(Vec2 pt)
@@ -310,24 +296,24 @@ HoltRequest::~HoltRequest()
 {
 }
 
-void HoltRequest::draw(cairo_t *cr)
+void HoltRequest::draw(Cairo::RefPtr<Cairo::Context>& cr)
 {
   Vec2 resource = _hp->get_intersection_to(_hr->get_position());
   Vec2 schedulable = _hr->get_intersection_to(_hp->get_position());
 
-  cairo_save(cr);
+  cr->save();
 
   switch(_state)
   {
     case Request::state_unallocable:
       // red
-      cairo_set_source_rgb(cr, 1, 0, 0);
+      cr->set_source_rgb(1, 0, 0);
       arrow(cr, schedulable, resource);
       break;
 
     case Request::state_allocated:
       // green
-      cairo_set_source_rgb(cr, 0, 1, 0);
+      cr->set_source_rgb(0, 1, 0);
       arrow(cr, resource, schedulable);
       break;
 
@@ -339,23 +325,23 @@ void HoltRequest::draw(cairo_t *cr)
 
     case Request::state_allocable:
       // yellow
-      cairo_set_source_rgb(cr, 1, 0.7, 0);
+      cr->set_source_rgb(1, 0.7, 0);
       arrow(cr, schedulable, resource);
       break;
   }
 
   // stroke all and restore status
-  cairo_stroke (cr);
+  cr->stroke();
-  cairo_restore(cr);
+  cr->restore();
 }
 
-void HoltRequest::arrow(cairo_t *cr, Vec2 first, Vec2 second)
+void HoltRequest::arrow(Cairo::RefPtr<Cairo::Context>& cr, Vec2 first, Vec2 second)
 {
   // option to draw the line a little translated
   // this allow to draw two counterflow arrows
   // without overlap
   bool traslate = true;
-  double line_width = cairo_get_line_width(cr);
+  double line_width = cr->get_line_width();
   if(traslate)
   {
     // if needed calc parallel versor of arrow
@@ -373,8 +359,8 @@ void HoltRequest::arrow(cairo_t *cr, Vec2 first, Vec2 second)
   }
 
   // draw main line
-  cairo_move_to(cr, second.real(), second.imag());
+  cr->move_to(second.real(), second.imag());
-  cairo_line_to(cr, first.real(), first.imag());
+  cr->line_to(first.real(), first.imag());
 
   // some calculation to draw arrowpoint...
   // take a short line parallel to main line
@@ -386,11 +372,11 @@ void HoltRequest::arrow(cairo_t *cr, Vec2 first, Vec2 second)
   Vec2 side1 = arrowside * deviation;
   Vec2 side2 = arrowside * conj(deviation);
   // draw one side
-  cairo_move_to(cr, first.real(), first.imag());
+  cr->move_to(first.real(), first.imag());
-  cairo_line_to(cr, first.real()+side1.real(), first.imag()+side1.imag());
+  cr->line_to(first.real()+side1.real(), first.imag()+side1.imag());
   // draw the other side
-  cairo_move_to(cr, first.real(), first.imag());
+  cr->move_to(first.real(), first.imag());
-  cairo_line_to(cr, first.real()+side2.real(), first.imag()+side2.imag());
+  cr->line_to(first.real()+side2.real(), first.imag()+side2.imag());
 }
 
 
@@ -806,7 +792,7 @@ HoltWidget::acquire()
 
 
 void
-HoltWidget::draw_widget(cairo_t* ctx)
+HoltWidget::draw_widget(Cairo::RefPtr<Cairo::Context>& ctx)
 {
 #ifndef NDEBUG
   std::cout << "HoltWidget::draw_widget" << endl;
@@ -820,17 +806,15 @@ HoltWidget::draw_widget(cairo_t* ctx)
   {
     const History& hist = _simulation->get_history();
     const unsigned int hist_front = hist.get_front() == 0 ? 0 : hist.get_front() - 1;
-    cairo_text_extents_t extents;
+    Cairo::TextExtents extents;
     stringstream ss;
     ss << "T = " << hist_front;
-    cairo_text_extents(ctx, ss.str().c_str(), &extents);
+    ctx->get_text_extents(ss.str(), extents);
-    cairo_move_to(ctx, _draw_w/2 - extents.width/2.0, extents.height*2.0);
+    ctx->move_to(_draw_w/2 - extents.width/2.0, extents.height*2.0);
-    cairo_show_text(ctx, ss.str().c_str());
+    ctx->show_text(ss.str());
-    cairo_stroke(ctx);
+    ctx->stroke();
   }
 
-
-
   // draw all resources
   typedef HoltResources::const_iterator holt_res_iterator;
   holt_res_iterator riter = _holt_resources.begin();
@@ -865,7 +849,7 @@ HoltWidget::draw_widget(cairo_t* ctx)
 
 
 void
-HoltWidget::calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height)
+HoltWidget::calc_drawing_size(Cairo::RefPtr<Cairo::Context>& ctx, size_t& width, size_t& height)
 {
 #ifndef NDEBUG
   cout << "Holt widget BEFORE calc_drawing_size width=" << width << " height=" << height << endl;
@@ -881,10 +865,10 @@ HoltWidget::calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height)
   int max   = _n_proc;
   if(_n_res>_n_proc)
     max = _n_res;
-  cairo_text_extents_t extents;
+  Cairo::TextExtents extents;
 
   static const Glib::ustring val("Process 999   Resource 999");
-  cairo_text_extents(ctx, val.c_str(), &extents);
+  ctx->get_text_extents(val, extents);
   _radius = extents.width/4.0;
 
   switch(_arrange_mode)

src/holt_widget.hh

@@ -89,7 +89,7 @@ namespace sgpem
      *
      * \param cr The cairo context to draw to.
      */
-    virtual void draw(cairo_t *cr) = 0;
+    virtual void draw(Cairo::RefPtr<Cairo::Context>& cr) = 0;
 
     /**
      * \brief Setter and getter method for position parameter.
@@ -195,7 +195,7 @@ namespace sgpem
      *
      * \param cr Cairo context to draw to.
      */
-    virtual void draw(cairo_t *cr);
+    virtual void draw(Cairo::RefPtr<Cairo::Context>& cr);
 
     /**
      * \brief Computes point of intersection with edge.
@@ -278,7 +278,7 @@ namespace sgpem
      *
      * \param cr Cairo context to draw to.
      */
-    virtual void draw(cairo_t *cr);
+    virtual void draw(Cairo::RefPtr<Cairo::Context>& cr);
 
     /**
      * \brief Computes point of intersection with edge.
@@ -336,7 +336,7 @@ namespace sgpem
      *
      * \param cr Cairo context to draw to.
      */
-    virtual void draw(cairo_t *cr);
+    virtual void draw(Cairo::RefPtr<Cairo::Context>& cr);
 
   private:
     /**
@@ -346,7 +346,7 @@ namespace sgpem
      * \param first Starting point.
      * \param first Ending point.
      */
-    virtual void arrow(cairo_t *cr, Vec2 first, Vec2 second);
+    virtual void arrow(Cairo::RefPtr<Cairo::Context>& cr, Vec2 first, Vec2 second);
 
     /**
      * \brief Pointer to the referring schedulable.
@@ -490,7 +490,7 @@ namespace sgpem
      * \param ctx the cairo context to draw to
      * \see CairoWidget for more.
      */
-    void draw_widget(cairo_t* ctx);
+    void draw_widget(Cairo::RefPtr<Cairo::Context>& ctx);
 
 
     /**
@@ -500,7 +500,7 @@ namespace sgpem
      * \param width the return parameter for desired width
      * \param height the return parameter for desired height
      */
-    virtual void calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height);
+    virtual void calc_drawing_size(Cairo::RefPtr<Cairo::Context>& ctx, size_t& width, size_t& height);
 
     // virtual void calc_widget_size(size_t& width, size_t& height);
 

src/simulation_widget.cc

@@ -22,15 +22,19 @@
 #include "simulation_widget.hh"
 #include "cairo_elements.hh"
 
+#include "sgpemv2/history.hh"
+#include "sgpemv2/process.hh"
+#include "sgpemv2/thread.hh"
+#include "sgpemv2/simulation.hh"
+#include "sgpemv2/string_utils.hh"
+
 #include <glibmm/refptr.h>
 #include <gtkmm/action.h>
 #include <gtkmm/actiongroup.h>
 #include <gtkmm/menu.h>
 #include <gtkmm/uimanager.h>
 
-#include <sgpemv2/history.hh>
+#include <cairomm/matrix.h>
-#include <sgpemv2/simulation.hh>
-#include <sgpemv2/string_utils.hh>
 
 #include <cassert>
 
@@ -42,7 +46,6 @@ using namespace sgpem;
 using namespace Gtk;
 using namespace Glib;
 
-
 SimulationWidget::SimulationWidget(Simulation& simulation)
     : Glib::ObjectBase("sgpem_SimulationWidget"),
     SimulationObserver(),
@@ -81,12 +84,6 @@ SimulationWidget::SimulationWidget(Simulation& simulation)
   // define thread bar height in y units
   _yu_thread_bar_height = 1.0;
 
-
-    // 
-    _ready_process_gradient   = 0;
-    _running_process_gradient = 0;
-    _blocked_process_gradient = 0;
-
   _partial_redraw = false;
   _last_drawn = 0;
 }
@@ -101,9 +98,20 @@ SimulationWidget::~SimulationWidget()
   _simulation->detach(*this);
 }
 
+void
+SimulationWidget::on_realize()
+{
+   CairoWidget::on_realize();
+
+  // Register for receiving click events:
+  RefPtr<Gdk::Window> gdk_win = get_window();
+  gdk_win->set_events(gdk_win->get_events() | Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK);
+}
+
 void
 SimulationWidget::update(const Simulation& /* changed_simulation */ )
 {
+  // FIXME: DEPRECATED. Does nothing.
 }
 
 void
@@ -132,12 +140,12 @@ SimulationWidget::set_show_threads(bool show)
 
 
 void
-SimulationWidget::draw_widget(cairo_t* ctx)
+SimulationWidget::draw_widget(Cairo::RefPtr<Cairo::Context>& ctx)
 {
   if(_n_proc<1) // nothing to draw
   {
-    cairo_move_to(ctx, 2.0*_x_unit, 2.0*_y_unit);
+    ctx->move_to(2.0*_x_unit, 2.0*_y_unit);
-    cairo_show_text(ctx, _("Nothing to see here... add some processes! Right-click on the Schedulables view in this window."));
+    ctx->show_text(_("Nothing to see here... add some processes! Right-click on the Schedulables view in this window."));
     return;
   }
 
@@ -148,7 +156,7 @@ SimulationWidget::draw_widget(cairo_t* ctx)
 
 
 void
-SimulationWidget::draw_names(cairo_t* ctx)
+SimulationWidget::draw_names(Cairo::RefPtr<Cairo::Context>& ctx)
 {
   // show processes (and thread) names...
 
@@ -165,11 +173,11 @@ SimulationWidget::draw_names(cairo_t* ctx)
 
   // set a rectangular clip region to cut long names
   // - set the rectangle
-  cairo_rectangle(ctx, 0, top_margin,
+  ctx->rectangle(0, top_margin,
     left_graph_margin - left_margin,
     _n_proc*process_height + _n_thr*thread_height);
   // - set the clip region
-  cairo_clip(ctx); 
+  ctx->clip(); 
 
   // text start position: margin + half of text height
   double ypos = top_margin + _y_unit / 2.0;  
@@ -184,9 +192,9 @@ SimulationWidget::draw_names(cairo_t* ctx)
 
     // move to bar center adding a white row before
     ypos += process_bar_spacing + process_bar_height/2.0; 
-    cairo_move_to(ctx, left_margin, ypos);
+    ctx->move_to(left_margin, ypos);
         // show process name
-    cairo_show_text(ctx,p->get_name().c_str());
+    ctx->show_text(p->get_name());
 
     // calc position to next row skipping height of process bar
     ypos += process_bar_height/2.0; 
@@ -202,9 +210,9 @@ SimulationWidget::draw_names(cairo_t* ctx)
         thr_iter++;
         // move to bar center adding white space as needed
         ypos += thread_height/2.0;
-        cairo_move_to(ctx, left_margin+_x_unit, ypos);
+        ctx->move_to(left_margin+_x_unit, ypos);
         // show thread name
-        cairo_show_text(ctx,t->get_name().c_str());
+        ctx->show_text(t->get_name());
 
         // calc position to next thread bar begin
         ypos += thread_height/2.0; // height of thread bar
@@ -216,11 +224,11 @@ SimulationWidget::draw_names(cairo_t* ctx)
   } // ~  while(proc_iter!=processes.end())
 
   // remove clip region
-  cairo_reset_clip(ctx);
+  ctx->reset_clip();
 }
 
 void
-SimulationWidget::draw_grid(cairo_t* ctx)
+SimulationWidget::draw_grid(Cairo::RefPtr<Cairo::Context>& ctx)
 {
   const History& hist              = _simulation->get_history();
 
@@ -243,8 +251,8 @@ SimulationWidget::draw_grid(cairo_t* ctx)
     Process* p = (*proc_iter);
     proc_iter++;
     // draw one HOR line per process
-    cairo_move_to(ctx, left_graph_margin, ypos);
+    ctx->move_to(left_graph_margin, ypos);
-    cairo_rel_line_to(ctx, graph_width, 0);
+    ctx->rel_line_to(graph_width, 0);
 
     // calc next line position
     ypos += process_height; // skip a process heigh
@@ -257,69 +265,69 @@ SimulationWidget::draw_grid(cairo_t* ctx)
   } // ~  while(proc_iter!=processes.end())
 
   // draw last HOR line
-  cairo_move_to(ctx, left_graph_margin, ypos);
+  ctx->move_to(left_graph_margin, ypos);
-  cairo_rel_line_to(ctx, graph_width, 0);
+  ctx->rel_line_to(graph_width, 0);
 
   // - draw left VER line
-  cairo_move_to(ctx, left_graph_margin, top_margin);
+  ctx->move_to(left_graph_margin, top_margin);
-  cairo_rel_line_to(ctx, 0, graph_height);
+  ctx->rel_line_to(0, graph_height);
 
   // right close the graph only if simulation stopped
   if(_simulation->get_state()==Simulation::state_stopped)
   {
     // - draw right VER line
-    cairo_move_to(ctx, left_graph_margin + graph_width, top_margin);
+    ctx->move_to(left_graph_margin + graph_width, top_margin);
-    cairo_rel_line_to(ctx, 0, graph_height);
+    ctx->rel_line_to(0, graph_height);
   }
 
   // trace lines on output context
-  cairo_stroke(ctx);
+  ctx->stroke();
 
   // Draw a grey vertical line every fifth step
-  cairo_save(ctx);
+  ctx->save();
-  cairo_set_line_width(ctx, 0.125 * cairo_get_line_width(ctx));
+  ctx->set_line_width(0.125 * ctx->get_line_width());
-  cairo_set_source_rgb(ctx, 0.3, 0.3, 0.3);
+  ctx->set_source_rgb(0.3, 0.3, 0.3);
   for(double step = _x_unit; step < graph_width - _x_unit; step += 5 * _x_unit)
   {
-    cairo_new_path(ctx);
+    ctx->begin_new_path();
-    cairo_move_to(ctx, left_graph_margin + step, top_margin);
+    ctx->move_to(left_graph_margin + step, top_margin);
-    cairo_rel_line_to(ctx, 0, graph_height);
+    ctx->rel_line_to(0, graph_height);
-    cairo_stroke(ctx); 
+    ctx->stroke(); 
   }
-  cairo_restore(ctx);
+  ctx->restore();
 
 
   // draw and write time line
-  cairo_save(ctx);
+  ctx->save();
-  cairo_set_source_rgb(ctx, 0, 0, 0);
+  ctx->set_source_rgb(0, 0, 0);
-  cairo_set_line_width(ctx, 0.25*cairo_get_line_width(ctx));
+  ctx->set_line_width(0.25*ctx->get_line_width());
 
   // "T" label
-  cairo_move_to(ctx, left_graph_margin,
+  ctx->move_to(left_graph_margin,
       top_margin + graph_height + 2.0 * _y_unit);
-  cairo_show_text(ctx,"T");
+  ctx->show_text("T");
 
   // ruler drawing cycle
   for(unsigned int t=0; t<=hist_front; t++)
   {
     // tick
-    cairo_move_to(ctx, left_graph_margin + (t+1)*_x_unit,
+    ctx->move_to(left_graph_margin + (t+1)*_x_unit,
       top_margin + graph_height);
-    cairo_rel_line_to(ctx, 0, 0.5 * _y_unit);
+    ctx->rel_line_to(0, 0.5 * _y_unit);
 
     // value
     Glib::ustring val;
     to_string<int>(t, val);
-    cairo_move_to(ctx, left_graph_margin + (t+1)*_x_unit,
+    ctx->move_to(left_graph_margin + (t+1)*_x_unit,
       top_margin + graph_height + 2.0 * _y_unit);
-    cairo_show_text(ctx,val.c_str());
+    ctx->show_text(val);
   } // ~  for(int t=0; t<=pos; t++)
-  cairo_stroke(ctx);
+  ctx->stroke();
-  cairo_restore(ctx);
+  ctx->restore();
 }
 
 void
-SimulationWidget::draw_bars(cairo_t* ctx)
+SimulationWidget::draw_bars(Cairo::RefPtr<Cairo::Context>& ctx)
 {
   // useful constants
   const History& hist              = _simulation->get_history();
@@ -408,53 +416,50 @@ SimulationWidget::draw_bars(cairo_t* ctx)
 
 // draw single rectangle using gradients
 void
-SimulationWidget::draw_instant_rect(cairo_t* ctx, double x, double y,
+SimulationWidget::draw_instant_rect(Cairo::RefPtr<Cairo::Context>& ctx, double x, double y,
                         double w, double h, Schedulable::state state)
 {
-  cairo_matrix_t matrix;
+  using namespace Cairo;
 
   switch(state)
   {
     case Schedulable::state_running:
-      cairo_save(ctx);
+      ctx->save();
-      cairo_set_source(ctx, _running_process_gradient);
+      ctx->set_source(_running_process_gradient);
 
       // translate the gradient at desired position
-      cairo_matrix_init_translate(&matrix, 0, -y);
+      _running_process_gradient->set_matrix(translation_matrix(0, -y));
-      cairo_pattern_set_matrix (_running_process_gradient, &matrix);
 
       // put the filled rectangle
-      cairo_rectangle(ctx, x, y, w, h);
+      ctx->rectangle(x, y, w, h);
-      cairo_fill(ctx);
+      ctx->fill();
-      cairo_restore(ctx);
+      ctx->restore();
       break;
 
     case Schedulable::state_ready:
-      cairo_save(ctx);
+      ctx->save();
-      cairo_set_source(ctx, _ready_process_gradient);
+      ctx->set_source(_ready_process_gradient);
 
       // translate the gradient at desired position
-      cairo_matrix_init_translate(&matrix, 0, -y);
+      _ready_process_gradient->set_matrix(translation_matrix(0, -y));
-      cairo_pattern_set_matrix (_ready_process_gradient, &matrix);
 
       // put the filled rectangle
-      cairo_rectangle(ctx, x, y, w, h);
+      ctx->rectangle(x, y, w, h);
-      cairo_fill(ctx);
+      ctx->fill();
-      cairo_restore(ctx);
+      ctx->restore();
       break;
 
     case Schedulable::state_blocked:
-      cairo_save(ctx);
+      ctx->save();
-      cairo_set_source(ctx, _blocked_process_gradient);
+      ctx->set_source(_blocked_process_gradient);
 
       // translate the gradient at desired position
-      cairo_matrix_init_translate(&matrix, 0, -y);
+      _blocked_process_gradient->set_matrix(translation_matrix(0, -y));
-      cairo_pattern_set_matrix (_blocked_process_gradient, &matrix);
 
       // put the filled rectangle
-      cairo_rectangle(ctx, x, y, w, h);
+      ctx->rectangle(x, y, w, h);
-      cairo_fill(ctx);
+      ctx->fill();
-      cairo_restore(ctx);
+      ctx->restore();
       break;
 
     case Schedulable::state_future:
@@ -469,7 +474,7 @@ SimulationWidget::draw_instant_rect(cairo_t* ctx, double x, double y,
 
 
 void
-SimulationWidget::calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height)
+SimulationWidget::calc_drawing_size(Cairo::RefPtr<Cairo::Context>& ctx, size_t& width, size_t& height)
 {
   if(!_simulation)
     return;
@@ -480,9 +485,9 @@ SimulationWidget::calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height)
   int pos = _simulation->get_history().get_front();
 
   // units are defined in terms of text dimensions
-  cairo_text_extents_t extents;
+  Cairo::TextExtents extents;
   Glib::ustring val("999");
-  cairo_text_extents(ctx, val.c_str(), &extents);
+  ctx->get_text_extents(val, extents);
   if(_x_unit < extents.width)
     _x_unit = extents.width;
   if(_y_unit < extents.height)
@@ -533,24 +538,25 @@ SimulationWidget::make_gradients()
 {
   // linear gradients are referred to 0, 0
   // must be translated if used elsewhere
+  using Cairo::LinearGradient;
 
-  _ready_process_gradient   = cairo_pattern_create_linear(0, 0, 0, _yu_process_bar_height * _y_unit);
+  _ready_process_gradient = LinearGradient::create(0, 0, 0, _yu_process_bar_height * _y_unit);
   // yellow
-  cairo_pattern_add_color_stop_rgb(_ready_process_gradient, 0.0, 1.00, 0.7, 0.0);
+  _ready_process_gradient->add_color_stop_rgb(0.0, 1.00, 0.7, 0.0);
-  cairo_pattern_add_color_stop_rgb(_ready_process_gradient, 0.3, 1.00, 0.9, 0.0);
+  _ready_process_gradient->add_color_stop_rgb(0.3, 1.00, 0.9, 0.0);
-  cairo_pattern_add_color_stop_rgb(_ready_process_gradient, 1.0, 1.00, 0.7, 0.0);
+  _ready_process_gradient->add_color_stop_rgb(1.0, 1.00, 0.7, 0.0);
 
-  _running_process_gradient = cairo_pattern_create_linear(0, 0, 0, _yu_process_bar_height * _y_unit);
+  _running_process_gradient = LinearGradient::create(0, 0, 0, _yu_process_bar_height * _y_unit);
   // green
-  cairo_pattern_add_color_stop_rgb(_running_process_gradient, 0.0, 0.0, 0.8, 0.0);
+  _running_process_gradient->add_color_stop_rgb(0.0, 0.0, 0.8, 0.0);
-  cairo_pattern_add_color_stop_rgb(_running_process_gradient, 0.3, 0.0, 1.0, 0.0);
+  _running_process_gradient->add_color_stop_rgb(0.3, 0.0, 1.0, 0.0);
-  cairo_pattern_add_color_stop_rgb(_running_process_gradient, 1.0, 0.0, 0.65, 0.0);
+  _running_process_gradient->add_color_stop_rgb(1.0, 0.0, 0.65, 0.0);
 
-  _blocked_process_gradient = cairo_pattern_create_linear(0, 0, 0, _yu_process_bar_height * _y_unit);
+  _blocked_process_gradient = LinearGradient::create(0, 0, 0, _yu_process_bar_height * _y_unit);
   // red
-  cairo_pattern_add_color_stop_rgb(_blocked_process_gradient, 0.0, 0.85, 0.0, 0.0);
+  _blocked_process_gradient->add_color_stop_rgb(0.0, 0.85, 0.0, 0.0);
-  cairo_pattern_add_color_stop_rgb(_blocked_process_gradient, 0.3, 1.0, 0.5, 0.5);
+  _blocked_process_gradient->add_color_stop_rgb(0.3, 1.0, 0.5, 0.5);
-  cairo_pattern_add_color_stop_rgb(_blocked_process_gradient, 1.0, 0.65, 0.0, 0.0);
+  _blocked_process_gradient->add_color_stop_rgb(1.0, 0.65, 0.0, 0.0);
 }
 
 
@@ -656,3 +662,5 @@ SimulationWidget::_on_stretch_scaling()
   resize_redraw();
   // set_size_request (20, 20); // force container redimensioning 
 }
+
+

src/simulation_widget.hh

@@ -21,12 +21,13 @@
 #ifndef SIMULATION_WIDGET_HH
 #define SIMULATION_WIDGET_HH 1
 
-
-
 #include "cairo_widget.hh"
-#include <sgpemv2/history_observer.hh>
+
-#include <sgpemv2/schedulable.hh>
+#include "sgpemv2/history_observer.hh"
-#include <sgpemv2/simulation_observer.hh>
+#include "sgpemv2/schedulable.hh"
+#include "sgpemv2/simulation_observer.hh"
+
+#include <cairomm/pattern.h>
 
 namespace sgpem
 {
@@ -48,7 +49,7 @@ namespace sgpem
    *
    * At the bottom of the graph there is a time line ruler.
    *
-   * This class implemets a SimulationObserver and HistoryObserver
+   * This class implements a SimulationObserver and HistoryObserver
    * to have an update signal (and related update) every simulation step.
    *
    * \deprecated The class should implement only HistoryObserver
@@ -77,7 +78,7 @@ namespace sgpem
     /**
      * \brief SimulationObserver's update method redefinition.
      *
-     * Actually is a dummy method.
+     * \deprecated Actually is a dummy method.
      *
      * \param changed_simulation the observed Simulation
      */
@@ -127,7 +128,7 @@ namespace sgpem
      * \param ctx the cairo context to draw to
      * \see CairoWidget for more.
      */
-    void draw_widget(cairo_t* ctx);
+    void draw_widget(Cairo::RefPtr<Cairo::Context>& ctx);
 
     /**
      * \brief calculated the needed drawing surface dimensions.
@@ -136,8 +137,12 @@ namespace sgpem
      * \param width the return parameter for desired width
      * \param height the return parameter for desired height
      */
-    virtual void calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height);
+    virtual void calc_drawing_size(Cairo::RefPtr<Cairo::Context>& ctx, size_t& width, size_t& height);
 
+    /**
+     * \brief Adds the click events to the underlying Gdk::Window
+     */
+    virtual void on_realize();
 
 
   private:
@@ -152,21 +157,21 @@ namespace sgpem
      *
      * \param ctx the cairo context to draw to
      */
-    void draw_names(cairo_t* ctx);
+    void draw_names(Cairo::RefPtr<Cairo::Context>& ctx);
     
     /**
      * \brief Used internally by draw_widget to show the bars container grid.
      *
      * \param ctx the cairo context to draw to
      */
-    void draw_grid(cairo_t* ctx);
+    void draw_grid(Cairo::RefPtr<Cairo::Context>& ctx);
     
     /**
      * \brief Used internally by draw_widget to show processes/threads bars.
      *
      * \param ctx the cairo context to draw to
      */
-    void draw_bars(cairo_t* ctx);
+    void draw_bars(Cairo::RefPtr<Cairo::Context>& ctx);
     
     /**
      * \brief Used internally by draw_widget to build the bars.
@@ -178,7 +183,7 @@ namespace sgpem
      * \param h height of rectangle
      * \param state select the color to apply
      */
-    void draw_instant_rect(cairo_t* ctx, double x, double y,
+    void draw_instant_rect(Cairo::RefPtr<Cairo::Context>& ctx, double x, double y,
                            double w, double h, sgpem::Schedulable::state state);
 
     /**
@@ -284,17 +289,17 @@ namespace sgpem
     /**
      * \brief Gradient used to draw ready processes/threads.
      */
-    cairo_pattern_t* _ready_process_gradient;
+    Cairo::RefPtr<Cairo::Gradient> _ready_process_gradient;
 
     /**
      * \brief Gradient used to draw running processes/threads.
      */
-    cairo_pattern_t* _running_process_gradient;
+    Cairo::RefPtr<Cairo::Gradient> _running_process_gradient;
 
     /**
      * \brief Gradient used to draw blocked processes/threads.
      */
-    cairo_pattern_t* _blocked_process_gradient;
+    Cairo::RefPtr<Cairo::Gradient> _blocked_process_gradient;
 
     /**
       * Used to redraw partially the widget.

src/testsuite/test-cairo_widget.cc

@@ -56,10 +56,10 @@ namespace sgpem
   protected:
     virtual bool on_button_press_event(GdkEventButton* event);
 
-    void draw_widget(cairo_t* ctx);
+    void draw_widget(Cairo::RefPtr<Cairo::Context>& ctx);
     void change_scaling_mode();
 
-    virtual void calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height);
+    virtual void calc_drawing_size(Cairo::RefPtr<Cairo::Context>& ctx, size_t& width, size_t& height);
   private:
     int _desired_w;
     int _desired_h;
@@ -90,13 +90,13 @@ TestWidget::on_button_press_event(GdkEventButton*)
 }
 
 void
-TestWidget::draw_widget(cairo_t* ctx)
+TestWidget::draw_widget(Cairo::RefPtr<Cairo::Context>& ctx)
 {
   // show line
-  cairo_set_source_rgb(ctx, 0, 0, 0);
+  ctx->set_source_rgb(0, 0, 0);
-  cairo_move_to(ctx, 0, 0);
+  ctx->move_to(0, 0);
-  cairo_line_to(ctx, _desired_w, _desired_w);
+  ctx->line_to(_desired_w, _desired_w);
-  cairo_stroke(ctx);
+  ctx->stroke();
   
   // NOTE: just to try
   CairoElements ce(ctx);
@@ -138,20 +138,16 @@ TestWidget::draw_widget(cairo_t* ctx)
       msg = "scaling_all = scale to stretch into client area";
       break;
   }
-  cairo_move_to(ctx, 10, 10);
+  ctx->move_to(10, 10);
-  cairo_show_text(ctx,msg.c_str());
+  ctx->show_text(msg);
   msg = "clic to change mode...";
-  cairo_move_to(ctx, 10, 30);
+  ctx->move_to(10, 30);
-  cairo_show_text(ctx,msg.c_str());
+  ctx->show_text(msg);
-  
-
-
-
 }
 
 
 void
-TestWidget::calc_drawing_size(cairo_t*, size_t& width, size_t& height)
+TestWidget::calc_drawing_size(Cairo::RefPtr<Cairo::Context>&, size_t& width, size_t& height)
 {
   width  = _desired_w;
   height = _desired_h;