Kapo C++

SEARCH_CRITERIA

#include 
.
.
.
for (double alpha = 0; alpha <= 2 * M_PI; aplha+=0.1)
{
  double px = cx + rx * cos (alpha);
  double py = cy + ry * sin (alpha);
  // px, py is current point
}

double alpha = 0;
double alpha_step = 0.1;

// First point
double px1 = cx + rx * cos (alpha);
double py1 = cy + ry * sin (alpha);
cr->move_to (px1, py1); // cr is the cairo context

for (double alpha = 0; alpha <= 2 * M_PI; aplha+=alpha_step)
{
  double px = cx + rx * cos (alpha);
  double py = cy + ry * sin (alpha);
  cr->line_to (px, py); // cr is the cairo context
}

/*
 * PolygonView.h
 *
 *  Created on: Sep 9, 2008
 *      Author: user
 */

#ifndef POLYGONVIEW_H_
#define POLYGONVIEW_H_

#include 

class PolygonView : public Gtk::DrawingArea
{
public:
 PolygonView();
 virtual ~PolygonView();

 double getSidesCount() const { return sides_count_; };
 void setSidesCound(double value) { sides_count_ = value; };

 void rotate(double cx, double cy, double radians);
 void saveSvg(const std::string& file_name);

protected:
 Gdk::Color back_color_;
 Gdk::Color stroke_color_;
 Gdk::Color fill_color_;
 Gdk::Color help_color_;
 Gdk::Color rotation_color_;
 Gdk::Rectangle polygon_bounds_;
 double rotation_center_x_;
 double rotation_center_y_;
 double rotation_degrees_;
 double sides_count_;
 bool draw_help_;
 bool draw_rotation_;

protected:
 bool on_expose_event(GdkEventExpose* event);

 void draw(Cairo::RefPtr< Cairo::Context > context_ref);
 void draw_ellipse(Cairo::RefPtr< Cairo::Context > context_ref, const Gdk::Rectangle& bounds);
};

#endif /* POLYGONVIEW_H_ */

/*
 * PolygonView.cpp
 *
 *  Created on: Sep 9, 2008
 *      Author: user
 */

#include "PolygonView.h"

#include 
#include 

PolygonView::PolygonView() :
 back_color_( "white" ),
 stroke_color_( "black" ),
 fill_color_( "white" ),
 help_color_( "gray" ),
 rotation_color_( "red" ),
 polygon_bounds_( 20, 20, 200, 200),
 rotation_center_x_( 110 ),
 rotation_center_y_( 110 ),
 rotation_degrees_( 0 ),
 sides_count_( 5 ),
 draw_help_( true ),
 draw_rotation_( false )
{
}

PolygonView::~PolygonView()
{
}

void PolygonView::rotate(double cx, double cy, double radians)
{
 rotation_center_x_ = cx;
 rotation_center_y_ = cy;
 rotation_degrees_ = radians;
}

bool PolygonView::on_expose_event(GdkEventExpose *event)
{
 Glib::RefPtr< Gdk::Window > window_ref = get_window();

 if (window_ref)
 {
  Gtk::Allocation allocation = get_allocation();

  Cairo::RefPtr< Cairo::Context > context_ref = window_ref->create_cairo_context();

  if (event)
  {
   context_ref->rectangle (event->area.x, event->area.y, event->area.width, event->area.height);
   context_ref->clip();
  }

  // Draw background
  context_ref->set_source_rgb (back_color_.get_red_p(),
    back_color_.get_green_p(),
    back_color_.get_blue_p());

  context_ref->rectangle (0, 0, allocation.get_width(), allocation.get_height());
  context_ref->fill();

  draw (context_ref);
 }

 return true;
}

void PolygonView::saveSvg(const std::string& file_name)
{
 double wx =  polygon_bounds_.get_width() + polygon_bounds_.get_x() * 2;
 double wy =  polygon_bounds_.get_height() + polygon_bounds_.get_y() * 2;
 Cairo::RefPtr< Cairo::SvgSurface > surface_ref = Cairo::SvgSurface::create ( file_name, wx, wy);
 Cairo::RefPtr< Cairo::Context > context_ref = Cairo::Context::create (surface_ref);

 draw (context_ref);

 context_ref->show_page();

}

void PolygonView::draw(Cairo::RefPtr< Cairo::Context > context_ref)
{
 // Draw not rotated vector
 if (draw_rotation_)
 {
  context_ref->save();

  context_ref->set_source_rgba (help_color_.get_red_p(),
    help_color_.get_green_p(),
    help_color_.get_blue_p(), 0.5);

  context_ref->move_to (rotation_center_x_, rotation_center_y_);
  context_ref->line_to (rotation_center_x_ + 20, rotation_center_y_);
  context_ref->stroke();

  context_ref->restore();
 }

 context_ref->save();

 // Set rotation
 context_ref->translate (rotation_center_x_, rotation_center_y_);
 context_ref->rotate (rotation_degrees_);
 context_ref->translate (-rotation_center_x_, -rotation_center_y_);

 // Draw polygon
 double rx = polygon_bounds_.get_width() / 2.0;
 double ry = polygon_bounds_.get_height() / 2.0;
 double cx = polygon_bounds_.get_x() + rx;
 double cy = polygon_bounds_.get_y() + ry;

 // Define first vertex
 double alpha = 0.0;
 context_ref->move_to (cx + rx * cos(alpha), cy + ry * sin(alpha));

 // Define other vertexes
 double alpha_step = 2 * M_PI / sides_count_;
 for (int i = 1; i < sides_count_; i++)
 {
  alpha += alpha_step;
  context_ref->line_to (cx + rx * cos(alpha), cy + ry * sin(alpha));
 }
 context_ref->close_path();

 // Stroke and fill polygon
 context_ref->set_source_rgb (stroke_color_.get_red_p(),
   stroke_color_.get_green_p(),
   stroke_color_.get_blue_p());

 context_ref->stroke_preserve();

 context_ref->set_source_rgb (fill_color_.get_red_p(),
   fill_color_.get_green_p(),
   fill_color_.get_blue_p());

 context_ref->fill();

 if (draw_rotation_)
 {
  // Draw rotation center
  context_ref->set_source_rgba (rotation_color_.get_red_p(),
    rotation_color_.get_green_p(),
    rotation_color_.get_blue_p(), 0.5);

  Gdk::Rectangle rot_center (rotation_center_x_ - 3, rotation_center_y_ - 3, 6, 6);

  draw_ellipse (context_ref, rot_center);
  context_ref->stroke();

  context_ref->move_to (rotation_center_x_, rotation_center_y_ - 6);
  context_ref->line_to (rotation_center_x_, rotation_center_y_ + 6);
  context_ref->stroke();

  context_ref->move_to (rotation_center_x_ - 6, rotation_center_y_);
  context_ref->line_to (rotation_center_x_ + 6, rotation_center_y_);
  context_ref->stroke();

  context_ref->move_to (rotation_center_x_, rotation_center_y_);
  context_ref->line_to (rotation_center_x_ + 20, rotation_center_y_);
  context_ref->stroke();
 }

 if (draw_help_)
 {
  // Draw center
  context_ref->set_source_rgba (help_color_.get_red_p(),
    help_color_.get_green_p(),
    help_color_.get_blue_p(), 0.5);

  Gdk::Rectangle center (cx - 3, cy - 3, 6, 6);

  draw_ellipse (context_ref, center);
  context_ref->stroke();

  context_ref->move_to (cx, cy - 6);
  context_ref->line_to (cx, cy + 6);
  context_ref->stroke();

  context_ref->move_to (cx - 6, cy);
  context_ref->line_to (cx + 6, cy);
  context_ref->stroke();

  // Draw 0, M_PI/2, M_PI, M_PI/2*3
  context_ref->move_to (cx + (rx - 3) * cos(0.0), cy + (ry - 3) * sin(0.0));
  context_ref->line_to (cx + (rx + 3) * cos(0.0), cy + (ry + 3) * sin(0.0));
  context_ref->stroke();

  context_ref->move_to (cx + (rx - 3) * cos(M_PI / 2.0), cy + (ry - 3) * sin(M_PI / 2.0));
  context_ref->line_to (cx + (rx + 3) * cos(M_PI / 2.0), cy + (ry + 3) * sin(M_PI / 2.0));
  context_ref->stroke();

  context_ref->move_to (cx + (rx - 3) * cos(M_PI), cy + (ry - 3) * sin(M_PI));
  context_ref->line_to (cx + (rx + 3) * cos(M_PI), cy + (ry + 3) * sin(M_PI));
  context_ref->stroke();

  context_ref->move_to (cx + (rx - 3) * cos(M_PI / 2.0 * 3.0), cy + (ry - 3) * sin(M_PI / 2.0 * 3.0));
  context_ref->line_to (cx + (rx + 3) * cos(M_PI / 2.0 * 3.0), cy + (ry + 3) * sin(M_PI / 2.0 * 3.0));
  context_ref->stroke();

  // Draw bounds ellipse
  draw_ellipse (context_ref, polygon_bounds_);
  context_ref->stroke();
 }

 context_ref->restore();
}

void PolygonView::draw_ellipse(Cairo::RefPtr< Cairo::Context > context_ref, const Gdk::Rectangle& bounds)
{
 context_ref->save();

 context_ref->translate (bounds.get_x() + (bounds.get_width() / 2.0),
   bounds.get_y() + (bounds.get_height() / 2.0));

 context_ref->scale (bounds.get_width() / 2.0,
   bounds.get_height() / 2.0);

 context_ref->arc (0.0, 0.0, 1.0, 0.0, 2 * M_PI);

 context_ref->restore();
}

#include <gtkmm.h>

class CellRendererComboDerived : public Gtk::CellRendererCombo

{
public:
 CellRendererComboDerived() :
  Glib::ObjectBase (typeid(CellRendererComboDerived)),
  Gtk::CellRendererCombo()

 {
 }

 virtual ~CellRendererComboDerived()
 {

 }
};

CellRendererCombo::CellRendererCombo()
:

  // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  Glib::ObjectBase(0),
  Gtk::CellRendererText(Glib::ConstructParams(cellrenderercombo_class_.init()))

{

}

#include <gtkmm.h>

class CellRendererComboDerived : public Gtk::CellRendererCombo

{
public:
 CellRendererComboDerived() :
  Glib::ObjectBase (0),
  Gtk::CellRendererCombo()

 {
 }

 virtual ~CellRendererComboDerived()
 {

 }
};

#include <gtkmm.h>

#include <iostream>

class CellRendererComboDerived : public Gtk::CellRendererCombo

{
public:
 CellRendererComboDerived() :
  Glib::ObjectBase (0),
  Gtk::CellRendererCombo()

 {
  this->signal_editing_started().connect(
    sigc::mem_fun(*this, &CellRendererComboDerived::on_editing_started));

 }

 virtual ~CellRendererComboDerived()
 {
 }

 virtual void on_editing_started(Gtk::CellEditable* editable, const Glib::ustring& path)

 {
  std::cout << "Editing started editable: " << editable << std::endl;

 }
};

#ifndef CELLRENDERERCOMBODERIVED_H_
#define CELLRENDERERCOMBODERIVED_H_

#include <gtkmm.h>

class CellRendererComboDerived : public Gtk::CellRendererCombo
{
public:
    CellRendererComboDerived();
    virtual ~CellRendererComboDerived();

    virtual void on_editing_started(Gtk::ComboBox* combo_ptr, const Glib::ustring& path);
};

#endif /* CELLRENDERERCOMBODERIVED_H_ */

#include "CellRendererComboDerived.h"

#include <iostream>

void cb_editing_started(GtkCellRenderer* cell,
                        GtkCellEditable* editable,
                        const gchar* path,
                        gpointer data)
{
    reinterpret_cast< CellRendererComboDerived* >(data)->on_editing_started (
            Glib::wrap(reinterpret_cast< GtkComboBox* >(editable), true), path);
};

CellRendererComboDerived::CellRendererComboDerived() :
    Glib::ObjectBase (0),
    Gtk::CellRendererCombo()
{
    g_signal_connect (this->gobj(), "editing-started", G_CALLBACK(cb_editing_started), (gpointer)this);
}

CellRendererComboDerived::~CellRendererComboDerived()
{
}

void CellRendererComboDerived::on_editing_started(Gtk::ComboBox* combo_ptr, const Glib::ustring& path)
{
    std::cout << "Editing started columns: " << combo_ptr->get_model()->get_n_columns() << std::endl;
}

    void calcVertexes(double start_x, double start_y, double end_x, double end_y, double& x1, double& y1, double& x2, double& y2)
    {
        double angle = atan2 (end_y - start_y, end_x - start_x) + M_PI;

        x1 = end_x + arrow_lenght_ * cos(angle - arrow_degrees_);
        y1 = end_y + arrow_lenght_ * sin(angle - arrow_degrees_);
        x2 = end_x + arrow_lenght_ * cos(angle + arrow_degrees_);
        y2 = end_y + arrow_lenght_ * sin(angle + arrow_degrees_);
    }

    enum ArrowStyle
    {
        ARROW_OPEN,
        ARROW_SOLID,
        ARROW_SOLID_FILLED,
        ARROW_DIAMOND,
        ARROW_DIAMOND_FILLED,
        ARROW_CIRCLE,
        ARROW_CIRCLE_FILLED
    };

class ArrowHead
{
public:
    enum ArrowStyle
    {
        ARROW_OPEN,
        ARROW_SOLID,
        ARROW_SOLID_FILLED,
        ARROW_DIAMOND,
        ARROW_DIAMOND_FILLED,
        ARROW_CIRCLE,
        ARROW_CIRCLE_FILLED
    };

    ArrowHead() :
        arrow_lenght_( 15 ),
        arrow_degrees_( 0.5 )
    {
    }

    virtual ~ArrowHead()
    {
    }

    void calcVertexes(double start_x, double start_y, double end_x, double end_y, double& x1, double& y1, double& x2, double& y2)
    {
        double angle = atan2 (end_y - start_y, end_x - start_x) + M_PI;

        x1 = end_x + arrow_lenght_ * cos(angle - arrow_degrees_);
        y1 = end_y + arrow_lenght_ * sin(angle - arrow_degrees_);
        x2 = end_x + arrow_lenght_ * cos(angle + arrow_degrees_);
        y2 = end_y + arrow_lenght_ * sin(angle + arrow_degrees_);
    }

    virtual void draw(Cairo::RefPtr< Cairo::Context > context_ref, double start_x, double start_y, double end_x, double end_y) = 0;

protected:
    double arrow_lenght_;
    double arrow_degrees_;
};

    std::auto_ptr< ArrowHead > start_arrow_head_ptr_;
    std::auto_ptr< ArrowHead > end_arrow_head_ptr_;

        start_arrow_head_ptr_->draw (context_ref, x2, y2, x1, y1);
        end_arrow_head_ptr_->draw (context_ref, x1, y1, x2, y2);

class ArrowOpen : public ArrowHead
{
public:
    ArrowOpen() :
        ArrowHead(),
        line_color_( "black" )
    {
    }

    virtual ~ArrowOpen()
    {
    }

    void draw(Cairo::RefPtr< Cairo::Context > context_ref, double start_x, double start_y, double end_x, double end_y)
    {
        double x1;
        double y1;
        double x2;
        double y2;

        calcVertexes (start_x, start_y, end_x, end_y, x1, y1, x2, y2);

        context_ref->set_source_rgb (line_color_.get_red_p(), line_color_.get_blue_p(), line_color_.get_green_p());

        context_ref->move_to (end_x, end_y);
        context_ref->line_to (x1, y1);
        context_ref->stroke();

        context_ref->move_to (end_x, end_y);
        context_ref->line_to (x2, y2);
        context_ref->stroke();
    }

protected:
    Gdk::Color line_color_;
};

class ArrowSolid : public ArrowHead
{
public:
    ArrowSolid() :
        ArrowHead(),
        line_color_( "black" ),
        fill_color_( "white" )
    {
    }

    virtual ~ArrowSolid()
    {
    }

    void draw(Cairo::RefPtr< Cairo::Context > context_ref, double start_x, double start_y, double end_x, double end_y)
    {
        double x1;
        double y1;
        double x2;
        double y2;

        calcVertexes (start_x, start_y, end_x, end_y, x1, y1, x2, y2);

        context_ref->move_to (end_x, end_y);
        context_ref->line_to (x1, y1);
        context_ref->line_to (x2, y2);
        context_ref->close_path();

        context_ref->set_source_rgb (line_color_.get_red_p(), line_color_.get_blue_p(), line_color_.get_green_p());
        context_ref->stroke_preserve();

        context_ref->set_source_rgb (fill_color_.get_red_p(), fill_color_.get_blue_p(), fill_color_.get_green_p());
        context_ref->fill();
    }

protected:
    Gdk::Color line_color_;
    Gdk::Color fill_color_;
};

class ArrowDiamond : public ArrowHead
{
public:
    ArrowDiamond() :
        ArrowHead(),
        line_color_( "black" ),
        fill_color_( "white" )
    {
        arrow_lenght_ = 10.0;
    }

    virtual ~ArrowDiamond()
    {
    }

    void draw(Cairo::RefPtr< Cairo::Context > context_ref, double start_x, double start_y, double end_x, double end_y)
    {
        double angle = atan2 (end_y - start_y, end_x - start_x) + M_PI;

        double x1 = end_x + arrow_lenght_ * cos(angle - arrow_degrees_);
        double y1 = end_y + arrow_lenght_ * sin(angle - arrow_degrees_);
        double x2 = end_x + arrow_lenght_ * cos(angle + arrow_degrees_);
        double y2 = end_y + arrow_lenght_ * sin(angle + arrow_degrees_);
        double x3 = end_x + arrow_lenght_ * 2 * cos(angle);
        double y3 = end_y + arrow_lenght_ * 2 * sin(angle);

        context_ref->move_to (end_x, end_y);
        context_ref->line_to (x1, y1);
        context_ref->line_to (x3, y3);
        context_ref->line_to (x2, y2);
        context_ref->close_path();

        context_ref->set_source_rgb (line_color_.get_red_p(), line_color_.get_blue_p(), line_color_.get_green_p());
        context_ref->stroke_preserve();

        context_ref->set_source_rgb (fill_color_.get_red_p(), fill_color_.get_blue_p(), fill_color_.get_green_p());
        context_ref->fill();
    }

protected:
    Gdk::Color line_color_;
    Gdk::Color fill_color_;
};

class ArrowCircle : public ArrowHead
{
public:
    ArrowCircle() :
        ArrowHead(),
        line_color_( "black" ),
        fill_color_( "white" )
    {
        arrow_lenght_ = 7.0;
    }

    virtual ~ArrowCircle()
    {
    }

    void draw(Cairo::RefPtr< Cairo::Context > context_ref, double start_x, double start_y, double end_x, double end_y)
    {
        double angle = atan2 (end_y - start_y, end_x - start_x) + M_PI;

        double xc = end_x + arrow_lenght_ * cos(angle);
        double yc = end_y + arrow_lenght_ * sin(angle);

        context_ref->arc (xc, yc, arrow_lenght_, 0.0, 2 * M_PI);

        context_ref->set_source_rgb (line_color_.get_red_p(), line_color_.get_blue_p(), line_color_.get_green_p());
        context_ref->stroke_preserve();

        context_ref->set_source_rgb (fill_color_.get_red_p(), fill_color_.get_blue_p(), fill_color_.get_green_p());
        context_ref->fill();
    }

protected:
    Gdk::Color line_color_;
    Gdk::Color fill_color_;
};

void CairoArea::setStartArrowStyle(ArrowHead::ArrowStyle style)
{
    switch (style)
    {
        case ArrowHead::ARROW_OPEN:
            start_arrow_head_ptr_ = std::auto_ptr< ArrowHead >( new ArrowOpen() );
            break;
        case ArrowHead::ARROW_SOLID_FILLED:
            start_arrow_head_ptr_ = std::auto_ptr< ArrowHead >( new ArrowSolid() );
            break;
        case ArrowHead::ARROW_DIAMOND_FILLED:
            start_arrow_head_ptr_ = std::auto_ptr< ArrowHead >( new ArrowDiamond() );
            break;
        case ArrowHead::ARROW_CIRCLE_FILLED:
            start_arrow_head_ptr_ = std::auto_ptr< ArrowHead >( new ArrowCircle() );
            break;
    }
}

void CairoArea::setEndArrowStyle(ArrowHead::ArrowStyle style)
{
    switch (style)
    {
        case ArrowHead::ARROW_OPEN:
            end_arrow_head_ptr_ = std::auto_ptr< ArrowHead >( new ArrowOpen() );
            break;
        case ArrowHead::ARROW_SOLID_FILLED:
            end_arrow_head_ptr_ = std::auto_ptr< ArrowHead >( new ArrowSolid() );
            break;
        case ArrowHead::ARROW_DIAMOND_FILLED:
            end_arrow_head_ptr_ = std::auto_ptr< ArrowHead >( new ArrowDiamond() );
            break;
        case ArrowHead::ARROW_CIRCLE_FILLED:
            end_arrow_head_ptr_ = std::auto_ptr< ArrowHead >( new ArrowCircle() );
            break;
    }
}

void MainWindow::addToRecent()

{
 // Fill Data structure
 Gtk::RecentManager::Data data;

 data.app_exec = "ddraw %u";
 data.app_name  ="ddraw";

 data.groups.push_back ("ddraw");
 data.description ="ddraw diagram";

 data.display_name = getDocumentTitle();
 data.mime_type = application_x_ggr_diagram;

 // Get unique instance of RecentManager
 Glib::RefPtr<Gtk::RecentManager> recent_manager = Gtk::RecentManager::get_default();

 // Add the new item
 recent_manager->add_item ("file://" + document_ptr_->getFileName(), data);

}

    Glib::ustring ui_info =
        "<ui>"
        "  <menubar name='MenuBar'>"
        "    <menu action='MenuFile'>"
        "      <menuitem action='New'/>"
        "      <menuitem action='Open'/>"
        "      <separator/>"
        "      <menuitem action='Save'/>"
        "      <menuitem action='SaveAs'/>"
        "      <menuitem action='RevertToSaved'/>"
        "      <separator/>"
        "      <menuitem action='PageSetup'/>"
        "      <menuitem action='PrintPreview'/>"
        "      <menuitem action='Print'/>"
        "      <separator/>"
        "      <menuitem action='FileRecentFiles'/>"
        "      <separator/>"
        "      <menuitem action='Quit'/>"
        "    </menu>"
        "    <menu action='MenuEdit'>"
        "      <menuitem action='Undo'/>"
        "      <menuitem action='Redo'/>"
        "      <separator/>"
        "      <menuitem action='Cut'/>"
        "      <menuitem action='Copy'/>"
        "      <menuitem action='Paste'/>"
        "      <separator/>"
        "      <menuitem action='Delete'/>"
        "      <separator/>"
        "      <menuitem action='SelectAll'/>"
        "      <menuitem action='DeselectAll'/>"
        "      <separator/>"
        "      <menuitem action='InsertPage'/>"
        "    </menu>"
        "    <menu action='MenuView'>"
        "      <menuitem action='Toolbar'/>"
        "      <menuitem action='Statusbar'/>"
        "      <menuitem action='ObjectsToolbar'/>"
        "      <separator/>"
        "      <menuitem action='DocumentBrowser'/>"
        "      <menuitem action='PropertiesBrowser'/>"
        "      <separator/>"
        "      <menuitem action='ZoomIn'/>"
        "      <menuitem action='ZoomOut'/>"
        "      <menuitem action='Zoom100'/>"
        "      <menuitem action='ZoomFit'/>"
        "    </menu>"
        "    <menu action='MenuGo'>"
        "      <menuitem action='PreviousPage'/>"
        "      <menuitem action='NextPage'/>"
        "      <menuitem action='GotoPage'/>"
        "      <separator/>"
        "      <menuitem action='FirstPage'/>"
        "      <menuitem action='LastPage'/>"
        "    </menu>"
        "    <menu action='Help'>"
        "      <menuitem action='About'/>"
        "    </menu>"
        "  </menubar>"
        "  <toolbar  name='ToolBar'>"
        "    <toolitem action='New'/>"
        "    <toolitem action='Open'/>"
        "    <toolitem action='Save'/>"
        "    <separator/>"
        "    <toolitem action='Print'/>"
        "    <separator/>"
        "    <toolitem action='Undo'/>"
        "    <toolitem action='Redo'/>"
        "    <separator/>"
        "    <toolitem action='Cut'/>"
        "    <toolitem action='Copy'/>"
        "    <toolitem action='Paste'/>"
        "  </toolbar>"
        "  <popup name='EditorPopupMenu'>"
        "    <menuitem action='Cut'/>"
        "    <menuitem action='Copy'/>"
        "    <menuitem action='Paste'/>"
        "    <separator/>"
        "    <menuitem action='Delete'/>"
        "  </popup>"
        "  <popup name='PagePopupMenu'>"
        "    <menuitem action='Cut'/>"
        "    <menuitem action='Copy'/>"
        "    <menuitem action='Paste'/>"
        "    <separator/>"
        "    <menuitem action='InsertPage'/>"
        "    <separator/>"
        "    <menuitem action='Delete'/>"
        "  </popup>"
        "</ui>";

     // Create the recent action
 recent_action_ptr_ = Gtk::RecentAction::create("FileRecentFiles",
   _("_Recent Files"));

 recent_action_ptr_->signal_item_activated().connect (
   sigc::mem_fun(*this, &MainWindow::onMenuFileRecentFiles));

 action_group_ptr_->add (recent_action_ptr_);

 // Create the recent action
 recent_action_ptr_ = Gtk::RecentAction::create("FileRecentFiles",
   _("_Recent Files"));

 // Create the recent filter for display only
 // ggredit files
 Gtk::RecentFilter* recent_filter_ptr = Gtk::manage(new Gtk::RecentFilter());

 recent_filter_ptr->add_mime_type (application_x_ggr_diagram);
 recent_action_ptr_->set_filter (*recent_filter_ptr);

 recent_action_ptr_->signal_item_activated().connect (
   sigc::mem_fun(*this, &MainWindow::onMenuFileRecentFiles));

 action_group_ptr_->add (recent_action_ptr_);

 // Create the recent action
 recent_action_ptr_ = Gtk::RecentAction::create("FileRecentFiles",
   _("_Recent Files"));

 // Create the recent filter for display only
 // ggredit files
 Gtk::RecentFilter* recent_filter_ptr = Gtk::manage(new Gtk::RecentFilter());

 recent_filter_ptr->add_mime_type (application_x_ggr_diagram);
 recent_action_ptr_->set_filter (*recent_filter_ptr);

 recent_action_ptr_->set_show_numbers (true);
 recent_action_ptr_->set_sort_type (Gtk::RECENT_SORT_MRU);

 recent_action_ptr_->signal_item_activated().connect (
   sigc::mem_fun(*this, &MainWindow::onMenuFileRecentFiles));

 action_group_ptr_->add (recent_action_ptr_);

/*!
 * @brief Base class for Zlib streams
 */
class ZStreamBase
{
public:
    /*!
     * @brief Buffert type
     */
    typedef unsigned char char_t;

    /*!
     * @brief Constructor
     */
    ZStreamBase();

    /*!
     * @brief Destructor
     */
    virtual ~ZStreamBase();

    /*!
     * @brief Byte available in input
     *
     * @return true if not data are available in input
     */
    bool isInEmpty() const { return z_stream_.avail_in == 0; };

    /*!
     * @briet Byte available in output
     *
     * @return true if not data are available in output
     */
    bool isOutEmpty() const { return z_stream_.avail_out == 0; };

    /*!
     * @brief Stream input complete on inflate
     *
     * @return true if the stream input is compltete on inflate
     */
    bool isStreamEnd() const { return stream_end_; }

    /*!
     * @brief Write a buffer to the ZLib stream
     *
     * @param buf pointer to the buffer
     * @param buf_size buffer size
     */
    void write(char_t* buf, size_t buf_size);

    /*!
     * @brief Read a buffer from the ZLib stream
     *
     * @param buf pointer to the buffer
     * @param buf_size buffer size
     */
    virtual void read(char_t* buf, size_t buf_size) = 0;

    /*!
     * @brief Read all ZLib output stream
     *
     * Use the read function for read each data chunk until
     * the output buffer is empty, isOutEmpty return true.
     *
     * @param buf return a new allocated buffer
     * @param buf_size return the size of the allocated buffer
     */
    void readAll(char_t** buf, size_t& buf_size);

    /*!
     * @brief Mark as complete the write operation
     */
    void flush() { flush_ = true; };

protected:
    z_stream z_stream_;
    bool flush_;
    bool stream_end_;
};

ZDeflateStream::ZDeflateStream(int compression_level/*=Z_DEFAULT_COMPRESSION*/) :
    compression_level_( compression_level )
{
    int ret = deflateInit (&z_stream_, compression_level_);

    if (ret != Z_OK)
        throw ZError ("Can not initialize deflate stream");
}

ZDeflateStream::~ZDeflateStream()
{
    deflateEnd (&z_stream_);
}

ZInflateStream::ZInflateStream()
{
    z_stream_.avail_in = 0;
    z_stream_.next_in = Z_NULL;

    int ret = inflateInit (&z_stream_);

    if (ret != Z_OK)
        throw ZError ("Can not initialize inflate stream");
}

ZInflateStream::~ZInflateStream()
{
    inflateEnd (&z_stream_);
}

void ZStreamBase::write(char_t* buf, size_t buf_size)
{
    z_stream_.avail_in = buf_size;
    z_stream_.next_in = reinterpret_cast< Bytef* >(buf);
}

void ZDeflateStream::read(char_t* buf, size_t buf_size)
{
    z_stream_.avail_out = buf_size;
    z_stream_.next_out = reinterpret_cast< Bytef* >(buf);

    int ret = deflate (&z_stream_, flush_ ? Z_FINISH : Z_NO_FLUSH);

    if (ret == Z_STREAM_ERROR)
        throw ZError( "Error on deflate" );
}

void ZInflateStream::read(char_t* buf, size_t buf_size)
{
    z_stream_.avail_out = buf_size;
    z_stream_.next_out = reinterpret_cast< Bytef* >(buf);

    int ret = inflate (&z_stream_, Z_NO_FLUSH);

    switch (ret)
    {
        case Z_STREAM_ERROR:
            throw ZError( "The stream structure was inconsistent" );
            break;
        case Z_NEED_DICT:
            throw ZError( "A preset dictionary is needed" );
            break;
        case Z_DATA_ERROR:
            throw ZError( "Input data was corrupted" );
            break;
        case Z_MEM_ERROR:
            throw ZError( "Not enough memory" );
            break;
        case Z_STREAM_END:
            stream_end_ = true;
            break;
    }
}

const size_t ChunkSize = 16384;
.
.
.
void ZStreamBase::readAll(char_t** buf, size_t& buf_size)
{
    std::stringstream out_stream;

    char_t out_buf[ChunkSize];

    do
    {
        read (out_buf, ChunkSize);

        size_t out_size = ChunkSize - z_stream_.avail_out;
        out_stream.write (reinterpret_cast< const char* >(out_buf), out_size);

        if (out_stream.bad())
            throw ZError( "Error writing temporary stream" );

    } while (isOutEmpty());

    buf_size = out_stream.str().size();
    *buf = new char_t[buf_size];
    out_stream.read (reinterpret_cast< std::stringstream::char_type* >(*buf), buf_size);;
}

I would like also to thanks Chrono© for report the bad code at line 137.
#ifndef BASE64_H_
#define BASE64_H_

#include <inttypes.h>
#include <string>
#include <sstream>
#include <memory>

namespace base64
{

const char base64chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const char base64pad = '=';

/**
 * @brief Encode a buffer on a string base64 encoded
 *
 * Base 64 encoding converts 3 bytes into 4 encoded ASCII
 * characters.
 * If the encoded string lenght is not multiple of 4
 * the padding character "=" is added for fill the buffer.
 * If the buf_size is 0 an empty string was returned.
 *
 * @param buf_ptr pointer to the source buffer
 * @param buf_size size of the buffer
 *
 * @return a string base64 encoded
 *
 * @see http://en.wikipedia.org/wiki/Base64
 */
std::string encode(uint8_t* buf_ptr, size_t buf_size)
{
    // If the buf_size is 0 return an empty string
    if (buf_size == 0)
        return "";

    uint32_t n = 0;
    uint8_t n0, n1, n2, n3;
    std::stringstream ss_result;

    // Iterate over the buffer
    for (size_t x = 0; x < buf_size; x += 3)
    {
        // Get 3 bytes of 8 bit from the buffer
        n = buf_ptr[x] << 16;

        if ((x + 1) < buf_size)
        {
            n += buf_ptr[x + 1] << 8;

            if ((x + 2) < buf_size)
            {
                n += buf_ptr[x + 2];
            }
        }

        // Transform on 4 bytes of 6 bit
        n0 = (uint8_t)(n >> 18) & 63;
        n1 = (uint8_t)(n >> 12) & 63;
        n2 = (uint8_t)(n >> 6) & 63;
        n3 = (uint8_t)n & 63;

        // Write first 2 bytes into the stream
        ss_result << base64chars[n0];
        ss_result << base64chars[n1];

        // Test if only 2 bytes
        if ((x + 1) < buf_size)
        {
            // Write 3rd into the stream
            ss_result << base64chars[n2];

            // Test if only 3 bytes
            if ((x + 2) < buf_size)
            {
                // Write 4th into the stream
                ss_result << base64chars[n3];
            }
        }
    }

    // Add padding character for fill the output string
    for (int pad_count = 0; pad_count < ss_result.str().size() % 4; pad_count++)
    {
        ss_result << base64pad;
    }

    return ss_result.str();
}

/*!
 * @brief Compute size of decoded stream
 *
 * @param encoded_size size of the encoded stream
 * @return the size of the decoded stream
 */
size_t decoded_size(size_t encoded_size)
{
    return (encoded_size + 3) / 4 * 3;
}

/**
 * @brief Decode a string base64 encoded and return a raw buffer
 *
 * The function allocate a buffer with size:
 * @code (text.size() + 3) / 4 * 3
 * and return the pointer. The caller has the ownership of the
 * pointer.
 * The source string lenght must be multiple of 4.
 * Use is_base_64 for test if a string is Base64 well formed.
 *
 * @param text the base64 string encoded
 *
 * @return the pointer to the decoded buffer
 */
std::auto_ptr< uint8_t > decode(const std::string& text)
{
    // Create the decode matrix
    uint8_t decode_base64chars[256];
    memset (decode_base64chars, 0, 256);

    for (uint8_t i = 0; i <= 63; i++)
    {
        decode_base64chars[(int)base64chars[(int)i]] = i;
    }

    // Allocate output buffer
    uint8_t* buf_ptr = new uint8[decoded_size(text.size())];

    // Start decode source string
    size_t buf_idx = 0;
    for (size_t i = 0; i < text.size(); i += 4, buf_idx += 3)
    {
        // Put first base64 char on the first output-byte
        buf_ptr[buf_idx] = decode_base64chars[(int)text[i]] << 2;

        // Test for string end
        if ((i + 1 < text.size()) && (text[i + 1] != base64pad))
        {
            // Add to the first output-byte 2 bit of the second base64 char
            buf_ptr[buf_idx] += (decode_base64chars[(int)text[i + 1]] >> 4) & 0x3;

            // Put remaining 4 bit of the second base64 char on the second output-byte
            buf_ptr[buf_idx + 1] = decode_base64chars[(int)text[i + 1]] << 4;

            // Test for string end
            if ((i + 2 < text.size()) && (text[i + 2] != base64pad))
            {
                // Add to the second output-byte 4 bit of the third base64 char
                buf_ptr[buf_idx + 1] += (decode_base64chars[(int)text[i + 2]] >> 2) & 0xf;

                // Put remaining 2 bit of the third base64 char on the third output-byte
                buf_ptr[buf_idx + 2] = decode_base64chars[(int)text[i + 2]] << 6;

                // Test for string end
                if ((i + 1 < text.size()) && (text[i + 3] != base64pad))
                {
                    // Add to the third output-byte the forth base64 char
                    buf_ptr[buf_idx + 2] += decode_base64chars[(int)text[i + 3]];
                }
            }
        }
    }

    return std::auto_ptr<uint8_t>(buf_ptr);
}

/**
 * @brief Test if a string is well Base64 encoded
 *
 * @param text the string Base64 encoded
 *
 * @return true if the string is well formed
 */
bool is_base_64(const std::string& text)
{
    // Create the decode matrix
    uint8_t decode_base64chars[256];
    memset (decode_base64chars, 65, 256);

    for (uint8_t i = 0; i <= 63; i++)
    {
        decode_base64chars[(int)base64chars[(int)i]] = i;
    }

    // Add padding character
    decode_base64chars[(int)'='] = 64;

    // Test string characters
    for (size_t i = 0; i < text.size(); i++)
    {
        if (decode_base64chars[(int)text[i]] == 65)
        {
            // Invalid character found
            return false;
        }
        else if ((decode_base64chars[(int)text[i]] == 64) && (i < text.size() - 3))
        {
            // Padding character at invalid position
            return false;
        }
    }

    return true;
}

};

#endif /*BASE64_H_*/

bool Schema::validate(const Glib::ustring& filename)
{
    bool result = false;

    if (xmlSchemaValidCtxtPtr validity_context_ptr = xmlSchemaNewValidCtxt (schema_ptr_))
    {
      result = xmlSchemaValidateFile (validity_context_ptr, filename.c_str(), 0) == 0;
      xmlSchemaFreeValidCtxt (validity_context_ptr);
    }

    return result;
}

bool Schema::validate(const XmlDocument& xml_doc)
{
    bool result = false;

    if (xmlSchemaValidCtxtPtr validity_context_ptr = xmlSchemaNewValidCtxt (schema_ptr_))
    {
      result = xmlSchemaValidateDoc (validity_context_ptr, xml_doc.getDocPtr()) == 0;
      xmlSchemaFreeValidCtxt (validity_context_ptr);
    }

    return result;
}

sudo rm /usr/share/applications/eclipse-ganymede-rc4.desktop
sudo rm /usr/bin/eclipse-ganymede-rc4
sudo rm -rf /opt/eclipse-ganymede-rc4/

sudo rm /usr/share/applications/eclipse.desktop
sudo rm /usr/bin/eclipse
sudo rm -rf /opt/eclipse/

user@ubuntu710desktop:~$ cd Public/
user@ubuntu710desktop:~/Public$ tar xzf eclipse-cpp-ganymede-linux-gtk.tar.gz 
user@ubuntu710desktop:~/Public$ sudo mv eclipse /opt/eclipse
[sudo] password for user:
user@ubuntu710desktop:~/Public$ cd /opt/
user@ubuntu710desktop:/opt$ sudo chown -R root:root eclipse
user@ubuntu710desktop:/opt$ sudo chmod -R +r eclipse
user@ubuntu710desktop:/opt$ sudo chmod +x `sudo find eclipse -type d`
user@ubuntu710desktop:/opt$ 

user@ubuntu710desktop:/opt$ sudo touch /usr/bin/eclipse
user@ubuntu710desktop:/opt$ sudo chmod 755 /usr/bin/eclipse
user@ubuntu710desktop:/opt$ sudo gedit /usr/bin/eclipse

#!/bin/sh
#export MOZILLA_FIVE_HOME="/usr/lib/mozilla/"
export ECLIPSE_HOME="/opt/eclipse"

$ECLIPSE_HOME/eclipse $*

user@ubuntu710desktop:/opt$ sudo gedit /usr/share/applications/eclipse.desktop

[Desktop Entry]
Encoding=UTF-8
Name=Eclipse
Comment=Eclipse IDE
Exec=eclipse
Icon=/opt/eclipse/icon.xpm
Terminal=false
Type=Application
Categories=GNOME;Application;Development;
StartupNotify=true

int value_;

    int getValue() const
    {
        return value_;
    }

    void setValue(int value_)
    {
        this->value_ = value_;
    }

class BaseClass
{
public:
    BaseClass();
    virtual ~BaseClass();

    int getValue() const
    {
        return value_;
    }

    void setValue(int value_)
    {
        this->value_ = value_;
    }

    void myMethod(int arg);

private:
    int value_;
};

class BaseClass
{
public:
    BaseClass();
    virtual ~BaseClass();

    int getValue() const
    {
        return value_;
    }

    void setValue(int value_)
    {
        this->value_ = value_;
    }

private:
    int value_;
    void myMethod(int arg);
};

    void myMethod(int arg);

void BaseClass::myMethod(int arg)
{
}

void BaseClass::myMethod(int arg)
{
    arg += 100;
}

void BaseClass::myMethod2(int arg)
{
    arg += 100;
}

namespace 
{
    const int Step_ = 100;
}

...

void BaseClass::myMethod(int arg)
{
    arg += Step_;
}

void BaseClass::myMethod2(int arg)
{
    arg += Step_;
}

void BaseClass::myMethod(int arg)
{
    int b = arg + 10;

    arg = b;
}

int BaseClass::addStep(int & arg)
{
    int b = arg + 10;
    return b;
}

void BaseClass::myMethod(int arg)
{
    int b = addStep(arg);

    arg = b;
}

sudo rm /usr/share/applications/eclipse-ganymede-rc2.desktop

sudo rm /usr/bin/eclipse-ganymede-rc2

sudo rm -rf /opt/eclipse-ganymede-rc2/

tar xzf eclipse-cpp-ganymede-RC2-linux-gtk.tar.gz
sudo mv eclipse /opt/eclipse-ganymede-rc2
cd /opt/
sudo chown -R root:root eclipse-ganymede-rc2/
sudo chmod -R +r eclipse-ganymede-rc2/
sudo chmod +x `sudo find eclipse-ganymede-rc2 -type d`

sudo touch /usr/bin/eclipse-ganymede-rc2
sudo chmod 755 /usr/bin/eclipse-ganymede-rc2
sudo gedit /usr/bin/eclipse-ganymede-rc2

#!/bin/sh
#export MOZILLA_FIVE_HOME="/usr/lib/mozilla/"
export ECLIPSE_HOME="/opt/eclipse-ganymede-rc2"

$ECLIPSE_HOME/eclipse $*

sudo gedit /usr/share/applications/eclipse-ganymede-rc2.desktop

[Desktop Entry]
Encoding=UTF-8
Name=Eclipse Ganymede RC2
Comment=Eclipse IDE
Exec=eclipse-ganymede-rc2
Icon=/opt/eclipse/icon.xpm
Terminal=false
Type=Application
Categories=GNOME;Application;Development;
StartupNotify=true

    // Compute scale
    double required_size = 22;
    double max_in_size = std::max(image_ptr_->get_width(), image_ptr_->get_height());
    double f_scale = required_size / max_img_size;

    // Set context scale
    context->scale (f_scale, f_scale);

    // Draw the source image
    context->set_source (image_surface_ptr_, 0.0, 0.0);
    context->rectangle (0.0, 0.0, image_ptr_->get_width(), image_ptr_->get_height());
    context->fill();

    double required_size = 22;
    double max_img_size = std::max (image_ptr_->get_width(), image_ptr_->get_height());
    int scaled_width = int(required_size * (image_ptr_->get_width() / max_img_size));
    int scaled_height = int(required_size * (image_ptr_->get_height() / max_img_size));

    icon_image_ptr_ = image_ptr->scale_simple(scaled_width, scaled_height, Gdk::INTERP_BILINEAR);

std::string encode(uint8_t* buf_ptr, size_t buf_size)

std::auto_ptr< uint8_t > decode(const std::string& text)

This code does not work well look here for the bug fixed version.
#ifndef BASE64_H_
#define BASE64_H_

#include <inttypes.h>
#include <string>
#include <sstream>
#include <memory>

namespace base64
{

const char base64chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const char base64pad = '=';

/**
 * @brief Encode a buffer on a string base64 encoded
 * 
 * Base 64 encoding converts 3 bytes into 4 encoded ASCII 
 * characters.
 * If the encoded string lenght is not multiple of 4
 * the padding character "=" is added for fill the buffer.
 *  
 * @param buf_ptr pointer to the source buffer
 * @param buf_size size of the buffer
 * 
 * @return a string base64 encoded
 * 
 * @see http://en.wikipedia.org/wiki/Base64
 */
std::string encode(uint8_t* buf_ptr, size_t buf_size)
{
   uint32_t n = 0;
   uint8_t n0, n1, n2, n3;
   std::stringstream ss_result;

   // Iterate over the buffer
   for (size_t x = 0; x < buf_size; x += 3) 
   {
      // Get 3 bytes of 8 bit from the buffer 
      n = buf_ptr[x] << 16;

      if ((x+1) < buf_size)
      {
          n += buf_ptr[x+1] << 8;

          if ((x+2) < buf_size)
          {
             n += buf_ptr[x+2];
          }
      }

      // Transform on 4 bytes of 6 bit
      n0 = (uint8_t)(n >> 18) & 63;
      n1 = (uint8_t)(n >> 12) & 63;
      n2 = (uint8_t)(n >> 6) & 63;
      n3 = (uint8_t)n & 63;

      // Write first 2 bytes into the stream
      ss_result << base64chars[n0];
      ss_result << base64chars[n1];

      // Test if only 2 bytes
      if ((x+1) < buf_size)
      {
          // Write 3rd into the stream
          ss_result << base64chars[n2];

          // Test if only 3 bytes
          if ((x+2) < buf_size)
          {
              // Write 4th into the stream
              ss_result << base64chars[n3];
          }
      }
   }  

   // Add padding character for fill the output string
   for (int pad_count = buf_size % 3; pad_count < 3; pad_count++) 
   { 
       ss_result << base64pad;
   } 

   return ss_result.str();
}

/**
 * @brief Decode a string base64 encoded and return a raw buffer
 * 
 * The function allocate a buffer with size: 
 * @(text.size() + 3) / 4 * 3
 * and return the pointer. The caller has the ownership of the
 * pointer.
 * The source string lenght must be multiple of 4.
 *  
 * @param text the base64 string encoded
 * 
 * @return the pointer to the decoded buffer
 */
std::auto_ptr< uint8_t > decode(const std::string& text)
{
    // Create the decode matrix
    uint8_t decode_base64chars[256];
    memset (decode_base64chars, 0, 256);

    for (uint8_t i = 0; i <= 63; i++)
    {
        decode_base64chars[(int)base64chars[(int)i]] = i;
    }

    // Allocate output buffer
    uint8_t* buf_ptr = new guint8[(text.size() + 3) / 4 * 3];

    // Start decode source string
    size_t buf_idx = 0;
    for (size_t i = 0; i < text.size(); i += 4, buf_idx += 3)
    {
        // Put first base64 char on the first output-byte
        buf_ptr[buf_idx] = decode_base64chars[(int)text[i]] << 2;

        // Test for string end
        if ((i + 1 < text.size()) && (text[i + 1] != base64pad))
        {
            // Add to the first output-byte 2 bit of the second base64 char
            buf_ptr[buf_idx] += (decode_base64chars[(int)text[i + 1]] >> 6) & 0x3;

            // Put remaining 4 bit of the second base64 char on the second output-byte
            buf_ptr[buf_idx + 1] = decode_base64chars[(int)text[i + 1]] << 4;

            // Test for string end
            if ((i + 2 < text.size()) && (text[i + 2] != base64pad))
            {
                // Add to the second output-byte 4 bit of the third base64 char
                buf_ptr[buf_idx + 1] += (decode_base64chars[(int)text[i + 2]] >> 4) & 0xf;

                // Put remaining 2 bit of the third base64 char on the third output-byte
                buf_ptr[buf_idx + 2] = decode_base64chars[(int)text[i + 2]] << 6;

                // Test for string end
                if ((i + 1 < text.size()) && (text[i + 3] != base64pad))
                {
                    // Add to the third output-byte the forth base64 char
                    buf_ptr[buf_idx + 2] += decode_base64chars[(int)text[i + 3]];
                }
            }
        }
    }

    return std::auto_ptr<uint8_t>(buf_ptr);
}

};

#endif /*BASE64_H_*/

    // Get Pixbuf from an image
    Glib::RefPtr< Gdk::Pixbuf > pixbuf_ref = source_image_.get_pixbuf();
    // Size except last row
    size_t buf_size = pixbuf_ref->get_rowstride() * (pixbuf_ref->get_height() - 1);
    // Add last row size
    buf_size += pixbuf_ref->get_width() * ((pixbuf_ref->get_n_channels() * pixbuf_ref->get_bits_per_sample() + 7) / 8);

    // Create a Pixbuf from raw buffer
    Glib::RefPtr< Gdk::Pixbuf > pixbuf_ref = Gdk::Pixbuf::create_from_data( buf_ptr.get(), 
            Gdk::COLORSPACE_RGB, has_alpha, bits_per_sample, width, height, rowstride);

    // Assign the Pixbuf to the Image widget
    source_image_.property_pixbuf() = pixbuf_ref; 

/**
 * @brief Proxy class for CellRenderer stored on CellRendererRouter
 * 
 * Implement the CellRendererChildInterface for expose public functions
 * and forward call to the baseT (a CellRenderer) class.
 * 
 * The baseT class must implement properties:
 * - property_editable of type bool
 * - property_text of type Glib::ustring
 * 
 * @param baseT a CellRenderer inherited class
 */
template< class baseT >
class CellRendererProxy : public virtual CellRendererChildInterface, public baseT
{
public:
    CellRendererProxy(CellRendererRouter* parent_ptr) :
        Glib::ObjectBase( typeid(CellRendererProxy) ),
        baseT(),
        parent_ptr_( parent_ptr )
    {
        //Make the CellRenderer editable, and handle its editing signals:
#ifdef GLIBMM_PROPERTIES_ENABLED
        baseT::property_editable() = true;
#else
        baseT::set_property("editable", true);
#endif
        baseT::signal_edited().connect (sigc::mem_fun (*this, &CellRendererProxy::onEdited));

    }
    virtual ~CellRendererProxy()
    {

    }

    /* implements */virtual void set_text(const Glib::ustring& value)
    {
#ifdef GLIBMM_PROPERTIES_ENABLED
        baseT::property_text() = value;
#else
        baseT::set_property("text", value);
#endif        
    }

    /* implements */virtual void get_size_vfunc (Gtk::Widget& widget, const Gdk::Rectangle* cell_area, int* x_offset, int* y_offset, int* width, int* height) const
    {
        baseT::get_size_vfunc (widget, cell_area, x_offset, y_offset, width, height);
    }

    /* implements */virtual void render_vfunc (const Glib::RefPtr<Gdk::Drawable>& window, Gtk::Widget& widget, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, Gtk::CellRendererState flags)
    {
        baseT::render_vfunc (window, widget, background_area, cell_area, expose_area, flags);
    }

    /* implements */virtual bool activate_vfunc (GdkEvent* event, Gtk::Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, Gtk::CellRendererState flags)
    {
        return baseT::activate_vfunc (event, widget, path, background_area, cell_area, flags);
    }

    /* implements */virtual Gtk::CellEditable* start_editing_vfunc(GdkEvent* event, Gtk::Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, Gtk::CellRendererState flags)
    {
        return baseT::start_editing_vfunc(event, widget, path, background_area, cell_area, flags);
    }

protected:
    CellRendererRouter* parent_ptr_;

    void onEdited(const Glib::ustring& path_string, const Glib::ustring& new_text);
};

/**
 * @brief Tell the CellRendererRouter to emit the edited signal
 */
template< class baseT >
void CellRendererProxy< baseT >::onEdited(const Glib::ustring& path_string, const Glib::ustring& new_text)
{
    parent_ptr_->notifyEdited (path_string, new_text);
};

/**
 * @brief Interface for CellRenderer stored on CellRendererRouter
 */
class CellRendererChildInterface
{
public:
    CellRendererChildInterface()
    {
    }
    virtual ~CellRendererChildInterface()
    {    
    }

    virtual void set_text(const Glib::ustring& value) = 0;

    virtual void get_size_vfunc (Gtk::Widget& widget, const Gdk::Rectangle* cell_area, int* x_offset, int* y_offset, int* width, int* height) const = 0;
    virtual void render_vfunc (const Glib::RefPtr<Gdk::Drawable>& window, Gtk::Widget& widget, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, Gtk::CellRendererState flags) = 0;
    virtual bool activate_vfunc (GdkEvent* event, Gtk::Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, Gtk::CellRendererState flags) = 0;
    virtual Gtk::CellEditable* start_editing_vfunc(GdkEvent* event, Gtk::Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, Gtk::CellRendererState flags) = 0;
};

/**
 * @brief Multiple CellRenderer for single column
 * 
 * Add a CellRendererRouter to a TreeView for implement
 * multiple CellRenderer for a single colum.
 * The CellRendererRouter is called by the system for
 * render or start edit, and it simply forward the call
 * to the registered CellRenderer for the current type.
 * Use registerTypeRenderer for define all CellRenderer
 * managed by the CellRendererRouter class.
 */
class CellRendererRouter : public Gtk::CellRenderer
{
public:
    typedef CellRendererChildInterface* cell_renderer_ptr_t;
    typedef std::map< Glib::ustring, cell_renderer_ptr_t > cell_renderer_map_t;
    typedef cell_renderer_map_t::iterator iterator_t;

    CellRendererRouter();
    virtual ~CellRendererRouter();

    /**
     * @brief Register a CellRenderer for a type-id
     * 
     * At least one CellRenderer must be registered and at least one
     * CellRenderer must be registered as default. The default CellRenderer
     * is used when the system ask for some operation on a row that
     * was not defined. If more than one CellRenderer are
     * registered as default only the last one is the default.
     * 
     * @param type_id the type-id
     * @param renderer_ptr the CellRenderer
     * @param is_default use the CellRenderer for unknown path
     */
    void registerTypeRenderer(const Glib::ustring& type_id, cell_renderer_ptr_t renderer_ptr, bool is_default=false);

    /**
     * @brief Select a registered CellRenderer as default
     * 
     * @param type_id type-id of a registered CellRenderer
     */
    void selectDefaultTypeRenderer(const Glib::ustring& type_id);

    /**
     * @brief Return the CellRenderer registered for gived type-id
     * 
     * If no CellRenderer is registered for gived type-id the default
     * CellRenderer is returned
     * 
     * @param type_id the type-id to search for
     * 
     * @return the CellRenderer registered for gived type-id or NULL if
     * no CellRenderer is registerer and the default CellRenderer is not set
     */
    cell_renderer_ptr_t getTypeRenderer(const Glib::ustring& type_id) const; 

    /**
     * @brief Remove an already registered CellRenderer
     * 
     * When a default CellRenderer is removed call selectDefaultTypeRenderer
     * for select a new default CellRenderer.
     * 
     * @param type_id the type-id of the registered CellRenderer to remove
     */
    void unregisterTypeRenderer(const Glib::ustring& type_id);

    /**
     * @brief Remove all registered CellRenderer
     */
    void unregisterAll();

    /**
     * @brief Emit the edited signal
     * 
     * @param path_string path of edited item
     * @param new_text new value of the item
     */
    void notifyEdited(const Glib::ustring& path_string, const Glib::ustring& new_text);

    /** @name Properties
     */    
    //@{

    /**
     * @brief Item text value
     */
    Glib::PropertyProxy< Glib::ustring > property_text();

    /**
     * @brief Item type
     */
    Glib::PropertyProxy< Glib::ustring > property_type();

    /**
     * @brief Item editable state
     */
    Glib::PropertyProxy< bool > property_editable();

    //@}

    /** @name Signals
     */    
    //@{

    typedef sigc::signal< void, const Glib::ustring &, const Glib::ustring& > signal_edited_t;
    signal_edited_t& signal_edited();

    //@}

protected:
    cell_renderer_map_t type_renderer_map_;
    Glib::ustring default_renderer_;
    Glib::Property< Glib::ustring > property_text_;
    Glib::Property< Glib::ustring > property_type_;
    Glib::Property< bool > property_editable_;
    signal_edited_t signal_edited_;

    /* override */virtual void get_size_vfunc (Gtk::Widget& widget, const Gdk::Rectangle* cell_area, int* x_offset, int* y_offset, int* width, int* height) const;
    /* override */virtual void render_vfunc (const Glib::RefPtr<Gdk::Drawable>& window, Gtk::Widget& widget, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, Gtk::CellRendererState flags);
    /* override */virtual bool activate_vfunc (GdkEvent* event, Gtk::Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, Gtk::CellRendererState flags);
    /* override */virtual Gtk::CellEditable* start_editing_vfunc(GdkEvent* event, Gtk::Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, Gtk::CellRendererState flags);

    // property_text events
    virtual void onTextChanged();
};

void CellRendererRouter::registerTypeRenderer(const Glib::ustring& type_id, cell_renderer_ptr_t renderer_ptr, bool is_default/*=false*/)
{
    if (type_renderer_map_.find(type_id) != type_renderer_map_.end())
        throw std::runtime_error ( "A CellRenderer was already registered for type: " + type_id );

    // TODO: who manage the pointer?
    type_renderer_map_.insert (std::make_pair (type_id, renderer_ptr));

    if (is_default)
        default_renderer_ = type_id;
}

void CellRendererRouter::selectDefaultTypeRenderer(const Glib::ustring& type_id)
{
    default_renderer_ = type_id;
}

CellRendererRouter::cell_renderer_ptr_t CellRendererRouter::getTypeRenderer(const Glib::ustring& type_id) const
{
    // Search for the CellRenderer to use
    if (type_renderer_map_.find (type_id) != type_renderer_map_.end())
    {
        // Use registered CellRenderer
        return type_renderer_map_.at(property_type_);
    }
    else
    {
        // Use default CellRenderer
        if (type_renderer_map_.find (default_renderer_) != type_renderer_map_.end())
        {
            return type_renderer_map_.at(default_renderer_);
        }
    }

    // TODO: Critical, throw an exception? 
    return 0;
}

void CellRendererRouter::unregisterTypeRenderer(const Glib::ustring& type_id)
{
    if (type_renderer_map_.find(type_id) == type_renderer_map_.end())
        throw std::runtime_error ( "Non existent CellRenderer registered for type: " + type_id );

    type_renderer_map_.erase (type_id);

    if (default_renderer_ == type_id)
        default_renderer_.clear();
}

void CellRendererRouter::unregisterAll()
{
    type_renderer_map_.clear();
    default_renderer_.clear();
}

/* override */void CellRendererRouter::get_size_vfunc (Gtk::Widget& widget, const Gdk::Rectangle* cell_area, int* x_offset, int* y_offset, int* width, int* height) const
{
    getTypeRenderer(property_type_)->get_size_vfunc (widget, cell_area, x_offset, y_offset, width, height);
}

/* override */void CellRendererRouter::render_vfunc (const Glib::RefPtr<Gdk::Drawable>& window, Gtk::Widget& widget, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, Gtk::CellRendererState flags)
{
    getTypeRenderer(property_type_)->render_vfunc (window, widget, background_area, cell_area, expose_area, flags);
}

/* override */bool CellRendererRouter::activate_vfunc (GdkEvent* event, Gtk::Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, Gtk::CellRendererState flags)
{
    return getTypeRenderer(property_type_)->activate_vfunc (event, widget, path, background_area, cell_area, flags);
}

/* override */Gtk::CellEditable* CellRendererRouter::start_editing_vfunc(GdkEvent* event, Gtk::Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, Gtk::CellRendererState flags)
{
    return getTypeRenderer(property_type_)->start_editing_vfunc(event, widget, path, background_area, cell_area, flags);
}

/**
 * @brief Model used by the PropertiesBrowser TreeView
 */
class PropertiesModelColumns : public Gtk::TreeModelColumnRecord
{
public:

    PropertiesModelColumns()
    { 
        add (col_name_); 
        add (col_value_);
        add (col_type_);
    }

    Gtk::TreeModelColumn< Glib::ustring > col_name_;
    Gtk::TreeModelColumn< Glib::ustring > col_value_;
    Gtk::TreeModelColumn< Glib::ustring > col_type_;
};

#ifndef COLORCELLRENDERER2_H_
#define COLORCELLRENDERER2_H_

#include <gdkmm.h>
#include <gtkmm/cellrenderer.h>

#include "ColorCellEditable2.h"

class ColorCellRenderer2 : public Gtk::CellRenderer
{
public:
    ColorCellRenderer2();
    virtual ~ColorCellRenderer2();

    // Properties
    Glib::PropertyProxy< Glib::ustring > property_text();
    Glib::PropertyProxy< bool > property_editable();

    // Edited signal
    typedef sigc::signal<void, const Glib::ustring&, const Glib::ustring& > signal_edited_t;
    signal_edited_t& signal_edited() { return signal_edited_; };

protected:
    Glib::Property< Glib::ustring > property_text_;
    Glib::Property< bool > property_editable_;
    signal_edited_t signal_edited_;
    ColorCellEditable2* color_cell_edit_ptr_;
    mutable int button_width_; //mutable because it is just a cache for get_size_vfunc

    // Raise the edited event
    void edited(const Glib::ustring& path, const Glib::ustring& new_text);

    /* override */virtual void get_size_vfunc (Gtk::Widget& widget, const Gdk::Rectangle* cell_area, int* x_offset, int* y_offset, int* width, int* height) const;
    /* override */virtual void render_vfunc (const Glib::RefPtr<Gdk::Drawable>& window, Gtk::Widget& widget, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, Gtk::CellRendererState flags);
    /* override */virtual bool activate_vfunc (GdkEvent*, Gtk::Widget&, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, Gtk::CellRendererState flags);
    /* override */virtual Gtk::CellEditable* start_editing_vfunc(GdkEvent* event, Gtk::Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, Gtk::CellRendererState flags);

    // Manage editing_done event for color_cell_edit_ptr_
    void on_editing_done();
};

#endif /*COLORCELLRENDERER2_H_*/

virtual void get_size_vfunc (Gtk::Widget& widget, const Gdk::Rectangle* cell_area, int* x_offset, int* y_offset, int* width, int* height) const;

/* static */ int ColorCellEditable2::get_button_width()
{
    Gtk::Window window (Gtk::WINDOW_POPUP);

    Gtk::Button *const button = new Gtk::Button();
    window.add(*Gtk::manage(button));

    button->add(*Gtk::manage(new Gtk::Arrow(Gtk::ARROW_DOWN, Gtk::SHADOW_OUT)));

    // Urgh.  Hackish :/
    window.move(-500, -500);
    window.show_all();

    Gtk::Requisition requisition = window.size_request();

    return requisition.width;
}

/* static */ int ColorCellEditable2::get_color_area_width()
{
    return 16;
}

/* override */void ColorCellRenderer2::get_size_vfunc (Gtk::Widget& widget, const Gdk::Rectangle* cell_area, int* x_offset, int* y_offset, int* width, int* height) const
{
    // We cache this because it takes a really long time to get the width.
    if(button_width_ < 0)
        button_width_ = ColorCellEditable2::get_button_width();

    // Compute text width
    Glib::RefPtr<Pango::Layout> layout_ptr = widget.create_pango_layout (property_text_);
    Pango::Rectangle rect = layout_ptr->get_pixel_logical_extents();

    const int calc_width  = property_xpad() * 4 + rect.get_width();
    const int calc_height = property_ypad() * 4 + rect.get_height();

    // Add button width and color area width
    if( width )
        *width = calc_width + button_width_ + ColorCellEditable2::get_color_area_width();

    if( height )
        *height = calc_height;    
}

virtual void render_vfunc (const Glib::RefPtr<Gdk::Drawable>& window, Gtk::Widget& widget, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, Gtk::CellRendererState flags);

    // Create the graphic context
    Glib::RefPtr< Gdk::GC > gc = Gdk::GC::create (window);

    // Draw color area
    gc->set_rgb_fg_color( color_value );
    window->draw_rectangle(gc, 
            true, 
            cell_area.get_x(), 
            cell_area.get_y(), 
            ColorCellEditable2::get_color_area_width(), 
            cell_area.get_height());

/* override */void ColorCellRenderer2::render_vfunc (const Glib::RefPtr<Gdk::Drawable>& window, Gtk::Widget& widget, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, Gtk::CellRendererState flags)
{
    // Get cell size
    int x_offset = 0, y_offset = 0, width = 0, height = 0;
    get_size (widget, cell_area, x_offset, y_offset, width, height);

    // Create the graphic context
    Glib::RefPtr< Gdk::GC > gc = Gdk::GC::create (window);

    // Get cell state
    Gtk::StateType state;
    Gtk::StateType text_state;
    if ((flags & Gtk::CELL_RENDERER_SELECTED) != 0)
    {
        state = Gtk::STATE_SELECTED;
        text_state = (widget.has_focus()) ? Gtk::STATE_SELECTED : Gtk::STATE_ACTIVE;
    }
    else
    {
        state = Gtk::STATE_NORMAL;
        text_state = (widget.is_sensitive()) ? Gtk::STATE_NORMAL : Gtk::STATE_INSENSITIVE;
    }

    // Get cell color
    int r = 0;
    int g = 0;
    int b = 0;

    std::stringstream ss;
    ss << property_text_;
    ss >> r;
    ss >> g;
    ss >> b;

    Gdk::Color color_value;
    color_value.set_rgb_p (r/255.0, g/255.0, b/255.0);

    // Draw color area
    gc->set_rgb_fg_color( color_value );
    window->draw_rectangle(gc, 
            true, 
            cell_area.get_x(), 
            cell_area.get_y(), 
            ColorCellEditable2::get_color_area_width(), 
            cell_area.get_height());

    // Draw color text
    Glib::RefPtr< Gdk::Window > win = Glib::RefPtr<Gdk::Window>::cast_dynamic (window);    
    Glib::RefPtr<Pango::Layout> layout_ptr = widget.create_pango_layout( property_text_ );
    widget.get_style()->paint_layout (win,
          text_state,
          true,
          cell_area,
          widget,
          "cellrenderertext",
          cell_area.get_x() + ColorCellEditable2::get_color_area_width() + x_offset + 2 * property_xpad(),
          cell_area.get_y() + y_offset + 2 * property_ypad(),
          layout_ptr);    
}

virtual Gtk::CellEditable* start_editing_vfunc(GdkEvent* event, Gtk::Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, Gtk::CellRendererState flags);

ColorCellRenderer2::ColorCellRenderer2() :
    Glib::ObjectBase( typeid(ColorCellRenderer2) ),
    Gtk::CellRenderer(),
    property_text_( *this, "text", "" ),
    property_editable_( *this, "editable", true ),
    color_cell_edit_ptr_( 0 ),
    button_width_( -1 )
{
    property_mode() = Gtk::CELL_RENDERER_MODE_EDITABLE;
    property_xpad() = 2;
    property_ypad() = 2;
}

/* override */Gtk::CellEditable* ColorCellRenderer2::start_editing_vfunc(GdkEvent* event, Gtk::Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, Gtk::CellRendererState flags)
{
    // If the cell isn't editable we return 0.
#ifdef GLIBMM_PROPERTIES_ENABLED
  if (!property_editable())
    return 0;
#else
  if (!(g_object_get_data(G_OBJECT(gobj()), "editable")))
    return 0;
#endif

    std::auto_ptr< ColorCellEditable2 > color_cell_edit_ptr( new ColorCellEditable2( path ) );

    Glib::ustring text;

#ifdef GLIBMM_PROPERTIES_ENABLED
    text = property_text();
#else
    get_property("text", text);
#endif

    color_cell_edit_ptr->set_text (text);
    color_cell_edit_ptr->signal_editing_done().connect(sigc::mem_fun(*this, &ColorCellRenderer2::on_editing_done));
    color_cell_edit_ptr->show();

    color_cell_edit_ptr_ = Gtk::manage( color_cell_edit_ptr.release() );
    return color_cell_edit_ptr_;
}

#ifndef COLORCELLRENDERER_H_
#define COLORCELLRENDERER_H_

#include <gdkmm.h>
#include <gtkmm/cellrenderertext.h>

#include "ColorCellEditable2.h"

class ColorCellRenderer : public Gtk::CellRendererText
{
public:
    ColorCellRenderer();
    virtual ~ColorCellRenderer();

protected:
    // The custom CellEditable
    ColorCellEditable2* color_cell_edit_ptr_;

    // Override CellRendererText
    virtual Gtk::CellEditable* start_editing_vfunc(GdkEvent* event, Gtk::Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, Gtk::CellRendererState flags);

    // Override CellRendererText
    void on_editing_done();
};

#endif /*COLORCELLRENDERER_H_*/

ColorCellRenderer::ColorCellRenderer() :
    Glib::ObjectBase( typeid(ColorCellRenderer) ),
    Gtk::CellRendererText(),
    color_cell_edit_ptr_( 0 ) 
{
}

ColorCellRenderer::~ColorCellRenderer()
{
}

#ifndef COLORCELLEDITABLE2_H_
#define COLORCELLEDITABLE2_H_

#include <gtkmm/celleditable.h>
#include <gtkmm/eventbox.h>
#include <gtkmm/box.h>
#include <gdkmm/color.h>
#include <gtkmm/entry.h>
#include <gtkmm/button.h>

class ColorCellEditable2 : public Gtk::EventBox, public Gtk::CellEditable
{
public:
    // Ctor/Dtor
    ColorCellEditable2(const Glib::ustring& path);
    virtual ~ColorCellEditable2();

    // Return creation path
    Glib::ustring get_path() const;

    // Get and set text
    void set_text(const Glib::ustring& text);
    Glib::ustring get_text() const;

    // Signal for editing done
    typedef sigc::signal<void> signal_editing_done_t;
    signal_editing_done_t& signal_editing_done() { return signal_editing_done_; };

protected:
    Glib::ustring path_;
    Gtk::Entry* entry_ptr_;
    Gtk::Button* button_ptr_;
    Gdk::Color color_;
    signal_editing_done_t signal_editing_done_;

    // Override CellEditable
    virtual void start_editing_vfunc(GdkEvent* event);

    // Manage button_clicked signal
    virtual void on_button_clicked();
};

#endif /*COLORCELLEDITABLE2_H_*/

#include "ColorCellEditable2.h"

#include <gtkmm.h>
#include <gtk/gtkentry.h> /* see XXX below */

#include <sstream>

ColorCellEditable2::ColorCellEditable2(const Glib::ustring& path) :
    Glib::ObjectBase( typeid(ColorCellEditable2) ),
    Gtk::EventBox(),
    Gtk::CellEditable(),
    path_( path ),
    entry_ptr_( 0 ),
    button_ptr_( 0 )
{
  Gtk::HBox *const hbox = new Gtk::HBox(false, 0);
  add (*Gtk::manage( hbox ));

  entry_ptr_ = new Gtk::Entry();
  hbox->pack_start (*Gtk::manage(entry_ptr_), Gtk::PACK_EXPAND_WIDGET);
  entry_ptr_->set_has_frame(false);
  entry_ptr_->gobj()->is_cell_renderer = true; // XXX

  button_ptr_ = new Gtk::Button();
  hbox->pack_start (*Gtk::manage( button_ptr_ ), Gtk::PACK_SHRINK);
  button_ptr_->add (*Gtk::manage(new Gtk::Arrow(Gtk::ARROW_DOWN, Gtk::SHADOW_OUT)));

  set_flags(Gtk::CAN_FOCUS);

  show_all_children();
}

ColorCellEditable2::~ColorCellEditable2()
{
}

entry_ptr_->gobj()->is_cell_renderer = true; // XXX

Glib::ustring ColorCellEditable2::get_path() const
{
  return path_;
}

void ColorCellEditable2::set_text(const Glib::ustring& text)
{
    entry_ptr_->set_text (text);

    int r = 0;
    int g = 0;
    int b = 0;

    std::stringstream ss;
    ss << text;
    ss >> r;
    ss >> g;
    ss >> b;

    color_.set_rgb_p (r/255.0, g/255.0, b/255.0);
}

Glib::ustring ColorCellEditable2::get_text() const
{
    std::stringstream ss;
    ss << int(color_.get_red_p() * 255) << " ";
    ss << int(color_.get_green_p() * 255) << " "; 
    ss << int(color_.get_blue_p() * 255);

    return ss.str();
}

void ColorCellEditable2::start_editing_vfunc(GdkEvent*)
{
    entry_ptr_->select_region(0, -1);

    button_ptr_->signal_clicked().connect (sigc::mem_fun( *this, &ColorCellEditable2::on_button_clicked ));
}

void ColorCellEditable2::on_button_clicked()
{
    Gtk::ColorSelectionDialog dialog( "Changing color" );

    dialog.set_transient_for ((Gtk::Window&)(*this->get_toplevel()));

    Gtk::ColorSelection* colorsel = dialog.get_colorsel();
    colorsel->set_previous_color (color_);
    colorsel->set_current_color (color_);
    colorsel->set_has_palette (true);

    if (dialog.run() == Gtk::RESPONSE_OK)
    {
        color_ = colorsel->get_current_color();

        signal_editing_done_.emit();
    }

}

Gtk::CellEditable* ColorCellRenderer::start_editing_vfunc(GdkEvent* event, Gtk::Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, Gtk::CellRendererState flags)
{
// If the cell isn't editable we return 0.
#ifdef GLIBMM_PROPERTIES_ENABLED
  if (!property_editable())
    return 0;
#else
  if (!(g_object_get_data(G_OBJECT(gobj()), "editable")))
    return 0;
#endif

    std::auto_ptr< ColorCellEditable2 > color_cell_edit_ptr( new ColorCellEditable2( path ) );

    Glib::ustring text;

#ifdef GLIBMM_PROPERTIES_ENABLED
    text = property_text();
#else
    get_property("text", text);
#endif

    color_cell_edit_ptr->set_text (text);
    color_cell_edit_ptr->signal_editing_done().connect(sigc::mem_fun(*this, &ColorCellRenderer::on_editing_done));
    color_cell_edit_ptr->show();

    color_cell_edit_ptr_ = Gtk::manage( color_cell_edit_ptr.release() );
    return color_cell_edit_ptr_;
}

void ColorCellRenderer::on_editing_done()
{
    edited (color_cell_edit_ptr_->get_path(), color_cell_edit_ptr_->get_text());
}

//////////////////////////////////////////////////////////////////////////////////////
//
// Primitive
//
//////////////////////////////////////////////////////////////////////////////////////

class Primitive
{
public:
    // Ctor/Dtor
    Primitive() {};
    Primitive(const std::string& value) { text_ = value; };
    virtual ~Primitive() {};

    // Text property
    std::string get_text() const { return text_; };
    void set_text(const std::string& value) { text_ = value; };

    // An operation
    virtual void write() { std::cout << text_ << std::endl; };

protected:
    std::string text_;
};

//////////////////////////////////////////////////////////////////////////////////////
//
// Composite
//
//////////////////////////////////////////////////////////////////////////////////////

class Composite : public Primitive
{
public:
    typedef std::list< Primitive* > list_t;
    typedef list_t::iterator iterator_t;

    // Ctor/Dtor
    Composite() {};
    Composite(const std::string& value) { text_ = value; };
    virtual ~Composite() {};

    // Add child to the composite
    void addChild(Primitive* ptr) { children_.push_back(ptr); };

    // An operation
    virtual void write() 
    { 
        std::cout << "Composite " << text_ << " {" << std::endl;

        for (iterator_t i = children_.begin(); i != children_.end(); i++)
        {
            (*i)->write();
        }

        std::cout << "}" << std::endl;
    };

protected:
    list_t children_;
};

//////////////////////////////////////////////////////////////////////////////////////
//
// Visitor interface
//
//////////////////////////////////////////////////////////////////////////////////////

class Primitive; // Forward declaration
class Composite; // Forward declaration

class Visitor
{
public:
    Visitor() {};
    virtual ~Visitor() {};

    virtual bool visit(Primitive* ptr) = 0;
};

//////////////////////////////////////////////////////////////////////////////////////
//
// Visitor implementation WriteTextVisitor
//
// Simply write text
//
//////////////////////////////////////////////////////////////////////////////////////

class WriteTextVisitor : public Visitor
{
public:
    WriteTextVisitor() {};
    virtual ~WriteTextVisitor() {};

    bool visit(Primitive* ptr);
};

//////////////////////////////////////////////////////////////////////////////////////
//
// Visitor implementation FindTextVisitor
//
// Search for text
//
//////////////////////////////////////////////////////////////////////////////////////

class FindTextVisitor : public Visitor
{
public:
    FindTextVisitor(const std::string& match) :
        match_( match ) {};
    virtual ~FindTextVisitor() {};

    bool visit(Primitive* ptr);

protected:
    std::string match_;
};

//////////////////////////////////////////////////////////////////////////////////////
//
// Primitive
//
//////////////////////////////////////////////////////////////////////////////////////

class Primitive
{
public:
    Primitive() {};
    Primitive(const std::string& value) { text_ = value; };
    virtual ~Primitive() {};

    std::string get_text() const { return text_; };
    void set_text(const std::string& value) { text_ = value; };

    virtual void write() { std::cout << text_ << std::endl; };

    virtual bool accept(Visitor* visitor)
    {
        return visitor->visit (this);
    }

protected:
    std::string text_;
};

//////////////////////////////////////////////////////////////////////////////////////
//
// Composite
//
//////////////////////////////////////////////////////////////////////////////////////

class Composite : public Primitive
{
public:
    typedef std::list< Primitive* > list_t;
    typedef list_t::iterator iterator_t;

    Composite() {};
    Composite(const std::string& value) { text_ = value; };
    virtual ~Composite() {};

    void addChild(Primitive* ptr) { children_.push_back(ptr); };

    virtual void write() 
    { 
        std::cout << "Composite " << text_ << " {" << std::endl;

        for (iterator_t i = children_.begin(); i != children_.end(); i++)
        {
            (*i)->write();
        }

        std::cout << "}" << std::endl;
    };

    virtual bool accept(Visitor* visitor)
    {
        if (!visitor->visit (this))
            return false;

        for (iterator_t i = children_.begin(); i != children_.end(); i++)
        {
            if (!((*i)->accept (visitor)))
                return false;
        }

        return true;
    }

protected:
    list_t children_;
};

//////////////////////////////////////////////////////////////////////////////////////
//
// WriteTextVisitor implementation
//
//////////////////////////////////////////////////////////////////////////////////////

bool WriteTextVisitor::visit(Primitive* ptr)
{
    std::cout << "visit primitive " << ptr->get_text() << std::endl;
    return true; // Continue walk
}

//////////////////////////////////////////////////////////////////////////////////////
//
// FindTextVisitor implementation
//
//////////////////////////////////////////////////////////////////////////////////////

bool FindTextVisitor::visit(Primitive* ptr)
{
    if (ptr->get_text() == match_)
    {
        std::cout << "Found primitive text '" << match_ << "'" << std::endl;
        return false; // Break walk
    }

    return true; // Continue walk
}

        Iterator i = root.create_iterator();
        i.first();
        while (!i.is_done())
        {
            std::cout << "Main loop: " << i.get_current()->get_text() << std::endl;
            i.next();
        }

//////////////////////////////////////////////////////////////////////////////////////
//
// Primitive
//
//////////////////////////////////////////////////////////////////////////////////////

class Primitive
{
public:
    enum component_type
    {
        primitive_e,
        composite_e
    };

    Primitive()
    {};
    Primitive(const std::string& value) 
    { 
        text_ = value; 
    };
    virtual ~Primitive() {};

    virtual component_type get_component_type() const { return primitive_e; };

    std::string get_text() const { return text_; };
    void set_text(const std::string& value) { text_ = value; };

    virtual void write() { std::cout << text_ << std::endl; };

protected:
    std::string text_;
};

//////////////////////////////////////////////////////////////////////////////////////
//
// Composite
//
//////////////////////////////////////////////////////////////////////////////////////

class Iterator; // Forward declaration

class Composite : public Primitive
{
public:
    typedef std::list< Primitive* > list_t;
    typedef list_t::iterator iterator_t;

    Composite()
    {};
    Composite(const std::string& value) 
    { 
        text_ = value; 
    };
    virtual ~Composite() {};

    virtual component_type get_component_type() const { return composite_e; };

    void add_child(Primitive* ptr) { children_.push_back(ptr); };

    iterator_t get_begin() { return children_.begin(); };
    iterator_t get_end() { return children_.end(); };

    virtual void write() 
    { 
        std::cout << "Composite " << text_ << " {" << std::endl;

        for (iterator_t i = children_.begin(); i != children_.end(); i++)
        {
            (*i)->write();
        }

        std::cout << "}" << std::endl;
    };

    Iterator create_iterator();

protected:
    list_t children_;
};

//////////////////////////////////////////////////////////////////////////////////////
//
// Composite implementation
//
//////////////////////////////////////////////////////////////////////////////////////

Iterator Composite::create_iterator()
{
    return Iterator(this);
};

//////////////////////////////////////////////////////////////////////////////////////
//
// MementoState
//
//////////////////////////////////////////////////////////////////////////////////////

class MementoState
{
public:
    typedef Composite::iterator_t iterator_t;

    MementoState(iterator_t itor, iterator_t end_itor) :
        itor_( itor ),
        end_itor_( end_itor )
    {};

    virtual ~MementoState()
    {};

    iterator_t& get_itor() { return itor_; };

    bool is_end() const { return itor_ == end_itor_; };

    void next() { itor_++; };

protected:
    iterator_t itor_;
    iterator_t end_itor_;
};

//////////////////////////////////////////////////////////////////////////////////////
//
// ItorMemento
//
//////////////////////////////////////////////////////////////////////////////////////

class ItorMemento
{
public:
    typedef MementoState item_t;

    ItorMemento() {};
    virtual ~ItorMemento() {};

    void push_state(const item_t& obj) { state_stack_.push (obj); };
    void pop_state() { state_stack_.pop(); };

    item_t& get_state() { return state_stack_.top(); };

    bool empty() const { return state_stack_.empty(); };

    void reset()
    {
        while(!state_stack_.empty()) 
        {
            state_stack_.pop();
        }                    
    }

    MementoState::iterator_t& get_current_itor() { return state_stack_.top().get_itor(); };

    void next() { state_stack_.top().next(); };

protected:
    std::stack< item_t > state_stack_;
};

//////////////////////////////////////////////////////////////////////////////////////
//
// Iterator
//
//////////////////////////////////////////////////////////////////////////////////////

class Iterator
{
public:
    Iterator(Composite* root_ptr) :
        root_ptr_( root_ptr )
    {
    };
    virtual ~Iterator() {};

    void first ()
    {
        itor_memento_.reset();

        if (root_ptr_->get_begin() == root_ptr_->get_end())
        {
            done_ = true;
            return;
        }

        done_ = false;
        itor_memento_.push_state(MementoState(root_ptr_->get_begin(), root_ptr_->get_end()));
    }

    void next()
    {
        if ((*itor_memento_.get_current_itor())->get_component_type() == Primitive::composite_e)
        {
            Composite* comp_ptr = dynamic_cast< Composite* >(*itor_memento_.get_current_itor());
            itor_memento_.push_state(MementoState(comp_ptr->get_begin(), comp_ptr->get_end()));
            return;
        }

        itor_memento_.next();

        while (!itor_memento_.empty() && itor_memento_.get_state().is_end())
        {
            itor_memento_.pop_state();
            if (!itor_memento_.empty())
            {
                itor_memento_.next();
            }
        }

        if (itor_memento_.empty())
        {
            done_ = true;
        }
    }

    Primitive* get_current() { return *itor_memento_.get_current_itor(); };

    bool is_done() { return done_; }

protected:
    ItorMemento itor_memento_;
    Composite* root_ptr_;
    bool done_;
};

Hi folks,

Just an update, I figured out how to render pango layouts with cairo!! :)

here are a few lines of text to demonstrate:

Cairo::RefPtr<Cairo::Context> cr = window->create_cairo_context();
Glib::RefPtr<Pango::Layout> pangoLayout = Pango::Layout::create (cr);
cr->move_to(doublexpos,doubleypos);
pangoLayout->set_text("text");
pangoLayout->update_from_cairo_context(cr);  //gets cairo cursor position
pangoLayout->add_to_cairo_context(cr);       //adds text to cairos stack of stuff to be drawn
cr->stroke();                                //tells Cairo to render it's stack

"[FAMILY-LIST] [STYLE-OPTIONS] [SIZE]"

sans
serif
serif,monospace

Normal: the font is upright.
Oblique: the font is slanted, but in a roman style.
Italic: the font is slanted in an italic style.

Ultra-Light: the ultralight weight (= 200)
Light: the light weight (=300)
Normal: the default weight (= 400)
Bold: the bold weight (= 700)
Ultra-Bold: the ultra-bold weight (= 800)
Heavy: the heavy weight (= 900)

Ultra-Condensed: the smallest width
Extra-Condensed    
Condensed    
Semi-Condensed    
Normal: the normal width
Semi-Expanded    
Expanded    
Extra-Expanded    
Ultra-Expanded: the widest width

fonts:///

    Pango::FontDescription font_descr( "sans bold 8" );
    pango_layout_ref->set_font_description( font_descr);

    double width = x2 - x1;
    pango_layout_ref->set_width (static_cast<int>(width * Pango::SCALE));

    Gdk::Color color("AliceBlue");
    cr->set_source_rgb(color.get_red_p(), color.get_green_p(), color.get_blue_p());

sudo /usr/bin/eclipse

Glib::ustring DomNode::getName() const 
{ 
    if (node_ptr_->name != NULL)
        return reinterpret_cast<const char*>(node_ptr_->name);
    else
        throw NodeError( "Invalid node pointer" );
}

Glib::ustring DomNode::getAttributeValue(const Glib::ustring& name) const
{
    xmlChar* value = xmlGetProp(node_ptr_, BAD_CAST name.c_str());

    if (value == NULL)
    {
        throw NodeError( "Attribute not found '" + name + "'" );
    }
    else
    {
        Glib::ustring ret_value( reinterpret_cast<const char*>(value) );
        xmlFree (value);
        return ret_value;
    }
}

Glib::ustring DomNode::getString() const
{
    xmlChar* value = xmlNodeListGetString(node_ptr_->doc, node_ptr_->xmlChildrenNode, 1);

    if (value == NULL)
    {
        return "";
    }
    else
    {
        Glib::ustring ret_value( reinterpret_cast<const char*>(value) );
        xmlFree (value);
        return ret_value;
    }
}

DomNode DomNode::getNext()
{
    return node_ptr_->next;
}

DomNode DomNode::getChild()
{
    return node_ptr_->children;
}

DomNode XmlDocument::getRootNode()
{
    if (doc_ptr_ == 0)
        throw DocumentError("Can not read root-node, document is NULL");

    xmlNodePtr root_node_ptr = xmlDocGetRootElement(doc_ptr_);

    if (root_node_ptr == 0)
        throw DocumentError("Error reading root element");

    return root_node_ptr;
}

Schema::Schema(const Glib::ustring& schema_uri) :
    schema_parser_ptr_( NULL ),
    schema_ptr_( NULL )
{
    schema_parser_ptr_ = xmlSchemaNewParserCtxt (schema_uri.c_str());
    if (schema_parser_ptr_ == NULL)
    {
        throw SchemaError ( "Unable to create schema parser for " + schema_uri );
    }

    schema_ptr_ = xmlSchemaParse (schema_parser_ptr_);
    if (schema_ptr_ == NULL)
    {
        throw SchemaError ( "Unable to create schema for " + schema_uri );
    }
}

bool Schema::validate(const Glib::ustring& filename)
{
    bool result = false;

    if (xmlSchemaValidCtxtPtr validity_context_ptr = xmlSchemaNewValidCtxt (schema_ptr_)) 
    {
      result = xmlSchemaValidateFile (validity_context_ptr, filename.c_str(), 0) == 0;
      xmlSchemaFreeValidCtxt (validity_context_ptr);
    }    

    return result;
}

Schema::~Schema()
{
    if (schema_ptr_ != NULL)
    {
        xmlSchemaFree (schema_ptr_);;
    }

    if (schema_parser_ptr_ != NULL)
    {
        xmlSchemaFreeParserCtxt (schema_parser_ptr_);
    }
}

void XPath::createContext()
{
    // Create xpath evaluation context
    xpath_ctx_ptr_ = xmlXPathNewContext (doc_ptr_);
    if (xpath_ctx_ptr_ == NULL) 
    {
        throw XPathError( "Unable to create new XPath context" );
    }    
}

void XPath::freeContext()
{
    // Cleanup
    if (xpath_ctx_ptr_ != NULL)
    {
        xmlXPathFreeContext (xpath_ctx_ptr_);
    }
}

void XPath::registerNamespace(const Glib::ustring& prefix, const Glib::ustring& href)
{
    // do register namespace
    if(xmlXPathRegisterNs (xpath_ctx_ptr_, BAD_CAST prefix.c_str(), BAD_CAST href.c_str()) != 0) 
    {
        throw XPathError( "Unable to register NS with prefix=" + prefix + " and href=" + href);
    }    
}

namespace xml
{

DomNodeSet::DomNodeSet(xmlNodeSetPtr node_set_ptr) :
    node_set_ptr_( node_set_ptr )
{
}

DomNodeSet::~DomNodeSet()
{
}

int DomNodeSet::getNodeSize() const
{
    return node_set_ptr_->nodeNr;
}

DomNode DomNodeSet::getNode(int index) const
{
    if (index >= node_set_ptr_->nodeNr)
    {
        throw DomNodeSetError( "Node index out of bound" );
    }

    return DomNode( node_set_ptr_->nodeTab[index] );
}

}

/**
 * @brief Result of XPath query
 */
class XPathResult
{
public:
    /**
     * @brief Constructor
     * 
     * @param xpath_obj_ptr xmlXPathObjectPtr returned from libxml2
     */
    XPathResult(xmlXPathObjectPtr xpath_obj_ptr) :
        xpath_obj_ptr_( xpath_obj_ptr )
    {
    };

    /**
     * @brief Destructor
     * 
     * Free xmlXPathObjectPtr
     */
    virtual ~XPathResult()
    {
        if (xpath_obj_ptr_ != NULL)
        {
            xmlXPathFreeObject (xpath_obj_ptr_);
        }
    };

    /**
     * @brief Test for nodes array existence
     * 
     * @return true if the nodes array is not null
     */
    bool hasNodeSet() const
    {
        return xpath_obj_ptr_->nodesetval != NULL;
    };

    /**
     * @brief Nodes array
     * 
     * @return the nodes array
     */
    DomNodeSet getNodeSet()
    {
        return xpath_obj_ptr_->nodesetval;
    };

protected:
    xmlXPathObjectPtr xpath_obj_ptr_;
};

XPathResult XPath::evalExpression(const Glib::ustring& expr)
{
    // Evaluate xpath expression
    xmlXPathObjectPtr xpath_obj_ptr = xmlXPathEvalExpression (BAD_CAST expr.c_str(), xpath_ctx_ptr_);
    if(xpath_obj_ptr == NULL) 
    {
        throw XPathError( "Unable to evaluate xpath expression " + expr);
    }

    return XPathResult( xpath_obj_ptr );    
}

void TextWriter::open(const Glib::ustring& file_name, bool compression/* =false */)
{
    writer_ = xmlNewTextWriterFilename(file_name.c_str(), compression ? 1 : 0);

    if (writer_ == NULL) 
        throw WriterError( "(libxml) Error creating the xml writer" );
}

void TextWriter::free()
{
    if (writer_ != NULL)
    {
        xmlFreeTextWriter(writer_);
        writer_ = NULL;
    }
}

void TextWriter::setIndent(bool value)
{
    if (writer_ == NULL) 
        throw WriterError( "Invalid writer" );

    int rc = xmlTextWriterSetIndent (writer_, value ? 1 : 0);

    if (rc < 0) 
        throw WriterError( "(libxml) Error at setIndent" );

    indent_ = true;
}

<?xml version="1.0" encoding="ISO-8859-1"?>

void TextWriter::startDocument(const Glib::ustring& version, const Glib::ustring& encoding)
{
    if (writer_ == NULL) 
        throw WriterError( "Invalid writer" );

    int rc = xmlTextWriterStartDocument(writer_, version.c_str(), encoding.c_str(), NULL);

    if (rc < 0) 
        throw WriterError( "(libxml) Error at startDocument" );

    encoding_ = encoding;
}

void TextWriter::endDocument()
{
    if (writer_ == NULL) 
        throw WriterError( "Invalid writer" );

    int rc = xmlTextWriterEndDocument(writer_);

    if (rc < 0) 
         throw WriterError( "(libxml) Error at endDocument" );
}

void TextWriter::startElement(const Glib::ustring& name)
{
    if (writer_ == NULL) 
        throw WriterError( "Invalid writer" );

    int rc = xmlTextWriterStartElement (writer_, BAD_CAST name.c_str());

    if (rc < 0) 
         throw WriterError( "(libxml) Error at startElement" );
}

void TextWriter::startElement(const Glib::ustring& name, const Glib::ustring& prefix)
{
    if (writer_ == NULL) 
        throw WriterError( "Invalid writer" );

    int rc = xmlTextWriterStartElementNS (writer_, 
                                        BAD_CAST prefix.c_str(), 
                                        BAD_CAST name.c_str(), 
                                        NULL);

    if (rc < 0) 
         throw WriterError( "(libxml) Error at startElement" );    
}

void TextWriter::startElement(const Glib::ustring& name, const Glib::ustring& prefix, const Glib::ustring& namespaceURI)
{
    if (writer_ == NULL) 
        throw WriterError( "Invalid writer" );

    int rc = xmlTextWriterStartElementNS (writer_, 
                                        BAD_CAST prefix.c_str(), 
                                        BAD_CAST name.c_str(), 
                                        BAD_CAST namespaceURI.c_str());

    if (rc < 0) 
         throw WriterError( "(libxml) Error at startElement" );    
}

void TextWriter::endElement()
{
    if (writer_ == NULL) 
        throw WriterError( "Invalid writer" );

    int rc = xmlTextWriterEndElement (writer_);

    if (rc < 0) 
         throw WriterError( "(libxml) Error at endElement" );
}

void TextWriter::writeAttribute(const Glib::ustring& name, const Glib::ustring& value)
{
    if (writer_ == NULL) 
        throw WriterError( "Invalid writer" );

    int rc = xmlTextWriterWriteAttribute (writer_, 
                                        BAD_CAST name.c_str(),
                                        BAD_CAST value.c_str());

    if (rc < 0) 
         throw WriterError( "(libxml) Error at endElement" );
}

void TextWriter::writeAttribute(const Glib::ustring& name, const Glib::ustring& value, const Glib::ustring& prefix)
{
    if (writer_ == NULL) 
        throw WriterError( "Invalid writer" );

    int rc = xmlTextWriterWriteAttributeNS (writer_,
                                            BAD_CAST prefix.c_str(),
                                            BAD_CAST name.c_str(),
                                            NULL,
                                            BAD_CAST value.c_str());

    if (rc < 0) 
         throw WriterError( "(libxml) Error at endElement" );
}

void TextWriter::writeAttribute(const Glib::ustring& name, const Glib::ustring& value, const Glib::ustring& prefix, const Glib::ustring& namespaceURI)
{
    if (writer_ == NULL) 
        throw WriterError( "Invalid writer" );

    int rc = xmlTextWriterWriteAttributeNS (writer_,
                                            BAD_CAST prefix.c_str(),
                                            BAD_CAST name.c_str(),
                                            BAD_CAST namespaceURI.c_str(),
                                            BAD_CAST value.c_str());

    if (rc < 0) 
         throw WriterError( "(libxml) Error at endElement" );
}

void TextWriter::writeString(const Glib::ustring& text)
{
    if (writer_ == NULL) 
        throw WriterError( "Invalid writer" );

    int rc = xmlTextWriterWriteString(writer_, BAD_CAST text.c_str());

    if (rc < 0) 
         throw WriterError( "(libxml) Error at writeString" );    
}

sudo xdg-icon-resource install --context mimetypes --size 48 /home/user/Pictures/ggredit/48x48/ggredit-file-type.png x-application-ggr-diagram

<?xml version="1.0"?>
<mime-info xmlns='http://www.freedesktop.org/standards/shared-mime-info'>
  <mime-type type="application/x-ggr-diagram">

    <comment>GGR diagram</comment>
    <comment xml:lang="it">Diagramma GGR</comment>

    <sub-class-of type="application/xml"/>

    <magic priority="80">
      <match type="string" offset="0:100" value="&lt;ggr:document"/>
    </magic>

    <glob pattern="*.ggr"/>

  </mime-type>
</mime-info>

sudo xdg-mime install ggredit-mime.xml

    Gtk::FileChooserDialog dialog(_("Choose file"),
        Gtk::FILE_CHOOSER_ACTION_OPEN);

    dialog.set_transient_for(*this);

    //Add response buttons the the dialog:
    dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
    dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);

    //Add filters, so that only certain file types can be selected:

    Gtk::FileFilter filter_text;
    filter_text.set_name("GGR Diagram");
    filter_text.add_mime_type("application/x-ggr-diagram");
    dialog.add_filter(filter_text);

    Gtk::FileFilter filter_any;
    filter_any.set_name("Any files");
    filter_any.add_pattern("*");
    dialog.add_filter(filter_any);

    //Show the dialog and wait for a user response:
    int result = dialog.run();

    //Handle the response:
    switch(result)
    {
        case(Gtk::RESPONSE_OK):
        {
            std::string filename = dialog.get_filename();

            try
            {
                // Load document...
            }
            catch (std::exception& e)
            {
                std::cerr << "Exception loading file: " << e.what() << std::endl;
            }
            break;
        }
        case(Gtk::RESPONSE_CANCEL):
        {
            break;
        }
        default:
        {
            break;
        }
    }

    Cairo::Matrix matrix_perspective;
    cairo_matrix_init (&matrix_perspective,
        scale_x, rotate_y,
        rotate_x, scale_y,
        translate_x, translate_y);

    // Set matrix for perspective
    Cairo::Matrix matrix_perspective;
    cairo_matrix_init (&matrix_perspective,
        0.5, 0.25,
        0.0, 1.0,
        0.0, 0.0);
    context->transform (matrix_perspective);

    // Draw the source image
    context->set_source (image_surface_ptr_, 0.0, 0.0);
    context->rectangle (0.0, 0.0, image_ptr_->get_width(), image_ptr_->get_height());
    context->fill();

    // Set matrix for reflection
    Cairo::Matrix matrix_reflex;
    cairo_matrix_init (&matrix_reflex,
        0.5, 0.25,
        0.0, -1.0,
        0.0, image_ptr_->get_height() * 2);    
    context->transform (matrix_reflex);

    // Set matrix for reflection
    Cairo::Matrix matrix_reflex;
    cairo_matrix_init (&matrix_reflex,
        0.5, 0.25,
        0.0, -1.0,
        0.0, image_ptr_->get_height() * 2);    
    context->transform (matrix_reflex);

    // Prepare mask
    Gdk::Color shadow_color( "black" );

    Cairo::RefPtr< Cairo::LinearGradient > mask_gradient_ptr = Cairo::LinearGradient::create (
        image_ptr_->get_width() / 2, image_ptr_->get_height() / 2, 
        image_ptr_->get_width() / 2, image_ptr_->get_height());

    mask_gradient_ptr->add_color_stop_rgba (0, 
            shadow_color.get_red_p(), shadow_color.get_green_p(), shadow_color.get_blue_p(), 0.0);

    mask_gradient_ptr->add_color_stop_rgba (1, 
            shadow_color.get_red_p(), shadow_color.get_green_p(), shadow_color.get_blue_p(), 0.5);

    // Draw the reflex
    context->set_source (image_surface_ptr_, 0.0, 0.0);
    context->mask (mask_gradient_ptr);

    context->save();

    context->translate (x + (width / 2.0), y + (height / 2.0));
    context->scale (width / 2.0, height / 2.0);    

    context->arc(0.0, 0.0, 1.0, 0.0, 2 * M_PI);

    context->restore

    double width = x1 - x0;
    double height = y1 - y0;

    Gdk::Color bk_start_color( "blue" );
    Gdk::Color bk_end_color( "midnight blue" );
    Gdk::Color dark_shadow_color( "black" );
    Gdk::Color light_color( "white" );

    // Store context
    context->save();

    // Update transformation matrix for draw an ellipse in the box
    context->translate (x0 + (width / 2.0), y0 + (height / 2.0));
    context->scale (width / 2.0, height / 2.0);

    // Ball background
    Cairo::RefPtr< Cairo::LinearGradient > bk_gradient_ptr = Cairo::LinearGradient::create (
        0.0, -1.0, 0.0, 1.0);

    bk_gradient_ptr->add_color_stop_rgb (0, 
            bk_start_color.get_red_p(), bk_start_color.get_green_p(), bk_start_color.get_blue_p());

    bk_gradient_ptr->add_color_stop_rgb (1, 
            bk_end_color.get_red_p(), bk_end_color.get_green_p(), bk_end_color.get_blue_p());

    context->set_source (bk_gradient_ptr);
    context->arc(0.0, 0.0, 1.0, 0.0, 2 * M_PI);
    context->fill();

    // Dark shadow
    Cairo::RefPtr< Cairo::RadialGradient > shadow_gradient_ptr = Cairo::RadialGradient::create (
            0.0, 0.0, .6,  0.0, 0.0, 1.0);    

    shadow_gradient_ptr->add_color_stop_rgba (0, 
            dark_shadow_color.get_red_p(), dark_shadow_color.get_green_p(), dark_shadow_color.get_blue_p(), 0);

    shadow_gradient_ptr->add_color_stop_rgba (1, 
            dark_shadow_color.get_red_p(), dark_shadow_color.get_green_p(), dark_shadow_color.get_blue_p(), .5);

    context->set_source (shadow_gradient_ptr);

    context->arc (0.0, 0.0, 1.0, 0.0, 2 * M_PI);

    context->fill();

    // Light
    context->save();
    context->translate (0.0, -0.4);
    context->scale (0.6, 0.4);

    Cairo::RefPtr< Cairo::LinearGradient > light_gradient_ptr = Cairo::LinearGradient::create (
        0.0, -1, 0.0, 0.5);

    light_gradient_ptr->add_color_stop_rgba (0, 
            light_color.get_red_p(), light_color.get_green_p(), light_color.get_blue_p(), 0.9);

    light_gradient_ptr->add_color_stop_rgba (0.2, 
            light_color.get_red_p(), light_color.get_green_p(), light_color.get_blue_p(), 0.4);

    light_gradient_ptr->add_color_stop_rgba (1, 
            light_color.get_red_p(), light_color.get_green_p(), light_color.get_blue_p(), 0.0);

    context->set_source (light_gradient_ptr);

    context->arc(0.0, 0.0, 1.0, 0.0, 2 * M_PI);

    context->fill();

    context->restore();

You can download the complete Eclipse project with sources here.
    // Create the context for the widget
    Cairo::RefPtr<Cairo::Context> context = get_window()->create_cairo_context();

    ...

    // Rectangle
    double x0 = 0.0;
    double y0 = 0.0;
    double x1 = 100.0;
    double y1 = 100.0;

    // Colors
    Gdk::Color start_color( "blue" );
    Gdk::Color end_color( "midnight blue" );

    // Create the linear gradient diagonal
    Cairo::RefPtr< Cairo::LinearGradient > background_gradient_ptr = Cairo::LinearGradient::create (
        x0, y0, x1, y1);

    // Set grandient colors
    background_gradient_ptr->add_color_stop_rgb (0, 
            start_color.get_red_p(), start_color.get_green_p(), start_color.get_blue_p());

    background_gradient_ptr->add_color_stop_rgb (1, 
            end_color.get_red_p(), end_color.get_green_p(), end_color.get_blue_p());

    // Draw a rectangle and fill with gradient
    context->set_source (background_gradient_ptr);

    context->rectangle (x0, y0, x1, y1);

    context->fill();

/**
 * This is the documentation
 */
/**
 * @brief One line documentation 
 *
 * A more detailed documentation
 *
 * @param arg1 the first function argument
 * @param arg2 the second function argument
 *
 * @return descrition for the function return value
 */
/** Signals */
/*\@{*/
signal_update_cursor_t signalUpdateCursor();
/*\@}*/
/* @see MyClass::myMethod
/* @see http://kapo-cpp.blogspot.com/

tar xzf eclipse-cpp-europa-fall2-linux-gtk.tar.gz
sudo mv eclipse /opt/eclipse
cd /opt/
sudo chown -R root:root eclipse
sudo chmod -R +r eclipse
sudo chmod +x `sudo find eclipse -type d`

sudo touch /usr/bin/eclipse
sudo chmod 755 /usr/bin/eclipse
sudo gedit /usr/bin/eclipse 

#!/bin/sh
#export MOZILLA_FIVE_HOME="/usr/lib/mozilla/"
export ECLIPSE_HOME="/opt/eclipse"

$ECLIPSE_HOME/eclipse $*

sudo gedit /usr/share/applications/eclipse.desktop

[Desktop Entry]
Encoding=UTF-8
Name=Eclipse
Comment=Eclipse IDE
Exec=eclipse
Icon=/opt/eclipse/icon.xpm
Terminal=false
Type=Application
Categories=GNOME;Application;Development;
StartupNotify=true

#include <gtkmm.h>
#include <iostream>

void button_clicked()
{
    std::cout << "Hello World!" << std::endl;
}

int main(int argc, char *argv[])
{
    Gtk::Main kit(argc, argv);

    Gtk::Window main_window;

    Gtk::Button button( "Click here" );

    main_window.set_title( "Eclipse/GTKmm Demo" );

    main_window.set_border_width( 4 );
    main_window.set_default_size( 200, 50 );

    main_window.add( button );
    button.show();

    button.signal_clicked().connect( sigc::ptr_fun(button_clicked) );

    Gtk::Main::run( main_window );

    return 0;
}

`pkg-config --libs gtkmm-2.4`

#include <gdkmm/general.h>

#ifndef IMAGEAREA_H_
#define IMAGEAREA_H_

#include <gtkmm/drawingarea.h>

#include <gdkmm/pixbuf.h>
#include <glibmm/refptr.h>
#include <cairomm/surface.h>

class ImageArea : public Gtk::DrawingArea
{
public:
    ImageArea();
    virtual ~ImageArea();

    bool loadFile(const Glib::ustring& file_name);

protected:
    Cairo::RefPtr< Cairo::Context > image_context_ptr_;
    Cairo::RefPtr< Cairo::ImageSurface > image_surface_ptr_;
    Glib::RefPtr< Gdk::Pixbuf > image_ptr_;
    bool loaded_;

    //Override default signal handler:
    virtual bool on_expose_event(GdkEventExpose* event);    
};

#endif /*IMAGEAREA_H_*/

bool ImageArea::loadFile(const Glib::ustring& file_name)
{
    // Load pixbuf
    image_ptr_ = Gdk::Pixbuf::create_from_file (file_name);

    // Detect transparent colors for loaded image
    Cairo::Format format = Cairo::FORMAT_RGB24;
    if (image_ptr_->get_has_alpha())
    {
        format = Cairo::FORMAT_ARGB32;
    }

    // Create a new ImageSurface
    image_surface_ptr_ = Cairo::ImageSurface::create  (format, image_ptr_->get_width(), image_ptr_->get_height());

    // Create the new Context for the ImageSurface
    image_context_ptr_ = Cairo::Context::create (image_surface_ptr_);

    // Draw the image on the new Context
    Gdk::Cairo::set_source_pixbuf (image_context_ptr_, image_ptr_, 0.0, 0.0);
    image_context_ptr_->paint();

    loaded_ = true;

    return true;
}

bool ImageArea::on_expose_event(GdkEventExpose* event)
{
    if (!loaded_)
        return true;

    // Create the context for the widget
    Cairo::RefPtr<Cairo::Context> context = get_window()->create_cairo_context();

    // Select the clipping rectangle
    context->rectangle(event->area.x, event->area.y,
        event->area.width, event->area.height);

    context->clip();

    // Store context
    context->save();

    // Draw the source image on the widget context
    context->set_source (image_surface_ptr_, 0.0, 0.0);
    context->rectangle (0.0, 0.0, image_ptr_->get_width(), image_ptr_->get_height());
    context->clip();
    context->paint();

    // Restore context
    context->restore();

    return true;
}

Kapo C++

Remove folder contents based on folder name

[DRAFT] Using Gtkmm on Windows with Eclipse CDT

Prepare the environment

Java runtime

Eclipse CDT

MinGW

Prototipo per Ubucompilator

Cheap multitouch

Intelligent connectors

Sta arrivando Dia 0.97

DDraw and GGredit 0.0.2 alpha release

Drawing regular polygons on Cairo

The Ellipse

Polygons

GGredit web site is up

GGredit Demo

Inheriting from Gtk::CellRendererCombo

The editing_started signal

Drawing arrows with Cairo

Basics

Effective arrow object

The prizes

Recents management with gtkmm

Add a file to recents

Display the recents menu

Beautify

Conclusion

And the winner is...me???

Data compression with ZLib

Initialization

Read and write data

Fixing my Base64 functions

Noi alfisti di oggi

LibXml2 and Schema validation performance

Finally Ganymede

Width CDT 5.0, the best c++ IDE on Linux

Uninstall previous version

Install Ganymede

Running Eclipse

Features

Spell checking

Doxygen integration

Refactoring

Generate Getter and Setters

Hide Method

Implement Method

Extract Constant

Extract Function

Uninstall Eclipse

Install Eclipse Ganymede RC2 (with CDT 5.0)

Using Eclipse

Spell check

Refactoring

Autotools

Resize a Pixbuf

Base64

Raw Pixbuf image data

Different CellRenderers on the same Column

How to breach a contract without pay

Custom CellRenderer links

Custom CellRenderer

Compute cell size

Cell rendering

Cell editing

Create a custom CellEditable for a CellRenderer

Iterate over a Composite

ggredit splash

Render text with Pango on Cairo

CDT 4.0.3 is available for download

Working with XML on linux

ggredit breaking news

Register your own MIME type on a free desktop

ggredit MIME icon

Perspective effect using cairo

GGredit on SourceForge

Draw a Mac-Ball using Cairo

Gradients in cairo

Documenting the code (using Doxygen)

Using Eclipse for your gtkmm project (new version)