C++-ification.

diff --git a/src/widgets/icon.cpp b/src/widgets/icon.cpp
index 99acbb8cab010f1d1bf00d70f796e3cee8337efe..3b9b47425d3826a40c45fb50f430591a5fe5e829 100644 (file)
--- a/src/widgets/icon.cpp
+++ b/src/widgets/icon.cpp
@@ -34,36 +34,58 @@
 
 #include "icon.h"
 
-static gboolean icon_prerender_task(gpointer data);
 
-static void addPreRender( GtkIconSize lsize, gchar const *name );
+struct IconImpl {
+    static void classInit(SPIconClass *klass);
+    static void init(SPIcon *icon);
 
-static void sp_icon_class_init(SPIconClass *klass);
-static void sp_icon_init(SPIcon *icon);
-static void sp_icon_dispose(GObject *object);
+    static GtkWidget *newFull( Inkscape::IconSize lsize, gchar const *name );
 
-static void sp_icon_reset(SPIcon *icon);
-static void sp_icon_clear(SPIcon *icon);
+    static void dispose(GObject *object);
 
-static void sp_icon_size_request(GtkWidget *widget, GtkRequisition *requisition);
-static void sp_icon_size_allocate(GtkWidget *widget, GtkAllocation *allocation);
-static int sp_icon_expose(GtkWidget *widget, GdkEventExpose *event);
+    static void reset(SPIcon *icon);
+    static void clear(SPIcon *icon);
 
-static void sp_icon_paint(SPIcon *icon, GdkRectangle const *area);
+    static void sizeRequest(GtkWidget *widget, GtkRequisition *requisition);
+    static void sizeAllocate(GtkWidget *widget, GtkAllocation *allocation);
+    static int expose(GtkWidget *widget, GdkEventExpose *event);
 
-static void sp_icon_screen_changed( GtkWidget *widget, GdkScreen *previous_screen );
-static void sp_icon_style_set( GtkWidget *widget, GtkStyle *previous_style );
-static void sp_icon_theme_changed( SPIcon *icon );
+    static void paint(SPIcon *icon, GdkRectangle const *area);
 
-static GdkPixbuf *sp_icon_image_load_pixmap(gchar const *name, unsigned lsize, unsigned psize);
-static GdkPixbuf *sp_icon_image_load_svg(std::list<Glib::ustring> const &names, GtkIconSize lsize, unsigned psize);
+    static void screenChanged( GtkWidget *widget, GdkScreen *previous_screen );
+    static void styleSet( GtkWidget *widget, GtkStyle *previous_style );
+    static void themeChanged( SPIcon *icon );
 
-static void sp_icon_overlay_pixels( guchar *px, int width, int height, int stride,
-                                    unsigned r, unsigned g, unsigned b );
+    static int getPhysSize(int size);
+    static void fetchPixbuf( SPIcon *icon );
 
-static void injectCustomSize();
+    static gboolean prerenderTask(gpointer data);
+    static void addPreRender( GtkIconSize lsize, gchar const *name );
+    static GdkPixbuf* renderup( gchar const* name, Inkscape::IconSize lsize, unsigned psize );
+
+
+    static GdkPixbuf *loadPixmap(gchar const *name, unsigned lsize, unsigned psize);
+    static GdkPixbuf *loadSvg(std::list<Glib::ustring> const &names, GtkIconSize lsize, unsigned psize);
+
+    static void overlayPixels( guchar *px, int width, int height, int stride,
+                               unsigned r, unsigned g, unsigned b );
+
+    static void injectCustomSize();
+
+    static void imageMapCB(GtkWidget* widget, gpointer user_data);
+    static void imageMapNamedCB(GtkWidget* widget, gpointer user_data);
+    static bool prerenderIcon(gchar const *name, GtkIconSize lsize, unsigned psize);
+
+    static void setupLegacyNaming();
+
+private:
+    static GtkWidgetClass *parent_class;
+    static std::map<Glib::ustring, Glib::ustring> legacyNames;
+};
+
+GtkWidgetClass *IconImpl::parent_class = 0;
+std::map<Glib::ustring, Glib::ustring> IconImpl::legacyNames;
 
-static GtkWidgetClass *parent_class;
 
 static bool sizeDirty = true;
 
@@ -79,8 +101,6 @@ static GtkIconSize iconSizeLookup[] = {
     GTK_ICON_SIZE_MENU, // for Inkscape::ICON_SIZE_DECORATION
 };
 
-static std::map<Glib::ustring, Glib::ustring> legacyNames;
-
 class IconCacheItem
 {
 public:
@@ -95,8 +115,7 @@ public:
 static std::map<Glib::ustring, std::vector<IconCacheItem> > iconSetCache;
 static std::set<Glib::ustring> internalNames;
 
-GType
-sp_icon_get_type()
+GType SPIcon::getType()
 {
     static GType type = 0;
     if (!type) {
@@ -104,12 +123,12 @@ sp_icon_get_type()
             sizeof(SPIconClass),
             NULL,
             NULL,
-            (GClassInitFunc) sp_icon_class_init,
+            reinterpret_cast<GClassInitFunc>(IconImpl::classInit),
             NULL,
             NULL,
             sizeof(SPIcon),
             0,
-            (GInstanceInitFunc) sp_icon_init,
+            reinterpret_cast<GInstanceInitFunc>(IconImpl::init),
             NULL
         };
         type = g_type_register_static(GTK_TYPE_WIDGET, "SPIcon", &info, (GTypeFlags)0);
@@ -117,8 +136,7 @@ sp_icon_get_type()
     return type;
 }
 
-static void
-sp_icon_class_init(SPIconClass *klass)
+void IconImpl::classInit(SPIconClass *klass)
 {
     GObjectClass *object_class;
     GtkWidgetClass *widget_class;
@@ -128,18 +146,16 @@ sp_icon_class_init(SPIconClass *klass)
 
     parent_class = (GtkWidgetClass*)g_type_class_peek_parent(klass);
 
-    object_class->dispose = sp_icon_dispose;
+    object_class->dispose = IconImpl::dispose;
 
-    widget_class->size_request = sp_icon_size_request;
-    widget_class->size_allocate = sp_icon_size_allocate;
-    widget_class->expose_event = sp_icon_expose;
-    widget_class->screen_changed = sp_icon_screen_changed;
-    widget_class->style_set = sp_icon_style_set;
+    widget_class->size_request = IconImpl::sizeRequest;
+    widget_class->size_allocate = IconImpl::sizeAllocate;
+    widget_class->expose_event = IconImpl::expose;
+    widget_class->screen_changed = IconImpl::screenChanged;
+    widget_class->style_set = IconImpl::styleSet;
 }
 
-
-static void
-sp_icon_init(SPIcon *icon)
+void IconImpl::init(SPIcon *icon)
 {
     GTK_WIDGET_FLAGS(icon) |= GTK_NO_WINDOW;
     icon->lsize = Inkscape::ICON_SIZE_BUTTON;
@@ -148,11 +164,10 @@ sp_icon_init(SPIcon *icon)
     icon->pb = 0;
 }
 
-static void
-sp_icon_dispose(GObject *object)
+void IconImpl::dispose(GObject *object)
 {
     SPIcon *icon = SP_ICON(object);
-    sp_icon_clear(icon);
+    clear(icon);
     if ( icon->name ) {
         g_free( icon->name );
         icon->name = 0;
@@ -161,32 +176,32 @@ sp_icon_dispose(GObject *object)
     ((GObjectClass *) (parent_class))->dispose(object);
 }
 
-static void sp_icon_reset( SPIcon *icon ) {
+void IconImpl::reset( SPIcon *icon )
+{
     icon->psize = 0;
-    sp_icon_clear(icon);
+    clear(icon);
 }
 
-static void sp_icon_clear( SPIcon *icon ) {
+void IconImpl::clear( SPIcon *icon )
+{
     if (icon->pb) {
         g_object_unref(G_OBJECT(icon->pb));
         icon->pb = NULL;
     }
 }
 
-static void
-sp_icon_size_request(GtkWidget *widget, GtkRequisition *requisition)
+void IconImpl::sizeRequest(GtkWidget *widget, GtkRequisition *requisition)
 {
     SPIcon const *icon = SP_ICON(widget);
 
     int const size = ( icon->psize
                        ? icon->psize
-                       : sp_icon_get_phys_size(icon->lsize) );
+                       : getPhysSize(icon->lsize) );
     requisition->width = size;
     requisition->height = size;
 }
 
-static void
-sp_icon_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
+void IconImpl::sizeAllocate(GtkWidget *widget, GtkAllocation *allocation)
 {
     widget->allocation = *allocation;
 
@@ -195,34 +210,37 @@ sp_icon_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
     }
 }
 
-static int sp_icon_expose(GtkWidget *widget, GdkEventExpose *event)
+int IconImpl::expose(GtkWidget *widget, GdkEventExpose *event)
 {
     if ( GTK_WIDGET_DRAWABLE(widget) ) {
         SPIcon *icon = SP_ICON(widget);
         if ( !icon->pb ) {
-            sp_icon_fetch_pixbuf( icon );
+            fetchPixbuf( icon );
         }
 
-        sp_icon_paint(SP_ICON(widget), &event->area);
+        paint(icon, &event->area);
     }
 
     return TRUE;
 }
 
-static GdkPixbuf* renderup( gchar const* name, Inkscape::IconSize lsize, unsigned psize );
-
 // PUBLIC CALL:
 void sp_icon_fetch_pixbuf( SPIcon *icon )
+{
+    return IconImpl::fetchPixbuf(icon);
+}
+
+void IconImpl::fetchPixbuf( SPIcon *icon )
 {
     if ( icon ) {
         if ( !icon->pb ) {
-            icon->psize = sp_icon_get_phys_size(icon->lsize);
+            icon->psize = getPhysSize(icon->lsize);
             icon->pb = renderup(icon->name, icon->lsize, icon->psize);
         }
     }
 }
 
-GdkPixbuf* renderup( gchar const* name, Inkscape::IconSize lsize, unsigned psize ) {
+GdkPixbuf* IconImpl::renderup( gchar const* name, Inkscape::IconSize lsize, unsigned psize ) {
     GtkIconTheme *theme = gtk_icon_theme_get_default();
 
     GdkPixbuf *pb = 0;
@@ -239,7 +257,7 @@ GdkPixbuf* renderup( gchar const* name, Inkscape::IconSize lsize, unsigned psize
             names.push_back(legacyNames[name]);
         }
 
-        pb = sp_icon_image_load_svg( names, Inkscape::getRegisteredIconSize(lsize), psize );
+        pb = loadSvg( names, Inkscape::getRegisteredIconSize(lsize), psize );
 
         // if this was loaded from SVG, add it as a builtin icon
         if (pb) {
@@ -247,7 +265,7 @@ GdkPixbuf* renderup( gchar const* name, Inkscape::IconSize lsize, unsigned psize
         }
     }
     if (!pb) {
-        pb = sp_icon_image_load_pixmap( name, lsize, psize );
+        pb = loadPixmap( name, lsize, psize );
     }
     if ( !pb ) {
         // TODO: We should do something more useful if we can't load the image.
@@ -256,43 +274,40 @@ GdkPixbuf* renderup( gchar const* name, Inkscape::IconSize lsize, unsigned psize
     return pb;
 }
 
-static void sp_icon_screen_changed( GtkWidget *widget, GdkScreen *previous_screen )
+void IconImpl::screenChanged( GtkWidget *widget, GdkScreen *previous_screen )
 {
     if ( GTK_WIDGET_CLASS( parent_class )->screen_changed ) {
         GTK_WIDGET_CLASS( parent_class )->screen_changed( widget, previous_screen );
     }
     SPIcon *icon = SP_ICON(widget);
-    sp_icon_theme_changed(icon);
+    themeChanged(icon);
 }
 
-static void sp_icon_style_set( GtkWidget *widget, GtkStyle *previous_style )
+void IconImpl::styleSet( GtkWidget *widget, GtkStyle *previous_style )
 {
     if ( GTK_WIDGET_CLASS( parent_class )->style_set ) {
         GTK_WIDGET_CLASS( parent_class )->style_set( widget, previous_style );
     }
     SPIcon *icon = SP_ICON(widget);
-    sp_icon_theme_changed(icon);
+    themeChanged(icon);
 }
 
-static void sp_icon_theme_changed( SPIcon *icon )
+void IconImpl::themeChanged( SPIcon *icon )
 {
     bool const dump = Inkscape::Preferences::get()->getBool("/debug/icons/dumpSvg");
     if ( dump ) {
         g_message("Got a change bump for this icon");
     }
     sizeDirty = true;
-    sp_icon_reset(icon);
+    reset(icon);
     gtk_widget_queue_draw( GTK_WIDGET(icon) );
 }
 
 
-static void imageMapCB(GtkWidget* widget, gpointer user_data);
-static void imageMapNamedCB(GtkWidget* widget, gpointer user_data);
-static bool prerender_icon(gchar const *name, GtkIconSize lsize, unsigned psize);
 static Glib::ustring icon_cache_key(Glib::ustring const &name, unsigned psize);
 static GdkPixbuf *get_cached_pixbuf(Glib::ustring const &key);
 
-static void setupLegacyNaming() {
+void IconImpl::setupLegacyNaming() {
     legacyNames["document-import"] ="file_import";
     legacyNames["document-export"] ="file_export";
     legacyNames["document-import-ocal"] ="ocal_import";
@@ -547,7 +562,7 @@ static void setupLegacyNaming() {
     legacyNames["zoom"] ="sticky_zoom";
 }
 
-static GtkWidget *sp_icon_new_full( Inkscape::IconSize lsize, gchar const *name )
+GtkWidget *IconImpl::newFull( Inkscape::IconSize lsize, gchar const *name )
 {
     static bool dump = Inkscape::Preferences::get()->getBool("/debug/icons/dumpGtk");
 
@@ -603,8 +618,8 @@ static GtkWidget *sp_icon_new_full( Inkscape::IconSize lsize, gchar const *name
             g_signal_connect( G_OBJECT(widget), "map", G_CALLBACK(imageMapNamedCB), GINT_TO_POINTER(0) );
 
             if ( Inkscape::Preferences::get()->getBool("/options/iconrender/named_nodelay") ) {
-                int psize = sp_icon_get_phys_size(lsize);
-                prerender_icon(name, mappedSize, psize);
+                int psize = getPhysSize(lsize);
+                prerenderIcon(name, mappedSize, psize);
             } else {
                 addPreRender( mappedSize, name );
             }
@@ -622,7 +637,7 @@ static GtkWidget *sp_icon_new_full( Inkscape::IconSize lsize, gchar const *name
         SPIcon *icon = (SPIcon *)g_object_new(SP_TYPE_ICON, NULL);
         icon->lsize = lsize;
         icon->name = g_strdup(name);
-        icon->psize = sp_icon_get_phys_size(lsize);
+        icon->psize = getPhysSize(lsize);
 
         widget = GTK_WIDGET(icon);
     }
@@ -630,17 +645,17 @@ static GtkWidget *sp_icon_new_full( Inkscape::IconSize lsize, gchar const *name
     return widget;
 }
 
-GtkWidget *
-sp_icon_new( Inkscape::IconSize lsize, gchar const *name )
+// PUBLIC CALL:
+GtkWidget *sp_icon_new( Inkscape::IconSize lsize, gchar const *name )
 {
-    return sp_icon_new_full( lsize, name );
+    return IconImpl::newFull( lsize, name );
 }
 
 // PUBLIC CALL:
 Gtk::Widget *sp_icon_get_icon( Glib::ustring const &oid, Inkscape::IconSize size )
 {
     Gtk::Widget *result = 0;
-    GtkWidget *widget = sp_icon_new_full( static_cast<Inkscape::IconSize>(Inkscape::getRegisteredIconSize(size)), oid.c_str() );
+    GtkWidget *widget = IconImpl::newFull( static_cast<Inkscape::IconSize>(Inkscape::getRegisteredIconSize(size)), oid.c_str() );
 
     if ( widget ) {
         if ( GTK_IS_IMAGE(widget) ) {
@@ -654,22 +669,7 @@ Gtk::Widget *sp_icon_get_icon( Glib::ustring const &oid, Inkscape::IconSize size
     return result;
 }
 
-GtkIconSize
-sp_icon_get_gtk_size(int size)
-{
-    static GtkIconSize sizemap[64] = {(GtkIconSize)0};
-    size = CLAMP(size, 4, 63);
-    if (!sizemap[size]) {
-        static int count = 0;
-        char c[64];
-        g_snprintf(c, 64, "InkscapeIcon%d", count++);
-        sizemap[size] = gtk_icon_size_register(c, size, size);
-    }
-    return sizemap[size];
-}
-
-
-static void injectCustomSize()
+void IconImpl::injectCustomSize()
 {
     // TODO - still need to handle the case of theme changes and resize, especially as we can't re-register a string.
     if ( !sizeMapDone )
@@ -700,7 +700,7 @@ static void injectCustomSize()
 GtkIconSize Inkscape::getRegisteredIconSize( Inkscape::IconSize size )
 {
     GtkIconSize other = GTK_ICON_SIZE_MENU;
-    injectCustomSize();
+    IconImpl::injectCustomSize();
     size = CLAMP( size, Inkscape::ICON_SIZE_MENU, Inkscape::ICON_SIZE_DECORATION );
     if ( size == Inkscape::ICON_SIZE_DECORATION ) {
         other = gtk_icon_size_from_name("inkscape-decoration");
@@ -714,6 +714,11 @@ GtkIconSize Inkscape::getRegisteredIconSize( Inkscape::IconSize size )
 
 // PUBLIC CALL:
 int sp_icon_get_phys_size(int size)
+{
+    return IconImpl::getPhysSize(size);
+}
+
+int IconImpl::getPhysSize(int size)
 {
     static bool init = false;
     static int lastSys[Inkscape::ICON_SIZE_DECORATION + 1];
@@ -828,7 +833,7 @@ int sp_icon_get_phys_size(int size)
     return vals[size];
 }
 
-static void sp_icon_paint(SPIcon *icon, GdkRectangle const */*area*/)
+void IconImpl::paint(SPIcon *icon, GdkRectangle const */*area*/)
 {
     GtkWidget &widget = *GTK_WIDGET(icon);
     GdkPixbuf *image = icon->pb;
@@ -864,7 +869,7 @@ static void sp_icon_paint(SPIcon *icon, GdkRectangle const */*area*/)
     }
 }
 
-GdkPixbuf *sp_icon_image_load_pixmap(gchar const *name, unsigned /*lsize*/, unsigned psize)
+GdkPixbuf *IconImpl::loadPixmap(gchar const *name, unsigned /*lsize*/, unsigned psize)
 {
     gchar *path = (gchar *) g_strdup_printf("%s/%s.png", INKSCAPE_PIXMAPDIR, name);
     // TODO: bulia, please look over
@@ -912,9 +917,8 @@ GdkPixbuf *sp_icon_image_load_pixmap(gchar const *name, unsigned /*lsize*/, unsi
 }
 
 // takes doc, root, icon, and icon name to produce pixels
-extern "C" guchar *
-sp_icon_doc_icon( SPDocument *doc, NRArenaItem *root,
-                  gchar const *name, unsigned psize )
+extern "C" guchar *sp_icon_doc_icon( SPDocument *doc, NRArenaItem *root,
+                                     gchar const *name, unsigned psize )
 {
     bool const dump = Inkscape::Preferences::get()->getBool("/debug/icons/dumpSvg");
     guchar *px = NULL;
@@ -1030,7 +1034,7 @@ sp_icon_doc_icon( SPDocument *doc, NRArenaItem *root,
                 nr_pixblock_release(&B);
 
                 if ( Inkscape::Preferences::get()->getBool("/debug/icons/overlaySvg") ) {
-                    sp_icon_overlay_pixels( px, psize, psize, 4 * psize, 0x00, 0x00, 0xff );
+                    IconImpl::overlayPixels( px, psize, psize, 4 * psize, 0x00, 0x00, 0xff );
                 }
             }
         }
@@ -1161,13 +1165,13 @@ void Inkscape::queueIconPrerender( Glib::ustring const &name, Inkscape::IconSize
     if (!stockFound && !themedFound ) {
         gint trySize = CLAMP( static_cast<gint>(lsize), 0, static_cast<gint>(G_N_ELEMENTS(iconSizeLookup) - 1) );
         if ( !sizeMapDone ) {
-            injectCustomSize();
+            IconImpl::injectCustomSize();
         }
         GtkIconSize mappedSize = iconSizeLookup[trySize];
 
-        int psize = sp_icon_get_phys_size(lsize);
+        int psize = IconImpl::getPhysSize(lsize);
         // TODO place in a queue that is triggered by other map events
-        prerender_icon(name.c_str(), mappedSize, psize);
+        IconImpl::prerenderIcon(name.c_str(), mappedSize, psize);
     }
 }
 
@@ -1185,7 +1189,7 @@ static std::string getDestDir( unsigned psize )
 }
 
 // returns true if icon needed preloading, false if nothing was done
-bool prerender_icon(gchar const *name, GtkIconSize lsize, unsigned psize)
+bool IconImpl::prerenderIcon(gchar const *name, GtkIconSize lsize, unsigned psize)
 {
     bool loadNeeded = false;
     static bool dump = Inkscape::Preferences::get()->getBool("/debug/icons/dumpGtk");
@@ -1196,7 +1200,7 @@ bool prerender_icon(gchar const *name, GtkIconSize lsize, unsigned psize)
         if ((internalNames.find(name) != internalNames.end())
             || (!gtk_icon_theme_has_icon(gtk_icon_theme_get_default(), name))) {
             if (dump) {
-                g_message("prerender_icon  [%s] %d:%d", name, lsize, psize);
+                g_message("prerenderIcon  [%s] %d:%d", name, lsize, psize);
             }
 
             std::string potentialFile;
@@ -1278,13 +1282,13 @@ bool prerender_icon(gchar const *name, GtkIconSize lsize, unsigned psize)
             }
         }
         else if (dump) {
-            g_message("prerender_icon  [%s] %d NOT!!!!!!", name, psize);
+            g_message("prerenderIcon  [%s] %d NOT!!!!!!", name, psize);
         }
     }
     return loadNeeded;
 }
 
-static GdkPixbuf *sp_icon_image_load_svg(std::list<Glib::ustring> const &names, GtkIconSize lsize, unsigned psize)
+GdkPixbuf *IconImpl::loadSvg(std::list<Glib::ustring> const &names, GtkIconSize lsize, unsigned psize)
 {
     Glib::ustring key = icon_cache_key(*names.begin(), psize);
 
@@ -1308,7 +1312,7 @@ static GdkPixbuf *sp_icon_image_load_svg(std::list<Glib::ustring> const &names,
     return pb;
 }
 
-void sp_icon_overlay_pixels(guchar *px, int width, int height, int stride,
+void IconImpl::overlayPixels(guchar *px, int width, int height, int stride,
                             unsigned r, unsigned g, unsigned b)
 {
     int bytesPerPixel = 4;
@@ -1380,18 +1384,18 @@ public:
 static std::vector<preRenderItem> pendingRenders;
 static bool callbackHooked = false;
 
-static void addPreRender( GtkIconSize lsize, gchar const *name )
+void IconImpl::addPreRender( GtkIconSize lsize, gchar const *name )
 {
     if ( !callbackHooked )
     {
         callbackHooked = true;
-        g_idle_add_full( G_PRIORITY_LOW, &icon_prerender_task, NULL, NULL );
+        g_idle_add_full( G_PRIORITY_LOW, &prerenderTask, NULL, NULL );
     }
 
     pendingRenders.push_back(preRenderItem(lsize, name));
 }
 
-gboolean icon_prerender_task(gpointer /*data*/) {
+gboolean IconImpl::prerenderTask(gpointer /*data*/) {
     if ( inkscapeIsCrashing() ) {
         // stop
     } else if (!pendingRenders.empty()) {
@@ -1399,8 +1403,8 @@ gboolean icon_prerender_task(gpointer /*data*/) {
         do {
             preRenderItem single = pendingRenders.front();
             pendingRenders.erase(pendingRenders.begin());
-            int psize = sp_icon_get_phys_size(single._lsize);
-            workDone = prerender_icon(single._name.c_str(), single._lsize, psize);
+            int psize = getPhysSize(single._lsize);
+            workDone = prerenderIcon(single._name.c_str(), single._lsize, psize);
         } while (!pendingRenders.empty() && !workDone);
     }
 
@@ -1413,22 +1417,23 @@ gboolean icon_prerender_task(gpointer /*data*/) {
 }
 
 
-void imageMapCB(GtkWidget* widget, gpointer user_data) {
+void IconImpl::imageMapCB(GtkWidget* widget, gpointer user_data)
+{
     gchar* id = 0;
     GtkIconSize size = GTK_ICON_SIZE_INVALID;
     gtk_image_get_stock(GTK_IMAGE(widget), &id, &size);
     GtkIconSize lsize = static_cast<GtkIconSize>(GPOINTER_TO_INT(user_data));
     if ( id ) {
-        int psize = sp_icon_get_phys_size(lsize);
+        int psize = getPhysSize(lsize);
         g_message("imageMapCB(%p) for [%s]:%d:%d", widget, id, lsize, psize);
         for ( std::vector<preRenderItem>::iterator it = pendingRenders.begin(); it != pendingRenders.end(); ++it ) {
             if ( (it->_name == id) && (it->_lsize == lsize) ) {
-                prerender_icon(id, lsize, psize);
+                prerenderIcon(id, lsize, psize);
                 pendingRenders.erase(it);
                 g_message("    prerender for %s:%d:%d", id, lsize, psize);
                 if (lsize != size) {
-                    int psize = sp_icon_get_phys_size(size);
-                    prerender_icon(id, size, psize);
+                    int psize = getPhysSize(size);
+                    prerenderIcon(id, size, psize);
                 }
                 break;
             }
@@ -1438,7 +1443,8 @@ void imageMapCB(GtkWidget* widget, gpointer user_data) {
     g_signal_handlers_disconnect_by_func(widget, (gpointer)imageMapCB, user_data);
 }
 
-static void imageMapNamedCB(GtkWidget* widget, gpointer user_data) {
+void IconImpl::imageMapNamedCB(GtkWidget* widget, gpointer user_data)
+{
     GtkImage* img = GTK_IMAGE(widget);
     gchar const* iconName = 0;
     GtkIconSize size = GTK_ICON_SIZE_INVALID;
@@ -1458,8 +1464,8 @@ static void imageMapNamedCB(GtkWidget* widget, gpointer user_data) {
 
             for ( std::vector<preRenderItem>::iterator it = pendingRenders.begin(); it != pendingRenders.end(); ++it ) {
                 if ( (it->_name == iconName) && (it->_lsize == size) ) {
-                    int psize = sp_icon_get_phys_size(size);
-                    prerender_icon(iconName, size, psize);
+                    int psize = getPhysSize(size);
+                    prerenderIcon(iconName, size, psize);
                     pendingRenders.erase(it);
                     break;
                 }

diff --git a/src/widgets/icon.h b/src/widgets/icon.h
index f70423702a862fe3d4eac399343a285bfb66d805..a20fad73a95011cde0f9b3a909fef9b068b1d520 100644 (file)
--- a/src/widgets/icon.h
+++ b/src/widgets/icon.h
@@ -6,8 +6,10 @@
  *
  * Author:
  *   Lauris Kaplinski <lauris@kaplinski.com>
+ *   Jon A. Cruz <jon@joncruz.org>
  *
  * Copyright (C) 2002 Lauris Kaplinski
+ * Copyright (C) 2010 Authors
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
@@ -16,12 +18,16 @@
 
 #include "icon-size.h"
 
-#define SP_TYPE_ICON (sp_icon_get_type ())
+#define SP_TYPE_ICON SPIcon::getType()
 #define SP_ICON(o) (GTK_CHECK_CAST ((o), SP_TYPE_ICON, SPIcon))
 #define SP_IS_ICON(o) (GTK_CHECK_TYPE ((o), SP_TYPE_ICON))
 
 #include <gtk/gtkwidget.h>
 
+struct SPIconClass {
+    GtkWidgetClass parent_class;
+};
+
 struct SPIcon {
     GtkWidget widget;
 
@@ -30,13 +36,12 @@ struct SPIcon {
     gchar *name;
 
     GdkPixbuf *pb;
-};
 
-struct SPIconClass {
-    GtkWidgetClass parent_class;
+    static GType getType(void);
+
+    friend class SPIconImpl;
 };
 
-GType sp_icon_get_type (void);
 
 GtkWidget *sp_icon_new( Inkscape::IconSize size, const gchar *name );
 
@@ -54,3 +59,14 @@ namespace Inkscape {
 }
 
 #endif // SEEN_SP_ICON_H
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :