C++ify EekPreview

6 files changed, 376 insertions, 639 deletions

diff --git a/src/ui/dialog/color-item.cpp b/src/ui/dialog/color-item.cpp
index 8c55747f0..d5d254e5d 100644
--- a/src/ui/dialog/color-item.cpp
+++ b/src/ui/dialog/color-item.cpp
@@ -94,43 +94,38 @@ static bool bruteForce( SPDocument* document, Inkscape::XML::Node* node, Glib::u
 }
 #endif // ENABLE_MAGIC_COLORS
 
-static void handleClick( GtkWidget* /*widget*/, gpointer callback_data ) {
-    ColorItem* item = reinterpret_cast<ColorItem*>(callback_data);
-    if ( item ) {
-        item->buttonClicked(false);
-    }
+void
+ColorItem::handleClick() {
+    buttonClicked(false);
 }
 
-static void handleSecondaryClick( GtkWidget* /*widget*/, gint /*arg1*/, gpointer callback_data ) {
-    ColorItem* item = reinterpret_cast<ColorItem*>(callback_data);
-    if ( item ) {
-        item->buttonClicked(true);
-    }
+void
+ColorItem::handleSecondaryClick(gint /*arg1*/) {
+    buttonClicked(true);
 }
 
-static gboolean handleEnterNotify( GtkWidget* /*widget*/, GdkEventCrossing* /*event*/, gpointer callback_data ) {
-    ColorItem* item = reinterpret_cast<ColorItem*>(callback_data);
-    if ( item ) {
-        SPDesktop *desktop = SP_ACTIVE_DESKTOP;
-        if ( desktop ) {
-            gchar* msg = g_strdup_printf(_("Color: <b>%s</b>; <b>Click</b> to set fill, <b>Shift+click</b> to set stroke"),
-                                         item->def.descr.c_str());
-            desktop->tipsMessageContext()->set(Inkscape::INFORMATION_MESSAGE, msg);
-            g_free(msg);
-        }
+bool
+ColorItem::handleEnterNotify(GdkEventCrossing* /*event*/) {
+    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+    if ( desktop ) {
+        gchar* msg = g_strdup_printf(_("Color: <b>%s</b>; <b>Click</b> to set fill, <b>Shift+click</b> to set stroke"),
+                def.descr.c_str());
+        desktop->tipsMessageContext()->set(Inkscape::INFORMATION_MESSAGE, msg);
+        g_free(msg);
     }
-    return FALSE;
+
+    return false;
 }
 
-static gboolean handleLeaveNotify( GtkWidget* /*widget*/, GdkEventCrossing* /*event*/, gpointer callback_data ) {
-    ColorItem* item = reinterpret_cast<ColorItem*>(callback_data);
-    if ( item ) {
-        SPDesktop *desktop = SP_ACTIVE_DESKTOP;
-        if ( desktop ) {
-            desktop->tipsMessageContext()->clear();
-        }
+bool
+ColorItem::handleLeaveNotify(GdkEventCrossing* /*event*/) {
+    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+
+    if ( desktop ) {
+        desktop->tipsMessageContext()->clear();
     }
-    return FALSE;
+
+    return false;
 }
 
 static void dieDieDie( GObject *obj, gpointer user_data )
@@ -183,54 +178,48 @@ static bool popVal( guint64& numVal, std::string& str )
 }
 
 // TODO resolve this more cleanly:
-extern gboolean colorItemHandleButtonPress( GtkWidget* /*widget*/, GdkEventButton* event, gpointer user_data);
+extern bool colorItemHandleButtonPress(GdkEventButton* event, EekPreview *preview, gpointer user_data);
 
-static void colorItemDragBegin( GtkWidget */*widget*/, GdkDragContext* dc, gpointer data )
+void
+ColorItem::drag_begin(const Glib::RefPtr<Gdk::DragContext> &dc)
 {
-    ColorItem* item = reinterpret_cast<ColorItem*>(data);
-    if ( item )
-    {
-        using Inkscape::IO::Resource::get_path;
-        using Inkscape::IO::Resource::PIXMAPS;
-        using Inkscape::IO::Resource::SYSTEM;
-        int width = 32;
-        int height = 24;
-
-        if (item->def.getType() != ege::PaintDef::RGB){
-            GError *error = nullptr;
-            gsize bytesRead = 0;
-            gsize bytesWritten = 0;
-            gchar *localFilename = g_filename_from_utf8(get_path(SYSTEM, PIXMAPS, "remove-color.png"), -1, &bytesRead,
-                                                        &bytesWritten, &error);
-            GdkPixbuf* pixbuf = gdk_pixbuf_new_from_file_at_scale(localFilename, width, height, FALSE, &error);
-            g_free(localFilename);
-            gtk_drag_set_icon_pixbuf( dc, pixbuf, 0, 0 );
+    using Inkscape::IO::Resource::get_path;
+    using Inkscape::IO::Resource::PIXMAPS;
+    using Inkscape::IO::Resource::SYSTEM;
+    int width = 32;
+    int height = 24;
+
+    if (def.getType() != ege::PaintDef::RGB){
+        GError *error;
+        gsize bytesRead = 0;
+        gsize bytesWritten = 0;
+        gchar *localFilename = g_filename_from_utf8(get_path(SYSTEM, PIXMAPS, "remove-color.png"), -1, &bytesRead,
+                &bytesWritten, &error);
+        auto pixbuf = Gdk::Pixbuf::create_from_file(localFilename, width, height, false);
+        g_free(localFilename);
+        dc->set_icon(pixbuf, 0, 0);
+    } else {
+        Glib::RefPtr<Gdk::Pixbuf> pixbuf;
+        if (getGradient() ){
+            cairo_surface_t *s = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
+            cairo_pattern_t *gradient = getGradient()->create_preview_pattern(width);
+            cairo_t *ct = cairo_create(s);
+            cairo_set_source(ct, gradient);
+            cairo_paint(ct);
+            cairo_destroy(ct);
+            cairo_pattern_destroy(gradient);
+            cairo_surface_flush(s);
+
+            pixbuf = Glib::wrap(ink_pixbuf_create_from_cairo_surface(s));
         } else {
-            GdkPixbuf* pixbuf = nullptr;
-            if ( item->getGradient() ){
-                cairo_surface_t *s = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
-                cairo_pattern_t *gradient = item->getGradient()->create_preview_pattern(width);
-                cairo_t *ct = cairo_create(s);
-                cairo_set_source(ct, gradient);
-                cairo_paint(ct);
-                cairo_destroy(ct);
-                cairo_pattern_destroy(gradient);
-                cairo_surface_flush(s);
-
-                pixbuf = ink_pixbuf_create_from_cairo_surface(s);
-            } else {
-                Glib::RefPtr<Gdk::Pixbuf> thumb = Gdk::Pixbuf::create( Gdk::COLORSPACE_RGB, false, 8, width, height );
-                guint32 fillWith = (0xff000000 & (item->def.getR() << 24))
-                    | (0x00ff0000 & (item->def.getG() << 16))
-                    | (0x0000ff00 & (item->def.getB() <<  8));
-                thumb->fill( fillWith );
-                pixbuf = thumb->gobj();
-                g_object_ref(G_OBJECT(pixbuf));
-            }
-            gtk_drag_set_icon_pixbuf( dc, pixbuf, 0, 0 );
+            pixbuf = Gdk::Pixbuf::create( Gdk::COLORSPACE_RGB, false, 8, width, height );
+            guint32 fillWith = (0xff000000 & (def.getR() << 24))
+                | (0x00ff0000 & (def.getG() << 16))
+                | (0x0000ff00 & (def.getB() <<  8));
+            pixbuf->fill( fillWith );
         }
+        dc->set_icon(pixbuf, 0, 0);
     }
-
 }
 
 //"drag-drop"
@@ -317,12 +306,11 @@ void ColorItem::setState( bool fill, bool stroke )
         _isFill = fill;
         _isStroke = stroke;
 
-        for ( std::vector<Gtk::Widget*>::iterator it = _previews.begin(); it != _previews.end(); ++it ) {
-            Gtk::Widget* widget = *it;
-            if ( EEK_IS_PREVIEW(widget->gobj()) ) {
-                EekPreview * preview = EEK_PREVIEW(widget->gobj());
+        for ( auto widget : _previews ) {
+            auto preview = dynamic_cast<EekPreview *>(widget);
 
-                int val = eek_preview_get_linked( preview );
+            if (preview) {
+                int val = preview->get_linked();
                 val &= ~(PREVIEW_FILL | PREVIEW_STROKE);
                 if ( _isFill ) {
                     val |= PREVIEW_FILL;
@@ -330,7 +318,7 @@ void ColorItem::setState( bool fill, bool stroke )
                 if ( _isStroke ) {
                     val |= PREVIEW_STROKE;
                 }
-                eek_preview_set_linked( preview, static_cast<LinkType>(val) );
+                preview->set_linked(static_cast<LinkType>(val));
             }
         }
     }
@@ -350,13 +338,14 @@ void ColorItem::setName(const Glib::ustring name)
 {
     //def.descr = name;
 
-    for ( std::vector<Gtk::Widget*>::iterator it = _previews.begin(); it != _previews.end(); ++it ) {
-        Gtk::Widget* widget = *it;
-        if ( EEK_IS_PREVIEW(widget->gobj()) ) {
-            gtk_widget_set_tooltip_text(GTK_WIDGET(widget->gobj()), name.c_str());
+    for (auto widget : _previews) {
+        auto preview = dynamic_cast<EekPreview *>(widget);
+        auto label = dynamic_cast<Gtk::Label *>(widget);
+        if (preview) {
+            preview->set_tooltip_text(name);
         }
-        else if ( GTK_IS_LABEL(widget->gobj()) ) {
-            gtk_label_set_text(GTK_LABEL(widget->gobj()), name.c_str());
+        else if (label) {
+            label->set_text(name);
         }
     }
 }
@@ -374,14 +363,12 @@ void ColorItem::setPattern(cairo_pattern_t *pattern)
     _updatePreviews();
 }
 
-void ColorItem::_dragGetColorData( GtkWidget */*widget*/,
-                                   GdkDragContext */*drag_context*/,
-                                   GtkSelectionData *data,
-                                   guint info,
-                                   guint /*time*/,
-                                   gpointer user_data)
+void
+ColorItem::_dragGetColorData(const Glib::RefPtr<Gdk::DragContext>& /*drag_context*/,
+                             Gtk::SelectionData                     &data,
+                             guint                                   info,
+                             guint                                 /*time*/)
 {
-    ColorItem* item = reinterpret_cast<ColorItem*>(user_data);
     std::string key;
     if ( info < mimeStrings.size() ) {
         key = mimeStrings[info];
@@ -393,10 +380,9 @@ void ColorItem::_dragGetColorData( GtkWidget */*widget*/,
         char* tmp = nullptr;
         int len = 0;
         int format = 0;
-        item->def.getMIMEData(key, tmp, len, format);
+        def.getMIMEData(key, tmp, len, format);
         if ( tmp ) {
-            GdkAtom dataAtom = gdk_atom_intern( key.c_str(), FALSE );
-            gtk_selection_data_set( data, dataAtom, format, (guchar*)tmp, len );
+            data.set(key, format, (guchar*)tmp, len );
             delete[] tmp;
         }
     }
@@ -422,14 +408,11 @@ void ColorItem::_colorDefChanged(void* data)
 
 void ColorItem::_updatePreviews()
 {
-    for ( std::vector<Gtk::Widget*>::iterator it =  _previews.begin(); it != _previews.end(); ++it ) {
-        Gtk::Widget* widget = *it;
-        if ( EEK_IS_PREVIEW(widget->gobj()) ) {
-            EekPreview * preview = EEK_PREVIEW(widget->gobj());
-
+    for (auto widget : _previews) {
+        auto preview = dynamic_cast<EekPreview *>(widget);
+        if (preview) {
             _regenPreview(preview);
-
-            widget->queue_draw();
+            preview->queue_draw();
         }
     }
 
@@ -508,19 +491,18 @@ void ColorItem::_regenPreview(EekPreview * preview)
         gsize bytesWritten = 0;
         gchar *localFilename =
             g_filename_from_utf8(get_path(SYSTEM, PIXMAPS, "remove-color.png"), -1, &bytesRead, &bytesWritten, &error);
-        GdkPixbuf* pixbuf = gdk_pixbuf_new_from_file(localFilename, &error);
+        auto pixbuf = Gdk::Pixbuf::create_from_file(localFilename);
         if (!pixbuf) {
             g_warning("Null pixbuf for %p [%s]", localFilename, localFilename );
         }
         g_free(localFilename);
 
-        eek_preview_set_pixbuf( preview, pixbuf );
+        preview->set_pixbuf(pixbuf);
     }
     else if ( !_pattern ){
-        eek_preview_set_color( preview,
-                               (def.getR() << 8) | def.getR(),
-                               (def.getG() << 8) | def.getG(),
-                               (def.getB() << 8) | def.getB() );
+        preview->set_color((def.getR() << 8) | def.getR(),
+                           (def.getG() << 8) | def.getG(),
+                           (def.getB() << 8) | def.getB() );
     } else {
         // These correspond to PREVIEW_PIXBUF_WIDTH and VBLOCK from swatches.cpp
         // TODO: the pattern to draw should be in the widget that draws the preview,
@@ -535,13 +517,13 @@ void ColorItem::_regenPreview(EekPreview * preview)
         cairo_destroy(ct);
         cairo_surface_flush(s);
 
-        GdkPixbuf* pixbuf = ink_pixbuf_create_from_cairo_surface(s);
-        eek_preview_set_pixbuf( preview, pixbuf );
+        auto pixbuf = Glib::wrap(ink_pixbuf_create_from_cairo_surface(s));
+        preview->set_pixbuf(pixbuf);
     }
 
-    eek_preview_set_linked( preview, (LinkType)((_linkSrc ? PREVIEW_LINK_IN:0)
-                                                | (_listeners.empty() ? 0:PREVIEW_LINK_OUT)
-                                                | (_isLive ? PREVIEW_LINK_OTHER:0)) );
+    preview->set_linked((LinkType)((_linkSrc ? PREVIEW_LINK_IN:0)
+                                  | (_listeners.empty() ? 0:PREVIEW_LINK_OUT)
+                                  | (_isLive ? PREVIEW_LINK_OTHER:0)) );
 }
 
 Gtk::Widget* ColorItem::getPreview(PreviewStyle style, ViewType view, ::PreviewSize size, guint ratio, guint border)
@@ -553,91 +535,51 @@ Gtk::Widget* ColorItem::getPreview(PreviewStyle style, ViewType view, ::PreviewS
         lbl->set_valign(Gtk::ALIGN_CENTER);
         widget = lbl;
     } else {
-        GtkWidget* eekWidget = eek_preview_new();
-        gtk_widget_set_name( eekWidget, "ColorItemPreview" );
+        auto preview = Gtk::manage(new EekPreview());
+        preview->set_name("ColorItemPreview");
 
-        EekPreview * preview = EEK_PREVIEW(eekWidget);
-        Gtk::Widget* newBlot = Glib::wrap(eekWidget);
         _regenPreview(preview);
 
-        eek_preview_set_details( preview, 
-                                 (::ViewType)view,
-                                 (::PreviewSize)size,
-                                 ratio,
-                                 border );
+        preview->set_details((::ViewType)view,
+                             (::PreviewSize)size,
+                             ratio,
+                             border );
 
         def.addCallback( _colorDefChanged, this );
-        eek_preview_set_focus_on_click(preview, FALSE);
-        newBlot->set_tooltip_text(def.descr);
+        preview->set_focus_on_click(false);
+        preview->set_tooltip_text(def.descr);
 
-        g_signal_connect( G_OBJECT(newBlot->gobj()),
-                          "clicked",
-                          G_CALLBACK(handleClick),
-                          this);
-
-        g_signal_connect( G_OBJECT(newBlot->gobj()),
-                          "alt-clicked",
-                          G_CALLBACK(handleSecondaryClick),
-                          this);
-
-        g_signal_connect( G_OBJECT(newBlot->gobj()),
-                          "button-press-event",
-                          G_CALLBACK(colorItemHandleButtonPress),
-                          this);
+        preview->signal_clicked().connect(sigc::mem_fun(*this, &ColorItem::handleClick));
+        preview->signal_alt_clicked().connect(sigc::mem_fun(*this, &ColorItem::handleSecondaryClick));
+        preview->signal_button_press_event().connect(sigc::bind(sigc::ptr_fun(&colorItemHandleButtonPress), preview, this));
 
         {
-            std::vector<std::string> listing = def.getMIMETypes();
-            int entryCount = listing.size();
-            GtkTargetEntry* entries = new GtkTargetEntry[entryCount];
-            GtkTargetEntry* curr = entries;
-            for ( std::vector<std::string>::iterator it = listing.begin(); it != listing.end(); ++it ) {
-                curr->target = g_strdup(it->c_str());
-                curr->flags = 0;
-                if ( mimeToInt.find(*it) == mimeToInt.end() ){
+            auto listing = def.getMIMETypes();
+            std::vector<Gtk::TargetEntry> entries;
+
+            for ( auto str : listing ) {
+                auto target = str.c_str();
+                guint flags = 0;
+                if ( mimeToInt.find(str) == mimeToInt.end() ){
                     // these next lines are order-dependent:
-                    mimeToInt[*it] = mimeStrings.size();
-                    mimeStrings.push_back(*it);
+                    mimeToInt[str] = mimeStrings.size();
+                    mimeStrings.push_back(str);
                 }
-                curr->info = mimeToInt[curr->target];
-                curr++;
+                auto info = mimeToInt[target];
+                Gtk::TargetEntry entry(target, (Gtk::TargetFlags)flags, info);
+                entries.push_back(entry);
             }
-            gtk_drag_source_set( GTK_WIDGET(newBlot->gobj()),
-                                 GDK_BUTTON1_MASK,
-                                 entries, entryCount,
-                                 GdkDragAction(GDK_ACTION_MOVE | GDK_ACTION_COPY) );
-            for ( int i = 0; i < entryCount; i++ ) {
-                g_free(entries[i].target);
-            }
-            delete[] entries;
-        }
 
-        g_signal_connect( G_OBJECT(newBlot->gobj()),
-                          "drag-data-get",
-                          G_CALLBACK(ColorItem::_dragGetColorData),
-                          this);
-
-        g_signal_connect( G_OBJECT(newBlot->gobj()),
-                          "drag-begin",
-                          G_CALLBACK(colorItemDragBegin),
-                          this );
-
-        g_signal_connect( G_OBJECT(newBlot->gobj()),
-                          "enter-notify-event",
-                          G_CALLBACK(handleEnterNotify),
-                          this);
-
-        g_signal_connect( G_OBJECT(newBlot->gobj()),
-                          "leave-notify-event",
-                          G_CALLBACK(handleLeaveNotify),
-                          this);
-
-        g_signal_connect( G_OBJECT(newBlot->gobj()),
-                          "destroy",
-                          G_CALLBACK(dieDieDie),
-                          this);
+            preview->drag_source_set(entries, Gdk::BUTTON1_MASK,
+                                     Gdk::DragAction(Gdk::ACTION_MOVE | Gdk::ACTION_COPY) );
+        }
 
+        preview->signal_drag_data_get().connect(sigc::mem_fun(*this, &ColorItem::_dragGetColorData));
+        preview->signal_drag_begin().connect(sigc::mem_fun(*this, &ColorItem::drag_begin));
+        preview->signal_enter_notify_event().connect(sigc::mem_fun(*this, &ColorItem::handleEnterNotify));
+        preview->signal_leave_notify_event().connect(sigc::mem_fun(*this, &ColorItem::handleLeaveNotify));
 
-        widget = newBlot;
+        widget = preview;
     }
 
     _previews.push_back( widget );
diff --git a/src/ui/dialog/color-item.h b/src/ui/dialog/color-item.h
index eb83552d5..47a694bae 100644
--- a/src/ui/dialog/color-item.h
+++ b/src/ui/dialog/color-item.h
@@ -79,12 +79,10 @@ private:
                              guint event_time,
                              gpointer user_data);
 
-    static void _dragGetColorData( GtkWidget *widget,
-                                   GdkDragContext *drag_context,
-                                   GtkSelectionData *data,
-                                   guint info,
-                                   guint time,
-                                   gpointer user_data);
+    void _dragGetColorData(const Glib::RefPtr<Gdk::DragContext> &drag_context,
+                           Gtk::SelectionData                   &data,
+                           guint                                 info,
+                           guint                                 time);
 
     static void _wireMagicColors( SwatchPage *colorSet );
     static void _colorDefChanged(void* data);
@@ -94,6 +92,11 @@ private:
 
     void _linkTint( ColorItem& other, int percent );
     void _linkTone( ColorItem& other, int percent, int grayLevel );
+    void drag_begin(const Glib::RefPtr<Gdk::DragContext> &dc);
+    void handleClick();
+    void handleSecondaryClick(gint arg1);
+    bool handleEnterNotify(GdkEventCrossing* event);
+    bool handleLeaveNotify(GdkEventCrossing* event);
 
     std::vector<Gtk::Widget*> _previews;
 
diff --git a/src/ui/dialog/swatches.cpp b/src/ui/dialog/swatches.cpp
index 82c797f47..7e348d18b 100644
--- a/src/ui/dialog/swatches.cpp
+++ b/src/ui/dialog/swatches.cpp
@@ -248,14 +248,12 @@ static void removeit( GtkWidget *widget, gpointer data )
 }
 
 /* extern'ed from color-item.cpp */
-gboolean colorItemHandleButtonPress( GtkWidget* widget, GdkEventButton* event, gpointer user_data );
-
-gboolean colorItemHandleButtonPress( GtkWidget* widget, GdkEventButton* event, gpointer user_data )
+bool colorItemHandleButtonPress(GdkEventButton* event, EekPreview *preview, gpointer user_data)
 {
     gboolean handled = FALSE;
 
     if ( event && (event->button == 3) && (event->type == GDK_BUTTON_PRESS) ) {
-        SwatchesPanel* swp = findContainingPanel( widget );
+        SwatchesPanel* swp = findContainingPanel( GTK_WIDGET(preview->gobj()) );
 
         if ( !popupMenu ) {
             popupMenu = gtk_menu_new();
@@ -329,7 +327,7 @@ gboolean colorItemHandleButtonPress( GtkWidget* widget, GdkEventButton* event, g
             if ( popupMenu ) {
                 gtk_container_foreach(GTK_CONTAINER(popupSub), removeit, popupSub);
                 bool processed = false;
-                GtkWidget *wdgt = gtk_widget_get_ancestor(widget, SP_TYPE_DESKTOP_WIDGET);
+                GtkWidget *wdgt = gtk_widget_get_ancestor(GTK_WIDGET(preview->gobj()), SP_TYPE_DESKTOP_WIDGET);
                 if ( wdgt ) {
                     SPDesktopWidget *dtw = SP_DESKTOP_WIDGET(wdgt);
                     if ( dtw && dtw->desktop ) {
diff --git a/src/ui/widget/panel.cpp b/src/ui/widget/panel.cpp
index aff7f98fe..d6e170c74 100644
--- a/src/ui/widget/panel.cpp
+++ b/src/ui/widget/panel.cpp
@@ -35,7 +35,7 @@ void Panel::prep() {
         GTK_ICON_SIZE_DND, // Not used by options, but included to make the last size larger
         GTK_ICON_SIZE_DIALOG
     };
-    eek_preview_set_size_mappings( G_N_ELEMENTS(sizes), sizes );
+    EekPreview::set_size_mappings( G_N_ELEMENTS(sizes), sizes );
 }
 
 Panel::Panel(gchar const *prefs_path, int verb_num) :
diff --git a/src/widgets/eek-preview.cpp b/src/widgets/eek-preview.cpp
index dd84b07ec..362c17977 100644
--- a/src/widgets/eek-preview.cpp
+++ b/src/widgets/eek-preview.cpp
@@ -38,7 +38,7 @@
 #include <algorithm>
 using std::min;
 
-#include <gtk/gtk.h>
+#include <gdkmm/general.h>
 #include "eek-preview.h"
 #include "preferences.h"
 
@@ -50,79 +50,38 @@ using std::min;
 
 #define PREVIEW_MAX_RATIO 500
 
-enum {
-    PROP_0,
-    PROP_FOCUS
-};
-
-struct EekPreviewPrivate
-{
-    int          scaledW;
-    int          scaledH;
-
-    int          r;
-    int          g;
-    int          b;
-
-    gboolean     hot;
-    gboolean     within;
-    gboolean     takesFocus;
-    ViewType     view;
-    PreviewSize  size;
-    guint        ratio;
-    guint        linked;
-    guint        border;
-    GdkPixbuf   *previewPixbuf;
-    GdkPixbuf   *scaled;
-};
-
-#define EEK_PREVIEW_GET_PRIVATE(preview) \
-    reinterpret_cast<EekPreviewPrivate *>(eek_preview_get_instance_private (preview))
-
-static void     eek_preview_class_init( EekPreviewClass *klass );
-static void     eek_preview_init( EekPreview *preview );
-static gboolean eek_preview_draw(GtkWidget* widget, cairo_t* cr);
-
-G_DEFINE_TYPE_WITH_PRIVATE (EekPreview, eek_preview, GTK_TYPE_DRAWING_AREA);
-
-static GtkWidgetClass* parent_class = nullptr;
-
-void eek_preview_set_color( EekPreview* preview, int r, int g, int b )
+void
+EekPreview::set_color(int r, int g, int b )
 {
-    EekPreviewPrivate *priv = EEK_PREVIEW_GET_PRIVATE(preview);
-
-    priv->r = r;
-    priv->g = g;
-    priv->b = b;
+    _r = r;
+    _g = g;
+    _b = b;
 
-    gtk_widget_queue_draw(GTK_WIDGET(preview));
+    queue_draw();
 }
 
 
 void
-eek_preview_set_pixbuf(EekPreview *preview,
-                       GdkPixbuf  *pixbuf)
+EekPreview::set_pixbuf(const Glib::RefPtr<Gdk::Pixbuf> &pixbuf)
 {
-    EekPreviewPrivate *priv = EEK_PREVIEW_GET_PRIVATE(preview);
+    _previewPixbuf = pixbuf;
 
-    priv->previewPixbuf     = pixbuf;
+    queue_draw();
 
-    gtk_widget_queue_draw(GTK_WIDGET(preview));
-
-    if (priv->scaled)
+    if (_scaled)
     {
-        g_object_unref(priv->scaled);
-        priv->scaled = nullptr;
+        _scaled.reset();
     }
 
-    priv->scaledW = gdk_pixbuf_get_width(priv->previewPixbuf);
-    priv->scaledH = gdk_pixbuf_get_height(priv->previewPixbuf);
+    _scaledW = _previewPixbuf->get_width();
+    _scaledH = _previewPixbuf->get_height();
 }
 
 static gboolean setupDone = FALSE;
 static GtkRequisition sizeThings[PREVIEW_SIZE_NEXTFREE];
 
-void eek_preview_set_size_mappings( guint count, GtkIconSize const* sizes )
+void
+EekPreview::set_size_mappings( guint count, GtkIconSize const* sizes )
 {
     gint width = 0;
     gint height = 0;
@@ -156,12 +115,11 @@ void eek_preview_set_size_mappings( guint count, GtkIconSize const* sizes )
     setupDone = TRUE;
 }
 
-static void eek_preview_size_request( GtkWidget* widget, GtkRequisition* req )
+void
+EekPreview::size_request(GtkRequisition* req) const
 {
-    gint               width   = 0;
-    gint               height  = 0;
-    EekPreview        *preview = EEK_PREVIEW(widget);
-    EekPreviewPrivate *priv    = EEK_PREVIEW_GET_PRIVATE(preview);
+    int               width   = 0;
+    int               height  = 0;
 
     if ( !setupDone ) {
         GtkIconSize sizes[] = {
@@ -171,18 +129,18 @@ static void eek_preview_size_request( GtkWidget* widget, GtkRequisition* req )
             GTK_ICON_SIZE_BUTTON,
             GTK_ICON_SIZE_DIALOG
         };
-        eek_preview_set_size_mappings( G_N_ELEMENTS(sizes), sizes );
+        set_size_mappings( G_N_ELEMENTS(sizes), sizes );
     }
 
-    width = sizeThings[priv->size].width;
-    height = sizeThings[priv->size].height;
+    width = sizeThings[_size].width;
+    height = sizeThings[_size].height;
 
-    if ( priv->view == VIEW_TYPE_LIST ) {
+    if ( _view == VIEW_TYPE_LIST ) {
         width *= 3;
     }
 
-    if ( priv->ratio != 100 ) {
-        width = (width * priv->ratio) / 100;
+    if ( _ratio != 100 ) {
+        width = (width * _ratio) / 100;
         if ( width < 0 ) {
             width = 1;
         }
@@ -192,116 +150,100 @@ static void eek_preview_size_request( GtkWidget* widget, GtkRequisition* req )
     req->height = height;
 }
 
-static void eek_preview_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width)
+void
+EekPreview::get_preferred_width_vfunc(int &minimal_width, int &natural_width) const
 {
-	GtkRequisition requisition;
-	eek_preview_size_request(widget, &requisition);
-	*minimal_width = *natural_width = requisition.width;
+    GtkRequisition requisition;
+    size_request(&requisition);
+    minimal_width = natural_width = requisition.width;
 }
 
-static void eek_preview_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height)
+void
+EekPreview::get_preferred_height_vfunc(int &minimal_height, int &natural_height) const
 {
-	GtkRequisition requisition;
-	eek_preview_size_request(widget, &requisition);
-	*minimal_height = *natural_height = requisition.height;
+    GtkRequisition requisition;
+    size_request(&requisition);
+    minimal_height = natural_height = requisition.height;
 }
 
-enum {
-  CLICKED_SIGNAL,
-  ALTCLICKED_SIGNAL,
-  LAST_SIGNAL
-};
-
-
-static guint eek_preview_signals[LAST_SIGNAL] = { 0 };
-
-static
-gboolean eek_preview_draw(GtkWidget *widget,
-                          cairo_t   *cr)
+bool
+EekPreview::on_draw(const Cairo::RefPtr<Cairo::Context> &cr)
 {
-
-    EekPreview        *preview = EEK_PREVIEW(widget);
-    EekPreviewPrivate *priv    = EEK_PREVIEW_GET_PRIVATE(preview);
-
-    GtkAllocation allocation;
-    gtk_widget_get_allocation(widget, &allocation);
+    auto allocation = get_allocation();
 
     gint insetTop = 0, insetBottom = 0;
     gint insetLeft = 0, insetRight = 0;
 
-    if (priv->border == BORDER_SOLID) {
+    if (_border == BORDER_SOLID) {
         insetTop = 1;
         insetLeft = 1;
     }
-    if (priv->border == BORDER_SOLID_LAST_ROW) {
+    if (_border == BORDER_SOLID_LAST_ROW) {
         insetTop = insetBottom = 1;
         insetLeft = 1;
     }
-    if (priv->border == BORDER_WIDE) {
+    if (_border == BORDER_WIDE) {
         insetTop = insetBottom = 1;
         insetLeft = insetRight = 1;
     }
 
-    auto context = gtk_widget_get_style_context(widget);
-
-    gtk_render_frame(context,
-                     cr,
-                     0, 0,
-                     allocation.width, allocation.height);
+    auto context = get_style_context();
 
-    gtk_render_background(context,
-                          cr,
+    context->render_frame(cr,
                           0, 0,
-                          allocation.width, allocation.height);
+                          allocation.get_width(), allocation.get_height());
+
+    context->render_background(cr,
+                               0, 0,
+                               allocation.get_width(), allocation.get_height());
 
     // Border
-    if (priv->border != BORDER_NONE) {
-        cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
-        cairo_rectangle(cr, 0, 0, allocation.width, allocation.height);
-        cairo_fill(cr);
+    if (_border != BORDER_NONE) {
+        cr->set_source_rgb(0.0, 0.0, 0.0);
+        cr->rectangle(0, 0, allocation.get_width(), allocation.get_height());
+        cr->fill();
     }
 
-    cairo_set_source_rgb(cr, priv->r/65535.0, priv->g/65535.0, priv->b/65535.0 );
-    cairo_rectangle(cr, insetLeft, insetTop, allocation.width - (insetLeft + insetRight), allocation.height - (insetTop + insetBottom));
-    cairo_fill(cr);
+    cr->set_source_rgb(_r/65535.0, _g/65535.0, _b/65535.0 );
+    cr->rectangle(insetLeft, insetTop, allocation.get_width() - (insetLeft + insetRight), allocation.get_height() - (insetTop + insetBottom));
+    cr->fill();
 
-    if (priv->previewPixbuf )
+    if (_previewPixbuf )
     {
-        if ((allocation.width != priv->scaledW) || (allocation.height != priv->scaledH)) {
-            if (priv->scaled)
+        if ((allocation.get_width() != _scaledW) || (allocation.get_height() != _scaledH)) {
+            if (_scaled)
             {
-                g_object_unref(priv->scaled);
+                _scaled.reset();
             }
 
-            priv->scaledW = allocation.width - (insetLeft + insetRight);
-            priv->scaledH = allocation.height - (insetTop + insetBottom);
+            _scaledW = allocation.get_width() - (insetLeft + insetRight);
+            _scaledH = allocation.get_height() - (insetTop + insetBottom);
 
-            priv->scaled = gdk_pixbuf_scale_simple(priv->previewPixbuf,
-                                                   priv->scaledW,
-                                                   priv->scaledH,
-                                                   GDK_INTERP_BILINEAR);
+            _scaled = _previewPixbuf->scale_simple(_scaledW,
+                                                   _scaledH,
+                                                   Gdk::INTERP_BILINEAR);
         }
 
-        GdkPixbuf *pix = (priv->scaled) ? priv->scaled : priv->previewPixbuf;
+        Glib::RefPtr<Gdk::Pixbuf> pix = (_scaled) ? _scaled : _previewPixbuf;
 
         // Border
-        if (priv->border != BORDER_NONE) {
-            cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
-            cairo_rectangle(cr, 0, 0, allocation.width, allocation.height);
-            cairo_fill(cr);
+        if (_border != BORDER_NONE) {
+            cr->set_source_rgb(0.0, 0.0, 0.0);
+            cr->rectangle(0, 0, allocation.get_width(), allocation.get_height());
+            cr->fill();
         }
 
-        gdk_cairo_set_source_pixbuf(cr, pix, insetLeft, insetTop);
-        cairo_paint(cr);
+        Gdk::Cairo::set_source_pixbuf(cr, pix, insetLeft, insetTop);
+        cr->paint();
     }
 
-    if (priv->linked)
+    if (_linked)
     {
         /* Draw arrow */
         GdkRectangle possible = {insetLeft,
                                  insetTop,
-                                 (allocation.width - (insetLeft + insetRight)),
-                                 (allocation.height - (insetTop + insetBottom))
+                                 (allocation.get_width() - (insetLeft + insetRight)),
+                                 (allocation.get_height() - (insetTop + insetBottom))
                                 };
 
         GdkRectangle area = {possible.x,
@@ -321,48 +263,45 @@ gboolean eek_preview_draw(GtkWidget *widget,
             area.x += diff;
         }
 
-        if (priv->linked & PREVIEW_LINK_IN)
+        if (_linked & PREVIEW_LINK_IN)
         {
-            gtk_render_arrow(context,
-                             cr,
-                             G_PI, // Down-pointing arrow
-                             area.x, area.y,
-                             min(area.width, area.height)
-                            );
+            context->render_arrow(cr,
+                                  G_PI, // Down-pointing arrow
+                                  area.x, area.y,
+                                  min(area.width, area.height)
+                                 );
         }
 
-        if (priv->linked & PREVIEW_LINK_OUT)
+        if (_linked & PREVIEW_LINK_OUT)
         {
             GdkRectangle otherArea = {area.x, area.y, area.width, area.height};
             if ( otherArea.height < possible.height ) {
                 otherArea.y = possible.y + (possible.height - otherArea.height);
             }
 
-            gtk_render_arrow(context,
-                             cr,
-                             G_PI, // Down-pointing arrow
-                             otherArea.x, otherArea.y,
-                             min(otherArea.width, otherArea.height)
-                            );
+            context->render_arrow(cr,
+                                  G_PI, // Down-pointing arrow
+                                  otherArea.x, otherArea.y,
+                                  min(otherArea.width, otherArea.height)
+                                 );
         }
 
-        if (priv->linked & PREVIEW_LINK_OTHER)
+        if (_linked & PREVIEW_LINK_OTHER)
         {
             GdkRectangle otherArea = {insetLeft, area.y, area.width, area.height};
             if ( otherArea.height < possible.height ) {
                 otherArea.y = possible.y + (possible.height - otherArea.height) / 2;
             }
 
-            gtk_render_arrow(context,
-                             cr,
-                             1.5*G_PI, // Left-pointing arrow
-                             otherArea.x, otherArea.y,
-                             min(otherArea.width, otherArea.height)
-                            );
+            context->render_arrow(cr,
+                                  1.5*G_PI, // Left-pointing arrow
+                                  otherArea.x, otherArea.y,
+                                  min(otherArea.width, otherArea.height)
+                                 );
         }
 
 
-        if (priv->linked & PREVIEW_FILL)
+        if (_linked & PREVIEW_FILL)
         {
             GdkRectangle otherArea = {possible.x + ((possible.width / 4) - (area.width / 2)),
                                       area.y,
@@ -370,13 +309,12 @@ gboolean eek_preview_draw(GtkWidget *widget,
             if ( otherArea.height < possible.height ) {
                 otherArea.y = possible.y + (possible.height - otherArea.height) / 2;
             }
-            gtk_render_check(context,
-                             cr,
-                             otherArea.x, otherArea.y,
-                             otherArea.width, otherArea.height );
+            context->render_check(cr,
+                                  otherArea.x, otherArea.y,
+                                  otherArea.width, otherArea.height );
         }
 
-        if (priv->linked & PREVIEW_STROKE)
+        if (_linked & PREVIEW_STROKE)
         {
             GdkRectangle otherArea = {possible.x + (((possible.width * 3) / 4) - (area.width / 2)),
                                       area.y,
@@ -385,329 +323,164 @@ gboolean eek_preview_draw(GtkWidget *widget,
                 otherArea.y = possible.y + (possible.height - otherArea.height) / 2;
             }
             // This should be a diamond too?
-            gtk_render_check(context,
-                             cr,
-                             otherArea.x, otherArea.y,
-                             otherArea.width, otherArea.height );
+            context->render_check(cr,
+                                  otherArea.x, otherArea.y,
+                                  otherArea.width, otherArea.height );
         }
     }
 
 
-    if ( gtk_widget_has_focus(widget) ) {
-        gtk_widget_get_allocation (widget, &allocation);
+    if ( has_focus() ) {
+        allocation = get_allocation();
 
-        gtk_render_focus(context,
-                         cr,
-                         0 + 1, 0 + 1,
-                         allocation.width - 2, allocation.height - 2 );
+        context->render_focus(cr,
+                              0 + 1, 0 + 1,
+                              allocation.get_width() - 2, allocation.get_height() - 2 );
     }
 
-    return FALSE;
+    return false;
 }
 
 
-static gboolean eek_preview_enter_cb( GtkWidget* widget, GdkEventCrossing* event )
+bool
+EekPreview::on_enter_notify_event(GdkEventCrossing* event )
 {
-    if ( gtk_get_event_widget( (GdkEvent*)event ) == widget ) {
-        EekPreview        *preview = EEK_PREVIEW(widget);
-        EekPreviewPrivate *priv    = EEK_PREVIEW_GET_PRIVATE(preview);
-
-        priv->within = TRUE;
-        gtk_widget_set_state_flags( widget, priv->hot ? GTK_STATE_FLAG_ACTIVE : GTK_STATE_FLAG_PRELIGHT, false );
-    }
+    _within = true;
+    set_state_flags(_hot ? Gtk::STATE_FLAG_ACTIVE : Gtk::STATE_FLAG_PRELIGHT, false);
 
-    return FALSE;
+    return false;
 }
 
-static gboolean eek_preview_leave_cb( GtkWidget* widget, GdkEventCrossing* event )
+bool
+EekPreview::on_leave_notify_event(GdkEventCrossing* event)
 {
-    if ( gtk_get_event_widget( (GdkEvent*)event ) == widget ) {
-        EekPreview        *preview = EEK_PREVIEW(widget);
-        EekPreviewPrivate *priv    = EEK_PREVIEW_GET_PRIVATE(preview);
+    _within = false;
+    set_state_flags(Gtk::STATE_FLAG_NORMAL, false);
 
-        priv->within = FALSE;
-        gtk_widget_set_state_flags( widget, GTK_STATE_FLAG_NORMAL, false );
-    }
-
-    return FALSE;
+    return false;
 }
 
-static gboolean eek_preview_button_press_cb( GtkWidget* widget, GdkEventButton* event )
+bool
+EekPreview::on_button_press_event(GdkEventButton *event)
 {
-    if ( gtk_get_event_widget( (GdkEvent*)event ) == widget )
+    if (_takesFocus && !has_focus() )
     {
-        EekPreview        *preview = EEK_PREVIEW(widget);
-        EekPreviewPrivate *priv    = EEK_PREVIEW_GET_PRIVATE(preview);
-
-        if ( priv->takesFocus && !gtk_widget_has_focus(widget) )
-        {
-            gtk_widget_grab_focus(widget);
-        }
-
-        if ( event->button == PRIME_BUTTON_MAGIC_NUMBER ||
-             event->button == 2 )
-        {
-            priv->hot = TRUE;
-
-            if ( priv->within )
-            {
-                gtk_widget_set_state_flags( widget, GTK_STATE_FLAG_ACTIVE, false );
-            }
-        }
+        grab_focus();
     }
 
-    return FALSE;
-}
-
-static gboolean eek_preview_button_release_cb( GtkWidget* widget, GdkEventButton* event )
-{
-    if ( gtk_get_event_widget( (GdkEvent*)event ) == widget ) {
-        EekPreview        *preview = EEK_PREVIEW(widget);
-        EekPreviewPrivate *priv    = EEK_PREVIEW_GET_PRIVATE(preview);
-
-        priv->hot = FALSE;
-        gtk_widget_set_state_flags( widget, GTK_STATE_FLAG_NORMAL, false );
+    if ( event->button == PRIME_BUTTON_MAGIC_NUMBER ||
+            event->button == 2 )
+    {
+        _hot = true;
 
-        if ( priv->within &&
-            (event->button == PRIME_BUTTON_MAGIC_NUMBER ||
-             event->button == 2))
+        if ( _within )
         {
-            gboolean isAlt = ( ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK) ||
-                                (event->button == 2));
-
-            if ( isAlt )
-            {
-                g_signal_emit( widget, eek_preview_signals[ALTCLICKED_SIGNAL], 0, 2 );
-            }
-            else
-            {
-                g_signal_emit( widget, eek_preview_signals[CLICKED_SIGNAL], 0 );
-            }
+            set_state_flags(Gtk::STATE_FLAG_ACTIVE, false);
         }
     }
 
-    return FALSE;
+    return false;
 }
 
-static void eek_preview_get_property( GObject    *object,
-                                      guint       prop_id,
-                                      GValue     *value,
-                                      GParamSpec *pspec)
+bool
+EekPreview::on_button_release_event(GdkEventButton* event)
 {
-    EekPreview        *preview   = EEK_PREVIEW( object );
-    EekPreviewPrivate *priv      = EEK_PREVIEW_GET_PRIVATE(preview);
+    _hot = false;
+    set_state_flags(Gtk::STATE_FLAG_NORMAL, false);
 
-    switch (prop_id)
+    if (_within &&
+         (event->button == PRIME_BUTTON_MAGIC_NUMBER ||
+          event->button == 2))
     {
-        case PROP_FOCUS:
-            g_value_set_boolean( value, priv->takesFocus );
-            break;
-
-        default:
-            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
-            break;
-    }
-}
+        gboolean isAlt = ( ((event->state & GDK_SHIFT_MASK) == GDK_SHIFT_MASK) ||
+                (event->button == 2));
 
-static void
-eek_preview_set_property(GObject      *object,
-                         guint         prop_id,
-                         const GValue *value,
-                         GParamSpec   *pspec)
-{
-    EekPreview        *preview   = EEK_PREVIEW( object );
-
-    switch (prop_id)
-    {
-        case PROP_FOCUS:
-            eek_preview_set_focus_on_click(preview, g_value_get_boolean(value));
-            break;
-
-        default:
-            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
-            break;
+        if ( isAlt )
+        {
+            _signal_alt_clicked(2);
+        }
+        else
+        {
+            _signal_clicked.emit();
+        }
     }
-}
-
 
-static gboolean eek_preview_popup_menu( GtkWidget* widget )
-{
-    gboolean blip = parent_class->popup_menu ? parent_class->popup_menu(widget) : FALSE;
-    return blip;
-}
-
-
-static void eek_preview_class_init( EekPreviewClass *klass )
-{
-    GObjectClass*   gobjClass   = G_OBJECT_CLASS(klass);
-    GtkWidgetClass* widgetClass = (GtkWidgetClass*)klass;
-
-    gobjClass->set_property = eek_preview_set_property;
-    gobjClass->get_property = eek_preview_get_property;
-
-    parent_class = (GtkWidgetClass*)g_type_class_peek_parent( klass );
-
-    widgetClass->get_preferred_width = eek_preview_get_preferred_width;
-    widgetClass->get_preferred_height = eek_preview_get_preferred_height;
-    widgetClass->draw = eek_preview_draw;
-    widgetClass->button_press_event = eek_preview_button_press_cb;
-    widgetClass->button_release_event = eek_preview_button_release_cb;
-    widgetClass->enter_notify_event = eek_preview_enter_cb;
-    widgetClass->leave_notify_event = eek_preview_leave_cb;
-
-    /* For keybindings: */
-    widgetClass->popup_menu = eek_preview_popup_menu;
-
-    eek_preview_signals[CLICKED_SIGNAL] =
-        g_signal_new( "clicked",
-                      G_TYPE_FROM_CLASS( klass ),
-                      (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
-                      G_STRUCT_OFFSET( EekPreviewClass, clicked ),
-                      nullptr, nullptr,
-                      g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0 );
-
-    eek_preview_signals[ALTCLICKED_SIGNAL] =
-        g_signal_new( "alt-clicked",
-                      G_TYPE_FROM_CLASS( klass ),
-                      (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION),
-                      G_STRUCT_OFFSET( EekPreviewClass, clicked ),
-                      nullptr, nullptr,
-                      g_cclosure_marshal_VOID__INT, G_TYPE_NONE,
-                      1, G_TYPE_INT );
-
-
-    g_object_class_install_property( gobjClass,
-                                     PROP_FOCUS,
-                                     g_param_spec_boolean(
-                                         "focus-on-click",
-                                         nullptr,
-                                         "flag to grab focus when clicked",
-                                         TRUE,
-                                         (GParamFlags)(G_PARAM_READWRITE | G_PARAM_CONSTRUCT)
-                                         )
-                                   );
+    return false;
 }
 
 void
-eek_preview_set_linked(EekPreview *preview,
-                       LinkType    link)
+EekPreview::set_linked(LinkType link)
 {
-    EekPreviewPrivate *priv = EEK_PREVIEW_GET_PRIVATE(preview);
-
-    g_return_if_fail(EEK_IS_PREVIEW(preview));
-
     link = (LinkType)(link & PREVIEW_LINK_ALL);
 
-    if (link != (LinkType)priv->linked)
+    if (link != _linked)
     {
-        priv->linked = link;
+        _linked = link;
 
-        gtk_widget_queue_draw(GTK_WIDGET(preview));
+        queue_draw();
     }
 }
 
 LinkType
-eek_preview_get_linked(EekPreview *preview)
+EekPreview::get_linked() const
 {
-    g_return_val_if_fail(EEK_IS_PREVIEW(preview), PREVIEW_LINK_NONE);
-
-    return (LinkType)EEK_PREVIEW_GET_PRIVATE(preview)->linked;
-}
-
-gboolean
-eek_preview_get_focus_on_click(EekPreview* preview)
-{
-    g_return_val_if_fail(EEK_IS_PREVIEW(preview), FALSE);
-
-    return EEK_PREVIEW_GET_PRIVATE(preview)->takesFocus;
+    return (LinkType)_linked;
 }
 
 void
-eek_preview_set_focus_on_click(EekPreview *preview,
-                               gboolean    focus_on_click)
-{
-    EekPreviewPrivate *priv = EEK_PREVIEW_GET_PRIVATE(preview);
-
-    g_return_if_fail(EEK_IS_PREVIEW(preview));
-
-    if (focus_on_click != priv->takesFocus)
-    {
-        priv->takesFocus = focus_on_click;
-    }
-}
-
-void
-eek_preview_set_details(EekPreview   *preview,
-                        ViewType      view,
+EekPreview::set_details(ViewType      view,
                         PreviewSize   size,
                         guint         ratio,
                         guint         border)
 {
-    EekPreviewPrivate *priv = EEK_PREVIEW_GET_PRIVATE(preview);
-
-    g_return_if_fail(EEK_IS_PREVIEW(preview));
-
-    priv->view  = view;
+    _view  = view;
 
     if ( size > PREVIEW_SIZE_LAST )
     {
         size = PREVIEW_SIZE_LAST;
     }
 
-    priv->size = size;
+    _size = size;
 
     if ( ratio > PREVIEW_MAX_RATIO )
     {
         ratio = PREVIEW_MAX_RATIO;
     }
 
-    priv->ratio  = ratio;
-    priv->border = border;
+    _ratio  = ratio;
+    _border = border;
 
-    gtk_widget_queue_draw(GTK_WIDGET(preview));
+    queue_draw();
 }
 
-static void
-eek_preview_init(EekPreview *preview)
-{
-    GtkWidget         *widg = GTK_WIDGET(preview);
-    EekPreviewPrivate *priv = EEK_PREVIEW_GET_PRIVATE(preview);
-
-    gtk_widget_set_can_focus( widg, TRUE );
-    gtk_widget_set_receives_default( widg, TRUE );
-
-    gtk_widget_set_sensitive( widg, TRUE );
-
-    gtk_widget_add_events(widg, GDK_BUTTON_PRESS_MASK
-                          | GDK_BUTTON_RELEASE_MASK
-                          | GDK_KEY_PRESS_MASK
-                          | GDK_KEY_RELEASE_MASK
-                          | GDK_FOCUS_CHANGE_MASK
-                          | GDK_ENTER_NOTIFY_MASK
-                          | GDK_LEAVE_NOTIFY_MASK );
-
-    priv->r             = 0x80;
-    priv->g             = 0x80;
-    priv->b             = 0xcc;
-    priv->scaledW       = 0;
-    priv->scaledH       = 0;
-
-    priv->hot           = FALSE;
-    priv->within        = FALSE;
-    priv->takesFocus    = FALSE;
-
-    priv->view          = VIEW_TYPE_LIST;
-    priv->size          = PREVIEW_SIZE_SMALL;
-    priv->ratio         = 100;
-    priv->border        = BORDER_NONE;
-    priv->previewPixbuf = nullptr;
-    priv->scaled        = nullptr;
-}
-
-
-GtkWidget* eek_preview_new(void)
+EekPreview::EekPreview()
+    : _r(0x80),
+      _g(0x80),
+      _b(0xcc),
+      _scaledW(0),
+      _scaledH(0),
+      _hot(false),
+      _within(false),
+      _takesFocus(false),
+      _view(VIEW_TYPE_LIST),
+      _size(PREVIEW_SIZE_SMALL),
+      _ratio(100),
+      _border(BORDER_NONE),
+      _previewPixbuf(nullptr),
+      _scaled(nullptr)
 {
-    return GTK_WIDGET( g_object_new( EEK_TYPE_PREVIEW, nullptr ) );
+    set_can_focus(true);
+    set_receives_default(true);
+
+    set_sensitive(true);
+
+    add_events(Gdk::BUTTON_PRESS_MASK
+              |Gdk::BUTTON_RELEASE_MASK
+              |Gdk::KEY_PRESS_MASK
+              |Gdk::KEY_RELEASE_MASK
+              |Gdk::FOCUS_CHANGE_MASK
+              |Gdk::ENTER_NOTIFY_MASK
+              |Gdk::LEAVE_NOTIFY_MASK );
 }
 
 /*
diff --git a/src/widgets/eek-preview.h b/src/widgets/eek-preview.h
index 258882a77..d01164b35 100644
--- a/src/widgets/eek-preview.h
+++ b/src/widgets/eek-preview.h
@@ -38,18 +38,13 @@
 #ifndef SEEN_EEK_PREVIEW_H
 #define SEEN_EEK_PREVIEW_H
 
-#include <gtk/gtk.h>
+#include <gtkmm/drawingarea.h>
 
 /**
  * @file
  * Generic implementation of an object that can be shown by a preview.
  */
 
-G_BEGIN_DECLS
-
-#define EEK_TYPE_PREVIEW eek_preview_get_type()
-G_DECLARE_DERIVABLE_TYPE (EekPreview, eek_preview, EEK, PREVIEW, GtkDrawingArea)
-
 enum PreviewStyle {
     PREVIEW_STYLE_ICON = 0,
     PREVIEW_STYLE_PREVIEW,
@@ -92,34 +87,60 @@ enum BorderStyle {
     BORDER_SOLID_LAST_ROW,
 };
 
-typedef struct _EekPreview       EekPreview;
-
-struct _EekPreviewClass
-{
-    GtkDrawingAreaClass parent_class;
-
-    void (*clicked) (EekPreview* splat);
+class EekPreview : public Gtk::DrawingArea {
+private:
+    int           _scaledW;
+    int           _scaledH;
+
+    int           _r;
+    int           _g;
+    int           _b;
+
+    bool          _hot;
+    bool          _within;
+    bool          _takesFocus; ///< flag to grab focus when clicked
+    ViewType      _view;
+    PreviewSize   _size;
+    unsigned int  _ratio;
+    LinkType      _linked;
+    unsigned int  _border;
+
+    Glib::RefPtr<Gdk::Pixbuf> _previewPixbuf;
+    Glib::RefPtr<Gdk::Pixbuf> _scaled;
+
+    // signals
+    sigc::signal<void> _signal_clicked;
+    sigc::signal<void, int> _signal_alt_clicked;
+
+    void size_request(GtkRequisition *req) const;
+
+protected:
+    void get_preferred_width_vfunc(int &minimal_width, int &natural_width) const override;
+    void get_preferred_height_vfunc(int &minimal_height, int &natural_height) const override;
+    bool on_draw(const Cairo::RefPtr<Cairo::Context> &cr) override;
+    bool on_button_press_event(GdkEventButton *button_event) override;
+    bool on_button_release_event(GdkEventButton *button_event) override;
+    bool on_enter_notify_event(GdkEventCrossing* event ) override;
+    bool on_leave_notify_event(GdkEventCrossing* event ) override;
+
+public:
+    EekPreview();
+    bool get_focus_on_click() const {return _takesFocus;}
+    void set_focus_on_click(bool focus_on_click) {_takesFocus = focus_on_click;}
+    LinkType get_linked() const;
+    void set_linked(LinkType link);
+    void set_details(ViewType      view,
+                     PreviewSize   size,
+                     guint         ratio,
+                     guint         border);
+    void set_color(int r, int g, int b);
+    void set_pixbuf(const Glib::RefPtr<Gdk::Pixbuf> &pixbuf);
+    static void set_size_mappings(guint count, GtkIconSize const* sizes);
+
+    decltype(_signal_clicked) signal_clicked() {return _signal_clicked;}
+    decltype(_signal_alt_clicked) signal_alt_clicked() {return _signal_alt_clicked;}
 };
 
-GtkWidget* eek_preview_new(void);
-
-void eek_preview_set_details(EekPreview   *preview,
-                             ViewType      view,
-                             PreviewSize   size,
-                             guint         ratio, 
-                             guint         border);
-void eek_preview_set_color( EekPreview* splat, int r, int g, int b );
-void eek_preview_set_pixbuf( EekPreview* splat, GdkPixbuf* pixbuf );
-
-void eek_preview_set_linked( EekPreview* splat, LinkType link );
-LinkType eek_preview_get_linked( EekPreview* splat );
-
-gboolean eek_preview_get_focus_on_click( EekPreview* preview );
-void eek_preview_set_focus_on_click( EekPreview* preview, gboolean focus_on_click );
-
-void eek_preview_set_size_mappings( guint count, GtkIconSize const* sizes );
-
-G_END_DECLS
 
 #endif /* SEEN_EEK_PREVIEW_H */