From: tweenk Date: Thu, 19 Feb 2009 23:57:21 +0000 (+0000) Subject: Make all icons themable (except the filter icons). X-Git-Url: https://git.tokkee.org/?a=commitdiff_plain;h=035e109c2dce9f6a9552f75d09b1573311d02546;p=inkscape.git Make all icons themable (except the filter icons). --- diff --git a/share/icons/icons.svg b/share/icons/icons.svg index ec05ea392..8f00bc765 100644 --- a/share/icons/icons.svg +++ b/share/icons/icons.svg @@ -1,3324 +1,19224 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -Created with Inkscape + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Created with Inkscape http://www.inkscape.org/ -image/svg+xml - - - - -Inkscape Developers - - - - -Inkscape Developers - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -none - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + image/svg+xml + + + + + Inkscape Developers + + + + + Inkscape Developers + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + none + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/dialogs/clonetiler.cpp b/src/dialogs/clonetiler.cpp index 467b34cff..55884fe4a 100644 --- a/src/dialogs/clonetiler.cpp +++ b/src/dialogs/clonetiler.cpp @@ -18,38 +18,34 @@ #include "application/application.h" #include "application/editor.h" -#include "helper/window.h" +#include "../desktop.h" +#include "../desktop-handles.h" +#include "dialog-events.h" +#include "display/nr-arena.h" +#include "display/nr-arena-item.h" +#include "../document.h" +#include "../filter-chemistry.h" #include "helper/unit-menu.h" #include "helper/units.h" -#include "widgets/icon.h" +#include "helper/window.h" #include "../inkscape.h" -#include "preferences.h" -#include "dialog-events.h" -#include "../macros.h" -#include "../verbs.h" #include "../interface.h" +#include "../macros.h" +#include "../message-stack.h" +#include "preferences.h" #include "../selection.h" -#include "../style.h" -#include "../desktop.h" -#include "../desktop-handles.h" +#include "../sp-filter.h" #include "../sp-namedview.h" -#include "../document.h" -#include "../message-stack.h" #include "../sp-use.h" -#include "unclump.h" - -#include "xml/repr.h" - -#include "svg/svg.h" +#include "../style.h" #include "svg/svg-color.h" - -#include "display/nr-arena.h" -#include "display/nr-arena-item.h" - +#include "svg/svg.h" +#include "ui/icon-names.h" #include "ui/widget/color-picker.h" - -#include "../sp-filter.h" -#include "../filter-chemistry.h" +#include "unclump.h" +#include "../verbs.h" +#include "widgets/icon.h" +#include "xml/repr.h" #define MIN_ONSCREEN_DISTANCE 50 @@ -1703,7 +1699,7 @@ clonetiler_table_x_y_rand (int values) { GtkWidget *hb = gtk_hbox_new (FALSE, 0); - GtkWidget *i = sp_icon_new (Inkscape::ICON_SIZE_DECORATION, "clonetiler_per_row"); + GtkWidget *i = sp_icon_new (Inkscape::ICON_SIZE_DECORATION, INKSCAPE_ICON_OBJECT_ROWS); gtk_box_pack_start (GTK_BOX (hb), i, FALSE, FALSE, 2); GtkWidget *l = gtk_label_new (""); @@ -1716,7 +1712,7 @@ clonetiler_table_x_y_rand (int values) { GtkWidget *hb = gtk_hbox_new (FALSE, 0); - GtkWidget *i = sp_icon_new (Inkscape::ICON_SIZE_DECORATION, "clonetiler_per_column"); + GtkWidget *i = sp_icon_new (Inkscape::ICON_SIZE_DECORATION, INKSCAPE_ICON_OBJECT_COLUMNS); gtk_box_pack_start (GTK_BOX (hb), i, FALSE, FALSE, 2); GtkWidget *l = gtk_label_new (""); diff --git a/src/dialogs/fill-style.cpp b/src/dialogs/fill-style.cpp index e1c30e7ae..24e46f056 100644 --- a/src/dialogs/fill-style.cpp +++ b/src/dialogs/fill-style.cpp @@ -18,22 +18,24 @@ # include "config.h" #endif +#include -#include "widgets/sp-widget.h" +#include "desktop-handles.h" +#include "desktop-style.h" +#include "display/sp-canvas.h" +#include "document-private.h" +#include "gradient-chemistry.h" +#include "inkscape.h" +#include "selection.h" #include "sp-linear-gradient.h" #include "sp-pattern.h" #include "sp-radial-gradient.h" -#include "widgets/paint-selector.h" #include "style.h" -#include "gradient-chemistry.h" -#include "desktop-style.h" -#include "desktop-handles.h" -#include "selection.h" -#include "inkscape.h" -#include "document-private.h" +#include "widgets/paint-selector.h" +#include "widgets/sp-widget.h" #include "xml/repr.h" -#include -#include "display/sp-canvas.h" + +#include "dialogs/fill-style.h" // These can be deleted once we sort out the libart dependence. diff --git a/src/dialogs/layers-panel.cpp b/src/dialogs/layers-panel.cpp index 1b754c606..c826777a2 100644 --- a/src/dialogs/layers-panel.cpp +++ b/src/dialogs/layers-panel.cpp @@ -40,6 +40,7 @@ #include "xml/repr.h" #include "svg/css-ostringstream.h" #include "desktop-style.h" +#include "ui/icon-names.h" //#define DUMP_LAYERS 1 @@ -601,7 +602,8 @@ LayersPanel::LayersPanel() : _tree.set_model( _store ); _tree.set_headers_visible(false); - Inkscape::UI::Widget::ImageToggler *eyeRenderer = manage( new Inkscape::UI::Widget::ImageToggler("visible", "hidden") ); + Inkscape::UI::Widget::ImageToggler *eyeRenderer = manage( new Inkscape::UI::Widget::ImageToggler( + INKSCAPE_ICON_OBJECT_VISIBLE, INKSCAPE_ICON_OBJECT_HIDDEN) ); int visibleColNum = _tree.append_column("vis", *eyeRenderer) - 1; eyeRenderer->signal_pre_toggle().connect( sigc::mem_fun(*this, &LayersPanel::_preToggle) ); eyeRenderer->signal_toggled().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_toggled), (int)COL_VISIBLE) ); @@ -611,7 +613,8 @@ LayersPanel::LayersPanel() : col->add_attribute( eyeRenderer->property_active(), _model->_colVisible ); } - Inkscape::UI::Widget::ImageToggler * renderer = manage( new Inkscape::UI::Widget::ImageToggler("width_height_lock", "lock_unlocked") ); + Inkscape::UI::Widget::ImageToggler * renderer = manage( new Inkscape::UI::Widget::ImageToggler( + INKSCAPE_ICON_OBJECT_LOCKED, INKSCAPE_ICON_OBJECT_UNLOCKED) ); int lockedColNum = _tree.append_column("lock", *renderer) - 1; renderer->signal_pre_toggle().connect( sigc::mem_fun(*this, &LayersPanel::_preToggle) ); renderer->signal_toggled().connect( sigc::bind( sigc::mem_fun(*this, &LayersPanel::_toggled), (int)COL_LOCKED) ); diff --git a/src/dialogs/stroke-style.cpp b/src/dialogs/stroke-style.cpp index b0375f755..566ee5117 100644 --- a/src/dialogs/stroke-style.cpp +++ b/src/dialogs/stroke-style.cpp @@ -20,38 +20,38 @@ #include #include - #include -#include "helper/unit-menu.h" -#include "helper/units.h" -#include "svg/css-ostringstream.h" -#include "widgets/sp-widget.h" -#include "widgets/spw-utilities.h" -#include "sp-linear-gradient.h" -#include "sp-radial-gradient.h" -#include "marker.h" -#include "sp-pattern.h" -#include "widgets/paint-selector.h" -#include "widgets/dash-selector.h" -#include "style.h" -#include "gradient-chemistry.h" -#include "sp-namedview.h" + #include "desktop-handles.h" #include "desktop-style.h" -#include "selection.h" -#include "inkscape.h" -#include "inkscape-stock.h" #include "dialogs/dialog-events.h" -#include "sp-text.h" -#include "sp-rect.h" -#include "document-private.h" #include "display/nr-arena.h" #include "display/nr-arena-item.h" -#include "path-prefix.h" -#include "widgets/icon.h" +#include "document-private.h" +#include "gradient-chemistry.h" #include "helper/stock-items.h" +#include "helper/unit-menu.h" +#include "helper/units.h" +#include "inkscape.h" #include "io/sys.h" +#include "marker.h" +#include "path-prefix.h" +#include "selection.h" +#include "sp-linear-gradient.h" +#include "sp-namedview.h" +#include "sp-pattern.h" +#include "sp-radial-gradient.h" +#include "sp-rect.h" +#include "sp-text.h" +#include "style.h" +#include "svg/css-ostringstream.h" #include "ui/cache/svg_preview_cache.h" +#include "ui/icon-names.h" +#include "widgets/dash-selector.h" +#include "widgets/icon.h" +#include "widgets/paint-selector.h" +#include "widgets/sp-widget.h" +#include "widgets/spw-utilities.h" #include "xml/repr.h" #include "dialogs/stroke-style.h" @@ -1118,7 +1118,7 @@ sp_stroke_style_line_widget_new(void) tb = NULL; - tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_JOIN_MITER, + tb = sp_stroke_radio_button(tb, INKSCAPE_ICON_STROKE_JOIN_MITER, hb, spw, "join", "miter"); // TRANSLATORS: Miter join: joining lines with a sharp (pointed) corner. @@ -1126,7 +1126,7 @@ sp_stroke_style_line_widget_new(void) // "Join" option (in the Fill and Stroke dialog). tt->set_tip(*tb, _("Miter join")); - tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_JOIN_ROUND, + tb = sp_stroke_radio_button(tb, INKSCAPE_ICON_STROKE_JOIN_ROUND, hb, spw, "join", "round"); // TRANSLATORS: Round join: joining lines with a rounded corner. @@ -1134,7 +1134,7 @@ sp_stroke_style_line_widget_new(void) // "Join" option (in the Fill and Stroke dialog). tt->set_tip(*tb, _("Round join")); - tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_JOIN_BEVEL, + tb = sp_stroke_radio_button(tb, INKSCAPE_ICON_STROKE_JOIN_BEVEL, hb, spw, "join", "bevel"); // TRANSLATORS: Bevel join: joining lines with a blunted (flattened) corner. @@ -1177,21 +1177,21 @@ sp_stroke_style_line_widget_new(void) tb = NULL; - tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_CAP_BUTT, + tb = sp_stroke_radio_button(tb, INKSCAPE_ICON_STROKE_CAP_BUTT, hb, spw, "cap", "butt"); // TRANSLATORS: Butt cap: the line shape does not extend beyond the end point // of the line; the ends of the line are square tt->set_tip(*tb, _("Butt cap")); - tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_CAP_ROUND, + tb = sp_stroke_radio_button(tb, INKSCAPE_ICON_STROKE_CAP_ROUND, hb, spw, "cap", "round"); // TRANSLATORS: Round cap: the line shape extends beyond the end point of the // line; the ends of the line are rounded tt->set_tip(*tb, _("Round cap")); - tb = sp_stroke_radio_button(tb, INKSCAPE_STOCK_CAP_SQUARE, + tb = sp_stroke_radio_button(tb, INKSCAPE_ICON_STROKE_CAP_SQUARE, hb, spw, "cap", "square"); // TRANSLATORS: Square cap: the line shape extends beyond the end point of the @@ -1329,13 +1329,13 @@ sp_jointype_set (Gtk::Container *spw, unsigned const jointype) Gtk::RadioButton *tb = NULL; switch (jointype) { case SP_STROKE_LINEJOIN_MITER: - tb = static_cast(spw->get_data(INKSCAPE_STOCK_JOIN_MITER)); + tb = static_cast(spw->get_data(INKSCAPE_ICON_STROKE_JOIN_MITER)); break; case SP_STROKE_LINEJOIN_ROUND: - tb = static_cast(spw->get_data(INKSCAPE_STOCK_JOIN_ROUND)); + tb = static_cast(spw->get_data(INKSCAPE_ICON_STROKE_JOIN_ROUND)); break; case SP_STROKE_LINEJOIN_BEVEL: - tb = static_cast(spw->get_data(INKSCAPE_STOCK_JOIN_BEVEL)); + tb = static_cast(spw->get_data(INKSCAPE_ICON_STROKE_JOIN_BEVEL)); break; default: break; @@ -1352,13 +1352,13 @@ sp_captype_set (Gtk::Container *spw, unsigned const captype) Gtk::RadioButton *tb = NULL; switch (captype) { case SP_STROKE_LINECAP_BUTT: - tb = static_cast(spw->get_data(INKSCAPE_STOCK_CAP_BUTT)); + tb = static_cast(spw->get_data(INKSCAPE_ICON_STROKE_CAP_BUTT)); break; case SP_STROKE_LINECAP_ROUND: - tb = static_cast(spw->get_data(INKSCAPE_STOCK_CAP_ROUND)); + tb = static_cast(spw->get_data(INKSCAPE_ICON_STROKE_CAP_ROUND)); break; case SP_STROKE_LINECAP_SQUARE: - tb = static_cast(spw->get_data(INKSCAPE_STOCK_CAP_SQUARE)); + tb = static_cast(spw->get_data(INKSCAPE_ICON_STROKE_CAP_SQUARE)); break; default: break; @@ -1674,16 +1674,16 @@ sp_stroke_style_set_join_buttons(Gtk::Container *spw, Gtk::ToggleButton *active) { Gtk::RadioButton *tb; - tb = static_cast(spw->get_data(INKSCAPE_STOCK_JOIN_MITER)); + tb = static_cast(spw->get_data(INKSCAPE_ICON_STROKE_JOIN_MITER)); tb->set_active(active == tb); Gtk::SpinButton *ml = static_cast(spw->get_data("miterlimit_sb")); ml->set_sensitive(active == tb); - tb = static_cast(spw->get_data(INKSCAPE_STOCK_JOIN_ROUND)); + tb = static_cast(spw->get_data(INKSCAPE_ICON_STROKE_JOIN_ROUND)); tb->set_active(active == tb); - tb = static_cast(spw->get_data(INKSCAPE_STOCK_JOIN_BEVEL)); + tb = static_cast(spw->get_data(INKSCAPE_ICON_STROKE_JOIN_BEVEL)); tb->set_active(active == tb); } @@ -1695,11 +1695,11 @@ sp_stroke_style_set_cap_buttons(Gtk::Container *spw, Gtk::ToggleButton *active) { Gtk::RadioButton *tb; - tb = static_cast(spw->get_data(INKSCAPE_STOCK_CAP_BUTT)); + tb = static_cast(spw->get_data(INKSCAPE_ICON_STROKE_CAP_BUTT)); tb->set_active(active == tb); - tb = static_cast(spw->get_data(INKSCAPE_STOCK_CAP_ROUND)); + tb = static_cast(spw->get_data(INKSCAPE_ICON_STROKE_CAP_ROUND)); tb->set_active(active == tb); - tb = static_cast(spw->get_data(INKSCAPE_STOCK_CAP_SQUARE)); + tb = static_cast(spw->get_data(INKSCAPE_ICON_STROKE_CAP_SQUARE)); tb->set_active(active == tb); } diff --git a/src/dialogs/text-edit.cpp b/src/dialogs/text-edit.cpp index e213a8aba..dc71de7c3 100644 --- a/src/dialogs/text-edit.cpp +++ b/src/dialogs/text-edit.cpp @@ -38,7 +38,7 @@ extern "C" { #include "../sp-text.h" #include "../sp-flowtext.h" #include "../text-editing.h" -#include "../inkscape-stock.h" +#include "../ui/icon-names.h" #include #include "dialog-events.h" @@ -295,7 +295,7 @@ sp_text_edit_dialog (void) // horizontal { GtkWidget *px = sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR, - INKSCAPE_STOCK_WRITING_MODE_LR ); + INKSCAPE_ICON_FORMAT_TEXT_DIRECTION_HORIZONTAL ); GtkWidget *b = group = gtk_radio_button_new (NULL); gtk_tooltips_set_tip (tt, b, _("Horizontal text"), NULL); gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE); @@ -303,13 +303,13 @@ sp_text_edit_dialog (void) gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE); gtk_container_add (GTK_CONTAINER (b), px); gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0); - g_object_set_data (G_OBJECT (dlg), INKSCAPE_STOCK_WRITING_MODE_LR, b); + g_object_set_data (G_OBJECT (dlg), INKSCAPE_ICON_FORMAT_TEXT_DIRECTION_HORIZONTAL, b); } // vertical { GtkWidget *px = sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR, - INKSCAPE_STOCK_WRITING_MODE_TB ); + INKSCAPE_ICON_FORMAT_TEXT_DIRECTION_VERTICAL ); GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group))); gtk_tooltips_set_tip (tt, b, _("Vertical text"), NULL); gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE); @@ -317,7 +317,7 @@ sp_text_edit_dialog (void) gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE); gtk_container_add (GTK_CONTAINER (b), px); gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0); - g_object_set_data (G_OBJECT (dlg), INKSCAPE_STOCK_WRITING_MODE_TB, b); + g_object_set_data (G_OBJECT (dlg), INKSCAPE_ICON_FORMAT_TEXT_DIRECTION_VERTICAL, b); } gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, 0); @@ -582,7 +582,7 @@ sp_get_text_dialog_style () } } - b = (GtkWidget*)g_object_get_data (G_OBJECT (dlg), INKSCAPE_STOCK_WRITING_MODE_LR ); + b = (GtkWidget*)g_object_get_data (G_OBJECT (dlg), INKSCAPE_ICON_FORMAT_TEXT_DIRECTION_HORIZONTAL ); if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (b))) { sp_repr_css_set_property (css, "writing-mode", "lr"); @@ -781,9 +781,9 @@ sp_text_edit_dialog_read_selection ( GtkWidget *dlg, gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b), TRUE); if (query->writing_mode.computed == SP_CSS_WRITING_MODE_LR_TB) { - b = (GtkWidget*)g_object_get_data ( G_OBJECT (dlg), INKSCAPE_STOCK_WRITING_MODE_LR ); + b = (GtkWidget*)g_object_get_data ( G_OBJECT (dlg), INKSCAPE_ICON_FORMAT_TEXT_DIRECTION_HORIZONTAL ); } else { - b = (GtkWidget*)g_object_get_data ( G_OBJECT (dlg), INKSCAPE_STOCK_WRITING_MODE_TB ); + b = (GtkWidget*)g_object_get_data ( G_OBJECT (dlg), INKSCAPE_ICON_FORMAT_TEXT_DIRECTION_VERTICAL ); } gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (b), TRUE); diff --git a/src/dialogs/xml-tree.cpp b/src/dialogs/xml-tree.cpp index 934045b33..65ae9a8a3 100644 --- a/src/dialogs/xml-tree.cpp +++ b/src/dialogs/xml-tree.cpp @@ -12,39 +12,34 @@ * Released under GNU GPL, read the file 'COPYING' for more information */ -#include +#include #include +#include + +#include "desktop.h" +#include "../desktop-handles.h" +#include "dialog-events.h" +#include "../document.h" +#include "../event-context.h" #include "helper/window.h" -#include "macros.h" +#include "in-dt-coordsys.h" #include "../inkscape.h" -#include "../document.h" -#include "../desktop-handles.h" -#include "desktop.h" +#include "../interface.h" +#include "macros.h" +#include "message-context.h" +#include "message-stack.h" +#include "../preferences.h" #include "../selection.h" +#include "shortcuts.h" +#include "../sp-root.h" #include "../sp-string.h" #include "../sp-tspan.h" -#include "../sp-root.h" -#include "../event-context.h" -#include "in-dt-coordsys.h" - - -#include "../widgets/sp-xmlview-tree.h" -#include "../widgets/sp-xmlview-content.h" -#include "../widgets/sp-xmlview-attr-list.h" - -#include "../inkscape-stock.h" -#include "widgets/icon.h" - -#include "dialog-events.h" -#include "../preferences.h" +#include "ui/icon-names.h" #include "../verbs.h" -#include "../interface.h" - -#include "shortcuts.h" -#include - -#include "message-stack.h" -#include "message-context.h" +#include "widgets/icon.h" +#include "../widgets/sp-xmlview-attr-list.h" +#include "../widgets/sp-xmlview-content.h" +#include "../widgets/sp-xmlview-tree.h" #define MIN_ONSCREEN_DISTANCE 50 @@ -288,7 +283,7 @@ void sp_xml_tree_dialog() _("New element node"), NULL, sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR, - INKSCAPE_STOCK_ADD_XML_ELEMENT_NODE ), + INKSCAPE_ICON_XML_ELEMENT_NEW ), G_CALLBACK(cmd_new_element_node), NULL); @@ -309,7 +304,7 @@ void sp_xml_tree_dialog() button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("New text node"), NULL, sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR, - INKSCAPE_STOCK_ADD_XML_TEXT_NODE ), + INKSCAPE_ICON_XML_TEXT_NEW ), G_CALLBACK(cmd_new_text_node), NULL); @@ -330,7 +325,7 @@ void sp_xml_tree_dialog() button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Duplicate node"), NULL, sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR, - INKSCAPE_STOCK_DUPLICATE_XML_NODE ), + INKSCAPE_ICON_XML_NODE_DUPLICATE ), G_CALLBACK(cmd_duplicate_node), NULL); @@ -351,7 +346,7 @@ void sp_xml_tree_dialog() button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Delete node"), NULL, sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR, - INKSCAPE_STOCK_DELETE_XML_NODE ), + INKSCAPE_ICON_XML_NODE_DELETE ), G_CALLBACK(cmd_delete_node), NULL ); gtk_signal_connect_while_alive(GTK_OBJECT(tree), "tree_select_row", @@ -451,7 +446,7 @@ void sp_xml_tree_dialog() button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Delete attribute"), NULL, sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR, - INKSCAPE_STOCK_DELETE_XML_ATTRIBUTE ), + INKSCAPE_ICON_XML_ATTRIBUTE_DELETE ), (GCallback) cmd_delete_attr, NULL); gtk_signal_connect_while_alive(GTK_OBJECT(attributes), "select_row", diff --git a/src/inkscape-stock.cpp b/src/inkscape-stock.cpp deleted file mode 100644 index 107d246b4..000000000 --- a/src/inkscape-stock.cpp +++ /dev/null @@ -1,59 +0,0 @@ -/* - * @file inkscape-stock.h GTK+ Stock resources - * - * Authors: - * Robert Crosbie - * - * Copyright (C) 1999-2002 Authors - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#include "gtk/gtkiconfactory.h" - -#include "widgets/icon.h" -#include "ui/widget/panel.h" - -void -inkscape_gtk_stock_init() { - static bool stock_initialized = false; - - if (stock_initialized) - return; - - // Ensure icon internal sizes get set up: - sp_icon_get_phys_size(GTK_ICON_SIZE_MENU); - - // And also prepare the swatches. - Inkscape::UI::Widget::Panel::prep(); - - GtkIconFactory *icon_factory = gtk_icon_factory_new(); - /* todo: Should we simply remove this file now that we're no longer - * calling gtk_icon_factory_add here? */ - gtk_icon_factory_add_default(icon_factory); - - stock_initialized = true; -} - -/* - 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:encoding=utf-8:textwidth=99 : diff --git a/src/inkscape-stock.h b/src/inkscape-stock.h deleted file mode 100644 index 0a18b7284..000000000 --- a/src/inkscape-stock.h +++ /dev/null @@ -1,150 +0,0 @@ -/* - * @file inkscape-stock.h GTK+ Stock resources - * - * Authors: - * Robert Crosbie - * - * Copyright (C) 1999-2002 Authors - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - */ - -#ifndef _INKSCAPE_STOCK_H_ -#define _INKSCAPE_STOCK_H_ - -/**************************************************************************/ -/** @name Inkscape Stock images */ -/**************************************************************************/ -/*@{*/ - -/*stroke style*/ -//#define INKSCAPE_STOCK_ABOUT "inkscape-about" -#define INKSCAPE_STOCK_JOIN_MITER "join_miter" -#define INKSCAPE_STOCK_JOIN_ROUND "join_round" -#define INKSCAPE_STOCK_JOIN_BEVEL "join_bevel" -#define INKSCAPE_STOCK_CAP_BUTT "cap_butt" -#define INKSCAPE_STOCK_CAP_ROUND "cap_round" -#define INKSCAPE_STOCK_CAP_SQUARE "cap_square" -//#define INKSCAPE_STOCK_START_MARKER "start_marker" -//#define INKSCAPE_STOCK_MID_MARKER "mid_marker" -//#define INKSCAPE_STOCK_END_MARKER "end_marker" -//#define INKSCAPE_STOCK_MARKER_NONE "-none" -//#define INKSCAPE_STOCK_MARKER_FILLED_ARROW "-filled_arrow" -//#define INKSCAPE_STOCK_MARKER_HOLLOW_ARROW "-hollow_arrow" -//#define INKSCAPE_STOCK_MARKER_QTY (3) - -/*object properties*/ -#define INKSCAPE_STOCK_ROTATE_LEFT "transform_rotate" -#define INKSCAPE_STOCK_SCALE_HOR "transform_scale_hor" -#define INKSCAPE_STOCK_SCALE_VER "transform_scale_ver" -#define INKSCAPE_STOCK_ARROWS_HOR "arrows_hor" -#define INKSCAPE_STOCK_ARROWS_VER "arrows_ver" -//#define INKSCAPE_STOCK_DIMENSION_HOR "dimension_hor" -//#define INKSCAPE_STOCK_DIMENSION_VER "dimension_ver" - -/*text editing*/ -#define INKSCAPE_STOCK_WRITING_MODE_LR "writing_mode_lr" -#define INKSCAPE_STOCK_WRITING_MODE_TB "writing_mode_tb" -#define INKSCAPE_STOCK_TEXT_LETTER_SPACING "text_letter_spacing" -#define INKSCAPE_STOCK_TEXT_LINE_SPACING "text_line_spacing" -#define INKSCAPE_STOCK_TEXT_HORZ_KERN "text_horz_kern" -#define INKSCAPE_STOCK_TEXT_VERT_KERN "text_vert_kern" -#define INKSCAPE_STOCK_TEXT_ROTATION "text_rotation" -#define INKSCAPE_STOCK_TEXT_REMOVE_KERNS "text_remove_kerns" - -/*xml-tree*/ -#define INKSCAPE_STOCK_ADD_XML_ELEMENT_NODE "add_xml_element_node" -#define INKSCAPE_STOCK_ADD_XML_TEXT_NODE "add_xml_text_node" -#define INKSCAPE_STOCK_DUPLICATE_XML_NODE "duplicate_xml_node" -#define INKSCAPE_STOCK_DELETE_XML_NODE "delete_xml_node" -#define INKSCAPE_STOCK_DELETE_XML_ATTRIBUTE "delete_xml_attribute" -#define INKSCAPE_STOCK_SET "set" - -/*paint-selector*/ -#define INKSCAPE_STOCK_FILL_NONE "fill_none" -#define INKSCAPE_STOCK_FILL_SOLID "fill_solid" -#define INKSCAPE_STOCK_FILL_GRADIENT "fill_gradient" -#define INKSCAPE_STOCK_FILL_RADIAL "fill_radial" -#define INKSCAPE_STOCK_FILL_PATTERN "fill_pattern" -#define INKSCAPE_STOCK_FILL_UNSET "fill_unset" -#define INKSCAPE_STOCK_FILL_FRACTAL "fill_fractal" - -//#define INKSCAPE_STOCK_GUIDE_DIALOG "guide_dialog" - -//#define INKSCAPE_STOCK_EDIT_DUPLICATE "edit_duplicate" - -//#define INKSCAPE_STOCK_SELECTION_TOP "selection_top" -//#define INKSCAPE_STOCK_SELECTION_BOT "selection_bot" -//#define INKSCAPE_STOCK_SELECTION_UP "selection_up" -//#define INKSCAPE_STOCK_SELECTION_DOWN "selection_down" -//#define INKSCAPE_STOCK_SELECTION_GROUP "selection_group" -//#define INKSCAPE_STOCK_SELECTION_UNGROUP "selection_ungroup" -//#define INKSCAPE_STOCK_SELECTION_COMBINE "selection_combine" -//#define INKSCAPE_STOCK_SELECTION_BREAK "selection_break" - -//#define INKSCAPE_STOCK_OBJECT_ROTATE "object_rotate" -//#define INKSCAPE_STOCK_OBJECT_RESET "object_reset" -//#define INKSCAPE_STOCK_OBJECT_TOCURVE "object_tocurve" - -//#define INKSCAPE_STOCK_DRAW_SELECT "draw_select" -//#define INKSCAPE_STOCK_DRAW_NODE "draw_node" -//#define INKSCAPE_STOCK_DRAW_RECT "draw_rect" -//#define INKSCAPE_STOCK_DRAW_ARC "draw_arc" -//#define INKSCAPE_STOCK_DRAW_STAR "draw_star" -//#define INKSCAPE_STOCK_DRAW_SPIRAL "draw_spiral" -//#define INKSCAPE_STOCK_DRAW_FREEHAND "draw_freehand" -//#define INKSCAPE_STOCK_DRAW_PEN "draw_pen" -//#define INKSCAPE_STOCK_DRAW_DYNAHAND "draw_dynahand" -//#define INKSCAPE_STOCK_DRAW_TEXT "draw_text" -//#define INKSCAPE_STOCK_DRAW_ZOOM "draw_zoom" -//#define INKSCAPE_STOCK_DRAW_DROPPER "draw_dropper" - -//#define INKSCAPE_STOCK_ZOOM_IN "zoom_in" -//#define INKSCAPE_STOCK_ZOOM_OUT "zoom_out" -//#define INKSCAPE_STOCK_TOGGLE_GRID "toggle_grid" -//#define INKSCAPE_STOCK_TOGGLE_GUIDES "toggle_guides" -//#define INKSCAPE_STOCK_ZOOM_PAGE "zoom_page" -//#define INKSCAPE_STOCK_ZOOM_DRAW "zoom_draw" -//#define INKSCAPE_STOCK_ZOOM_SELECT "zoom_select" - -//#define INKSCAPE_STOCK_OBJECT_LAYOUT "object_layout" -//#define INKSCAPE_STOCK_OBJECT_TRANS "object_trans" -//#define INKSCAPE_STOCK_OBJECT_ALIGN "object_align" -//#define INKSCAPE_STOCK_OBJECT_FONT "object_font" - -#define INKSCAPE_STOCK_PROPERTIES_FILL_PAGE "properties_fill" -#define INKSCAPE_STOCK_PROPERTIES_STROKE_PAINT_PAGE "properties_stroke_paint" -#define INKSCAPE_STOCK_PROPERTIES_STROKE_PAGE "properties_stroke" - -/** - * Sets up the inkscape stock repository. - */ - -void inkscape_gtk_stock_init(void); - -/*@}*/ -#endif /* _INKSCAPE_STOCK_H_ */ - -/* - Local Variables: - mode:c++ - c-file-style:"stroustrup" - c-file-offsets:((innamespace . 0)(inline-open . 0)) - indent-tabs-mode:nil - fill-column:99 - End: -*/ -// vim: filetype=c++:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 : - diff --git a/src/main.cpp b/src/main.cpp index 7bbe691d7..b9e5a98e2 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -68,7 +68,6 @@ #include "svg/stringstream.h" #include "inkscape-private.h" -#include "inkscape-stock.h" #include "inkscape-version.h" #include "sp-namedview.h" @@ -110,8 +109,10 @@ using Inkscape::Extension::Internal::PrintWin32; #endif #include "application/application.h" - #include "main-cmdlineact.h" +#include "widgets/icon.h" +#include "ui/widget/panel.h" + #include #include @@ -833,19 +834,17 @@ sp_main_gui(int argc, char const **argv) int retVal = sp_common_main( argc, argv, &fl ); g_return_val_if_fail(retVal == 0, 1); - inkscape_gtk_stock_init(); + // Add our icon directory to the search path for icon theme lookups. + gtk_icon_theme_append_search_path(gtk_icon_theme_get_default(), INKSCAPE_PIXMAPDIR); gdk_event_handler_set((GdkEventFunc)snooper, NULL, NULL); - Inkscape::Debug::log_display_config(); - /* Set default icon */ - gchar *filename = (gchar *) g_build_filename (INKSCAPE_APPICONDIR, "inkscape.png", NULL); - if (Inkscape::IO::file_test(filename, (GFileTest)(G_FILE_TEST_IS_REGULAR | G_FILE_TEST_IS_SYMLINK))) { - gtk_window_set_default_icon_from_file(filename, NULL); - } - g_free (filename); - filename = 0; + // Set default window icon. Obeys the theme. + gtk_window_set_default_icon_name("inkscape"); + // Do things that were previously in inkscape_gtk_stock_init(). + sp_icon_get_phys_size(GTK_ICON_SIZE_MENU); + Inkscape::UI::Widget::Panel::prep(); gboolean create_new = TRUE; diff --git a/src/nodepath.h b/src/nodepath.h index 8c3d27442..7a0c671e1 100644 --- a/src/nodepath.h +++ b/src/nodepath.h @@ -1,25 +1,21 @@ -#ifndef __SP_NODEPATH_H__ -#define __SP_NODEPATH_H__ - -/** \file - * Path handler in node edit mode +/** @file + * @brief Path handler in node edit mode */ - -/* - * Authors: +/* Authors: * Lauris Kaplinski * * This code is in public domain */ -//#include "knot.h" -//#include "sp-path.h" -//#include "desktop-handles.h" +#ifndef SEEN_SP_NODEPATH_H +#define SEEN_SP_NODEPATH_H + #include "libnr/nr-path-code.h" #include #include #include -#include <2geom/forward.h> +#include <2geom/point.h> +#include <2geom/matrix.h> #include diff --git a/src/ui/Makefile_insert b/src/ui/Makefile_insert index cb4812000..94c003584 100644 --- a/src/ui/Makefile_insert +++ b/src/ui/Makefile_insert @@ -11,8 +11,4 @@ ui_libui_a_SOURCES = \ ui/previewable.h \ ui/previewfillable.h \ ui/previewholder.cpp \ - ui/previewholder.h \ - ui/stock-items.cpp \ - ui/stock-items.h \ - ui/stock.cpp \ - ui/stock.h + ui/previewholder.h diff --git a/src/ui/cache/svg_preview_cache.cpp b/src/ui/cache/svg_preview_cache.cpp index ce10de477..6e05f6c03 100644 --- a/src/ui/cache/svg_preview_cache.cpp +++ b/src/ui/cache/svg_preview_cache.cpp @@ -24,7 +24,6 @@ #include "sp-namedview.h" #include "selection.h" #include "inkscape.h" -#include "inkscape-stock.h" #include "sp-rect.h" #include "document-private.h" #include "display/nr-arena.h" diff --git a/src/ui/dialog/align-and-distribute.cpp b/src/ui/dialog/align-and-distribute.cpp index 0014a3ce5..0a59c004f 100644 --- a/src/ui/dialog/align-and-distribute.cpp +++ b/src/ui/dialog/align-and-distribute.cpp @@ -18,38 +18,29 @@ # include #endif -#include "verbs.h" +#include +#include "desktop-handles.h" #include "dialogs/unclump.h" -#include "removeoverlap/removeoverlap.h" +#include "document.h" +#include "enums.h" #include "graphlayout/graphlayout.h" - -#include - - - - -#include "util/glib-list-iterators.h" - -#include "widgets/icon.h" - #include "inkscape.h" -#include "document.h" -#include "selection.h" -#include "desktop-handles.h" #include "macros.h" -#include "sp-item-transform.h" +#include "node-context.h" //For access to ShapeEditor #include "preferences.h" -#include "enums.h" - -#include "sp-text.h" +#include "removeoverlap/removeoverlap.h" +#include "selection.h" +#include "shape-editor.h" //For node align/distribute methods #include "sp-flowtext.h" +#include "sp-item-transform.h" +#include "sp-text.h" #include "text-editing.h" - -#include "node-context.h" //For access to ShapeEditor -#include "shape-editor.h" //For node align/distribute methods - #include "tools-switch.h" +#include "ui/icon-names.h" +#include "util/glib-list-iterators.h" +#include "verbs.h" +#include "widgets/icon.h" #include "align-and-distribute.h" @@ -807,110 +798,110 @@ AlignAndDistribute::AlignAndDistribute() Inkscape::Preferences *prefs = Inkscape::Preferences::get(); //Instanciate the align buttons - addAlignButton("al_left_out", - _("Align right sides of objects to left side of anchor"), + addAlignButton(INKSCAPE_ICON_ALIGN_HORIZONTAL_RIGHT_TO_ANCHOR, + _("Align right edges of objects to the left edge of the anchor"), 0, 0); - addAlignButton("al_left_in", - _("Align left sides"), + addAlignButton(INKSCAPE_ICON_ALIGN_HORIZONTAL_LEFT, + _("Align left edges"), 0, 1); - addAlignButton("al_center_hor", - _("Center on vertical axis"), + addAlignButton(INKSCAPE_ICON_ALIGN_HORIZONTAL_CENTER, + _("Center objects horizontally"), 0, 2); - addAlignButton("al_right_in", + addAlignButton(INKSCAPE_ICON_ALIGN_HORIZONTAL_RIGHT, _("Align right sides"), 0, 3); - addAlignButton("al_right_out", - _("Align left sides of objects to right side of anchor"), + addAlignButton(INKSCAPE_ICON_ALIGN_HORIZONTAL_LEFT_TO_ANCHOR, + _("Align left edges of objects to the right edge of the anchor"), 0, 4); - addAlignButton("al_top_out", - _("Align bottoms of objects to top of anchor"), + addAlignButton(INKSCAPE_ICON_ALIGN_VERTICAL_BOTTOM_TO_ANCHOR, + _("Align bottom edges of objects to the top edge of the anchor"), 1, 0); - addAlignButton("al_top_in", - _("Align tops"), + addAlignButton(INKSCAPE_ICON_ALIGN_VERTICAL_TOP, + _("Align top edges"), 1, 1); - addAlignButton("al_center_ver", + addAlignButton(INKSCAPE_ICON_ALIGN_VERTICAL_CENTER, _("Center on horizontal axis"), 1, 2); - addAlignButton("al_bottom_in", - _("Align bottoms"), + addAlignButton(INKSCAPE_ICON_ALIGN_VERTICAL_BOTTOM, + _("Align bottom edges"), 1, 3); - addAlignButton("al_bottom_out", - _("Align tops of objects to bottom of anchor"), + addAlignButton(INKSCAPE_ICON_ALIGN_VERTICAL_TOP_TO_ANCHOR, + _("Align top edges of objects to the bottom edge of the anchor"), 1, 4); //Baseline aligns - addBaselineButton("al_baselines_vert", - _("Align baseline anchors of texts vertically"), - 0, 5, this->align_table(), Geom::X, false); - addBaselineButton("al_baselines_hor", + addBaselineButton(INKSCAPE_ICON_ALIGN_HORIZONTAL_BASELINE, _("Align baseline anchors of texts horizontally"), + 0, 5, this->align_table(), Geom::X, false); + addBaselineButton(INKSCAPE_ICON_ALIGN_VERTICAL_BASELINE, + _("Align baselines of texts"), 1, 5, this->align_table(), Geom::Y, false); //The distribute buttons - addDistributeButton("distribute_hdist", + addDistributeButton(INKSCAPE_ICON_DISTRIBUTE_HORIZONTAL_GAPS, _("Make horizontal gaps between objects equal"), 0, 4, true, Geom::X, .5, .5); - addDistributeButton("distribute_left", - _("Distribute left sides equidistantly"), + addDistributeButton(INKSCAPE_ICON_DISTRIBUTE_HORIZONTAL_LEFT, + _("Distribute left edges equidistantly"), 0, 1, false, Geom::X, 1., 0.); - addDistributeButton("distribute_hcentre", + addDistributeButton(INKSCAPE_ICON_DISTRIBUTE_HORIZONTAL_CENTER, _("Distribute centers equidistantly horizontally"), 0, 2, false, Geom::X, .5, .5); - addDistributeButton("distribute_right", - _("Distribute right sides equidistantly"), + addDistributeButton(INKSCAPE_ICON_DISTRIBUTE_HORIZONTAL_RIGHT, + _("Distribute right edges equidistantly"), 0, 3, false, Geom::X, 0., 1.); - addDistributeButton("distribute_vdist", + addDistributeButton(INKSCAPE_ICON_DISTRIBUTE_VERTICAL_GAPS, _("Make vertical gaps between objects equal"), 1, 4, true, Geom::Y, .5, .5); - addDistributeButton("distribute_top", - _("Distribute tops equidistantly"), + addDistributeButton(INKSCAPE_ICON_DISTRIBUTE_VERTICAL_TOP, + _("Distribute top edges equidistantly"), 1, 1, false, Geom::Y, 0, 1); - addDistributeButton("distribute_vcentre", + addDistributeButton(INKSCAPE_ICON_DISTRIBUTE_VERTICAL_CENTER, _("Distribute centers equidistantly vertically"), 1, 2, false, Geom::Y, .5, .5); - addDistributeButton("distribute_bottom", - _("Distribute bottoms equidistantly"), + addDistributeButton(INKSCAPE_ICON_DISTRIBUTE_VERTICAL_BOTTOM, + _("Distribute bottom edges equidistantly"), 1, 3, false, Geom::Y, 1., 0.); //Baseline distribs - addBaselineButton("distribute_baselines_hor", + addBaselineButton(INKSCAPE_ICON_DISTRIBUTE_HORIZONTAL_BASELINE, _("Distribute baseline anchors of texts horizontally"), 0, 5, this->distribute_table(), Geom::X, true); - addBaselineButton("distribute_baselines_vert", - _("Distribute baseline anchors of texts vertically"), + addBaselineButton(INKSCAPE_ICON_DISTRIBUTE_VERTICAL_BASELINE, + _("Distribute baselines of texts vertically"), 1, 5, this->distribute_table(), Geom::Y, true); //Randomize & Unclump - addRandomizeButton("distribute_randomize", + addRandomizeButton(INKSCAPE_ICON_DISTRIBUTE_RANDOMIZE, _("Randomize centers in both dimensions"), 2, 2); - addUnclumpButton("unclump", + addUnclumpButton(INKSCAPE_ICON_DISTRIBUTE_UNCLUMP, _("Unclump objects: try to equalize edge-to-edge distances"), 2, 4); //Remove overlaps - addRemoveOverlapsButton("remove_overlaps", + addRemoveOverlapsButton(INKSCAPE_ICON_DISTRIBUTE_REMOVE_OVERLAPS, _("Move objects as little as possible so that their bounding boxes do not overlap"), 0, 0); //Graph Layout - addGraphLayoutButton("graph_layout", + addGraphLayoutButton(INKSCAPE_ICON_DISTRIBUTE_GRAPH, _("Nicely arrange selected connector network"), 0, 0); //Node Mode buttons - addNodeButton("node_halign", + addNodeButton(INKSCAPE_ICON_ALIGN_HORIZONTAL_NODES, _("Align selected nodes horizontally"), 0, Geom::X, false); - addNodeButton("node_valign", + addNodeButton(INKSCAPE_ICON_ALIGN_VERTICAL_NODES, _("Align selected nodes vertically"), 1, Geom::Y, false); - addNodeButton("node_hdistribute", + addNodeButton(INKSCAPE_ICON_DISTRIBUTE_HORIZONTAL_NODE, _("Distribute selected nodes horizontally"), 2, Geom::X, true); - addNodeButton("node_vdistribute", + addNodeButton(INKSCAPE_ICON_DISTRIBUTE_VERTICAL_NODE, _("Distribute selected nodes vertically"), 3, Geom::Y, true); diff --git a/src/ui/dialog/fill-and-stroke.cpp b/src/ui/dialog/fill-and-stroke.cpp index a05c20b36..d28dc7955 100644 --- a/src/ui/dialog/fill-and-stroke.cpp +++ b/src/ui/dialog/fill-and-stroke.cpp @@ -18,13 +18,13 @@ #include "fill-and-stroke.h" #include "filter-chemistry.h" #include "inkscape.h" -#include "inkscape-stock.h" #include "selection.h" #include "style.h" #include "svg/css-ostringstream.h" #include "verbs.h" #include "xml/repr.h" #include "widgets/icon.h" +#include "ui/icon-names.h" #include "dialogs/fill-style.h" #include "dialogs/stroke-style.h" @@ -47,9 +47,9 @@ FillAndStroke::FillAndStroke() contents->pack_start(_notebook, true, true); - _notebook.append_page(_page_fill, _createPageTabLabel(_("Fill"), INKSCAPE_STOCK_PROPERTIES_FILL_PAGE)); - _notebook.append_page(_page_stroke_paint, _createPageTabLabel(_("Stroke _paint"), INKSCAPE_STOCK_PROPERTIES_STROKE_PAINT_PAGE)); - _notebook.append_page(_page_stroke_style, _createPageTabLabel(_("Stroke st_yle"), INKSCAPE_STOCK_PROPERTIES_STROKE_PAGE)); + _notebook.append_page(_page_fill, _createPageTabLabel(_("Fill"), INKSCAPE_ICON_OBJECT_FILL)); + _notebook.append_page(_page_stroke_paint, _createPageTabLabel(_("Stroke _paint"), INKSCAPE_ICON_OBJECT_STROKE)); + _notebook.append_page(_page_stroke_style, _createPageTabLabel(_("Stroke st_yle"), INKSCAPE_ICON_OBJECT_STROKE_STYLE)); _layoutPageFill(); _layoutPageStrokePaint(); diff --git a/src/ui/dialog/livepatheffect-editor.cpp b/src/ui/dialog/livepatheffect-editor.cpp index 1c66160dd..7746e1a60 100644 --- a/src/ui/dialog/livepatheffect-editor.cpp +++ b/src/ui/dialog/livepatheffect-editor.cpp @@ -15,30 +15,31 @@ #endif #include -#include "livepatheffect-editor.h" -#include "ui/widget/imagetoggler.h" -#include "verbs.h" +#include +#include +#include + +#include "desktop.h" +#include "desktop-handles.h" +#include "document.h" +#include "gtkmm/widget.h" +#include "inkscape.h" +#include "live_effects/effect.h" +#include "live_effects/lpeobject.h" +#include "live_effects/lpeobject-reference.h" +#include "path-chemistry.h" #include "selection.h" -#include "sp-shape.h" #include "sp-item-group.h" +#include "sp-lpe-item.h" #include "sp-path.h" #include "sp-rect.h" -#include "sp-lpe-item.h" -#include "path-chemistry.h" -#include "live_effects/effect.h" -#include "live_effects/lpeobject.h" -#include "live_effects/lpeobject-reference.h" -#include "gtkmm/widget.h" -#include -#include "inkscape.h" -#include "desktop-handles.h" -#include "desktop.h" -#include "document.h" +#include "sp-shape.h" +#include "ui/icon-names.h" +#include "ui/widget/imagetoggler.h" +#include "verbs.h" #include "xml/node.h" -#include -#include -#include "live_effects/lpeobject-reference.h" +#include "livepatheffect-editor.h" namespace Inkscape { class Application; @@ -133,7 +134,8 @@ LivePathEffectEditor::LivePathEffectEditor() effectlist_selection->signal_changed().connect( sigc::mem_fun(*this, &LivePathEffectEditor::on_effect_selection_changed) ); //Add the visibility icon column: - Inkscape::UI::Widget::ImageToggler *eyeRenderer = manage( new Inkscape::UI::Widget::ImageToggler("visible", "hidden") ); + Inkscape::UI::Widget::ImageToggler *eyeRenderer = manage( new Inkscape::UI::Widget::ImageToggler( + INKSCAPE_ICON_OBJECT_VISIBLE, INKSCAPE_ICON_OBJECT_HIDDEN) ); int visibleColNum = effectlist_view.append_column("is_visible", *eyeRenderer) - 1; eyeRenderer->signal_toggled().connect( sigc::mem_fun(*this, &LivePathEffectEditor::on_visibility_toggled) ); eyeRenderer->property_activatable() = true; diff --git a/src/ui/dialog/session-player.cpp b/src/ui/dialog/session-player.cpp index b9a44fd98..0e484c3f2 100644 --- a/src/ui/dialog/session-player.cpp +++ b/src/ui/dialog/session-player.cpp @@ -24,8 +24,6 @@ #include "desktop-handles.h" #include "document.h" -#include "ui/stock.h" - #include "jabber_whiteboard/node-tracker.h" #include "jabber_whiteboard/session-manager.h" #include "jabber_whiteboard/session-file-player.h" @@ -120,14 +118,6 @@ SessionPlaybackDialogImpl::_construct() // Playback controls this->_playbackcontrols.set_show_arrow(false); - /* these are waiting for the Gtkmm conversion - this->_controls[0].set_stock_id(Stock::SESSION_PLAYBACK_REW); - this->_controls[1].set_stock_id(Stock::SESSION_PLAYBACK_STEPBACK); - this->_controls[2].set_stock_id(Stock::SESSION_PLAYBACK_PAUSE); - this->_controls[3].set_stock_id(Stock::SESSION_PLAYBACK_STEPFORWARD); - this->_controls[4].set_stock_id(Stock::SESSION_PLAYBACK_PLAY); - */ - this->_controls[0].set_label("Rewind"); this->_controls[1].set_label("Go back one"); this->_controls[2].set_label("Pause"); diff --git a/src/ui/dialog/tile.cpp b/src/ui/dialog/tile.cpp index a383f7b1a..2921bf62e 100644 --- a/src/ui/dialog/tile.cpp +++ b/src/ui/dialog/tile.cpp @@ -803,7 +803,7 @@ TileDialog::TileDialog() { /*#### Y Padding ####*/ - GtkWidget *i = sp_icon_new (Inkscape::ICON_SIZE_MENU, "clonetiler_per_row"); + GtkWidget *i = sp_icon_new (Inkscape::ICON_SIZE_MENU, "object-rows"); YPadBox.pack_start (*(Glib::wrap(i)), false, false, MARGIN); YPadSpinner.set_digits(1); @@ -828,7 +828,7 @@ TileDialog::TileDialog() { /*#### X padding ####*/ - GtkWidget *i = sp_icon_new (Inkscape::ICON_SIZE_MENU, "clonetiler_per_column"); + GtkWidget *i = sp_icon_new (Inkscape::ICON_SIZE_MENU, "object-columns"); XPadBox.pack_start (*(Glib::wrap(i)), false, false, MARGIN); XPadSpinner.set_digits(1); diff --git a/src/ui/dialog/transformation.cpp b/src/ui/dialog/transformation.cpp index a242aaa4c..1cab38d98 100644 --- a/src/ui/dialog/transformation.cpp +++ b/src/ui/dialog/transformation.cpp @@ -80,19 +80,19 @@ Transformation::Transformation() _page_skew (4, 2), _page_transform (3, 3), _scalar_move_horizontal (_("_Horizontal"), _("Horizontal displacement (relative) or position (absolute)"), UNIT_TYPE_LINEAR, - "", "arrows_hor", &_units_move), + "", "transform-move-horizontal", &_units_move), _scalar_move_vertical (_("_Vertical"), _("Vertical displacement (relative) or position (absolute)"), UNIT_TYPE_LINEAR, - "", "arrows_ver", &_units_move), + "", "transform-move-vertical", &_units_move), _scalar_scale_horizontal(_("_Width"), _("Horizontal size (absolute or percentage of current)"), UNIT_TYPE_DIMENSIONLESS, - "", "transform_scale_hor", &_units_scale), + "", "transform-scale-horizontal", &_units_scale), _scalar_scale_vertical (_("_Height"), _("Vertical size (absolute or percentage of current)"), UNIT_TYPE_DIMENSIONLESS, - "", "transform_scale_ver", &_units_scale), + "", "transform-scale-vertical", &_units_scale), _scalar_rotate (_("A_ngle"), _("Rotation angle (positive = counterclockwise)"), UNIT_TYPE_RADIAL, - "", "transform_rotate", &_units_rotate), + "", "transform-rotate", &_units_rotate), _scalar_skew_horizontal (_("_Horizontal"), _("Horizontal skew angle (positive = counterclockwise), or absolute displacement, or percentage displacement"), UNIT_TYPE_LINEAR, - "", "transform_scew_hor", &_units_skew), + "", "transform-skew-horizontal", &_units_skew), _scalar_skew_vertical (_("_Vertical"), _("Vertical skew angle (positive = counterclockwise), or absolute displacement, or percentage displacement"), UNIT_TYPE_LINEAR, - "", "transform_scew_ver", &_units_skew), + "", "transform-skew-vertical", &_units_skew), _scalar_transform_a ("_A", _("Transformation matrix element A")), _scalar_transform_b ("_B", _("Transformation matrix element B")), diff --git a/src/ui/icon-names.h b/src/ui/icon-names.h new file mode 100644 index 000000000..00341c4dd --- /dev/null +++ b/src/ui/icon-names.h @@ -0,0 +1,567 @@ +/** @file + * @brief Macro for icon names used in Inkscape + * + * This file exists for several reasons: firstly, it contains all the icon names + * in Inkscape, so it can serve as a reference to themers. Secondly, using + * macros instead of strings avoids typos. Thirdly, we can change names + * to conform to external icon sets / specifications without changing any code. + */ +/* Authors: + * Krzysztof Kosiński + * + * Copyright (C) 2009 Authors + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#ifndef SEEN_INKSCAPE_ICON_NAMES_H +#define SEEN_INKSCAPE_ICON_NAMES_H + +#define INKSCAPE_ICON_ALIGN_HORIZONTAL_BASELINE \ + "align-horizontal-baseline" +#define INKSCAPE_ICON_ALIGN_HORIZONTAL_CENTER \ + "align-horizontal-center" +#define INKSCAPE_ICON_ALIGN_HORIZONTAL_LEFT \ + "align-horizontal-left" +#define INKSCAPE_ICON_ALIGN_HORIZONTAL_LEFT_TO_ANCHOR \ + "align-horizontal-left-to-anchor" +#define INKSCAPE_ICON_ALIGN_HORIZONTAL_NODES \ + "align-horizontal-nodes" +#define INKSCAPE_ICON_ALIGN_HORIZONTAL_RIGHT \ + "align-horizontal-right" +#define INKSCAPE_ICON_ALIGN_HORIZONTAL_RIGHT_TO_ANCHOR \ + "align-horizontal-right-to-anchor" +#define INKSCAPE_ICON_ALIGN_VERTICAL_BASELINE \ + "align-vertical-baseline" +#define INKSCAPE_ICON_ALIGN_VERTICAL_BOTTOM \ + "align-vertical-bottom" +#define INKSCAPE_ICON_ALIGN_VERTICAL_BOTTOM_TO_ANCHOR \ + "align-vertical-bottom-to-anchor" +#define INKSCAPE_ICON_ALIGN_VERTICAL_CENTER \ + "align-vertical-center" +#define INKSCAPE_ICON_ALIGN_VERTICAL_NODES \ + "align-vertical-nodes" +#define INKSCAPE_ICON_ALIGN_VERTICAL_TOP \ + "align-vertical-top" +#define INKSCAPE_ICON_ALIGN_VERTICAL_TOP_TO_ANCHOR \ + "align-vertical-top-to-anchor" +#define INKSCAPE_ICON_BITMAP_TRACE \ + "bitmap-trace" +#define INKSCAPE_ICON_COLOR_FILL \ + "color-fill" +#define INKSCAPE_ICON_COLOR_GRADIENT \ + "color-gradient" +#define INKSCAPE_ICON_COLOR_MANAGEMENT \ + "color-management" +#define INKSCAPE_ICON_COLOR_PICKER \ + "color-picker" +#define INKSCAPE_ICON_COLOR_REMOVE \ + "color-remove" +#define INKSCAPE_ICON_CONNECTOR_AVOID \ + "connector-avoid" +#define INKSCAPE_ICON_CONNECTOR_IGNORE \ + "connector-ignore" +#define INKSCAPE_ICON_DIALOG_ALIGN_AND_DISTRIBUTE \ + "dialog-align-and-distribute" +#define INKSCAPE_ICON_DIALOG_FILL_AND_STROKE \ + "dialog-fill-and-stroke" +#define INKSCAPE_ICON_DIALOG_ICON_PREVIEW \ + "dialog-icon-preview" +#define INKSCAPE_ICON_DIALOG_INPUT_DEVICES \ + "dialog-input-devices" +#define INKSCAPE_ICON_DIALOG_LAYERS \ + "dialog-layers" +#define INKSCAPE_ICON_DIALOG_MEMORY \ + "dialog-memory" +#define INKSCAPE_ICON_DIALOG_MESSAGES \ + "dialog-messages" +#define INKSCAPE_ICON_DIALOG_OBJECT_PROPERTIES \ + "dialog-object-properties" +#define INKSCAPE_ICON_DIALOG_ROWS_AND_COLUMNS \ + "dialog-rows-and-columns" +#define INKSCAPE_ICON_DIALOG_SCRIPTS \ + "dialog-scripts" +#define INKSCAPE_ICON_DIALOG_TEXT_AND_FONT \ + "dialog-text-and-font" +#define INKSCAPE_ICON_DIALOG_TILE_CLONES \ + "dialog-tile-clones" +#define INKSCAPE_ICON_DIALOG_TRANSFORM \ + "dialog-transform" +#define INKSCAPE_ICON_DIALOG_XML_EDITOR \ + "dialog-xml-editor" +#define INKSCAPE_ICON_DISTRIBUTE_GRAPH \ + "distribute-graph" +#define INKSCAPE_ICON_DISTRIBUTE_GRAPH_DIRECTED \ + "distribute-graph-directed" +#define INKSCAPE_ICON_DISTRIBUTE_HORIZONTAL_BASELINE \ + "distribute-horizontal-baseline" +#define INKSCAPE_ICON_DISTRIBUTE_HORIZONTAL_CENTER \ + "distribute-horizontal-center" +#define INKSCAPE_ICON_DISTRIBUTE_HORIZONTAL_GAPS \ + "distribute-horizontal-gaps" +#define INKSCAPE_ICON_DISTRIBUTE_HORIZONTAL_LEFT \ + "distribute-horizontal-left" +#define INKSCAPE_ICON_DISTRIBUTE_HORIZONTAL_NODE \ + "distribute-horizontal-node" +#define INKSCAPE_ICON_DISTRIBUTE_HORIZONTAL_RIGHT \ + "distribute-horizontal-right" +#define INKSCAPE_ICON_DISTRIBUTE_RANDOMIZE \ + "distribute-randomize" +#define INKSCAPE_ICON_DISTRIBUTE_REMOVE_OVERLAPS \ + "distribute-remove-overlaps" +#define INKSCAPE_ICON_DISTRIBUTE_UNCLUMP \ + "distribute-unclump" +#define INKSCAPE_ICON_DISTRIBUTE_VERTICAL_BASELINE \ + "distribute-vertical-baseline" +#define INKSCAPE_ICON_DISTRIBUTE_VERTICAL_BOTTOM \ + "distribute-vertical-bottom" +#define INKSCAPE_ICON_DISTRIBUTE_VERTICAL_CENTER \ + "distribute-vertical-center" +#define INKSCAPE_ICON_DISTRIBUTE_VERTICAL_GAPS \ + "distribute-vertical-gaps" +#define INKSCAPE_ICON_DISTRIBUTE_VERTICAL_NODE \ + "distribute-vertical-node" +#define INKSCAPE_ICON_DISTRIBUTE_VERTICAL_TOP \ + "distribute-vertical-top" +#define INKSCAPE_ICON_DOCUMENT_CLEANUP \ + "document-cleanup" +#define INKSCAPE_ICON_DOCUMENT_EXPORT \ + "document-export" +#define INKSCAPE_ICON_DOCUMENT_EXPORT_OCAL \ + "document-export-ocal" +#define INKSCAPE_ICON_DOCUMENT_IMPORT \ + "document-import" +#define INKSCAPE_ICON_DOCUMENT_IMPORT_OCAL \ + "document-import-ocal" +#define INKSCAPE_ICON_DOCUMENT_METADATA \ + "document-metadata" +#define INKSCAPE_ICON_DOCUMENT_OPEN_RECENT \ + "document-open-recent" +#define INKSCAPE_ICON_DRAW_CALLIGRAPHIC \ + "draw-calligraphic" +#define INKSCAPE_ICON_DRAW_CONNECTOR \ + "draw-connector" +#define INKSCAPE_ICON_DRAW_CUBOID \ + "draw-cuboid" +#define INKSCAPE_ICON_DRAW_ELLIPSE \ + "draw-ellipse" +#define INKSCAPE_ICON_DRAW_ELLIPSE_ARC \ + "draw-ellipse-arc" +#define INKSCAPE_ICON_DRAW_ELLIPSE_SEGMENT \ + "draw-ellipse-segment" +#define INKSCAPE_ICON_DRAW_ELLIPSE_WHOLE \ + "draw-ellipse-whole" +#define INKSCAPE_ICON_DRAW_ERASER \ + "draw-eraser" +#define INKSCAPE_ICON_DRAW_ERASER_DELETE_OBJECTS \ + "draw-eraser-delete-objects" +#define INKSCAPE_ICON_DRAW_FREEHAND \ + "draw-freehand" +#define INKSCAPE_ICON_DRAW_PATH \ + "draw-path" +#define INKSCAPE_ICON_DRAW_POLYGON \ + "draw-polygon" +#define INKSCAPE_ICON_DRAW_POLYGON_STAR \ + "draw-polygon-star" +#define INKSCAPE_ICON_DRAW_RECTANGLE \ + "draw-rectangle" +#define INKSCAPE_ICON_DRAW_SPIRAL \ + "draw-spiral" +#define INKSCAPE_ICON_DRAW_STAR \ + "draw-star" +#define INKSCAPE_ICON_DRAW_TEXT \ + "draw-text" +#define INKSCAPE_ICON_DRAW_TRACE_BACKGROUND \ + "draw-trace-background" +#define INKSCAPE_ICON_DRAW_USE_PRESSURE \ + "draw-use-pressure" +#define INKSCAPE_ICON_DRAW_USE_TILT \ + "draw-use-tilt" +#define INKSCAPE_ICON_EDIT_CLONE \ + "edit-clone" +#define INKSCAPE_ICON_EDIT_CLONE_UNLINK \ + "edit-clone-unlink" +#define INKSCAPE_ICON_EDIT_DUPLICATE \ + "edit-duplicate" +#define INKSCAPE_ICON_EDIT_PASTE_IN_PLACE \ + "edit-paste-in-place" +#define INKSCAPE_ICON_EDIT_PASTE_STYLE \ + "edit-paste-style" +#define INKSCAPE_ICON_EDIT_SELECT_ALL \ + "edit-select-all" +#define INKSCAPE_ICON_EDIT_SELECT_ALL_LAYERS \ + "edit-select-all-layers" +#define INKSCAPE_ICON_EDIT_SELECT_INVERT \ + "edit-select-invert" +#define INKSCAPE_ICON_EDIT_SELECT_NONE \ + "edit-select-none" +#define INKSCAPE_ICON_EDIT_SELECT_ORIGINAL \ + "edit-select-original" +#define INKSCAPE_ICON_EDIT_UNDO_HISTORY \ + "edit-undo-history" +#define INKSCAPE_ICON_FILL_RULE_EVEN_ODD \ + "fill-rule-even-odd" +#define INKSCAPE_ICON_FILL_RULE_NONZERO \ + "fill-rule-nonzero" +#define INKSCAPE_ICON_FORMAT_TEXT_DIRECTION_HORIZONTAL \ + "format-text-direction-horizontal" +#define INKSCAPE_ICON_FORMAT_TEXT_DIRECTION_VERTICAL \ + "format-text-direction-vertical" +#define INKSCAPE_ICON_GRID_AXONOMETRIC \ + "grid-axonometric" +#define INKSCAPE_ICON_GRID_RECTANGULAR \ + "grid-rectangular" +#define INKSCAPE_ICON_GUIDES \ + "guides" +#define INKSCAPE_ICON_HELP_CONTENTS \ + "help-contents" +#define INKSCAPE_ICON_HELP_KEYBOARD_SHORTCUTS \ + "help-keyboard-shortcuts" +#define INKSCAPE_ICON_IMAGE_FILTER_BLEND \ + "image-filter-blend" +#define INKSCAPE_ICON_IMAGE_FILTER_COLOR_MATRIX \ + "image-filter-color-matrix" +#define INKSCAPE_ICON_IMAGE_FILTER_DIFFUSE_LIGHTING \ + "image-filter-diffuse-lighting" +#define INKSCAPE_ICON_IMAGE_FILTER_DISPLACEMENT_MAP \ + "image-filter-displacement-map" +#define INKSCAPE_ICON_IMAGE_FILTER_FLOOD \ + "image-filter-flood" +#define INKSCAPE_ICON_IMAGE_FILTER_GAUSSIAN_BLUR \ + "image-filter-gaussian-blur" +#define INKSCAPE_ICON_IMAGE_FILTER_MORPHOLOGY \ + "image-filter-morphology" +#define INKSCAPE_ICON_IMAGE_FILTER_OFFSET \ + "image-filter-offset" +#define INKSCAPE_ICON_IMAGE_FILTER_TURBULENCE \ + "image-filter-turbulence" +#define INKSCAPE_ICON_INKSCAPE \ + "inkscape" +#define INKSCAPE_ICON_LAYER_BOTTOM \ + "layer-bottom" +#define INKSCAPE_ICON_LAYER_DELETE \ + "layer-delete" +#define INKSCAPE_ICON_LAYER_LOWER \ + "layer-lower" +#define INKSCAPE_ICON_LAYER_NEW \ + "layer-new" +#define INKSCAPE_ICON_LAYER_NEXT \ + "layer-next" +#define INKSCAPE_ICON_LAYER_PREVIOUS \ + "layer-previous" +#define INKSCAPE_ICON_LAYER_RAISE \ + "layer-raise" +#define INKSCAPE_ICON_LAYER_RENAME \ + "layer-rename" +#define INKSCAPE_ICON_LAYER_TOP \ + "layer-top" +#define INKSCAPE_ICON_NODE_ADD \ + "node-add" +#define INKSCAPE_ICON_NODE_BREAK \ + "node-break" +#define INKSCAPE_ICON_NODE_DELETE \ + "node-delete" +#define INKSCAPE_ICON_NODE_DELETE_SEGMENT \ + "node-delete-segment" +#define INKSCAPE_ICON_NODE_DISTRIBUTE_HORIZONTAL \ + "node-distribute-horizontal" +#define INKSCAPE_ICON_NODE_DISTRIBUTE_VERTICAL \ + "node-distribute-vertical" +#define INKSCAPE_ICON_NODE_JOIN \ + "node-join" +#define INKSCAPE_ICON_NODE_JOIN_SEGMENT \ + "node-join-segment" +#define INKSCAPE_ICON_NODE_SEGMENT_CURVE \ + "node-segment-curve" +#define INKSCAPE_ICON_NODE_SEGMENT_LINE \ + "node-segment-line" +#define INKSCAPE_ICON_NODE_TYPE_AUTO_SMOOTH \ + "node-type-auto-smooth" +#define INKSCAPE_ICON_NODE_TYPE_CUSP \ + "node-type-cusp" +#define INKSCAPE_ICON_NODE_TYPE_SMOOTH \ + "node-type-smooth" +#define INKSCAPE_ICON_NODE_TYPE_SYMMETRIC \ + "node-type-symmetric" +#define INKSCAPE_ICON_OBJECT_COLUMNS \ + "object-columns" +#define INKSCAPE_ICON_OBJECT_FILL \ + "object-fill" +#define INKSCAPE_ICON_OBJECT_FLIP_HORIZONTAL \ + "object-flip-horizontal" +#define INKSCAPE_ICON_OBJECT_FLIP_VERTICAL \ + "object-flip-vertical" +#define INKSCAPE_ICON_OBJECT_GROUP \ + "object-group" +#define INKSCAPE_ICON_OBJECT_HIDDEN \ + "object-hidden" +#define INKSCAPE_ICON_OBJECT_LOCKED \ + "object-locked" +#define INKSCAPE_ICON_OBJECT_ROTATE_LEFT \ + "object-rotate-left" +#define INKSCAPE_ICON_OBJECT_ROTATE_RIGHT \ + "object-rotate-right" +#define INKSCAPE_ICON_OBJECT_ROWS \ + "object-rows" +#define INKSCAPE_ICON_OBJECT_STROKE \ + "object-stroke" +#define INKSCAPE_ICON_OBJECT_STROKE_STYLE \ + "object-stroke-style" +#define INKSCAPE_ICON_OBJECT_TO_PATH \ + "object-to-path" +#define INKSCAPE_ICON_OBJECT_TWEAK_ATTRACT \ + "object-tweak-attract" +#define INKSCAPE_ICON_OBJECT_TWEAK_BLUR \ + "object-tweak-blur" +#define INKSCAPE_ICON_OBJECT_TWEAK_DUPLICATE \ + "object-tweak-duplicate" +#define INKSCAPE_ICON_OBJECT_TWEAK_JITTER_COLOR \ + "object-tweak-jitter-color" +#define INKSCAPE_ICON_OBJECT_TWEAK_PAINT \ + "object-tweak-paint" +#define INKSCAPE_ICON_OBJECT_TWEAK_PUSH \ + "object-tweak-push" +#define INKSCAPE_ICON_OBJECT_TWEAK_RANDOMIZE \ + "object-tweak-randomize" +#define INKSCAPE_ICON_OBJECT_TWEAK_ROTATE \ + "object-tweak-rotate" +#define INKSCAPE_ICON_OBJECT_TWEAK_SHRINK \ + "object-tweak-shrink" +#define INKSCAPE_ICON_OBJECT_UNGROUP \ + "object-ungroup" +#define INKSCAPE_ICON_OBJECT_UNLOCKED \ + "object-unlocked" +#define INKSCAPE_ICON_OBJECT_VISIBLE \ + "object-visible" +#define INKSCAPE_ICON_PAINT_GRADIENT_LINEAR \ + "paint-gradient-linear" +#define INKSCAPE_ICON_PAINT_GRADIENT_RADIAL \ + "paint-gradient-radial" +#define INKSCAPE_ICON_PAINT_NONE \ + "paint-none" +#define INKSCAPE_ICON_PAINT_PATTERN \ + "paint-pattern" +#define INKSCAPE_ICON_PAINT_SOLID \ + "paint-solid" +#define INKSCAPE_ICON_PAINT_UNKNOWN \ + "paint-unknown" +#define INKSCAPE_ICON_PATH_BREAK_APART \ + "path-break-apart" +#define INKSCAPE_ICON_PATH_CLIP_EDIT \ + "path-clip-edit" +#define INKSCAPE_ICON_PATH_COMBINE \ + "path-combine" +#define INKSCAPE_ICON_PATH_CUT \ + "path-cut" +#define INKSCAPE_ICON_PATH_DIFFERENCE \ + "path-difference" +#define INKSCAPE_ICON_PATH_DIVISION \ + "path-division" +#define INKSCAPE_ICON_PATH_EFFECT_PARAMETER_NEXT \ + "path-effect-parameter-next" +#define INKSCAPE_ICON_PATH_EXCLUSION \ + "path-exclusion" +#define INKSCAPE_ICON_PATH_INSET \ + "path-inset" +#define INKSCAPE_ICON_PATH_INTERSECTION \ + "path-intersection" +#define INKSCAPE_ICON_PATH_MASK_EDIT \ + "path-mask-edit" +#define INKSCAPE_ICON_PATH_MODE_BEZIER \ + "path-mode-bezier" +#define INKSCAPE_ICON_PATH_MODE_POLYLINE \ + "path-mode-polyline" +#define INKSCAPE_ICON_PATH_MODE_POLYLINE_PARAXIAL \ + "path-mode-polyline-paraxial" +#define INKSCAPE_ICON_PATH_MODE_SPIRO \ + "path-mode-spiro" +#define INKSCAPE_ICON_PATH_OFFSET_DYNAMIC \ + "path-offset-dynamic" +#define INKSCAPE_ICON_PATH_OFFSET_LINKED \ + "path-offset-linked" +#define INKSCAPE_ICON_PATH_OUTSET \ + "path-outset" +#define INKSCAPE_ICON_PATH_REVERSE \ + "path-reverse" +#define INKSCAPE_ICON_PATH_SIMPLIFY \ + "path-simplify" +#define INKSCAPE_ICON_PATH_TWEAK_ATTRACT \ + "path-tweak-attract" +#define INKSCAPE_ICON_PATH_TWEAK_GROW \ + "path-tweak-grow" +#define INKSCAPE_ICON_PATH_TWEAK_PUSH \ + "path-tweak-push" +#define INKSCAPE_ICON_PATH_TWEAK_ROUGHEN \ + "path-tweak-roughen" +#define INKSCAPE_ICON_PATH_TWEAK_SHRINK \ + "path-tweak-shrink" +#define INKSCAPE_ICON_PATH_UNION \ + "path-union" +#define INKSCAPE_ICON_PERSPECTIVE_PARALLEL \ + "perspective-parallel" +#define INKSCAPE_ICON_RECTANGLE_MAKE_CORNERS_SHARP \ + "rectangle-make-corners-sharp" +#define INKSCAPE_ICON_SELECTION_BOTTOM \ + "selection-bottom" +#define INKSCAPE_ICON_SELECTION_LOWER \ + "selection-lower" +#define INKSCAPE_ICON_SELECTION_MAKE_BITMAP_COPY \ + "selection-make-bitmap-copy" +#define INKSCAPE_ICON_SELECTION_MOVE_TO_LAYER_ABOVE \ + "selection-move-to-layer-above" +#define INKSCAPE_ICON_SELECTION_MOVE_TO_LAYER_BELOW \ + "selection-move-to-layer-below" +#define INKSCAPE_ICON_SELECTION_RAISE \ + "selection-raise" +#define INKSCAPE_ICON_SELECTION_TOP \ + "selection-top" +#define INKSCAPE_ICON_SHOW_DIALOGS \ + "show-dialogs" +#define INKSCAPE_ICON_SHOW_GRID \ + "show-grid" +#define INKSCAPE_ICON_SHOW_GUIDES \ + "show-guides" +#define INKSCAPE_ICON_SHOW_NODE_HANDLES \ + "show-node-handles" +#define INKSCAPE_ICON_SHOW_PATH_OUTLINE \ + "show-path-outline" +#define INKSCAPE_ICON_SNAP \ + "snap" +#define INKSCAPE_ICON_SNAP_BOUNDING_BOX \ + "snap-bounding-box" +#define INKSCAPE_ICON_SNAP_BOUNDING_BOX_CENTER \ + "snap-bounding-box-center" +#define INKSCAPE_ICON_SNAP_BOUNDING_BOX_CORNERS \ + "snap-bounding-box-corners" +#define INKSCAPE_ICON_SNAP_BOUNDING_BOX_EDGES \ + "snap-bounding-box-edges" +#define INKSCAPE_ICON_SNAP_BOUNDING_BOX_MIDPOINTS \ + "snap-bounding-box-midpoints" +#define INKSCAPE_ICON_SNAP_GRID_GUIDE_INTERSECTIONS \ + "snap-grid-guide-intersections" +#define INKSCAPE_ICON_SNAP_NODES \ + "snap-nodes" +#define INKSCAPE_ICON_SNAP_NODES_CENTER \ + "snap-nodes-center" +#define INKSCAPE_ICON_SNAP_NODES_CUSP \ + "snap-nodes-cusp" +#define INKSCAPE_ICON_SNAP_NODES_INTERSECTION \ + "snap-nodes-intersection" +#define INKSCAPE_ICON_SNAP_NODES_MIDPOINT \ + "snap-nodes-midpoint" +#define INKSCAPE_ICON_SNAP_NODES_PATH \ + "snap-nodes-path" +#define INKSCAPE_ICON_SNAP_NODES_ROTATION_CENTER \ + "snap-nodes-rotation-center" +#define INKSCAPE_ICON_SNAP_NODES_SMOOTH \ + "snap-nodes-smooth" +#define INKSCAPE_ICON_SNAP_PAGE \ + "snap-page" +#define INKSCAPE_ICON_STROKE_CAP_BUTT \ + "stroke-cap-butt" +#define INKSCAPE_ICON_STROKE_CAP_ROUND \ + "stroke-cap-round" +#define INKSCAPE_ICON_STROKE_CAP_SQUARE \ + "stroke-cap-square" +#define INKSCAPE_ICON_STROKE_JOIN_BEVEL \ + "stroke-join-bevel" +#define INKSCAPE_ICON_STROKE_JOIN_MITER \ + "stroke-join-miter" +#define INKSCAPE_ICON_STROKE_JOIN_ROUND \ + "stroke-join-round" +#define INKSCAPE_ICON_STROKE_TO_PATH \ + "stroke-to-path" +#define INKSCAPE_ICON_TEXT_CONVERT_TO_REGULAR \ + "text-convert-to-regular" +#define INKSCAPE_ICON_TEXT_FLOW_INTO_FRAME \ + "text-flow-into-frame" +#define INKSCAPE_ICON_TEXT_PUT_ON_PATH \ + "text-put-on-path" +#define INKSCAPE_ICON_TEXT_REMOVE_FROM_PATH \ + "text-remove-from-path" +#define INKSCAPE_ICON_TEXT_UNFLOW \ + "text-unflow" +#define INKSCAPE_ICON_TEXT_UNKERN \ + "text-unkern" +#define INKSCAPE_ICON_TOOL_NODE_EDITOR \ + "tool-node-editor" +#define INKSCAPE_ICON_TOOL_POINTER \ + "tool-pointer" +#define INKSCAPE_ICON_TOOL_TWEAK \ + "tool-tweak" +#define INKSCAPE_ICON_TRANSFORM_AFFECT_GRADIENT \ + "transform-affect-gradient" +#define INKSCAPE_ICON_TRANSFORM_AFFECT_PATTERN \ + "transform-affect-pattern" +#define INKSCAPE_ICON_TRANSFORM_AFFECT_ROUNDED_CORNERS \ + "transform-affect-rounded-corners" +#define INKSCAPE_ICON_TRANSFORM_AFFECT_STROKE \ + "transform-affect-stroke" +#define INKSCAPE_ICON_TRANSFORM_MOVE_HORIZONTAL \ + "transform-move-horizontal" +#define INKSCAPE_ICON_TRANSFORM_MOVE_VERTICAL \ + "transform-move-vertical" +#define INKSCAPE_ICON_TRANSFORM_ROTATE \ + "transform-rotate" +#define INKSCAPE_ICON_TRANSFORM_SCALE_HORIZONTAL \ + "transform-scale-horizontal" +#define INKSCAPE_ICON_TRANSFORM_SCALE_VERTICAL \ + "transform-scale-vertical" +#define INKSCAPE_ICON_TRANSFORM_SKEW_HORIZONTAL \ + "transform-skew-horizontal" +#define INKSCAPE_ICON_TRANSFORM_SKEW_VERTICAL \ + "transform-skew-vertical" +#define INKSCAPE_ICON_VIEW_FULLSCREEN \ + "view-fullscreen" +#define INKSCAPE_ICON_WINDOW_NEW \ + "window-neW" +#define INKSCAPE_ICON_WINDOW_NEXT \ + "window-next" +#define INKSCAPE_ICON_WINDOW_PREVIOUS \ + "window-previous" +#define INKSCAPE_ICON_XML_ATTRIBUTE_DELETE \ + "xml-attribute-delete" +#define INKSCAPE_ICON_XML_ELEMENT_NEW \ + "xml-element-new" +#define INKSCAPE_ICON_XML_NODE_DELETE \ + "xml-node-delete" +#define INKSCAPE_ICON_XML_NODE_DUPLICATE \ + "xml-node-duplicate" +#define INKSCAPE_ICON_XML_TEXT_NEW \ + "xml-text-new" +#define INKSCAPE_ICON_ZOOM \ + "zoom" +#define INKSCAPE_ICON_ZOOM_DOUBLE_SIZE \ + "zoom-double-size" +#define INKSCAPE_ICON_ZOOM_FIT_DRAWING \ + "zoom-fit-drawing" +#define INKSCAPE_ICON_ZOOM_FIT_PAGE \ + "zoom-fit-page" +#define INKSCAPE_ICON_ZOOM_FIT_SELECTION \ + "zoom-fit-selection" +#define INKSCAPE_ICON_ZOOM_FIT_WIDTH \ + "zoom-fit-width" +#define INKSCAPE_ICON_ZOOM_HALF_SIZE \ + "zoom-half-size" +#define INKSCAPE_ICON_ZOOM_IN \ + "zoom-in" +#define INKSCAPE_ICON_ZOOM_NEXT \ + "zoom-next" +#define INKSCAPE_ICON_ZOOM_ORIGINAL \ + "zoom-original" +#define INKSCAPE_ICON_ZOOM_OUT \ + "zoom-out" +#define INKSCAPE_ICON_ZOOM_PREVIOUS \ + "zoom-previous" + +#endif /* ifdef SEEN_INKSCAPE_ICON_NAMES_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:encoding=utf-8:textwidth=99 : diff --git a/src/ui/stock-items.cpp b/src/ui/stock-items.cpp deleted file mode 100644 index 6ac6042d4..000000000 --- a/src/ui/stock-items.cpp +++ /dev/null @@ -1,217 +0,0 @@ -/** - * \brief StockItems for Inkscape-specific menu/button labels and key - * accelerators. - * - * Author: - * Derek P. Moore - * - * Copyright (C) 2004 Derek P. Moore - * - * Released under GNU GPL. Read the file 'COPYING' for more information. - */ - -#include -#include - -#include "stock.h" - -namespace Inkscape { -namespace UI { -namespace Stock { - -void -init() -{ - using namespace Gtk::Stock; - -// FIXME: strings are replaced by placeholders, NOT to be translated until the code is enabled -// See http://sourceforge.net/mailarchive/message.php?msg_id=11746016 for details - - // File menu - add(Gtk::StockItem(OPEN, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(OPEN_RECENT, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SAVE_AS, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(IMPORT, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(EXPORT, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(IMPORTFROMOCAL, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(EXPORTTOOCAL, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(PRINT, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(PRINT_PREVIEW, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(VACUUM_DEFS, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(PROPERTIES, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(PREFERENCES, _("PLACEHOLDER, do not translate"))); - - // Edit menu - add(Gtk::StockItem(PASTE_IN_PLACE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(PASTE_STYLE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(DUPLICATE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(CLONE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(CLONE_UNLINK, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(CLONE_SELECT_ORIG, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(MAKE_BITMAP, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TILE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(UNTILE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SELECT_ALL, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SELECT_ALL_IN_ALL_LAYERS, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SELECT_INVERT, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SELECT_NONE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(XML_EDITOR, _("PLACEHOLDER, do not translate"))); - - // View menu - add(Gtk::StockItem(ZOOM, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(ZOOM_IN, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(ZOOM_OUT, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(ZOOM_100, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(ZOOM_50, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(ZOOM_200, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(ZOOM_SELECTION, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(ZOOM_DRAWING, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(ZOOM_PAGE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(ZOOM_WIDTH, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(ZOOM_PREV, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(ZOOM_NEXT, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SHOW_HIDE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SHOW_HIDE_COMMANDS_BAR, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SHOW_HIDE_TOOL_CONTROLS_BAR, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SHOW_HIDE_TOOLS_BAR, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SHOW_HIDE_RULERS, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SHOW_HIDE_SCROLLBARS, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SHOW_HIDE_STATUSBAR, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SHOW_HIDE_DIALOGS, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(GRID, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(GUIDES, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(FULLSCREEN, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(MESSAGES, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SCRIPTS, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(WINDOW_PREV, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(WINDOW_NEXT, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(WINDOW_DUPLICATE, _("PLACEHOLDER, do not translate"))); - - // Layer menu - add(Gtk::StockItem(LAYER_NEW, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(LAYER_RENAME, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(LAYER_DUPLICATE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(LAYER_ANCHOR, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(LAYER_MERGE_DOWN, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(LAYER_DELETE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(LAYER_SELECT_NEXT, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(LAYER_SELECT_PREV, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(LAYER_SELECT_TOP, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(LAYER_SELECT_BOTTOM, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(LAYER_RAISE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(LAYER_LOWER, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(LAYER_TO_TOP, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(LAYER_TO_BOTTOM, _("PLACEHOLDER, do not translate"))); - - // Object menu - add(Gtk::StockItem(FILL_STROKE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(OBJECT_PROPERTIES, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(GROUP, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(UNGROUP, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(RAISE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(LOWER, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(RAISE_TO_TOP, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(LOWER_TO_BOTTOM, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(MOVE_TO_NEW_LAYER, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(MOVE_TO_NEXT_LAYER, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(MOVE_TO_PREV_LAYER, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(MOVE_TO_TOP_LAYER, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(MOVE_TO_BOTTOM_LAYER, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(ROTATE_90_CW, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(ROTATE_90_CCW, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(FLIP_HORIZ, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(FLIP_VERT, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TRANSFORM, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TRANSFORMATION, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(ALIGN_DISTRIBUTE, _("PLACEHOLDER, do not translate"))); - - // Path menu - add(Gtk::StockItem(OBJECT_TO_PATH, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(STROKE_TO_PATH, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TRACE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(UNION, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(DIFFERENCE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(INTERSECTION, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(EXCLUSION, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(DIVISION, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(CUT_PATH, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(COMBINE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(BREAK_APART, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(INSET, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(OUTSET, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(OFFSET_DYNAMIC, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(OFFSET_LINKED, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SIMPLIFY, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(REVERSE, _("PLACEHOLDER, do not translate"))); - //add(Gtk::StockItem(CLEANUP, _("PLACEHOLDER, do not translate"))); (using Gtk::Stock::CLEAR) - - // Text menu - add(Gtk::StockItem(SELECT_FONT, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(PUT_ON_PATH, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(REMOVE_FROM_PATH, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(REMOVE_MANUAL_KERNS, _("PLACEHOLDER, do not translate"))); - - // About menu - add(Gtk::StockItem(KEYS_MOUSE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TUTORIALS, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(ABOUT, _("PLACEHOLDER, do not translate"))); - - // Tools toolbox - add(Gtk::StockItem(TOOL_SELECT, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TOOL_NODE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TOOL_ZOOM, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TOOL_RECT, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TOOL_ARC, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TOOL_STAR, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TOOL_SPIRAL, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TOOL_FREEHAND, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TOOL_PEN, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TOOL_DYNADRAW, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TOOL_TEXT, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TOOL_DROPPER, _("PLACEHOLDER, do not translate"))); - - // Select Tool controls - add(Gtk::StockItem(TRANSFORM_STROKE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TRANSFORM_CORNERS, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TRANSFORM_GRADIENT, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(TRANSFORM_PATTERN, _("PLACEHOLDER, do not translate"))); - - // Node Tool controls - add(Gtk::StockItem(NODE_INSERT, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(NODE_DELETE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(NODE_JOIN, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(NODE_JOIN_SEGMENT, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(NODE_DELETE_SEGMENT, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(NODE_BREAK, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(NODE_CORNER, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(NODE_SMOOTH, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(NODE_SYMMETRIC, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(NODE_LINE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(NODE_CURVE, _("PLACEHOLDER, do not translate"))); - - // Calligraphy Tool controls - add(Gtk::StockItem(USE_PRESSURE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(USE_TILT, _("PLACEHOLDER, do not translate"))); - - // Session playback controls - add(Gtk::StockItem(SESSION_PLAYBACK_REW, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SESSION_PLAYBACK_STEPBACK, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SESSION_PLAYBACK_PAUSE, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SESSION_PLAYBACK_STEPFORWARD, _("PLACEHOLDER, do not translate"))); - add(Gtk::StockItem(SESSION_PLAYBACK_PLAY, _("PLACEHOLDER, do not translate"))); -} - -} // namespace Stock -} // namespace UI -} // namespace Inkscape - -/* - 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:encoding=utf-8:textwidth=99 : diff --git a/src/ui/stock-items.h b/src/ui/stock-items.h deleted file mode 100644 index a109c2960..000000000 --- a/src/ui/stock-items.h +++ /dev/null @@ -1,37 +0,0 @@ -/** - * \brief StockItems for Inkscape-specific menu and button labels and key - * accelerators. - * - * Author: - * Derek P. Moore - * - * Copyright (C) 2004 Derek P. Moore - * - * Released under GNU GPL. Read the file 'COPYING' for more information. - */ - -#ifndef INKSCAPE_UI_STOCK_ITEMS_H -#define INKSCAPE_UI_STOCK_ITEMS_H - -namespace Inkscape { -namespace UI { -namespace Stock { - -void init(); - -} // namespace Stock -} // namespace UI -} // namespace Inkscape - -#endif // INKSCAPE_UI_STOCK_ITEMS_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:encoding=utf-8:textwidth=99 : diff --git a/src/ui/stock.cpp b/src/ui/stock.cpp deleted file mode 100644 index f0ec456b1..000000000 --- a/src/ui/stock.cpp +++ /dev/null @@ -1,191 +0,0 @@ -/** - * \brief StockIDs for Inkscape-specific stock menu/toolbar items and icons. - * - * Author: - * Derek P. Moore - * - * Copyright (C) 2004 Derek P. Moore - * - * Released under GNU GPL. Read the file 'COPYING' for more information. - */ - -#include "stock.h" - -namespace Inkscape { -namespace UI { -namespace Stock { - -// File menu -Gtk::StockID const OPEN_RECENT("open-recent"); -Gtk::StockID const IMPORT("import"); -Gtk::StockID const EXPORT("export"); -Gtk::StockID const IMPORTFROMOCAL("import_from_ocal"); -Gtk::StockID const EXPORTTOOCAL("export_to_ocal"); -Gtk::StockID const VACUUM_DEFS("vacuum-defs"); -// Edit menu -Gtk::StockID const UNDO_HISTORY("undo-history"); -Gtk::StockID const PASTE_IN_PLACE("paste-in-place"); -Gtk::StockID const PASTE_STYLE("paste-style"); -Gtk::StockID const DUPLICATE("duplicate"); -Gtk::StockID const CLONE("clone"); -Gtk::StockID const CLONE_UNLINK("clone-unlink"); -Gtk::StockID const CLONE_SELECT_ORIG("clone-select-orig"); -Gtk::StockID const MAKE_BITMAP("make-bitmap"); -Gtk::StockID const TILE("tile"); -Gtk::StockID const UNTILE("untile"); -Gtk::StockID const SELECT_ALL("select-all"); -Gtk::StockID const SELECT_ALL_IN_ALL_LAYERS("select-all-in-all-layers"); -Gtk::StockID const SELECT_INVERT("select-invert"); -Gtk::StockID const SELECT_NONE("select-none"); -Gtk::StockID const XML_EDITOR("xml-editor"); -// View menu -Gtk::StockID const ZOOM("zoom"); -Gtk::StockID const ZOOM_IN("zoom-in"); -Gtk::StockID const ZOOM_OUT("zoom-out"); -Gtk::StockID const ZOOM_100("zoom-100"); -Gtk::StockID const ZOOM_50("zoom-50"); -Gtk::StockID const ZOOM_200("zoom-200"); -Gtk::StockID const ZOOM_SELECTION("zoom-selection"); -Gtk::StockID const ZOOM_DRAWING("zoom-drawing"); -Gtk::StockID const ZOOM_PAGE("zoom-page"); -Gtk::StockID const ZOOM_WIDTH("zoom-width"); -Gtk::StockID const ZOOM_PREV("zoom-prev"); -Gtk::StockID const ZOOM_NEXT("zoom-next"); -Gtk::StockID const SHOW_HIDE("show-hide"); -Gtk::StockID const SHOW_HIDE_COMMANDS_BAR("show-hide-commands-bar"); -Gtk::StockID const SHOW_HIDE_TOOL_CONTROLS_BAR("show-hide-tool-controls-bar"); -Gtk::StockID const SHOW_HIDE_TOOLS_BAR("show-hide-tools-bar"); -Gtk::StockID const SHOW_HIDE_RULERS("show-hide-rulers"); -Gtk::StockID const SHOW_HIDE_SCROLLBARS("show-hide-scrollbars"); -Gtk::StockID const SHOW_HIDE_STATUSBAR("show-hide-statusbar"); -Gtk::StockID const SHOW_HIDE_DIALOGS("show-hide-dialogs"); -Gtk::StockID const GRID("grid"); -Gtk::StockID const GUIDES("guides"); -Gtk::StockID const FULLSCREEN("fullscreen"); -Gtk::StockID const MESSAGES("messages"); -Gtk::StockID const SCRIPTS("scripts"); -Gtk::StockID const WINDOW_PREV("window-prev"); -Gtk::StockID const WINDOW_NEXT("window-next"); -Gtk::StockID const WINDOW_DUPLICATE("window-duplicate"); -// Layer menu -Gtk::StockID const LAYER_NEW("layer-new"); -Gtk::StockID const LAYER_RENAME("layer-rename"); -Gtk::StockID const LAYER_DUPLICATE("layer-duplicate"); -Gtk::StockID const LAYER_ANCHOR("layer-anchor"); -Gtk::StockID const LAYER_MERGE_DOWN("layer-merge-down"); -Gtk::StockID const LAYER_DELETE("layer-delete"); -Gtk::StockID const LAYER_SELECT_NEXT("layer-select-next"); -Gtk::StockID const LAYER_SELECT_PREV("layer-select-prev"); -Gtk::StockID const LAYER_SELECT_TOP("layer-select-top"); -Gtk::StockID const LAYER_SELECT_BOTTOM("layer-select-bottom"); -Gtk::StockID const LAYER_RAISE("layer-raise"); -Gtk::StockID const LAYER_LOWER("layer-lower"); -Gtk::StockID const LAYER_TO_TOP("layer-to-top"); -Gtk::StockID const LAYER_TO_BOTTOM("layer-to-bottom"); -// Object menu -Gtk::StockID const FILL_STROKE("fill-stroke"); -Gtk::StockID const OBJECT_PROPERTIES("object-properties"); -Gtk::StockID const FILTER_EFFECTS("filter-effects"); -Gtk::StockID const GROUP("group"); -Gtk::StockID const UNGROUP("upgroup"); -Gtk::StockID const RAISE("raise"); -Gtk::StockID const LOWER("lower"); -Gtk::StockID const RAISE_TO_TOP("raise-to-top"); -Gtk::StockID const LOWER_TO_BOTTOM("lower-to-bottom"); -Gtk::StockID const MOVE_TO_NEW_LAYER("move-to-new-layer"); -Gtk::StockID const MOVE_TO_NEXT_LAYER("move-to-next-layer"); -Gtk::StockID const MOVE_TO_PREV_LAYER("move-to-prev-layer"); -Gtk::StockID const MOVE_TO_TOP_LAYER("move-to-top-layer"); -Gtk::StockID const MOVE_TO_BOTTOM_LAYER("move-to-bottom-layer"); -Gtk::StockID const ROTATE_90_CW("rotate-90-cw"); -Gtk::StockID const ROTATE_90_CCW("rotate-90-ccw"); -Gtk::StockID const FLIP_HORIZ("flip-horiz"); -Gtk::StockID const FLIP_VERT("flip-vert"); -Gtk::StockID const TRANSFORM("transform"); -Gtk::StockID const TRANSFORMATION("transformation"); -Gtk::StockID const ALIGN_DISTRIBUTE("align-distribute"); -// Path menu -Gtk::StockID const OBJECT_TO_PATH("object-to-path"); -Gtk::StockID const STROKE_TO_PATH("stroke-to-path"); -Gtk::StockID const TRACE("trace"); -Gtk::StockID const UNION("union"); -Gtk::StockID const DIFFERENCE("difference"); -Gtk::StockID const INTERSECTION("intersection"); -Gtk::StockID const EXCLUSION("exclusion"); -Gtk::StockID const DIVISION("division"); -Gtk::StockID const CUT_PATH("cut-path"); -Gtk::StockID const COMBINE("combine"); -Gtk::StockID const BREAK_APART("break-apart"); -Gtk::StockID const INSET("inset"); -Gtk::StockID const OUTSET("outset"); -Gtk::StockID const OFFSET_DYNAMIC("offset-dynamic"); -Gtk::StockID const OFFSET_LINKED("offset-linked"); -Gtk::StockID const SIMPLIFY("simplify"); -Gtk::StockID const REVERSE("reverse"); -//Gtk::StockID const CLEANUP("cleanup"); (using Gtk::Stock::CLEAR) -// Text menu -Gtk::StockID const TEXT_PROPERTIES("text-properties"); -Gtk::StockID const PUT_ON_PATH("put-on-path"); -Gtk::StockID const REMOVE_FROM_PATH("remove-from-path"); -Gtk::StockID const REMOVE_MANUAL_KERNS("remove-manual-kerns"); -// About menu -Gtk::StockID const KEYS_MOUSE("keys-mouse"); -Gtk::StockID const TUTORIALS("tutorials"); -Gtk::StockID const ABOUT("about"); -Gtk::StockID const ABOUT_SPLASH("about-splash"); -Gtk::StockID const ABOUT_42("about-42"); -Gtk::StockID const ABOUT_QUICK_HELP("about-quick-help"); -// Tools bar -Gtk::StockID const TOOL_SELECT("tool-select"); -Gtk::StockID const TOOL_NODE("tool-node"); -Gtk::StockID const TOOL_ZOOM("tool-zoom"); -Gtk::StockID const TOOL_RECT("tool-rect"); -Gtk::StockID const TOOL_ARC("tool-arc"); -Gtk::StockID const TOOL_STAR("tool-star"); -Gtk::StockID const TOOL_SPIRAL("tool-spiral"); -Gtk::StockID const TOOL_FREEHAND("tool-freehand"); -Gtk::StockID const TOOL_PEN("tool-pen"); -Gtk::StockID const TOOL_DYNADRAW("tool-dynadraw"); -Gtk::StockID const TOOL_TEXT("tool-text"); -Gtk::StockID const TOOL_DROPPER("tool-dropper"); -// Select Tool controls -Gtk::StockID const TRANSFORM_STROKE("transform-stroke"); -Gtk::StockID const TRANSFORM_CORNERS("transform-corners"); -Gtk::StockID const TRANSFORM_GRADIENT("transform-gradient"); -Gtk::StockID const TRANSFORM_PATTERN("transform-pattern"); -// Node Tool controls -Gtk::StockID const NODE_INSERT("node-insert"); -Gtk::StockID const NODE_DELETE("node-delete"); -Gtk::StockID const NODE_JOIN("node-join"); -Gtk::StockID const NODE_JOIN_SEGMENT("node-join-segment"); -Gtk::StockID const NODE_DELETE_SEGMENT("node-delete-segment"); -Gtk::StockID const NODE_BREAK("node-break"); -Gtk::StockID const NODE_CORNER("node-corner"); -Gtk::StockID const NODE_SMOOTH("node-smooth"); -Gtk::StockID const NODE_SYMMETRIC("node-symmetric"); -Gtk::StockID const NODE_LINE("node-line"); -Gtk::StockID const NODE_CURVE("node-curve"); -// Calligraphy Tool controls -Gtk::StockID const USE_PRESSURE("use-pressure"); -Gtk::StockID const USE_TILT("use-tilt"); - -Gtk::StockID const SESSION_PLAYBACK_REW("session-rewind"); -Gtk::StockID const SESSION_PLAYBACK_STEPBACK("session-stepback"); -Gtk::StockID const SESSION_PLAYBACK_PAUSE("session-pause"); -Gtk::StockID const SESSION_PLAYBACK_STEPFORWARD("session-stepforward"); -Gtk::StockID const SESSION_PLAYBACK_PLAY("session-play"); - -} // namespace Stock -} // namespace UI -} // namespace Inkscape - -/* - 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:encoding=utf-8:textwidth=99 : diff --git a/src/ui/stock.h b/src/ui/stock.h deleted file mode 100644 index ad99a3c05..000000000 --- a/src/ui/stock.h +++ /dev/null @@ -1,196 +0,0 @@ -/** - * \brief StockIDs for Inkscape-specific stock items and icons. - * - * Author: - * Derek P. Moore - * - * Copyright (C) 2004 Derek P. Moore - * - * Released under GNU GPL. Read the file 'COPYING' for more information. - */ - -#ifndef INKSCAPE_UI_STOCK_H -#define INKSCAPE_UI_STOCK_H - -#include - -namespace Inkscape { -namespace UI { -namespace Stock { - -// File menu -extern Gtk::StockID const OPEN_RECENT; -extern Gtk::StockID const IMPORT; -extern Gtk::StockID const EXPORT; -extern Gtk::StockID const IMPORTFROMOCAL; -extern Gtk::StockID const EXPORTTOOCAL; -extern Gtk::StockID const VACUUM_DEFS; -// Edit menu -extern Gtk::StockID const UNDO_HISTORY; -extern Gtk::StockID const PASTE_IN_PLACE; -extern Gtk::StockID const PASTE_STYLE; -extern Gtk::StockID const DUPLICATE; -extern Gtk::StockID const CLONE; -extern Gtk::StockID const CLONE_UNLINK; -extern Gtk::StockID const CLONE_SELECT_ORIG; -extern Gtk::StockID const MAKE_BITMAP; -extern Gtk::StockID const TILE; -extern Gtk::StockID const UNTILE; -extern Gtk::StockID const SELECT_ALL; -extern Gtk::StockID const SELECT_ALL_IN_ALL_LAYERS; -extern Gtk::StockID const SELECT_INVERT; -extern Gtk::StockID const SELECT_NONE; -extern Gtk::StockID const XML_EDITOR; -// View menu -extern Gtk::StockID const ZOOM; -extern Gtk::StockID const ZOOM_IN; -extern Gtk::StockID const ZOOM_OUT; -extern Gtk::StockID const ZOOM_100; -extern Gtk::StockID const ZOOM_50; -extern Gtk::StockID const ZOOM_200; -extern Gtk::StockID const ZOOM_SELECTION; -extern Gtk::StockID const ZOOM_DRAWING; -extern Gtk::StockID const ZOOM_PAGE; -extern Gtk::StockID const ZOOM_WIDTH; -extern Gtk::StockID const ZOOM_PREV; -extern Gtk::StockID const ZOOM_NEXT; -extern Gtk::StockID const SHOW_HIDE; -extern Gtk::StockID const SHOW_HIDE_COMMANDS_BAR; -extern Gtk::StockID const SHOW_HIDE_TOOL_CONTROLS_BAR; -extern Gtk::StockID const SHOW_HIDE_TOOLS_BAR; -extern Gtk::StockID const SHOW_HIDE_RULERS; -extern Gtk::StockID const SHOW_HIDE_SCROLLBARS; -extern Gtk::StockID const SHOW_HIDE_STATUSBAR; -extern Gtk::StockID const SHOW_HIDE_DIALOGS; -extern Gtk::StockID const GRID; -extern Gtk::StockID const GUIDES; -extern Gtk::StockID const FULLSCREEN; -extern Gtk::StockID const MESSAGES; -extern Gtk::StockID const SCRIPTS; -extern Gtk::StockID const WINDOW_PREV; -extern Gtk::StockID const WINDOW_NEXT; -extern Gtk::StockID const WINDOW_DUPLICATE; -// Layer menu -extern Gtk::StockID const LAYER_NEW; -extern Gtk::StockID const LAYER_RENAME; -extern Gtk::StockID const LAYER_DUPLICATE; -extern Gtk::StockID const LAYER_ANCHOR; -extern Gtk::StockID const LAYER_MERGE_DOWN; -extern Gtk::StockID const LAYER_DELETE; -extern Gtk::StockID const LAYER_SELECT_NEXT; -extern Gtk::StockID const LAYER_SELECT_PREV; -extern Gtk::StockID const LAYER_SELECT_TOP; -extern Gtk::StockID const LAYER_SELECT_BOTTOM; -extern Gtk::StockID const LAYER_RAISE; -extern Gtk::StockID const LAYER_LOWER; -extern Gtk::StockID const LAYER_TO_TOP; -extern Gtk::StockID const LAYER_TO_BOTTOM; -// Object menu -extern Gtk::StockID const FILL_STROKE; -extern Gtk::StockID const OBJECT_PROPERTIES; -extern Gtk::StockID const FILTER_EFFECTS; -extern Gtk::StockID const GROUP; -extern Gtk::StockID const UNGROUP; -extern Gtk::StockID const RAISE; -extern Gtk::StockID const LOWER; -extern Gtk::StockID const RAISE_TO_TOP; -extern Gtk::StockID const LOWER_TO_BOTTOM; -extern Gtk::StockID const MOVE_TO_NEW_LAYER; -extern Gtk::StockID const MOVE_TO_NEXT_LAYER; -extern Gtk::StockID const MOVE_TO_PREV_LAYER; -extern Gtk::StockID const MOVE_TO_TOP_LAYER; -extern Gtk::StockID const MOVE_TO_BOTTOM_LAYER; -extern Gtk::StockID const ROTATE_90_CW; -extern Gtk::StockID const ROTATE_90_CCW; -extern Gtk::StockID const FLIP_HORIZ; -extern Gtk::StockID const FLIP_VERT; -extern Gtk::StockID const TRANSFORM; -extern Gtk::StockID const TRANSFORMATION; -extern Gtk::StockID const ALIGN_DISTRIBUTE; -// Path menu -extern Gtk::StockID const OBJECT_TO_PATH; -extern Gtk::StockID const STROKE_TO_PATH; -extern Gtk::StockID const TRACE; -extern Gtk::StockID const UNION; -extern Gtk::StockID const DIFFERENCE; -extern Gtk::StockID const INTERSECTION; -extern Gtk::StockID const EXCLUSION; -extern Gtk::StockID const DIVISION; -extern Gtk::StockID const CUT_PATH; -extern Gtk::StockID const COMBINE; -extern Gtk::StockID const BREAK_APART; -extern Gtk::StockID const INSET; -extern Gtk::StockID const OUTSET; -extern Gtk::StockID const OFFSET_DYNAMIC; -extern Gtk::StockID const OFFSET_LINKED; -extern Gtk::StockID const SIMPLIFY; -extern Gtk::StockID const REVERSE; -//extern Gtk::StockID const CLEANUP; (using Gtk::Stock::CLEAR) -// Text menu -extern Gtk::StockID const TEXT_PROPERTIES; -extern Gtk::StockID const PUT_ON_PATH; -extern Gtk::StockID const REMOVE_FROM_PATH; -extern Gtk::StockID const REMOVE_MANUAL_KERNS; -// About menu -extern Gtk::StockID const KEYS_MOUSE; -extern Gtk::StockID const TUTORIALS; -extern Gtk::StockID const ABOUT; -extern Gtk::StockID const ABOUT_SPLASH; -extern Gtk::StockID const ABOUT_42; -extern Gtk::StockID const ABOUT_QUICK_HELP; -// Tools bar -extern Gtk::StockID const TOOL_SELECT; -extern Gtk::StockID const TOOL_NODE; -extern Gtk::StockID const TOOL_ZOOM; -extern Gtk::StockID const TOOL_RECT; -extern Gtk::StockID const TOOL_ARC; -extern Gtk::StockID const TOOL_STAR; -extern Gtk::StockID const TOOL_SPIRAL; -extern Gtk::StockID const TOOL_FREEHAND; -extern Gtk::StockID const TOOL_PEN; -extern Gtk::StockID const TOOL_DYNADRAW; -extern Gtk::StockID const TOOL_TEXT; -extern Gtk::StockID const TOOL_DROPPER; -// Select Tool controls -extern Gtk::StockID const TRANSFORM_STROKE; -extern Gtk::StockID const TRANSFORM_CORNERS; -extern Gtk::StockID const TRANSFORM_GRADIENT; -extern Gtk::StockID const TRANSFORM_PATTERN; -// Node Tool controls -extern Gtk::StockID const NODE_INSERT; -extern Gtk::StockID const NODE_DELETE; -extern Gtk::StockID const NODE_JOIN; -extern Gtk::StockID const NODE_JOIN_SEGMENT; -extern Gtk::StockID const NODE_DELETE_SEGMENT; -extern Gtk::StockID const NODE_BREAK; -extern Gtk::StockID const NODE_CORNER; -extern Gtk::StockID const NODE_SMOOTH; -extern Gtk::StockID const NODE_SYMMETRIC; -extern Gtk::StockID const NODE_LINE; -extern Gtk::StockID const NODE_CURVE; -// Calligraphy Tool controls -extern Gtk::StockID const USE_PRESSURE; -extern Gtk::StockID const USE_TILT; -// Session playback dialog controls -extern Gtk::StockID const SESSION_PLAYBACK_REW; -extern Gtk::StockID const SESSION_PLAYBACK_STEPBACK; -extern Gtk::StockID const SESSION_PLAYBACK_PAUSE; -extern Gtk::StockID const SESSION_PLAYBACK_STEPFORWARD; -extern Gtk::StockID const SESSION_PLAYBACK_PLAY; - -} // namespace Stock -} // namespace UI -} // namespace Inkscape - -#endif // INKSCAPE_UI_STOCK_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:encoding=utf-8:textwidth=99 : diff --git a/src/ui/view/edit-widget.cpp b/src/ui/view/edit-widget.cpp index 6f571a4ef..f11fac4cd 100644 --- a/src/ui/view/edit-widget.cpp +++ b/src/ui/view/edit-widget.cpp @@ -50,8 +50,6 @@ #include "file.h" #include "application/editor.h" #include "edit-widget.h" -#include "ui/stock.h" -#include "ui/stock-items.h" #include "display/sodipodi-ctrlrect.h" #include "helper/units.h" @@ -85,7 +83,6 @@ EditWidget::EditWidget (SPDocument *doc) g_warning("Creating new EditWidget"); _desktop = 0; - Stock::init(); initActions(); initAccelMap(); initUIManager(); @@ -315,16 +312,8 @@ EditWidget::onUriChanged() void EditWidget::initMenuActions() { -// _act_grp->add(Gtk::Action::create("MenuFile", _("PLACEHOLDER, do not translate"))); -// _act_grp->add(Gtk::Action::create("MenuEdit", _("PLACEHOLDER, do not translate"))); -// _act_grp->add(Gtk::Action::create("MenuView", _("PLACEHOLDER, do not translate"))); -// _act_grp->add(Gtk::Action::create("MenuLayer", _("PLACEHOLDER, do not translate"))); -// _act_grp->add(Gtk::Action::create("MenuObject", _("PLACEHOLDER, do not translate"))); -// _act_grp->add(Gtk::Action::create("MenuPath", _("PLACEHOLDER, do not translate"))); -// _act_grp->add(Gtk::Action::create("MenuText", _("PLACEHOLDER, do not translate"))); -// _act_grp->add(Gtk::Action::create("MenuHelp", _("PLACEHOLDER, do not translate"))); -// temporarily replaced with non-gettext version to have a well-sized menu -// for testing: +// This has no chance of working right now. +// Has to be converted to Gtk::Action::create_with_icon_name. _act_grp->add(Gtk::Action::create("MenuFile", "File")); _act_grp->add(Gtk::Action::create("MenuEdit", "Edit")); @@ -345,9 +334,9 @@ EditWidget::initMenuActions() Gtk::Stock::OPEN, Glib::ustring(), _("PLACEHOLDER, do not translate")), sigc::mem_fun(*this, &EditWidget::onActionFileOpen)); - +/* _act_grp->add(Gtk::Action::create("OpenRecent", - Stock::OPEN_RECENT)); + Stock::OPEN_RECENT));*/ _act_grp->add(Gtk::Action::create("Revert", Gtk::Stock::REVERT_TO_SAVED, Glib::ustring(), @@ -363,7 +352,7 @@ EditWidget::initMenuActions() Gtk::Stock::SAVE_AS, Glib::ustring(), _("PLACEHOLDER, do not translate")), sigc::mem_fun(*this, &EditWidget::onActionFileOpen)); - +/* _act_grp->add(Gtk::Action::create("Import", Stock::IMPORT, Glib::ustring(), _("PLACEHOLDER, do not translate")), @@ -372,7 +361,7 @@ EditWidget::initMenuActions() _act_grp->add(Gtk::Action::create("Export", Stock::EXPORT, Glib::ustring(), _("PLACEHOLDER, do not translate")), - sigc::mem_fun(*this, &EditWidget::onDialogExport)); + sigc::mem_fun(*this, &EditWidget::onDialogExport));*/ _act_grp->add(Gtk::Action::create("Print", Gtk::Stock::PRINT, Glib::ustring(), @@ -382,10 +371,10 @@ EditWidget::initMenuActions() _act_grp->add(Gtk::Action::create("PrintPreview", Gtk::Stock::PRINT_PREVIEW), sigc::mem_fun(*this, &EditWidget::onActionFileOpen)); - +/* _act_grp->add(Gtk::Action::create("VacuumDefs", Stock::VACUUM_DEFS), - sigc::mem_fun(*this, &EditWidget::onActionFileOpen)); + sigc::mem_fun(*this, &EditWidget::onActionFileOpen));*/ _act_grp->add(Gtk::Action::create("DocumentProperties", Gtk::Stock::PROPERTIES, Glib::ustring(), @@ -413,10 +402,10 @@ EditWidget::initMenuActions() _act_grp->add(Gtk::Action::create("Redo", Gtk::Stock::REDO, Glib::ustring(), _("PLACEHOLDER, do not translate"))); - +/* _act_grp->add(Gtk::Action::create("UndoHistory", Stock::UNDO_HISTORY, Glib::ustring(), - _("PLACEHOLDER, do not translate"))); + _("PLACEHOLDER, do not translate")));*/ _act_grp->add(Gtk::Action::create("Cut", Gtk::Stock::CUT, Glib::ustring(), @@ -429,17 +418,17 @@ EditWidget::initMenuActions() _act_grp->add(Gtk::Action::create("Paste", Gtk::Stock::PASTE, Glib::ustring(), _("PLACEHOLDER, do not translate"))); - +/* _act_grp->add(Gtk::Action::create("PasteInPlace", Stock::PASTE_IN_PLACE)); _act_grp->add(Gtk::Action::create("PasteStyle", - Stock::PASTE_STYLE)); + Stock::PASTE_STYLE));*/ _act_grp->add(Gtk::Action::create("Find", Gtk::Stock::FIND), sigc::mem_fun(*this, &EditWidget::onDialogFind)); - +/* _act_grp->add(Gtk::Action::create("Duplicate", Stock::DUPLICATE, Glib::ustring(), _("PLACEHOLDER, do not translate"))); @@ -760,7 +749,7 @@ EditWidget::initMenuActions() Stock::SIMPLIFY)); _act_grp->add(Gtk::Action::create("Reverse", - Stock::REVERSE)); + Stock::REVERSE));*/ _act_grp->add(Gtk::Action::create("Cleanup", Gtk::Stock::CLEAR, @@ -771,7 +760,7 @@ EditWidget::initMenuActions() Gtk::Stock::SELECT_FONT, Glib::ustring(), _("PLACEHOLDER, do not translate")), sigc::mem_fun(*this, &EditWidget::onDialogTextProperties)); - +/* _act_grp->add(Gtk::Action::create("PutOnPath", Stock::PUT_ON_PATH)); @@ -779,13 +768,14 @@ EditWidget::initMenuActions() Stock::REMOVE_FROM_PATH)); _act_grp->add(Gtk::Action::create("RemoveManualKerns", - Stock::REMOVE_MANUAL_KERNS)); + Stock::REMOVE_MANUAL_KERNS));*/ // Whiteboard menu #ifdef WITH_INKBOARD #endif // About menu +/* _act_grp->add(Gtk::Action::create("KeysAndMouse", Stock::KEYS_MOUSE)); @@ -794,15 +784,16 @@ EditWidget::initMenuActions() _act_grp->add(Gtk::Action::create("About", Stock::ABOUT), - sigc::mem_fun(*this, &EditWidget::onDialogAbout)); + sigc::mem_fun(*this, &EditWidget::onDialogAbout));*/ } void EditWidget::initToolbarActions() { // Tools bar + // This has zero chance to work, and has to be converted to create_with_icon_name Gtk::RadioAction::Group tools; - +/* _act_grp->add(Gtk::RadioAction::create(tools, "ToolSelect", Stock::TOOL_SELECT, Glib::ustring(), _("PLACEHOLDER, do not translate")), @@ -868,7 +859,7 @@ EditWidget::initToolbarActions() _act_grp->add(Gtk::ToggleAction::create("TransformPattern", Stock::TRANSFORM_PATTERN, Glib::ustring(), - _("PLACEHOLDER, do not translate"))); + _("PLACEHOLDER, do not translate")));*/ // Node Controls bar _act_grp->add(Gtk::Action::create("NodeInsert", @@ -878,7 +869,7 @@ EditWidget::initToolbarActions() _act_grp->add(Gtk::Action::create("NodeDelete", Gtk::Stock::REMOVE, Glib::ustring(), _("PLACEHOLDER, do not translate"))); - +/* _act_grp->add(Gtk::Action::create("NodeJoin", Stock::NODE_JOIN, Glib::ustring(), _("PLACEHOLDER, do not translate"))); @@ -913,7 +904,7 @@ EditWidget::initToolbarActions() _act_grp->add(Gtk::Action::create("NodeCurve", Stock::NODE_CURVE, Glib::ustring(), - _("PLACEHOLDER, do not translate"))); + _("PLACEHOLDER, do not translate")));*/ } void diff --git a/src/ui/widget/imagetoggler.cpp b/src/ui/widget/imagetoggler.cpp index e3670bd49..961cce5b5 100644 --- a/src/ui/widget/imagetoggler.cpp +++ b/src/ui/widget/imagetoggler.cpp @@ -31,19 +31,14 @@ ImageToggler::ImageToggler( char const* on, char const* off) : { property_mode() = Gtk::CELL_RENDERER_MODE_ACTIVATABLE; int phys = sp_icon_get_phys_size((int)Inkscape::ICON_SIZE_DECORATION); + Glib::RefPtr icon_theme = Gtk::IconTheme::get_default(); - Glib::RefPtr pbmm = Gtk::IconTheme::get_default()->load_icon(_pixOnName, phys, (Gtk::IconLookupFlags)0); - if ( pbmm ) { - GdkPixbuf* pb = gdk_pixbuf_copy(pbmm->gobj()); - _property_pixbuf_on = Glib::wrap( pb ); - pbmm->unreference(); + if (icon_theme->has_icon(_pixOnName)) { + _property_pixbuf_on = icon_theme->load_icon(_pixOnName, phys, (Gtk::IconLookupFlags)0); } - pbmm = Gtk::IconTheme::get_default()->load_icon(_pixOffName, phys, (Gtk::IconLookupFlags)0); - if ( pbmm ) { - GdkPixbuf* pb = gdk_pixbuf_copy(pbmm->gobj()); - _property_pixbuf_off = Glib::wrap( pb ); - pbmm->unreference(); + if (icon_theme->has_icon(_pixOffName)) { + _property_pixbuf_off = icon_theme->load_icon(_pixOffName, phys, (Gtk::IconLookupFlags)0); } property_pixbuf() = _property_pixbuf_off.get_value(); diff --git a/src/ui/widget/object-composite-settings.cpp b/src/ui/widget/object-composite-settings.cpp index 0ad7187f5..3e6683c64 100644 --- a/src/ui/widget/object-composite-settings.cpp +++ b/src/ui/widget/object-composite-settings.cpp @@ -18,7 +18,6 @@ #include "document.h" #include "filter-chemistry.h" #include "inkscape.h" -#include "inkscape-stock.h" #include "selection.h" #include "style.h" #include "sp-item.h" @@ -26,6 +25,7 @@ #include "verbs.h" #include "xml/repr.h" #include "widgets/icon.h" +#include "ui/icon-names.h" #include "ui/widget/object-composite-settings.h" #include "display/sp-canvas.h" diff --git a/src/verbs.cpp b/src/verbs.cpp index 56d4e667d..ce624b14c 100644 --- a/src/verbs.cpp +++ b/src/verbs.cpp @@ -28,65 +28,62 @@ #endif #include -#include #include - -#include "helper/action.h" - -#include #include +#include #include +#include -#include "layer-manager.h" -#include "dialogs/text-edit.h" -#include "dialogs/xml-tree.h" -#include "dialogs/item-properties.h" -#include "dialogs/find.h" -#include "dialogs/spellcheck.h" -#include "dialogs/layer-properties.h" +#include "bind/javabind.h" +#include "desktop.h" +#include "desktop-handles.h" #include "dialogs/clonetiler.h" -#include "dialogs/iconpreview.h" #include "dialogs/extensions.h" -#include "dialogs/swatches.h" -#include "dialogs/layers-panel.h" +#include "dialogs/find.h" +#include "dialogs/iconpreview.h" #include "dialogs/input.h" - -#ifdef WITH_INKBOARD -#include "jabber_whiteboard/session-manager.h" -#endif - +#include "dialogs/item-properties.h" +#include "dialogs/layer-properties.h" +#include "dialogs/layers-panel.h" +#include "dialogs/spellcheck.h" +#include "dialogs/swatches.h" +#include "dialogs/text-edit.h" +#include "dialogs/xml-tree.h" +#include "display/curve.h" +#include "document.h" +#include "draw-context.h" #include "extension/effect.h" -#include "bind/javabind.h" - -#include "tools-switch.h" -#include "inkscape-private.h" #include "file.h" +#include "gradient-context.h" +#include "gradient-drag.h" +#include "helper/action.h" #include "help.h" -#include "document.h" -#include "desktop.h" -#include "message-stack.h" -#include "desktop-handles.h" -#include "selection-chemistry.h" -#include "path-chemistry.h" -#include "text-chemistry.h" -#include "ui/dialog/dialog-manager.h" -#include "ui/dialog/document-properties.h" -#include "ui/dialog/inkscape-preferences.h" +#include "inkscape-private.h" #include "interface.h" -#include "preferences.h" -#include "splivarot.h" -#include "sp-namedview.h" -#include "sp-flowtext.h" #include "layer-fns.h" +#include "layer-manager.h" +#include "message-stack.h" #include "node-context.h" +#include "path-chemistry.h" +#include "preferences.h" #include "select-context.h" +#include "selection-chemistry.h" #include "seltrans.h" -#include "gradient-context.h" #include "shape-editor.h" -#include "draw-context.h" -#include "gradient-drag.h" +#include "sp-flowtext.h" #include "sp-guide.h" -#include "display/curve.h" +#include "splivarot.h" +#include "sp-namedview.h" +#include "text-chemistry.h" +#include "tools-switch.h" +#include "ui/dialog/dialog-manager.h" +#include "ui/dialog/document-properties.h" +#include "ui/dialog/inkscape-preferences.h" +#include "ui/icon-names.h" + +#ifdef WITH_INKBOARD +#include "jabber_whiteboard/session-manager.h" +#endif /** * \brief Return the name without underscores and ellipsis, for use in dialog @@ -2239,19 +2236,19 @@ Verb *Verb::_base_verbs[] = { GTK_STOCK_PRINT ), // TRANSLATORS: "Vacuum Defs" means "Clean up defs" (so as to remove unused definitions) new FileVerb(SP_VERB_FILE_VACUUM, "FileVacuum", N_("Vac_uum Defs"), N_("Remove unused definitions (such as gradients or clipping paths) from the <defs> of the document"), - "file_vacuum" ), + INKSCAPE_ICON_DOCUMENT_CLEANUP ), new FileVerb(SP_VERB_FILE_PRINT_PREVIEW, "FilePrintPreview", N_("Print Previe_w"), N_("Preview document printout"), GTK_STOCK_PRINT_PREVIEW ), new FileVerb(SP_VERB_FILE_IMPORT, "FileImport", N_("_Import..."), - N_("Import a bitmap or SVG image into this document"), "file_import"), + N_("Import a bitmap or SVG image into this document"), INKSCAPE_ICON_DOCUMENT_IMPORT), new FileVerb(SP_VERB_FILE_EXPORT, "FileExport", N_("_Export Bitmap..."), - N_("Export this document or a selection as a bitmap image"), "file_export"), - new FileVerb(SP_VERB_FILE_IMPORT_FROM_OCAL, "FileImportFromOCAL", N_("Import From Open Clip Art Library"), N_("Import a document from Open Clip Art Library"), "ocal_import"), - new FileVerb(SP_VERB_FILE_EXPORT_TO_OCAL, "FileExportToOCAL", N_("Export To Open Clip Art Library"), N_("Export this document to Open Clip Art Library"), "ocal_export"), + N_("Export this document or a selection as a bitmap image"), INKSCAPE_ICON_DOCUMENT_EXPORT), + new FileVerb(SP_VERB_FILE_IMPORT_FROM_OCAL, "FileImportFromOCAL", N_("Import From Open Clip Art Library"), N_("Import a document from Open Clip Art Library"), INKSCAPE_ICON_DOCUMENT_IMPORT_OCAL), + new FileVerb(SP_VERB_FILE_EXPORT_TO_OCAL, "FileExportToOCAL", N_("Export To Open Clip Art Library"), N_("Export this document to Open Clip Art Library"), INKSCAPE_ICON_DOCUMENT_EXPORT_OCAL), new FileVerb(SP_VERB_FILE_NEXT_DESKTOP, "NextWindow", N_("N_ext Window"), - N_("Switch to the next document window"), "window_next"), + N_("Switch to the next document window"), INKSCAPE_ICON_WINDOW_NEXT), new FileVerb(SP_VERB_FILE_PREV_DESKTOP, "PrevWindow", N_("P_revious Window"), - N_("Switch to the previous document window"), "window_previous"), + N_("Switch to the previous document window"), INKSCAPE_ICON_WINDOW_PREVIOUS), new FileVerb(SP_VERB_FILE_CLOSE_VIEW, "FileClose", N_("_Close"), N_("Close this document window"), GTK_STOCK_CLOSE), new FileVerb(SP_VERB_FILE_QUIT, "FileQuit", N_("_Quit"), N_("Quit Inkscape"), GTK_STOCK_QUIT), @@ -2268,7 +2265,7 @@ Verb *Verb::_base_verbs[] = { new EditVerb(SP_VERB_EDIT_PASTE, "EditPaste", N_("_Paste"), N_("Paste objects from clipboard to mouse point, or paste text"), GTK_STOCK_PASTE), new EditVerb(SP_VERB_EDIT_PASTE_STYLE, "EditPasteStyle", N_("Paste _Style"), - N_("Apply the style of the copied object to selection"), "selection_paste_style"), + N_("Apply the style of the copied object to selection"), INKSCAPE_ICON_EDIT_PASTE_STYLE), new EditVerb(SP_VERB_EDIT_PASTE_SIZE, "EditPasteSize", N_("Paste Si_ze"), N_("Scale selection to match the size of the copied object"), NULL), new EditVerb(SP_VERB_EDIT_PASTE_SIZE_X, "EditPasteWidth", N_("Paste _Width"), @@ -2282,7 +2279,7 @@ Verb *Verb::_base_verbs[] = { new EditVerb(SP_VERB_EDIT_PASTE_SIZE_SEPARATELY_Y, "EditPasteHeightSeparately", N_("Paste Height Separately"), N_("Scale each selected object vertically to match the height of the copied object"), NULL), new EditVerb(SP_VERB_EDIT_PASTE_IN_PLACE, "EditPasteInPlace", N_("Paste _In Place"), - N_("Paste objects from clipboard to the original location"), "selection_paste_in_place"), + N_("Paste objects from clipboard to the original location"), INKSCAPE_ICON_EDIT_PASTE_IN_PLACE), new EditVerb(SP_VERB_EDIT_PASTE_LIVEPATHEFFECT, "PasteLivePathEffect", N_("Paste Path _Effect"), N_("Apply the path effect of the copied object to selection"), NULL), new EditVerb(SP_VERB_EDIT_REMOVE_LIVEPATHEFFECT, "RemoveLivePathEffect", N_("Remove Path _Effect"), @@ -2292,35 +2289,31 @@ Verb *Verb::_base_verbs[] = { new EditVerb(SP_VERB_EDIT_DELETE, "EditDelete", N_("_Delete"), N_("Delete selection"), GTK_STOCK_DELETE), new EditVerb(SP_VERB_EDIT_DUPLICATE, "EditDuplicate", N_("Duplic_ate"), - N_("Duplicate selected objects"), "edit_duplicate"), + N_("Duplicate selected objects"), INKSCAPE_ICON_EDIT_DUPLICATE), new EditVerb(SP_VERB_EDIT_CLONE, "EditClone", N_("Create Clo_ne"), - N_("Create a clone (a copy linked to the original) of selected object"), "edit_clone"), + N_("Create a clone (a copy linked to the original) of selected object"), INKSCAPE_ICON_EDIT_CLONE), new EditVerb(SP_VERB_EDIT_UNLINK_CLONE, "EditUnlinkClone", N_("Unlin_k Clone"), - N_("Cut the selected clones' links to the originals, turning them into standalone objects"), "edit_unlink_clone"), + N_("Cut the selected clones' links to the originals, turning them into standalone objects"), INKSCAPE_ICON_EDIT_CLONE_UNLINK), new EditVerb(SP_VERB_EDIT_RELINK_CLONE, "EditRelinkClone", N_("Relink to Copied"), N_("Relink the selected clones to the object currently on the clipboard"), NULL), new EditVerb(SP_VERB_EDIT_CLONE_SELECT_ORIGINAL, "EditCloneSelectOriginal", N_("Select _Original"), - N_("Select the object to which the selected clone is linked"), "edit_select_original"), - // TRANSLATORS: Convert selection to a line marker + N_("Select the object to which the selected clone is linked"), INKSCAPE_ICON_EDIT_SELECT_ORIGINAL), new EditVerb(SP_VERB_EDIT_SELECTION_2_MARKER, "ObjectsToMarker", N_("Objects to _Marker"), N_("Convert selection to a line marker"), NULL), - // TRANSLATORS: Convert selection to a collection of guidelines new EditVerb(SP_VERB_EDIT_SELECTION_2_GUIDES, "ObjectsToGuides", N_("Objects to Gu_ides"), N_("Convert selected objects to a collection of guidelines aligned with their edges"), NULL), - // TRANSLATORS: Convert selection to a rectangle with tiled pattern fill new EditVerb(SP_VERB_EDIT_TILE, "ObjectsToPattern", N_("Objects to Patter_n"), N_("Convert selection to a rectangle with tiled pattern fill"), NULL), - // TRANSLATORS: Extract objects from a tiled pattern fill new EditVerb(SP_VERB_EDIT_UNTILE, "ObjectsFromPattern", N_("Pattern to _Objects"), N_("Extract objects from a tiled pattern fill"), NULL), new EditVerb(SP_VERB_EDIT_CLEAR_ALL, "EditClearAll", N_("Clea_r All"), N_("Delete all objects from document"), NULL), new EditVerb(SP_VERB_EDIT_SELECT_ALL, "EditSelectAll", N_("Select Al_l"), - N_("Select all objects or all nodes"), "selection_select_all"), + N_("Select all objects or all nodes"), INKSCAPE_ICON_EDIT_SELECT_ALL), new EditVerb(SP_VERB_EDIT_SELECT_ALL_IN_ALL_LAYERS, "EditSelectAllInAllLayers", N_("Select All in All La_yers"), - N_("Select all objects in all visible and unlocked layers"), "selection_select_all_in_all_layers"), + N_("Select all objects in all visible and unlocked layers"), INKSCAPE_ICON_EDIT_SELECT_ALL_LAYERS), new EditVerb(SP_VERB_EDIT_INVERT, "EditInvert", N_("In_vert Selection"), - N_("Invert selection (unselect what is selected and select everything else)"), "selection_invert"), + N_("Invert selection (unselect what is selected and select everything else)"), INKSCAPE_ICON_EDIT_SELECT_INVERT), new EditVerb(SP_VERB_EDIT_INVERT_IN_ALL_LAYERS, "EditInvertInAllLayers", N_("Invert in All Layers"), N_("Invert selection in all visible and unlocked layers"), NULL), new EditVerb(SP_VERB_EDIT_SELECT_NEXT, "EditSelectNext", N_("Select Next"), @@ -2328,54 +2321,54 @@ Verb *Verb::_base_verbs[] = { new EditVerb(SP_VERB_EDIT_SELECT_PREV, "EditSelectPrev", N_("Select Previous"), N_("Select previous object or node"), NULL), new EditVerb(SP_VERB_EDIT_DESELECT, "EditDeselect", N_("D_eselect"), - N_("Deselect any selected objects or nodes"), "selection_deselect"), + N_("Deselect any selected objects or nodes"), INKSCAPE_ICON_EDIT_SELECT_NONE), new EditVerb(SP_VERB_EDIT_GUIDES_AROUND_PAGE, "EditGuidesAroundPage", N_("_Guides around page"), N_("Create four guides aligned with the page borders"), NULL), new EditVerb(SP_VERB_EDIT_NEXT_PATHEFFECT_PARAMETER, "EditNextPathEffectParameter", N_("Next Path Effect Parameter"), - N_("Show next Path Effect parameter for editing"), "edit_next_parameter"), + N_("Show next Path Effect parameter for editing"), INKSCAPE_ICON_PATH_EFFECT_PARAMETER_NEXT), /* Selection */ new SelectionVerb(SP_VERB_SELECTION_TO_FRONT, "SelectionToFront", N_("Raise to _Top"), - N_("Raise selection to top"), "selection_top"), + N_("Raise selection to top"), INKSCAPE_ICON_SELECTION_TOP), new SelectionVerb(SP_VERB_SELECTION_TO_BACK, "SelectionToBack", N_("Lower to _Bottom"), - N_("Lower selection to bottom"), "selection_bot"), + N_("Lower selection to bottom"), INKSCAPE_ICON_SELECTION_BOTTOM), new SelectionVerb(SP_VERB_SELECTION_RAISE, "SelectionRaise", N_("_Raise"), - N_("Raise selection one step"), "selection_up"), + N_("Raise selection one step"), INKSCAPE_ICON_SELECTION_RAISE), new SelectionVerb(SP_VERB_SELECTION_LOWER, "SelectionLower", N_("_Lower"), - N_("Lower selection one step"), "selection_down"), + N_("Lower selection one step"), INKSCAPE_ICON_SELECTION_LOWER), new SelectionVerb(SP_VERB_SELECTION_GROUP, "SelectionGroup", N_("_Group"), - N_("Group selected objects"), "selection_group"), + N_("Group selected objects"), INKSCAPE_ICON_OBJECT_GROUP), new SelectionVerb(SP_VERB_SELECTION_UNGROUP, "SelectionUnGroup", N_("_Ungroup"), - N_("Ungroup selected groups"), "selection_ungroup"), + N_("Ungroup selected groups"), INKSCAPE_ICON_OBJECT_UNGROUP), new SelectionVerb(SP_VERB_SELECTION_TEXTTOPATH, "SelectionTextToPath", N_("_Put on Path"), - N_("Put text on path"), "put_on_path"), + N_("Put text on path"), INKSCAPE_ICON_TEXT_PUT_ON_PATH), new SelectionVerb(SP_VERB_SELECTION_TEXTFROMPATH, "SelectionTextFromPath", N_("_Remove from Path"), - N_("Remove text from path"), "remove_from_path"), + N_("Remove text from path"), INKSCAPE_ICON_TEXT_REMOVE_FROM_PATH), new SelectionVerb(SP_VERB_SELECTION_REMOVE_KERNS, "SelectionTextRemoveKerns", N_("Remove Manual _Kerns"), // TRANSLATORS: "glyph": An image used in the visual representation of characters; // roughly speaking, how a character looks. A font is a set of glyphs. - N_("Remove all manual kerns and glyph rotations from a text object"), "remove_manual_kerns"), + N_("Remove all manual kerns and glyph rotations from a text object"), INKSCAPE_ICON_TEXT_UNKERN), new SelectionVerb(SP_VERB_SELECTION_UNION, "SelectionUnion", N_("_Union"), - N_("Create union of selected paths"), "union"), + N_("Create union of selected paths"), INKSCAPE_ICON_PATH_UNION), new SelectionVerb(SP_VERB_SELECTION_INTERSECT, "SelectionIntersect", N_("_Intersection"), - N_("Create intersection of selected paths"), "intersection"), + N_("Create intersection of selected paths"), INKSCAPE_ICON_PATH_INTERSECTION), new SelectionVerb(SP_VERB_SELECTION_DIFF, "SelectionDiff", N_("_Difference"), - N_("Create difference of selected paths (bottom minus top)"), "difference"), + N_("Create difference of selected paths (bottom minus top)"), INKSCAPE_ICON_PATH_DIFFERENCE), new SelectionVerb(SP_VERB_SELECTION_SYMDIFF, "SelectionSymDiff", N_("E_xclusion"), - N_("Create exclusive OR of selected paths (those parts that belong to only one path)"), "exclusion"), + N_("Create exclusive OR of selected paths (those parts that belong to only one path)"), INKSCAPE_ICON_PATH_EXCLUSION), new SelectionVerb(SP_VERB_SELECTION_CUT, "SelectionDivide", N_("Di_vision"), - N_("Cut the bottom path into pieces"), "division"), + N_("Cut the bottom path into pieces"), INKSCAPE_ICON_PATH_DIVISION), // TRANSLATORS: "to cut a path" is not the same as "to break a path apart" - see the // Advanced tutorial for more info new SelectionVerb(SP_VERB_SELECTION_SLICE, "SelectionCutPath", N_("Cut _Path"), - N_("Cut the bottom path's stroke into pieces, removing fill"), "cut_path"), + N_("Cut the bottom path's stroke into pieces, removing fill"), INKSCAPE_ICON_PATH_CUT), // TRANSLATORS: "outset": expand a shape by offsetting the object's path, // i.e. by displacing it perpendicular to the path in each point. // See also the Advanced Tutorial for explanation. new SelectionVerb(SP_VERB_SELECTION_OFFSET, "SelectionOffset", N_("Outs_et"), - N_("Outset selected paths"), "outset_path"), + N_("Outset selected paths"), INKSCAPE_ICON_PATH_OUTSET), new SelectionVerb(SP_VERB_SELECTION_OFFSET_SCREEN, "SelectionOffsetScreen", N_("O_utset Path by 1 px"), N_("Outset selected paths by 1 px"), NULL), @@ -2386,7 +2379,7 @@ Verb *Verb::_base_verbs[] = { // i.e. by displacing it perpendicular to the path in each point. // See also the Advanced Tutorial for explanation. new SelectionVerb(SP_VERB_SELECTION_INSET, "SelectionInset", N_("I_nset"), - N_("Inset selected paths"), "inset_path"), + N_("Inset selected paths"), INKSCAPE_ICON_PATH_INSET), new SelectionVerb(SP_VERB_SELECTION_INSET_SCREEN, "SelectionInsetScreen", N_("I_nset Path by 1 px"), N_("Inset selected paths by 1 px"), NULL), @@ -2394,137 +2387,137 @@ Verb *Verb::_base_verbs[] = { N_("I_nset Path by 10 px"), N_("Inset selected paths by 10 px"), NULL), new SelectionVerb(SP_VERB_SELECTION_DYNAMIC_OFFSET, "SelectionDynOffset", - N_("D_ynamic Offset"), N_("Create a dynamic offset object"), "dynamic_offset"), + N_("D_ynamic Offset"), N_("Create a dynamic offset object"), INKSCAPE_ICON_PATH_OFFSET_DYNAMIC), new SelectionVerb(SP_VERB_SELECTION_LINKED_OFFSET, "SelectionLinkedOffset", N_("_Linked Offset"), N_("Create a dynamic offset object linked to the original path"), - "linked_offset"), + INKSCAPE_ICON_PATH_OFFSET_LINKED), new SelectionVerb(SP_VERB_SELECTION_OUTLINE, "StrokeToPath", N_("_Stroke to Path"), - N_("Convert selected object's stroke to paths"), "stroke_tocurve"), + N_("Convert selected object's stroke to paths"), INKSCAPE_ICON_STROKE_TO_PATH), new SelectionVerb(SP_VERB_SELECTION_SIMPLIFY, "SelectionSimplify", N_("Si_mplify"), - N_("Simplify selected paths (remove extra nodes)"), "simplify"), + N_("Simplify selected paths (remove extra nodes)"), INKSCAPE_ICON_PATH_SIMPLIFY), new SelectionVerb(SP_VERB_SELECTION_REVERSE, "SelectionReverse", N_("_Reverse"), - N_("Reverse the direction of selected paths (useful for flipping markers)"), "selection_reverse"), + N_("Reverse the direction of selected paths (useful for flipping markers)"), INKSCAPE_ICON_PATH_REVERSE), // TRANSLATORS: "to trace" means "to convert a bitmap to vector graphics" (to vectorize) new SelectionVerb(SP_VERB_SELECTION_TRACE, "SelectionTrace", N_("_Trace Bitmap..."), - N_("Create one or more paths from a bitmap by tracing it"), "selection_trace"), + N_("Create one or more paths from a bitmap by tracing it"), INKSCAPE_ICON_BITMAP_TRACE), new SelectionVerb(SP_VERB_SELECTION_CREATE_BITMAP, "SelectionCreateBitmap", N_("_Make a Bitmap Copy"), - N_("Export selection to a bitmap and insert it into document"), "selection_bitmap" ), + N_("Export selection to a bitmap and insert it into document"), INKSCAPE_ICON_SELECTION_MAKE_BITMAP_COPY ), new SelectionVerb(SP_VERB_SELECTION_COMBINE, "SelectionCombine", N_("_Combine"), - N_("Combine several paths into one"), "selection_combine"), + N_("Combine several paths into one"), INKSCAPE_ICON_PATH_COMBINE), // TRANSLATORS: "to cut a path" is not the same as "to break a path apart" - see the // Advanced tutorial for more info new SelectionVerb(SP_VERB_SELECTION_BREAK_APART, "SelectionBreakApart", N_("Break _Apart"), - N_("Break selected paths into subpaths"), "selection_break"), + N_("Break selected paths into subpaths"), INKSCAPE_ICON_PATH_BREAK_APART), new SelectionVerb(SP_VERB_SELECTION_GRIDTILE, "DialogGridArrange", N_("Rows and Columns..."), - N_("Arrange selected objects in a table"), "grid_arrange"), + N_("Arrange selected objects in a table"), INKSCAPE_ICON_DIALOG_ROWS_AND_COLUMNS), /* Layer */ new LayerVerb(SP_VERB_LAYER_NEW, "LayerNew", N_("_Add Layer..."), - N_("Create a new layer"), "new_layer"), + N_("Create a new layer"), INKSCAPE_ICON_LAYER_NEW), new LayerVerb(SP_VERB_LAYER_RENAME, "LayerRename", N_("Re_name Layer..."), - N_("Rename the current layer"), "rename_layer"), + N_("Rename the current layer"), INKSCAPE_ICON_LAYER_RENAME), new LayerVerb(SP_VERB_LAYER_NEXT, "LayerNext", N_("Switch to Layer Abov_e"), - N_("Switch to the layer above the current"), "switch_to_layer_above"), + N_("Switch to the layer above the current"), INKSCAPE_ICON_LAYER_PREVIOUS), new LayerVerb(SP_VERB_LAYER_PREV, "LayerPrev", N_("Switch to Layer Belo_w"), - N_("Switch to the layer below the current"), "switch_to_layer_below"), + N_("Switch to the layer below the current"), INKSCAPE_ICON_LAYER_NEXT), new LayerVerb(SP_VERB_LAYER_MOVE_TO_NEXT, "LayerMoveToNext", N_("Move Selection to Layer Abo_ve"), - N_("Move selection to the layer above the current"), "move_selection_above"), + N_("Move selection to the layer above the current"), INKSCAPE_ICON_SELECTION_MOVE_TO_LAYER_ABOVE), new LayerVerb(SP_VERB_LAYER_MOVE_TO_PREV, "LayerMoveToPrev", N_("Move Selection to Layer Bel_ow"), - N_("Move selection to the layer below the current"), "move_selection_below"), + N_("Move selection to the layer below the current"), INKSCAPE_ICON_SELECTION_MOVE_TO_LAYER_BELOW), new LayerVerb(SP_VERB_LAYER_TO_TOP, "LayerToTop", N_("Layer to _Top"), - N_("Raise the current layer to the top"), "layer_to_top"), + N_("Raise the current layer to the top"), INKSCAPE_ICON_LAYER_TOP), new LayerVerb(SP_VERB_LAYER_TO_BOTTOM, "LayerToBottom", N_("Layer to _Bottom"), - N_("Lower the current layer to the bottom"), "layer_to_bottom"), + N_("Lower the current layer to the bottom"), INKSCAPE_ICON_LAYER_BOTTOM), new LayerVerb(SP_VERB_LAYER_RAISE, "LayerRaise", N_("_Raise Layer"), - N_("Raise the current layer"), "raise_layer"), + N_("Raise the current layer"), INKSCAPE_ICON_LAYER_RAISE), new LayerVerb(SP_VERB_LAYER_LOWER, "LayerLower", N_("_Lower Layer"), - N_("Lower the current layer"), "lower_layer"), + N_("Lower the current layer"), INKSCAPE_ICON_LAYER_LOWER), new LayerVerb(SP_VERB_LAYER_DUPLICATE, "LayerDuplicate", N_("Duplicate Current Layer..."), - N_("Duplicate an existing layer"), 0), + N_("Duplicate an existing layer"), NULL), new LayerVerb(SP_VERB_LAYER_DELETE, "LayerDelete", N_("_Delete Current Layer"), - N_("Delete the current layer"), "delete_layer"), + N_("Delete the current layer"), INKSCAPE_ICON_LAYER_DELETE), new LayerVerb(SP_VERB_LAYER_SOLO, "LayerSolo", N_("_Show/hide other layers"), - N_("Solo the current layer"), 0), + N_("Solo the current layer"), NULL), /* Object */ new ObjectVerb(SP_VERB_OBJECT_ROTATE_90_CW, "ObjectRotate90", N_("Rotate _90° CW"), // This is shared between tooltips and statusbar, so they // must use UTF-8, not HTML entities for special characters. - N_("Rotate selection 90\xc2\xb0 clockwise"), "object_rotate_90_CW"), + N_("Rotate selection 90\xc2\xb0 clockwise"), INKSCAPE_ICON_OBJECT_ROTATE_RIGHT), new ObjectVerb(SP_VERB_OBJECT_ROTATE_90_CCW, "ObjectRotate90CCW", N_("Rotate 9_0° CCW"), // This is shared between tooltips and statusbar, so they // must use UTF-8, not HTML entities for special characters. - N_("Rotate selection 90\xc2\xb0 counter-clockwise"), "object_rotate_90_CCW"), + N_("Rotate selection 90\xc2\xb0 counter-clockwise"), INKSCAPE_ICON_OBJECT_ROTATE_LEFT), new ObjectVerb(SP_VERB_OBJECT_FLATTEN, "ObjectRemoveTransform", N_("Remove _Transformations"), - N_("Remove transformations from object"), "object_reset"), + N_("Remove transformations from object"), NULL), new ObjectVerb(SP_VERB_OBJECT_TO_CURVE, "ObjectToPath", N_("_Object to Path"), - N_("Convert selected object to path"), "object_tocurve"), + N_("Convert selected object to path"), INKSCAPE_ICON_OBJECT_TO_PATH), new ObjectVerb(SP_VERB_OBJECT_FLOW_TEXT, "ObjectFlowText", N_("_Flow into Frame"), - N_("Put text into a frame (path or shape), creating a flowed text linked to the frame object"), "flow_into_frame"), + N_("Put text into a frame (path or shape), creating a flowed text linked to the frame object"), "text-flow-into-frame"), new ObjectVerb(SP_VERB_OBJECT_UNFLOW_TEXT, "ObjectUnFlowText", N_("_Unflow"), - N_("Remove text from frame (creates a single-line text object)"), "unflow"), + N_("Remove text from frame (creates a single-line text object)"), INKSCAPE_ICON_TEXT_UNFLOW), new ObjectVerb(SP_VERB_OBJECT_FLOWTEXT_TO_TEXT, "ObjectFlowtextToText", N_("_Convert to Text"), - N_("Convert flowed text to regular text object (preserves appearance)"), "convert_to_text"), + N_("Convert flowed text to regular text object (preserves appearance)"), INKSCAPE_ICON_TEXT_CONVERT_TO_REGULAR), new ObjectVerb(SP_VERB_OBJECT_FLIP_HORIZONTAL, "ObjectFlipHorizontally", N_("Flip _Horizontal"), N_("Flip selected objects horizontally"), - "object_flip_hor"), + INKSCAPE_ICON_OBJECT_FLIP_HORIZONTAL), new ObjectVerb(SP_VERB_OBJECT_FLIP_VERTICAL, "ObjectFlipVertically", N_("Flip _Vertical"), N_("Flip selected objects vertically"), - "object_flip_ver"), + INKSCAPE_ICON_OBJECT_FLIP_VERTICAL), new ObjectVerb(SP_VERB_OBJECT_SET_MASK, "ObjectSetMask", N_("_Set"), N_("Apply mask to selection (using the topmost object as mask)"), NULL), new ObjectVerb(SP_VERB_OBJECT_EDIT_MASK, "ObjectEditMask", N_("_Edit"), - N_("Edit mask"), "nodeedit-mask"), + N_("Edit mask"), INKSCAPE_ICON_PATH_MASK_EDIT), new ObjectVerb(SP_VERB_OBJECT_UNSET_MASK, "ObjectUnSetMask", N_("_Release"), N_("Remove mask from selection"), NULL), new ObjectVerb(SP_VERB_OBJECT_SET_CLIPPATH, "ObjectSetClipPath", N_("_Set"), N_("Apply clipping path to selection (using the topmost object as clipping path)"), NULL), new ObjectVerb(SP_VERB_OBJECT_EDIT_CLIPPATH, "ObjectEditClipPath", N_("_Edit"), - N_("Edit clipping path"), "nodeedit-clippath"), + N_("Edit clipping path"), INKSCAPE_ICON_PATH_CLIP_EDIT), new ObjectVerb(SP_VERB_OBJECT_UNSET_CLIPPATH, "ObjectUnSetClipPath", N_("_Release"), N_("Remove clipping path from selection"), NULL), /* Tools */ new ContextVerb(SP_VERB_CONTEXT_SELECT, "ToolSelector", N_("Select"), - N_("Select and transform objects"), "draw_select"), + N_("Select and transform objects"), INKSCAPE_ICON_TOOL_POINTER), new ContextVerb(SP_VERB_CONTEXT_NODE, "ToolNode", N_("Node Edit"), - N_("Edit paths by nodes"), "draw_node"), + N_("Edit paths by nodes"), INKSCAPE_ICON_TOOL_NODE_EDITOR), new ContextVerb(SP_VERB_CONTEXT_TWEAK, "ToolTweak", N_("Tweak"), - N_("Tweak objects by sculpting or painting"), "draw_tweak"), + N_("Tweak objects by sculpting or painting"), INKSCAPE_ICON_TOOL_TWEAK), new ContextVerb(SP_VERB_CONTEXT_RECT, "ToolRect", N_("Rectangle"), - N_("Create rectangles and squares"), "draw_rect"), + N_("Create rectangles and squares"), INKSCAPE_ICON_DRAW_RECTANGLE), new ContextVerb(SP_VERB_CONTEXT_3DBOX, "Tool3DBox", N_("3D Box"), - N_("Create 3D boxes"), "draw_3dbox"), + N_("Create 3D boxes"), INKSCAPE_ICON_DRAW_CUBOID), new ContextVerb(SP_VERB_CONTEXT_ARC, "ToolArc", N_("Ellipse"), - N_("Create circles, ellipses, and arcs"), "draw_arc"), + N_("Create circles, ellipses, and arcs"), INKSCAPE_ICON_DRAW_ELLIPSE), new ContextVerb(SP_VERB_CONTEXT_STAR, "ToolStar", N_("Star"), - N_("Create stars and polygons"), "draw_star"), + N_("Create stars and polygons"), INKSCAPE_ICON_DRAW_POLYGON_STAR), new ContextVerb(SP_VERB_CONTEXT_SPIRAL, "ToolSpiral", N_("Spiral"), - N_("Create spirals"), "draw_spiral"), + N_("Create spirals"), INKSCAPE_ICON_DRAW_SPIRAL), new ContextVerb(SP_VERB_CONTEXT_PENCIL, "ToolPencil", N_("Pencil"), - N_("Draw freehand lines"), "draw_freehand"), + N_("Draw freehand lines"), INKSCAPE_ICON_DRAW_FREEHAND), new ContextVerb(SP_VERB_CONTEXT_PEN, "ToolPen", N_("Pen"), - N_("Draw Bezier curves and straight lines"), "draw_pen"), + N_("Draw Bezier curves and straight lines"), INKSCAPE_ICON_DRAW_PATH), new ContextVerb(SP_VERB_CONTEXT_CALLIGRAPHIC, "ToolCalligraphic", N_("Calligraphy"), - N_("Draw calligraphic or brush strokes"), "draw_calligraphic"), + N_("Draw calligraphic or brush strokes"), INKSCAPE_ICON_DRAW_CALLIGRAPHIC), new ContextVerb(SP_VERB_CONTEXT_TEXT, "ToolText", N_("Text"), - N_("Create and edit text objects"), "draw_text"), + N_("Create and edit text objects"), INKSCAPE_ICON_DRAW_TEXT), new ContextVerb(SP_VERB_CONTEXT_GRADIENT, "ToolGradient", N_("Gradient"), - N_("Create and edit gradients"), "draw_gradient"), + N_("Create and edit gradients"), INKSCAPE_ICON_COLOR_GRADIENT), new ContextVerb(SP_VERB_CONTEXT_ZOOM, "ToolZoom", N_("Zoom"), - N_("Zoom in or out"), "draw_zoom"), + N_("Zoom in or out"), INKSCAPE_ICON_ZOOM), new ContextVerb(SP_VERB_CONTEXT_DROPPER, "ToolDropper", N_("Dropper"), - N_("Pick colors from image"), "draw_dropper"), + N_("Pick colors from image"), INKSCAPE_ICON_COLOR_PICKER), new ContextVerb(SP_VERB_CONTEXT_CONNECTOR, "ToolConnector", N_("Connector"), - N_("Create diagram connectors"), "draw_connector"), + N_("Create diagram connectors"), INKSCAPE_ICON_DRAW_CONNECTOR), new ContextVerb(SP_VERB_CONTEXT_PAINTBUCKET, "ToolPaintBucket", N_("Paint Bucket"), - N_("Fill bounded areas"), "draw_paintbucket"), + N_("Fill bounded areas"), INKSCAPE_ICON_COLOR_FILL), new ContextVerb(SP_VERB_CONTEXT_LPE, "ToolLPE", N_("LPE Edit"), - N_("Edit Path Effect parameters"), "draw_lpe"), + N_("Edit Path Effect parameters"), NULL), new ContextVerb(SP_VERB_CONTEXT_ERASER, "ToolEraser", N_("Eraser"), - N_("Erase existing paths"), "draw_erase"), + N_("Erase existing paths"), INKSCAPE_ICON_DRAW_ERASER), new ContextVerb(SP_VERB_CONTEXT_LPETOOL, "ToolLPETool", N_("LPE Tool"), - N_("Do geometric constructions"), "draw_lpetool"), + N_("Do geometric constructions"), NULL), /* Tool prefs */ new ContextVerb(SP_VERB_CONTEXT_SELECT_PREFS, "SelectPrefs", N_("Selector Preferences"), N_("Open Preferences for the Selector tool"), NULL), @@ -2566,31 +2559,31 @@ Verb *Verb::_base_verbs[] = { N_("Open Preferences for the LPETool tool"), NULL), /* Zoom/View */ - new ZoomVerb(SP_VERB_ZOOM_IN, "ZoomIn", N_("Zoom In"), N_("Zoom in"), "zoom_in"), - new ZoomVerb(SP_VERB_ZOOM_OUT, "ZoomOut", N_("Zoom Out"), N_("Zoom out"), "zoom_out"), - new ZoomVerb(SP_VERB_TOGGLE_RULERS, "ToggleRulers", N_("_Rulers"), N_("Show or hide the canvas rulers"), "rulers"), - new ZoomVerb(SP_VERB_TOGGLE_SCROLLBARS, "ToggleScrollbars", N_("Scroll_bars"), N_("Show or hide the canvas scrollbars"), "scrollbars"), - new ZoomVerb(SP_VERB_TOGGLE_GRID, "ToggleGrid", N_("_Grid"), N_("Show or hide the grid"), "grid"), - new ZoomVerb(SP_VERB_TOGGLE_GUIDES, "ToggleGuides", N_("G_uides"), N_("Show or hide guides (drag from a ruler to create a guide)"), "guides"), - new ZoomVerb(SP_VERB_TOGGLE_SNAPPING, "ToggleSnapGlobal", N_("Snap"), N_("Toggle snapping on or off"), NULL), + new ZoomVerb(SP_VERB_ZOOM_IN, "ZoomIn", N_("Zoom In"), N_("Zoom in"), INKSCAPE_ICON_ZOOM_IN), + new ZoomVerb(SP_VERB_ZOOM_OUT, "ZoomOut", N_("Zoom Out"), N_("Zoom out"), INKSCAPE_ICON_ZOOM_OUT), + new ZoomVerb(SP_VERB_TOGGLE_RULERS, "ToggleRulers", N_("_Rulers"), N_("Show or hide the canvas rulers"), NULL), + new ZoomVerb(SP_VERB_TOGGLE_SCROLLBARS, "ToggleScrollbars", N_("Scroll_bars"), N_("Show or hide the canvas scrollbars"), NULL), + new ZoomVerb(SP_VERB_TOGGLE_GRID, "ToggleGrid", N_("_Grid"), N_("Show or hide the grid"), INKSCAPE_ICON_SHOW_GRID), + new ZoomVerb(SP_VERB_TOGGLE_GUIDES, "ToggleGuides", N_("G_uides"), N_("Show or hide guides (drag from a ruler to create a guide)"), INKSCAPE_ICON_SHOW_GUIDES), + new ZoomVerb(SP_VERB_TOGGLE_SNAPPING, "ToggleSnapGlobal", N_("Snap"), N_("Toggle snapping on or off"), INKSCAPE_ICON_SNAP), new ZoomVerb(SP_VERB_ZOOM_NEXT, "ZoomNext", N_("Nex_t Zoom"), N_("Next zoom (from the history of zooms)"), - "zoom_next"), + INKSCAPE_ICON_ZOOM_NEXT), new ZoomVerb(SP_VERB_ZOOM_PREV, "ZoomPrev", N_("Pre_vious Zoom"), N_("Previous zoom (from the history of zooms)"), - "zoom_previous"), + INKSCAPE_ICON_ZOOM_PREVIOUS), new ZoomVerb(SP_VERB_ZOOM_1_1, "Zoom1:0", N_("Zoom 1:_1"), N_("Zoom to 1:1"), - "zoom_1_to_1"), + INKSCAPE_ICON_ZOOM_ORIGINAL), new ZoomVerb(SP_VERB_ZOOM_1_2, "Zoom1:2", N_("Zoom 1:_2"), N_("Zoom to 1:2"), - "zoom_1_to_2"), + INKSCAPE_ICON_ZOOM_HALF_SIZE), new ZoomVerb(SP_VERB_ZOOM_2_1, "Zoom2:1", N_("_Zoom 2:1"), N_("Zoom to 2:1"), - "zoom_2_to_1"), + INKSCAPE_ICON_ZOOM_DOUBLE_SIZE), #ifdef HAVE_GTK_WINDOW_FULLSCREEN new ZoomVerb(SP_VERB_FULLSCREEN, "FullScreen", N_("_Fullscreen"), N_("Stretch this document window to full screen"), - "view-fullscreen"), + INKSCAPE_ICON_VIEW_FULLSCREEN), #endif /* HAVE_GTK_WINDOW_FULLSCREEN */ new ZoomVerb(SP_VERB_FOCUSTOGGLE, "FocusToggle", N_("Toggle _Focus Mode"), N_("Remove excess toolbars to focus on drawing"), NULL), new ZoomVerb(SP_VERB_VIEW_NEW, "ViewNew", N_("Duplic_ate Window"), N_("Open a new window with the same document"), - "window-new"), + INKSCAPE_ICON_WINDOW_NEW), new ZoomVerb(SP_VERB_VIEW_NEW_PREVIEW, "ViewNewPreview", N_("_New View Preview"), N_("New View Preview"), NULL/*"view_new_preview"*/), @@ -2604,18 +2597,18 @@ Verb *Verb::_base_verbs[] = { N_("Toggle between normal and outline display modes"), NULL), new ZoomVerb(SP_VERB_VIEW_CMS_TOGGLE, "ViewCmsToggle", N_("Color-managed view"), - N_("Toggle color-managed display for this document window"), "color_management"), + N_("Toggle color-managed display for this document window"), INKSCAPE_ICON_COLOR_MANAGEMENT), new ZoomVerb(SP_VERB_VIEW_ICON_PREVIEW, "ViewIconPreview", N_("Ico_n Preview..."), - N_("Open a window to preview objects at different icon resolutions"), "view_icon_preview"), + N_("Open a window to preview objects at different icon resolutions"), INKSCAPE_ICON_DIALOG_ICON_PREVIEW), new ZoomVerb(SP_VERB_ZOOM_PAGE, "ZoomPage", N_("_Page"), - N_("Zoom to fit page in window"), "zoom_page"), + N_("Zoom to fit page in window"), INKSCAPE_ICON_ZOOM_FIT_PAGE), new ZoomVerb(SP_VERB_ZOOM_PAGE_WIDTH, "ZoomPageWidth", N_("Page _Width"), - N_("Zoom to fit page width in window"), "zoom_pagewidth"), + N_("Zoom to fit page width in window"), INKSCAPE_ICON_ZOOM_FIT_WIDTH), new ZoomVerb(SP_VERB_ZOOM_DRAWING, "ZoomDrawing", N_("_Drawing"), - N_("Zoom to fit drawing in window"), "zoom_draw"), + N_("Zoom to fit drawing in window"), INKSCAPE_ICON_ZOOM_FIT_DRAWING), new ZoomVerb(SP_VERB_ZOOM_SELECTION, "ZoomSelection", N_("_Selection"), - N_("Zoom to fit selection in window"), "zoom_select"), + N_("Zoom to fit selection in window"), INKSCAPE_ICON_ZOOM_FIT_SELECTION), /* Dialogs */ new DialogVerb(SP_VERB_DIALOG_DISPLAY, "DialogPreferences", N_("In_kscape Preferences..."), @@ -2623,22 +2616,22 @@ Verb *Verb::_base_verbs[] = { new DialogVerb(SP_VERB_DIALOG_NAMEDVIEW, "DialogDocumentProperties", N_("_Document Properties..."), N_("Edit properties of this document (to be saved with the document)"), GTK_STOCK_PROPERTIES ), new DialogVerb(SP_VERB_DIALOG_METADATA, "DialogMetadata", N_("Document _Metadata..."), - N_("Edit document metadata (to be saved with the document)"), "document_metadata" ), + N_("Edit document metadata (to be saved with the document)"), INKSCAPE_ICON_DOCUMENT_METADATA ), new DialogVerb(SP_VERB_DIALOG_FILL_STROKE, "DialogFillStroke", N_("_Fill and Stroke..."), - N_("Edit objects' colors, gradients, stroke width, arrowheads, dash patterns..."), "fill_and_stroke"), + N_("Edit objects' colors, gradients, stroke width, arrowheads, dash patterns..."), INKSCAPE_ICON_DIALOG_FILL_AND_STROKE), // TRANSLATORS: "Swatches" means: color samples new DialogVerb(SP_VERB_DIALOG_SWATCHES, "DialogSwatches", N_("S_watches..."), N_("Select colors from a swatches palette"), GTK_STOCK_SELECT_COLOR), new DialogVerb(SP_VERB_DIALOG_TRANSFORM, "DialogTransform", N_("Transfor_m..."), - N_("Precisely control objects' transformations"), "object_trans"), + N_("Precisely control objects' transformations"), INKSCAPE_ICON_DIALOG_TRANSFORM), new DialogVerb(SP_VERB_DIALOG_ALIGN_DISTRIBUTE, "DialogAlignDistribute", N_("_Align and Distribute..."), - N_("Align and distribute objects"), "object_align"), + N_("Align and distribute objects"), INKSCAPE_ICON_DIALOG_ALIGN_AND_DISTRIBUTE), new DialogVerb(SP_VERB_DIALOG_UNDO_HISTORY, "DialogUndoHistory", N_("Undo _History..."), - N_("Undo History"), "edit_undo_history"), + N_("Undo History"), INKSCAPE_ICON_EDIT_UNDO_HISTORY), new DialogVerb(SP_VERB_DIALOG_TEXT, "DialogText", N_("_Text and Font..."), - N_("View and select font family, font size and other text properties"), "object_font"), + N_("View and select font family, font size and other text properties"), INKSCAPE_ICON_DIALOG_TEXT_AND_FONT), new DialogVerb(SP_VERB_DIALOG_XML_EDITOR, "DialogXMLEditor", N_("_XML Editor..."), - N_("View and edit the XML tree of the document"), "xml_editor"), + N_("View and edit the XML tree of the document"), INKSCAPE_ICON_DIALOG_XML_EDITOR), new DialogVerb(SP_VERB_DIALOG_FIND, "DialogFind", N_("_Find..."), N_("Find objects in document"), GTK_STOCK_FIND ), new DialogVerb(SP_VERB_DIALOG_FINDREPLACE, "DialogFindReplace", N_("Find and _Replace Text..."), @@ -2646,27 +2639,27 @@ Verb *Verb::_base_verbs[] = { new DialogVerb(SP_VERB_DIALOG_SPELLCHECK, "DialogSpellcheck", N_("Check Spellin_g..."), N_("Check spelling of text in document"), GTK_STOCK_SPELL_CHECK ), new DialogVerb(SP_VERB_DIALOG_DEBUG, "DialogDebug", N_("_Messages..."), - N_("View debug messages"), "messages"), + N_("View debug messages"), INKSCAPE_ICON_DIALOG_MESSAGES), new DialogVerb(SP_VERB_DIALOG_SCRIPT, "DialogScript", N_("S_cripts..."), - N_("Run scripts"), "scripts"), + N_("Run scripts"), INKSCAPE_ICON_DIALOG_SCRIPTS), new DialogVerb(SP_VERB_DIALOG_TOGGLE, "DialogsToggle", N_("Show/Hide D_ialogs"), - N_("Show or hide all open dialogs"), "dialog_toggle"), + N_("Show or hide all open dialogs"), INKSCAPE_ICON_SHOW_DIALOGS), new DialogVerb(SP_VERB_DIALOG_CLONETILER, "DialogClonetiler", N_("Create Tiled Clones..."), - N_("Create multiple clones of selected object, arranging them into a pattern or scattering"), "edit_create_tiled_clones"), + N_("Create multiple clones of selected object, arranging them into a pattern or scattering"), INKSCAPE_ICON_DIALOG_TILE_CLONES), new DialogVerb(SP_VERB_DIALOG_ITEM, "DialogObjectProperties", N_("_Object Properties..."), - N_("Edit the ID, locked and visible status, and other object properties"), "dialog_item_properties"), + N_("Edit the ID, locked and visible status, and other object properties"), INKSCAPE_ICON_DIALOG_OBJECT_PROPERTIES), #ifdef WITH_INKBOARD new DialogVerb(SP_VERB_XMPP_CLIENT, "DialogXmppClient", N_("_Instant Messaging..."), N_("Jabber Instant Messaging Client"), NULL), #endif new DialogVerb(SP_VERB_DIALOG_INPUT, "DialogInput", N_("_Input Devices..."), - N_("Configure extended input devices, such as a graphics tablet"), "input_devices"), + N_("Configure extended input devices, such as a graphics tablet"), INKSCAPE_ICON_DIALOG_INPUT_DEVICES), new DialogVerb(SP_VERB_DIALOG_INPUT2, "DialogInput2", N_("_Input Devices (new)..."), - N_("Configure extended input devices, such as a graphics tablet"), "input_devices"), + N_("Configure extended input devices, such as a graphics tablet"), INKSCAPE_ICON_DIALOG_INPUT_DEVICES), new DialogVerb(SP_VERB_DIALOG_EXTENSIONEDITOR, "org.inkscape.dialogs.extensioneditor", N_("_Extensions..."), N_("Query information about extensions"), NULL), new DialogVerb(SP_VERB_DIALOG_LAYERS, "DialogLayers", N_("Layer_s..."), - N_("View Layers"), "layers"), + N_("View Layers"), INKSCAPE_ICON_DIALOG_LAYERS), new DialogVerb(SP_VERB_DIALOG_LIVE_PATH_EFFECT, "DialogLivePathEffect", N_("Path Effect Editor..."), N_("Manage, edit, and apply path effects"), NULL), new DialogVerb(SP_VERB_DIALOG_FILTER_EFFECTS, "DialogFilterEffects", N_("Filter Editor..."), @@ -2678,9 +2671,9 @@ Verb *Verb::_base_verbs[] = { new HelpVerb(SP_VERB_HELP_ABOUT_EXTENSIONS, "HelpAboutExtensions", N_("About E_xtensions"), N_("Information on Inkscape extensions"), NULL), new HelpVerb(SP_VERB_HELP_MEMORY, "HelpAboutMemory", N_("About _Memory"), - N_("Memory usage information"), "about_memory"), + N_("Memory usage information"), INKSCAPE_ICON_DIALOG_MEMORY), new HelpVerb(SP_VERB_HELP_ABOUT, "HelpAbout", N_("_About Inkscape"), - N_("Inkscape version, authors, license"), /*"help_about"*/"inkscape_options"), + N_("Inkscape version, authors, license"), INKSCAPE_ICON_INKSCAPE), //new HelpVerb(SP_VERB_SHOW_LICENSE, "ShowLicense", N_("_License"), // N_("Distribution terms"), /*"show_license"*/"inkscape_options"), diff --git a/src/widgets/gradient-toolbar.cpp b/src/widgets/gradient-toolbar.cpp index 1ab8fe435..ddd9fd96a 100644 --- a/src/widgets/gradient-toolbar.cpp +++ b/src/widgets/gradient-toolbar.cpp @@ -38,6 +38,7 @@ #include "sp-radial-gradient.h" #include "gradient-chemistry.h" #include "selection.h" +#include "ui/icon-names.h" #include "toolbox.h" @@ -535,7 +536,7 @@ sp_gradient_toolbox_new(SPDesktop *desktop) GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION, SP_BUTTON_TYPE_TOGGLE, NULL, - "fill_gradient", + INKSCAPE_ICON_PAINT_GRADIENT_LINEAR, _("Create linear gradient"), tt); g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_type), tbl); @@ -549,7 +550,7 @@ sp_gradient_toolbox_new(SPDesktop *desktop) GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION, SP_BUTTON_TYPE_TOGGLE, NULL, - "fill_radial", + INKSCAPE_ICON_PAINT_GRADIENT_RADIAL, _("Create radial (elliptic or circular) gradient"), tt); g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_type), tbl); @@ -577,7 +578,7 @@ sp_gradient_toolbox_new(SPDesktop *desktop) GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION, SP_BUTTON_TYPE_TOGGLE, NULL, - "controls_fill", + INKSCAPE_ICON_OBJECT_FILL, _("Create gradient in the fill"), tt); g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_fillstroke), tbl); @@ -591,7 +592,7 @@ sp_gradient_toolbox_new(SPDesktop *desktop) GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION, SP_BUTTON_TYPE_TOGGLE, NULL, - "controls_stroke", + INKSCAPE_ICON_OBJECT_STROKE, _("Create gradient in the stroke"), tt); g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (gr_toggle_fillstroke), tbl); diff --git a/src/widgets/icon.cpp b/src/widgets/icon.cpp index 35ab1842d..46ccfc15d 100644 --- a/src/widgets/icon.cpp +++ b/src/widgets/icon.cpp @@ -222,11 +222,16 @@ void sp_icon_fetch_pixbuf( SPIcon *icon ) if ( !icon->pb ) { icon->psize = sp_icon_get_phys_size(icon->lsize); - GdkPixbuf *pb = sp_icon_image_load_svg( icon->name, Inkscape::getRegisteredIconSize(icon->lsize), icon->psize ); + GdkPixbuf *pb; + + pb = gtk_icon_theme_load_icon(gtk_icon_theme_get_default(), icon->name, icon->psize, + (GtkIconLookupFlags) 0, NULL); + if (!pb) { + pb = sp_icon_image_load_svg( icon->name, Inkscape::getRegisteredIconSize(icon->lsize), icon->psize ); + } if (!pb) { pb = sp_icon_image_load_pixmap( icon->name, icon->lsize, icon->psize ); } - if ( pb ) { icon->pb = pb; icon->pb_faded = gdk_pixbuf_copy(icon->pb); @@ -288,73 +293,71 @@ sp_icon_new_full( Inkscape::IconSize lsize, gchar const *name ) static bool dump = prefs->getBool( "/debug/icons/dumpGtk"); GtkWidget *widget = 0; - gint trySize = CLAMP( static_cast(lsize), 0, static_cast(G_N_ELEMENTS(iconSizeLookup) - 1) ); - if ( !sizeMapDone ) { - injectCustomSize(); - } - GtkIconSize mappedSize = iconSizeLookup[trySize]; + gint trySize = CLAMP( static_cast(lsize), 0, static_cast(G_N_ELEMENTS(iconSizeLookup) - 1) ); + if ( !sizeMapDone ) { + injectCustomSize(); + } + GtkIconSize mappedSize = iconSizeLookup[trySize]; - GtkStockItem stock; - gboolean stockFound = gtk_stock_lookup( name, &stock ); + GtkStockItem stock; + gboolean stockFound = gtk_stock_lookup( name, &stock ); - GtkWidget *img = 0; - if ( legacyNames.empty() ) { - setupLegacyNaming(); - } + GtkWidget *img = 0; + if ( legacyNames.empty() ) { + setupLegacyNaming(); + } - bool flagMe = false; - if ( legacyNames.find(name) != legacyNames.end() ) { - img = gtk_image_new_from_icon_name( name, mappedSize ); - flagMe = true; - if ( dump ) { - g_message("gtk_image_new_from_icon_name( '%s', %d ) = %p", name, mappedSize, img); - GtkImageType thing = gtk_image_get_storage_type(GTK_IMAGE(img)); - g_message(" Type is %d %s", (int)thing, (thing == GTK_IMAGE_EMPTY ? "Empty" : "ok")); - } - } else { - img = gtk_image_new_from_stock( name, mappedSize ); + if ( legacyNames.find(name) != legacyNames.end() ) { + img = gtk_image_new_from_icon_name( name, mappedSize ); + if ( dump ) { + g_message("gtk_image_new_from_icon_name( '%s', %d ) = %p", name, mappedSize, img); + GtkImageType thing = gtk_image_get_storage_type(GTK_IMAGE(img)); + g_message(" Type is %d %s", (int)thing, (thing == GTK_IMAGE_EMPTY ? "Empty" : "ok")); } + } else { + img = gtk_image_new_from_stock( name, mappedSize ); + } - if ( img ) { - GtkImageType type = gtk_image_get_storage_type( GTK_IMAGE(img) ); - if ( type == GTK_IMAGE_STOCK ) { - if ( !stockFound ) { - // It's not showing as a stock ID, so assume it will be present internally - populate_placeholder_icon( name, mappedSize ); - addPreRender( mappedSize, name ); + if ( img ) { + GtkImageType type = gtk_image_get_storage_type( GTK_IMAGE(img) ); + if ( type == GTK_IMAGE_STOCK ) { + if ( !stockFound ) { + // It's not showing as a stock ID, so assume it will be present internally + populate_placeholder_icon( name, mappedSize ); + addPreRender( mappedSize, name ); - // Add a hook to render if set visible before prerender is done. - g_signal_connect( G_OBJECT(img), "map", G_CALLBACK(imageMapCB), GINT_TO_POINTER(static_cast(mappedSize)) ); - if ( dump ) { - g_message(" connecting %p for imageMapCB for [%s] %d", img, name, (int)mappedSize); - } - } - widget = GTK_WIDGET(img); - img = 0; + // Add a hook to render if set visible before prerender is done. + g_signal_connect( G_OBJECT(img), "map", G_CALLBACK(imageMapCB), GINT_TO_POINTER(static_cast(mappedSize)) ); if ( dump ) { - g_message( "loaded gtk '%s' %d (GTK_IMAGE_STOCK) %s on %p", name, mappedSize, (stockFound ? "STOCK" : "local"), widget ); + g_message(" connecting %p for imageMapCB for [%s] %d", img, name, (int)mappedSize); } - } else if ( type == GTK_IMAGE_ICON_NAME ) { - widget = GTK_WIDGET(img); - img = 0; + } + widget = GTK_WIDGET(img); + img = 0; + if ( dump ) { + g_message( "loaded gtk '%s' %d (GTK_IMAGE_STOCK) %s on %p", name, mappedSize, (stockFound ? "STOCK" : "local"), widget ); + } + } else if ( type == GTK_IMAGE_ICON_NAME ) { + widget = GTK_WIDGET(img); + img = 0; - // Add a hook to render if set visible before prerender is done. - g_signal_connect( G_OBJECT(widget), "map", G_CALLBACK(imageMapNamedCB), GINT_TO_POINTER(0) ); + // Add a hook to render if set visible before prerender is done. + g_signal_connect( G_OBJECT(widget), "map", G_CALLBACK(imageMapNamedCB), GINT_TO_POINTER(0) ); - if ( prefs->getBool("/options/iconrender/named_nodelay") ) { - int psize = sp_icon_get_phys_size(lsize); - prerender_icon(name, mappedSize, psize); - } else { - addPreRender( mappedSize, name ); - } + if ( prefs->getBool("/options/iconrender/named_nodelay") ) { + int psize = sp_icon_get_phys_size(lsize); + prerender_icon(name, mappedSize, psize); } else { - if ( dump ) { - g_message( "skipped gtk '%s' %d (not GTK_IMAGE_STOCK)", name, lsize ); - } - //g_object_unref( (GObject *)img ); - img = 0; + addPreRender( mappedSize, name ); + } + } else { + if ( dump ) { + g_message( "skipped gtk '%s' %d (not GTK_IMAGE_STOCK)", name, lsize ); } + //g_object_unref( (GObject *)img ); + img = 0; } + } if ( !widget ) { //g_message("Creating an SPIcon instance for %s:%d", name, (int)lsize); @@ -940,25 +943,31 @@ bool prerender_icon(gchar const *name, GtkIconSize lsize, unsigned psize) if (pb) { return false; } else { - guchar* px = load_svg_pixels(name, lsize, psize); - if ( !px ) { - // check for a fallback name - if ( legacyNames.find(name) != legacyNames.end() ) { - if ( dump ) { - g_message("load_svg_pixels([%s]=%s, %d, %d)", name, legacyNames[name].c_str(), lsize, psize); + pb = gtk_icon_theme_load_icon(gtk_icon_theme_get_default(), name, psize, + (GtkIconLookupFlags) 0, NULL); + if (!pb) { + guchar* px = load_svg_pixels(name, lsize, psize); + if ( !px ) { + // check for a fallback name + if ( legacyNames.find(name) != legacyNames.end() ) { + if ( dump ) { + g_message("load_svg_pixels([%s]=%s, %d, %d)", name, legacyNames[name].c_str(), lsize, psize); + } + px = load_svg_pixels(legacyNames[name].c_str(), lsize, psize); } - px = load_svg_pixels(legacyNames[name].c_str(), lsize, psize); + } + if (px) { + pb = gdk_pixbuf_new_from_data(px, GDK_COLORSPACE_RGB, TRUE, 8, + psize, psize, psize * 4, + (GdkPixbufDestroyNotify)g_free, NULL); + } else if (dump) { + g_message("XXXXXXXXXXXXXXXXXXXXXXXXXXXXX error!!! pixels not found for '%s'", name); } } - if (px) { - pb = gdk_pixbuf_new_from_data(px, GDK_COLORSPACE_RGB, TRUE, 8, - psize, psize, psize * 4, - (GdkPixbufDestroyNotify)g_free, NULL); + if (pb) { pb_cache[key] = pb; addToIconSet(pb, name, lsize, psize); - } else if (dump) { - g_message("XXXXXXXXXXXXXXXXXXXXXXXXXXXXX error!!! pixels not found for '%s'", name); } return true; } diff --git a/src/widgets/paint-selector.cpp b/src/widgets/paint-selector.cpp index a55b7bbc0..f888555c9 100644 --- a/src/widgets/paint-selector.cpp +++ b/src/widgets/paint-selector.cpp @@ -31,7 +31,6 @@ #include "../sp-pattern.h" #include #include "../widgets/icon.h" -#include "../inkscape-stock.h" #include "widgets/widget-sizes.h" #include "xml/repr.h" @@ -49,6 +48,7 @@ #include "path-prefix.h" #include "io/sys.h" #include "helper/stock-items.h" +#include "ui/icon-names.h" #include "paint-selector.h" @@ -177,17 +177,17 @@ sp_paint_selector_init(SPPaintSelector *psel) gtk_box_pack_start(GTK_BOX(psel), psel->style, FALSE, FALSE, 0); /* Buttons */ - psel->none = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_NONE, + psel->none = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_NONE, SP_PAINT_SELECTOR_MODE_NONE, tt, _("No paint")); - psel->solid = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_SOLID, + psel->solid = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_SOLID, SP_PAINT_SELECTOR_MODE_COLOR_RGB, tt, _("Flat color")); - psel->gradient = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_GRADIENT, + psel->gradient = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_GRADIENT_LINEAR, SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR, tt, _("Linear gradient")); - psel->radial = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_RADIAL, + psel->radial = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_GRADIENT_RADIAL, SP_PAINT_SELECTOR_MODE_GRADIENT_RADIAL, tt, _("Radial gradient")); - psel->pattern = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_PATTERN, + psel->pattern = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_PATTERN, SP_PAINT_SELECTOR_MODE_PATTERN, tt, _("Pattern")); - psel->unset = sp_paint_selector_style_button_add(psel, INKSCAPE_STOCK_FILL_UNSET, + psel->unset = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON_PAINT_UNKNOWN, SP_PAINT_SELECTOR_MODE_UNSET, tt, _("Unset paint (make it undefined so it can be inherited)")); /* Fillrule */ @@ -202,7 +202,7 @@ sp_paint_selector_init(SPPaintSelector *psel) // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty gtk_tooltips_set_tip(tt, psel->evenodd, _("Any path self-intersections or subpaths create holes in the fill (fill-rule: evenodd)"), NULL); gtk_object_set_data(GTK_OBJECT(psel->evenodd), "mode", GUINT_TO_POINTER(SP_PAINT_SELECTOR_FILLRULE_EVENODD)); - w = sp_icon_new(Inkscape::ICON_SIZE_DECORATION, "fillrule_evenodd"); + w = sp_icon_new(Inkscape::ICON_SIZE_DECORATION, INKSCAPE_ICON_FILL_RULE_EVEN_ODD); gtk_container_add(GTK_CONTAINER(psel->evenodd), w); gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->evenodd, FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(psel->evenodd), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_fillrule_toggled), psel); @@ -213,7 +213,7 @@ sp_paint_selector_init(SPPaintSelector *psel) // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty gtk_tooltips_set_tip(tt, psel->nonzero, _("Fill is solid unless a subpath is counterdirectional (fill-rule: nonzero)"), NULL); gtk_object_set_data(GTK_OBJECT(psel->nonzero), "mode", GUINT_TO_POINTER(SP_PAINT_SELECTOR_FILLRULE_NONZERO)); - w = sp_icon_new(Inkscape::ICON_SIZE_DECORATION, "fillrule_nonzero"); + w = sp_icon_new(Inkscape::ICON_SIZE_DECORATION, INKSCAPE_ICON_FILL_RULE_NONZERO); gtk_container_add(GTK_CONTAINER(psel->nonzero), w); gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->nonzero, FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(psel->nonzero), "toggled", GTK_SIGNAL_FUNC(sp_paint_selector_fillrule_toggled), psel); diff --git a/src/widgets/select-toolbar.cpp b/src/widgets/select-toolbar.cpp index 931ad4e2d..00fd8d2e3 100644 --- a/src/widgets/select-toolbar.cpp +++ b/src/widgets/select-toolbar.cpp @@ -49,6 +49,7 @@ #include "ege-output-action.h" #include "ink-action.h" #include <2geom/rect.h> +#include "ui/icon-names.h" using Inkscape::UnitTracker; @@ -348,9 +349,9 @@ static void toggle_pattern( GtkToggleAction* act, gpointer data ) static void toggle_lock( GtkToggleAction *act, gpointer /*data*/ ) { gboolean active = gtk_toggle_action_get_active( act ); if ( active ) { - g_object_set( G_OBJECT(act), "iconId", "width_height_lock", NULL ); + g_object_set( G_OBJECT(act), "iconId", INKSCAPE_ICON_OBJECT_LOCKED, NULL ); } else { - g_object_set( G_OBJECT(act), "iconId", "lock_unlocked", NULL ); + g_object_set( G_OBJECT(act), "iconId", INKSCAPE_ICON_OBJECT_UNLOCKED, NULL ); } } @@ -481,7 +482,7 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb InkToggleAction* itact = ink_toggle_action_new( "LockAction", _("Lock width and height"), _("When locked, change both width and height by the same proportion"), - "lock_unlocked", + INKSCAPE_ICON_OBJECT_UNLOCKED, Inkscape::ICON_SIZE_DECORATION ); g_object_set( itact, "short_label", "Lock", NULL ); g_object_set_data( G_OBJECT(spw), "lock", itact ); @@ -540,7 +541,7 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb InkToggleAction* itact = ink_toggle_action_new( "transform_stroke", _("Scale stroke width"), _("When scaling objects, scale the stroke width by the same proportion"), - "transform_stroke", + INKSCAPE_ICON_TRANSFORM_AFFECT_STROKE, Inkscape::ICON_SIZE_DECORATION ); gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(itact), prefs->getBool("/options/transform/stroke", true) ); g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(toggle_stroke), desktop) ; @@ -551,7 +552,7 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb InkToggleAction* itact = ink_toggle_action_new( "transform_corners", _("Scale rounded corners"), _("When scaling rectangles, scale the radii of rounded corners"), - "transform_corners", + INKSCAPE_ICON_TRANSFORM_AFFECT_ROUNDED_CORNERS, Inkscape::ICON_SIZE_DECORATION ); gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(itact), prefs->getBool("/options/transform/rectcorners", true) ); g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(toggle_corners), desktop) ; @@ -562,7 +563,7 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb InkToggleAction* itact = ink_toggle_action_new( "transform_gradient", _("Move gradients"), _("Move gradients (in fill or stroke) along with the objects"), - "transform_gradient", + INKSCAPE_ICON_TRANSFORM_AFFECT_GRADIENT, Inkscape::ICON_SIZE_DECORATION ); gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(itact), prefs->getBool("/options/transform/gradient", true) ); g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(toggle_gradient), desktop) ; @@ -573,7 +574,7 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb InkToggleAction* itact = ink_toggle_action_new( "transform_pattern", _("Move patterns"), _("Move patterns (in fill or stroke) along with the objects"), - "transform_pattern", + INKSCAPE_ICON_TRANSFORM_AFFECT_PATTERN, Inkscape::ICON_SIZE_DECORATION ); gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(itact), prefs->getBool("/options/transform/pattern", true) ); g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(toggle_pattern), desktop) ; diff --git a/src/widgets/toolbox.cpp b/src/widgets/toolbox.cpp index f7e1e9bc6..14acb188a 100644 --- a/src/widgets/toolbox.cpp +++ b/src/widgets/toolbox.cpp @@ -58,7 +58,6 @@ #include "icon.h" #include "../ink-action.h" #include "../inkscape.h" -#include "../inkscape-stock.h" #include "../interface.h" #include "../libnrtype/font-instance.h" #include "../libnrtype/font-lister.h" @@ -88,6 +87,7 @@ #include "../svg/css-ostringstream.h" #include "../tools-switch.h" #include "../tweak-context.h" +#include "../ui/icon-names.h" #include "../ui/widget/style-swatch.h" #include "../verbs.h" #include "../widgets/button.h" @@ -1287,7 +1287,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions InkAction* inky = ink_action_new( "NodeInsertAction", _("Insert node"), _("Insert new nodes into selected segments"), - "node_insert", + INKSCAPE_ICON_NODE_ADD, secondarySize ); g_object_set( inky, "short_label", _("Insert"), NULL ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_add), 0 ); @@ -1298,7 +1298,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions InkAction* inky = ink_action_new( "NodeDeleteAction", _("Delete node"), _("Delete selected nodes"), - "node_delete", + INKSCAPE_ICON_NODE_DELETE, secondarySize ); g_object_set( inky, "short_label", _("Delete"), NULL ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_delete), 0 ); @@ -1309,7 +1309,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions InkAction* inky = ink_action_new( "NodeJoinAction", _("Join endnodes"), _("Join selected endnodes"), - "node_join", + INKSCAPE_ICON_NODE_JOIN, secondarySize ); g_object_set( inky, "short_label", _("Join"), NULL ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_join), 0 ); @@ -1320,7 +1320,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions InkAction* inky = ink_action_new( "NodeBreakAction", _("Break nodes"), _("Break path at selected nodes"), - "node_break", + INKSCAPE_ICON_NODE_BREAK, secondarySize ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_break), 0 ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -1331,7 +1331,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions InkAction* inky = ink_action_new( "NodeJoinSegmentAction", _("Join with segment"), _("Join selected endnodes with a new segment"), - "node_join_segment", + INKSCAPE_ICON_NODE_JOIN_SEGMENT, secondarySize ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_join_segment), 0 ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -1341,7 +1341,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions InkAction* inky = ink_action_new( "NodeDeleteSegmentAction", _("Delete segment"), _("Delete segment between two non-endpoint nodes"), - "node_delete_segment", + INKSCAPE_ICON_NODE_DELETE_SEGMENT, secondarySize ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_delete_segment), 0 ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -1351,7 +1351,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions InkAction* inky = ink_action_new( "NodeCuspAction", _("Node Cusp"), _("Make selected nodes corner"), - "node_cusp", + INKSCAPE_ICON_NODE_TYPE_CUSP, secondarySize ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_cusp), 0 ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -1361,7 +1361,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions InkAction* inky = ink_action_new( "NodeSmoothAction", _("Node Smooth"), _("Make selected nodes smooth"), - "node_smooth", + INKSCAPE_ICON_NODE_TYPE_SMOOTH, secondarySize ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_smooth), 0 ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -1371,7 +1371,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions InkAction* inky = ink_action_new( "NodeSymmetricAction", _("Node Symmetric"), _("Make selected nodes symmetric"), - "node_symmetric", + INKSCAPE_ICON_NODE_TYPE_SYMMETRIC, secondarySize ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_symmetrical), 0 ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -1381,7 +1381,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions InkAction* inky = ink_action_new( "NodeAutoAction", _("Node Auto"), _("Make selected nodes auto-smooth"), - "node_auto", + INKSCAPE_ICON_NODE_TYPE_AUTO_SMOOTH, secondarySize ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_auto), 0 ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -1391,7 +1391,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions InkAction* inky = ink_action_new( "NodeLineAction", _("Node Line"), _("Make selected segments lines"), - "node_line", + INKSCAPE_ICON_NODE_SEGMENT_LINE, secondarySize ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_toline), 0 ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -1401,7 +1401,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions InkAction* inky = ink_action_new( "NodeCurveAction", _("Node Curve"), _("Make selected segments curves"), - "node_curve", + INKSCAPE_ICON_NODE_SEGMENT_CURVE, secondarySize ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_tocurve), 0 ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -1411,7 +1411,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions InkToggleAction* act = ink_toggle_action_new( "NodesShowHandlesAction", _("Show Handles"), _("Show the Bezier handles of selected nodes"), - "nodes_show_handles", + INKSCAPE_ICON_SHOW_NODE_HANDLES, Inkscape::ICON_SIZE_DECORATION ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_show_handles), desktop ); @@ -1422,7 +1422,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions InkToggleAction* act = ink_toggle_action_new( "NodesShowHelperpath", _("Show Outline"), _("Show the outline of the path"), - "nodes_show_helperpath", + INKSCAPE_ICON_SHOW_PATH_OUTLINE, Inkscape::ICON_SIZE_DECORATION ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_show_helperpath), desktop ); @@ -1433,7 +1433,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions InkAction* inky = ink_action_new( "EditNextLPEParameterAction", _("Next path effect parameter"), _("Show next path effect parameter for editing"), - "edit_next_parameter", + INKSCAPE_ICON_PATH_EFFECT_PARAMETER_NEXT, Inkscape::ICON_SIZE_DECORATION ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_nextLPEparam), desktop ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -1444,7 +1444,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions InkAction* inky = ink_action_new( "ObjectEditClipPathAction", _("Edit clipping path"), _("Edit the clipping path of the object"), - "nodeedit-clippath", + INKSCAPE_ICON_PATH_CLIP_EDIT, Inkscape::ICON_SIZE_DECORATION ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_clippath), desktop ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -1455,7 +1455,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions InkAction* inky = ink_action_new( "ObjectEditMaskPathAction", _("Edit mask path"), _("Edit the mask of the object"), - "nodeedit-mask", + INKSCAPE_ICON_PATH_MASK_EDIT, Inkscape::ICON_SIZE_DECORATION ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_maskpath), desktop ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -1996,7 +1996,7 @@ void setup_snap_toolbox(GtkWidget *toolbox, SPDesktop *desktop) " " " " " " - " " + " " " " " " " " @@ -2004,8 +2004,8 @@ void setup_snap_toolbox(GtkWidget *toolbox, SPDesktop *desktop) " " " " " " - " " - " " + " " + " " " " " " " " @@ -2017,216 +2017,163 @@ void setup_snap_toolbox(GtkWidget *toolbox, SPDesktop *desktop) Inkscape::IconSize secondarySize = prefToSize("/toolbox/secondary", 1); { - InkToggleAction* act = ink_toggle_action_new("ToggleSnapGlobal", // "name" - _("Snap"), // "label" - _("Enable snapping"), // "tooltip" - "toggle_snap_global", // "iconId" - secondarySize, - SP_ATTR_INKSCAPE_SNAP_GLOBAL); + InkToggleAction* act = ink_toggle_action_new("ToggleSnapGlobal", + _("Snap"), _("Enable snapping"), INKSCAPE_ICON_SNAP, secondarySize, + SP_ATTR_INKSCAPE_SNAP_GLOBAL); gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox ); } { - InkToggleAction* act = ink_toggle_action_new("ToggleSnapFromBBoxCorner",// "name" - _("Bounding box"), // "label" - _("Snap bounding box corners"), // "tooltip" - "toggle_snap_bbox", // "iconId" - secondarySize, - SP_ATTR_INKSCAPE_SNAP_BBOX); + InkToggleAction* act = ink_toggle_action_new("ToggleSnapFromBBoxCorner", + _("Bounding box"), _("Snap bounding box corners"), INKSCAPE_ICON_SNAP_BOUNDING_BOX, + secondarySize, SP_ATTR_INKSCAPE_SNAP_BBOX); gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox ); } { - InkToggleAction* act = ink_toggle_action_new("ToggleSnapToBBoxPath", // "name" - _("Bounding box edges"), // "label" - _("Snap to edges of a bounding box"), // "tooltip" - "toggle_snap_to_bbox_path", // "iconId" - secondarySize, - SP_ATTR_INKSCAPE_BBOX_PATHS); + InkToggleAction* act = ink_toggle_action_new("ToggleSnapToBBoxPath", + _("Bounding box edges"), _("Snap to edges of a bounding box"), + INKSCAPE_ICON_SNAP_BOUNDING_BOX_EDGES, secondarySize, SP_ATTR_INKSCAPE_BBOX_PATHS); gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox ); } { - InkToggleAction* act = ink_toggle_action_new("ToggleSnapToBBoxNode", // "name" - _("Bounding box corners"), // "label" - _("Snap to bounding box corners"), // "tooltip" - "toggle_snap_to_bbox_node", // "iconId" - secondarySize, - SP_ATTR_INKSCAPE_BBOX_NODES); + InkToggleAction* act = ink_toggle_action_new("ToggleSnapToBBoxNode", + _("Bounding box corners"), _("Snap to bounding box corners"), + INKSCAPE_ICON_SNAP_BOUNDING_BOX_CORNERS, secondarySize, SP_ATTR_INKSCAPE_BBOX_NODES); gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox ); } { - InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromBBoxEdgeMidpoints", // "name" - _("BBox Edge Midpoints"), // "label" - _("Snap from and to midpoints of bounding box edges"), // "tooltip" - "toggle_snap_to_bbox_edge_midpoints", // "iconId" - secondarySize, - SP_ATTR_INKSCAPE_SNAP_BBOX_EDGE_MIDPOINTS); + InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromBBoxEdgeMidpoints", + _("BBox Edge Midpoints"), _("Snap from and to midpoints of bounding box edges"), + INKSCAPE_ICON_SNAP_BOUNDING_BOX_MIDPOINTS, secondarySize, + SP_ATTR_INKSCAPE_SNAP_BBOX_EDGE_MIDPOINTS); gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox ); } { - InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromBBoxMidpoints", // "name" - _("BBox Midpoints"), // "label" - _("Snapping from and to midpoints of bounding boxes"), // "tooltip" - "toggle_snap_to_bbox_midpoints", // "iconId" - secondarySize, - SP_ATTR_INKSCAPE_SNAP_BBOX_MIDPOINTS); + InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromBBoxCenters", + _("BBox Centers"), _("Snapping from and to centers of bounding boxes"), + INKSCAPE_ICON_SNAP_BOUNDING_BOX_CENTER, secondarySize, SP_ATTR_INKSCAPE_SNAP_BBOX_MIDPOINTS); gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox ); } { - InkToggleAction* act = ink_toggle_action_new("ToggleSnapFromNode", // "name" - _("Nodes"), // "label" - _("Snap nodes"), // "tooltip" - "toggle_snap_nodes", // "iconId" - secondarySize, - SP_ATTR_INKSCAPE_SNAP_NODES); + InkToggleAction* act = ink_toggle_action_new("ToggleSnapFromNode", + _("Nodes"), _("Snap nodes"), INKSCAPE_ICON_SNAP_NODES, secondarySize, SP_ATTR_INKSCAPE_SNAP_NODES); gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox ); } { - InkToggleAction* act = ink_toggle_action_new("ToggleSnapToItemPath", // "name" - _("Paths"), // "label" - _("Snap to paths"), // "tooltip" - "toggle_snap_to_paths", // "iconId" - secondarySize, - SP_ATTR_INKSCAPE_OBJECT_PATHS); + InkToggleAction* act = ink_toggle_action_new("ToggleSnapToItemPath", + _("Paths"), _("Snap to paths"), INKSCAPE_ICON_SNAP_NODES_PATH, secondarySize, + SP_ATTR_INKSCAPE_OBJECT_PATHS); gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox ); } { - InkToggleAction* act = ink_toggle_action_new("ToggleSnapToPathIntersections", // "name" - _("Path intersections"), // "label" - _("Snap to path intersections"), // "tooltip" - "toggle_snap_to_path_intersections", // "iconId" - secondarySize, - SP_ATTR_INKSCAPE_SNAP_INTERS_PATHS); + InkToggleAction* act = ink_toggle_action_new("ToggleSnapToPathIntersections", + _("Path intersections"), _("Snap to path intersections"), + INKSCAPE_ICON_SNAP_NODES_INTERSECTION, secondarySize, SP_ATTR_INKSCAPE_SNAP_INTERS_PATHS); gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox ); } { - InkToggleAction* act = ink_toggle_action_new("ToggleSnapToItemNode", // "name" - _("To nodes"), // "label" - _("Snap to cusp nodes"), // "tooltip" - "toggle_snap_to_nodes", // "iconId" - secondarySize, - SP_ATTR_INKSCAPE_OBJECT_NODES); + InkToggleAction* act = ink_toggle_action_new("ToggleSnapToItemNode", + _("To nodes"), _("Snap to cusp nodes"), INKSCAPE_ICON_SNAP_NODES_CUSP, secondarySize, + SP_ATTR_INKSCAPE_OBJECT_NODES); gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox ); } { - InkToggleAction* act = ink_toggle_action_new("ToggleSnapToSmoothNodes", // "name" - _("Smooth nodes"), // "label" - _("Snap to smooth nodes"),// "tooltip" - "toggle_snap_to_smooth_nodes", // "iconId" - secondarySize, - SP_ATTR_INKSCAPE_SNAP_SMOOTH_NODES); + InkToggleAction* act = ink_toggle_action_new("ToggleSnapToSmoothNodes", + _("Smooth nodes"), _("Snap to smooth nodes"), INKSCAPE_ICON_SNAP_NODES_SMOOTH, + secondarySize, SP_ATTR_INKSCAPE_SNAP_SMOOTH_NODES); gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox ); } { - InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromLineMidpoints", // "name" - _("Line Midpoints"), // "label" - _("Snap from and to midpoints of line segments"), // "tooltip" - "toggle_snap_to_midpoints", // "iconId" - secondarySize, - SP_ATTR_INKSCAPE_SNAP_LINE_MIDPOINTS); + InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromLineMidpoints", + _("Line Midpoints"), _("Snap from and to midpoints of line segments"), + INKSCAPE_ICON_SNAP_NODES_MIDPOINT, secondarySize, SP_ATTR_INKSCAPE_SNAP_LINE_MIDPOINTS); gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox ); } { - InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromObjectMidpoints", // "name" - _("Object Midpoints"), // "label" - _("Snap from and to midpoints of objects"), // "tooltip" - "toggle_snap_to_object_midpoints", // "iconId" - secondarySize, - SP_ATTR_INKSCAPE_SNAP_OBJECT_MIDPOINTS); + InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromObjectCenters", + _("Object Centers"), _("Snap from and to centers of objects"), + INKSCAPE_ICON_SNAP_NODES_CENTER, secondarySize, SP_ATTR_INKSCAPE_SNAP_OBJECT_MIDPOINTS); gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox ); } { - InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromCenter",// "name" - _("Center"), // "label" - _("Snap from and to an item's rotation center"), // "tooltip" - "toggle_snap_center", // "iconId" - secondarySize, - SP_ATTR_INKSCAPE_SNAP_CENTER); + InkToggleAction* act = ink_toggle_action_new("ToggleSnapToFromRotationCenter", + _("Rotation Centers"), _("Snap from and to an item's rotation center"), + INKSCAPE_ICON_SNAP_NODES_ROTATION_CENTER, secondarySize, SP_ATTR_INKSCAPE_SNAP_CENTER); gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox ); } { - InkToggleAction* act = ink_toggle_action_new("ToggleSnapToPageBorder", // "name" - _("Page border"), // "label" - _("Snap to the page border"), // "tooltip" - "toggle_snap_page_border", // "iconId" - secondarySize, - SP_ATTR_INKSCAPE_SNAP_PAGE); + InkToggleAction* act = ink_toggle_action_new("ToggleSnapToPageBorder", + _("Page border"), _("Snap to the page border"), INKSCAPE_ICON_SNAP_PAGE, + secondarySize, SP_ATTR_INKSCAPE_SNAP_PAGE); gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox ); } { - InkToggleAction* act = ink_toggle_action_new("ToggleSnapToGrids", // "name" - _("Grids"), // "label" - _("Snap to grids"), // "tooltip" - "grid_xy", // "iconId" - secondarySize, - SP_ATTR_INKSCAPE_SNAP_GRIDS); + InkToggleAction* act = ink_toggle_action_new("ToggleSnapToGrids", + _("Grids"), _("Snap to grids"), INKSCAPE_ICON_GRID_RECTANGULAR, secondarySize, + SP_ATTR_INKSCAPE_SNAP_GRIDS); gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox ); } { - InkToggleAction* act = ink_toggle_action_new("ToggleSnapToGuides", // "name" - _("Guides"), // "label" - _("Snap to guides"), // "tooltip" - "guide", // "iconId" - secondarySize, - SP_ATTR_INKSCAPE_SNAP_TO_GUIDES); + InkToggleAction* act = ink_toggle_action_new("ToggleSnapToGuides", + _("Guides"), _("Snap to guides"), INKSCAPE_ICON_GUIDES, secondarySize, + SP_ATTR_INKSCAPE_SNAP_TO_GUIDES); gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox ); } /*{ - InkToggleAction* act = ink_toggle_action_new("ToggleSnapToGridGuideIntersections", // "name" - _("Grid/guide intersections"), // "label" - _("Snap to intersections of a grid with a guide"), // "tooltip" - "toggle_snap_grid_guide_intersections", // "iconId" - secondarySize, - SP_ATTR_INKSCAPE_SNAP_INTERS_GRIDGUIDE); + InkToggleAction* act = ink_toggle_action_new("ToggleSnapToGridGuideIntersections", + _("Grid/guide intersections"), _("Snap to intersections of a grid with a guide"), + INKSCAPE_ICON_SNAP_GRID_GUIDE_INTERSECTIONS, secondarySize, + SP_ATTR_INKSCAPE_SNAP_INTERS_GRIDGUIDE); gtk_action_group_add_action( mainActions->gobj(), GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_snap_callback), toolbox ); @@ -2278,15 +2225,15 @@ void update_snap_toolbox(SPDesktop *desktop, SPEventContext */*eventcontext*/, G Glib::RefPtr act3 = mainActions->get_action("ToggleSnapToBBoxPath"); Glib::RefPtr act4 = mainActions->get_action("ToggleSnapToBBoxNode"); Glib::RefPtr act4b = mainActions->get_action("ToggleSnapToFromBBoxEdgeMidpoints"); - Glib::RefPtr act4c = mainActions->get_action("ToggleSnapToFromBBoxMidpoints"); + Glib::RefPtr act4c = mainActions->get_action("ToggleSnapToFromBBoxCenters"); Glib::RefPtr act5 = mainActions->get_action("ToggleSnapFromNode"); Glib::RefPtr act6 = mainActions->get_action("ToggleSnapToItemPath"); Glib::RefPtr act6b = mainActions->get_action("ToggleSnapToPathIntersections"); Glib::RefPtr act7 = mainActions->get_action("ToggleSnapToItemNode"); Glib::RefPtr act8 = mainActions->get_action("ToggleSnapToSmoothNodes"); Glib::RefPtr act9 = mainActions->get_action("ToggleSnapToFromLineMidpoints"); - Glib::RefPtr act10 = mainActions->get_action("ToggleSnapToFromObjectMidpoints"); - Glib::RefPtr act11 = mainActions->get_action("ToggleSnapToFromCenter"); + Glib::RefPtr act10 = mainActions->get_action("ToggleSnapToFromObjectCenters"); + Glib::RefPtr act11 = mainActions->get_action("ToggleSnapToFromRotationCenter"); Glib::RefPtr act12 = mainActions->get_action("ToggleSnapToPageBorder"); //Glib::RefPtr act13 = mainActions->get_action("ToggleSnapToGridGuideIntersections"); Glib::RefPtr act14 = mainActions->get_action("ToggleSnapToGrids"); @@ -2769,14 +2716,14 @@ static void sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions gtk_list_store_set( model, &iter, 0, _("Polygon"), 1, _("Regular polygon (with one handle) instead of a star"), - 2, "star_flat", + 2, INKSCAPE_ICON_DRAW_POLYGON, -1 ); gtk_list_store_append( model, &iter ); gtk_list_store_set( model, &iter, 0, _("Star"), 1, _("Star instead of a regular polygon (with one handle)"), - 2, "star_angled", + 2, INKSCAPE_ICON_DRAW_STAR, -1 ); EgeSelectOneAction* act = ege_select_one_action_new( "FlatAction", (""), (""), NULL, GTK_TREE_MODEL(model) ); @@ -3206,7 +3153,7 @@ static void sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions InkAction* inky = ink_action_new( "RectResetAction", _("Not rounded"), _("Make corners sharp"), - "squared_corner", + INKSCAPE_ICON_RECTANGLE_MAKE_CORNERS_SHARP, secondarySize ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_rtb_defaults), holder ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -3489,7 +3436,7 @@ static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, // Translators: VP is short for 'vanishing point' _("State of VP in X direction"), _("Toggle VP in X direction between 'finite' and 'infinite' (=parallel)"), - "toggle_vp_x", + INKSCAPE_ICON_PERSPECTIVE_PARALLEL, Inkscape::ICON_SIZE_DECORATION ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); g_object_set_data( holder, "box3d_vp_x_state_action", act ); @@ -3528,7 +3475,7 @@ static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, // Translators: VP is short for 'vanishing point' _("State of VP in Y direction"), _("Toggle VP in Y direction between 'finite' and 'infinite' (=parallel)"), - "toggle_vp_y", + INKSCAPE_ICON_PERSPECTIVE_PARALLEL, Inkscape::ICON_SIZE_DECORATION ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); g_object_set_data( holder, "box3d_vp_y_state_action", act ); @@ -3567,7 +3514,7 @@ static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, // Translators: VP is short for 'vanishing point' _("State of VP in Z direction"), _("Toggle VP in Z direction between 'finite' and 'infinite' (=parallel)"), - "toggle_vp_z", + INKSCAPE_ICON_PERSPECTIVE_PARALLEL, Inkscape::ICON_SIZE_DECORATION ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); g_object_set_data( holder, "box3d_vp_z_state_action", act ); @@ -3871,14 +3818,14 @@ static void sp_add_freehand_mode_toggle(GtkActionGroup* mainActions, GObject* ho gtk_list_store_set( model, &iter, 0, _("Bezier"), 1, _("Create regular Bezier path"), - 2, "bezier_mode", + 2, INKSCAPE_ICON_PATH_MODE_BEZIER, -1 ); gtk_list_store_append( model, &iter ); gtk_list_store_set( model, &iter, 0, _("Spiro"), 1, _("Create Spiro path"), - 2, "spiro_splines_mode", + 2, INKSCAPE_ICON_PATH_MODE_SPIRO, -1 ); if (!tool_is_pencil) { @@ -3886,14 +3833,14 @@ static void sp_add_freehand_mode_toggle(GtkActionGroup* mainActions, GObject* ho gtk_list_store_set( model, &iter, 0, _("Zigzag"), 1, _("Create a sequence of straight line segments"), - 2, "polylines_mode", + 2, INKSCAPE_ICON_PATH_MODE_POLYLINE, -1 ); gtk_list_store_append( model, &iter ); gtk_list_store_set( model, &iter, 0, _("Paraxial"), 1, _("Create a sequence of paraxial line segments"), - 2, "paraxial_lines_mode", + 2, INKSCAPE_ICON_PATH_MODE_POLYLINE_PARAXIAL, -1 ); } @@ -4202,91 +4149,91 @@ static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction gtk_list_store_set( model, &iter, 0, _("Move mode"), 1, _("Move objects in any direction"), - 2, "tweak_move_mode", + 2, INKSCAPE_ICON_OBJECT_TWEAK_PUSH, -1 ); gtk_list_store_append( model, &iter ); gtk_list_store_set( model, &iter, 0, _("Move in/out mode"), 1, _("Move objects towards cursor; with Shift from cursor"), - 2, "tweak_move_mode_inout", + 2, INKSCAPE_ICON_OBJECT_TWEAK_ATTRACT, -1 ); gtk_list_store_append( model, &iter ); gtk_list_store_set( model, &iter, 0, _("Move jitter mode"), 1, _("Move objects in random directions"), - 2, "tweak_move_mode_jitter", + 2, INKSCAPE_ICON_OBJECT_TWEAK_RANDOMIZE, -1 ); gtk_list_store_append( model, &iter ); gtk_list_store_set( model, &iter, 0, _("Scale mode"), - 1, _("Scale objects, with Shift scale up"), - 2, "tweak_scale_mode", + 1, _("Shrink objects, with Shift enlarge"), + 2, INKSCAPE_ICON_OBJECT_TWEAK_SHRINK, -1 ); gtk_list_store_append( model, &iter ); gtk_list_store_set( model, &iter, 0, _("Rotate mode"), 1, _("Rotate objects, with Shift counterclockwise"), - 2, "tweak_rotate_mode", + 2, INKSCAPE_ICON_OBJECT_TWEAK_ROTATE, -1 ); gtk_list_store_append( model, &iter ); gtk_list_store_set( model, &iter, 0, _("Duplicate/delete mode"), 1, _("Duplicate objects, with Shift delete"), - 2, "tweak_moreless_mode", + 2, INKSCAPE_ICON_OBJECT_TWEAK_DUPLICATE, -1 ); gtk_list_store_append( model, &iter ); gtk_list_store_set( model, &iter, 0, _("Push mode"), 1, _("Push parts of paths in any direction"), - 2, "tweak_push_mode", + 2, INKSCAPE_ICON_PATH_TWEAK_PUSH, -1 ); gtk_list_store_append( model, &iter ); gtk_list_store_set( model, &iter, 0, _("Shrink/grow mode"), 1, _("Shrink (inset) parts of paths; with Shift grow (outset)"), - 2, "tweak_shrink_mode", + 2, INKSCAPE_ICON_PATH_TWEAK_SHRINK, -1 ); gtk_list_store_append( model, &iter ); gtk_list_store_set( model, &iter, 0, _("Attract/repel mode"), 1, _("Attract parts of paths towards cursor; with Shift from cursor"), - 2, "tweak_attract_mode", + 2, INKSCAPE_ICON_PATH_TWEAK_ATTRACT, -1 ); gtk_list_store_append( model, &iter ); gtk_list_store_set( model, &iter, 0, _("Roughen mode"), 1, _("Roughen parts of paths"), - 2, "tweak_roughen_mode", + 2, INKSCAPE_ICON_PATH_TWEAK_ROUGHEN, -1 ); gtk_list_store_append( model, &iter ); gtk_list_store_set( model, &iter, 0, _("Color paint mode"), 1, _("Paint the tool's color upon selected objects"), - 2, "tweak_colorpaint_mode", + 2, INKSCAPE_ICON_OBJECT_TWEAK_PAINT, -1 ); gtk_list_store_append( model, &iter ); gtk_list_store_set( model, &iter, 0, _("Color jitter mode"), 1, _("Jitter the colors of selected objects"), - 2, "tweak_colorjitter_mode", + 2, INKSCAPE_ICON_OBJECT_TWEAK_JITTER_COLOR, -1 ); gtk_list_store_append( model, &iter ); gtk_list_store_set( model, &iter, 0, _("Blur mode"), 1, _("Blur selected objects more; with Shift, blur less"), - 2, "tweak_blur_mode", + 2, INKSCAPE_ICON_OBJECT_TWEAK_BLUR, -1 ); @@ -4893,7 +4840,7 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main InkToggleAction* act = ink_toggle_action_new( "TraceAction", _("Trace Background"), _("Trace the lightness of the background by the width of the pen (white - minimum width, black - maximum width)"), - "trace_background", + INKSCAPE_ICON_DRAW_TRACE_BACKGROUND, Inkscape::ICON_SIZE_DECORATION ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_ddc_trace_background_changed), holder); @@ -4906,7 +4853,7 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main InkToggleAction* act = ink_toggle_action_new( "PressureAction", _("Pressure"), _("Use the pressure of the input device to alter the width of the pen"), - "use_pressure", + INKSCAPE_ICON_DRAW_USE_PRESSURE, Inkscape::ICON_SIZE_DECORATION ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_ddc_pressure_state_changed), holder); @@ -4919,7 +4866,7 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main InkToggleAction* act = ink_toggle_action_new( "TiltAction", _("Tilt"), _("Use the tilt of the input device to alter the angle of the pen's nib"), - "use_tilt", + INKSCAPE_ICON_DRAW_USE_TILT, Inkscape::ICON_SIZE_DECORATION ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_ddc_tilt_state_changed), holder ); @@ -5241,14 +5188,14 @@ static void sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, gtk_list_store_set( model, &iter, 0, _("Closed arc"), 1, _("Switch to segment (closed shape with two radii)"), - 2, "circle_closed_arc", + 2, INKSCAPE_ICON_DRAW_ELLIPSE_SEGMENT, -1 ); gtk_list_store_append( model, &iter ); gtk_list_store_set( model, &iter, 0, _("Open Arc"), 1, _("Switch to arc (unclosed shape)"), - 2, "circle_open_arc", + 2, INKSCAPE_ICON_DRAW_ELLIPSE_ARC, -1 ); EgeSelectOneAction* act = ege_select_one_action_new( "ArcOpenAction", (""), (""), NULL, GTK_TREE_MODEL(model) ); @@ -5272,7 +5219,7 @@ static void sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, InkAction* inky = ink_action_new( "ArcResetAction", _("Make whole"), _("Make the shape a whole ellipse, not arc or segment"), - "reset_circle", + INKSCAPE_ICON_DRAW_ELLIPSE_WHOLE, secondarySize ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_arctb_defaults), holder ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -5795,14 +5742,14 @@ static void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActio gtk_list_store_set( model, &iter, 0, _("Delete"), 1, _("Delete objects touched by the eraser"), - 2, "delete_object", + 2, INKSCAPE_ICON_DRAW_ERASER_DELETE_OBJECTS, -1 ); gtk_list_store_append( model, &iter ); gtk_list_store_set( model, &iter, 0, _("Cut"), 1, _("Cut out from objects"), - 2, "difference", + 2, INKSCAPE_ICON_PATH_DIFFERENCE, -1 ); EgeSelectOneAction* act = ege_select_one_action_new( "EraserModeAction", (""), (""), NULL, GTK_TREE_MODEL(model) ); @@ -6802,7 +6749,7 @@ sp_text_toolbox_new (SPDesktop *desktop) //spacer gtk_toolbar_append_widget( tbl, gtk_vseparator_new(), "", "" ); - ////////////Text orientation + // Text orientation group = gtk_radio_button_new (NULL); row = gtk_hbox_new (FALSE, 4); g_object_set_data (G_OBJECT (tbl), "orientation-group", group); @@ -6811,7 +6758,7 @@ sp_text_toolbox_new (SPDesktop *desktop) rbutton = group; gtk_button_set_relief (GTK_BUTTON (rbutton), GTK_RELIEF_NONE); gtk_container_add (GTK_CONTAINER (rbutton), - sp_icon_new (static_cast(secondarySize), INKSCAPE_STOCK_WRITING_MODE_LR)); + sp_icon_new (static_cast(secondarySize), INKSCAPE_ICON_FORMAT_TEXT_DIRECTION_HORIZONTAL)); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (rbutton), FALSE); gtk_tooltips_set_tip(tt, rbutton, _("Horizontal text"), NULL); @@ -6823,7 +6770,7 @@ sp_text_toolbox_new (SPDesktop *desktop) rbutton = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group))); gtk_button_set_relief (GTK_BUTTON (rbutton), GTK_RELIEF_NONE); gtk_container_add (GTK_CONTAINER (rbutton), - sp_icon_new (static_cast(secondarySize), INKSCAPE_STOCK_WRITING_MODE_TB)); + sp_icon_new (static_cast(secondarySize), INKSCAPE_ICON_FORMAT_TEXT_DIRECTION_VERTICAL)); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (rbutton), FALSE); gtk_tooltips_set_tip(tt, rbutton, _("Vertical text"), NULL); @@ -7009,7 +6956,7 @@ static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainA InkAction* inky = ink_action_new( "ConnectorAvoidAction", _("Avoid"), _("Make connectors avoid selected objects"), - "connector_avoid", + INKSCAPE_ICON_CONNECTOR_AVOID, secondarySize ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_path_set_avoid), holder ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -7019,7 +6966,7 @@ static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainA InkAction* inky = ink_action_new( "ConnectorIgnoreAction", _("Ignore"), _("Make connectors ignore selected objects"), - "connector_ignore", + INKSCAPE_ICON_CONNECTOR_IGNORE, secondarySize ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_path_set_ignore), holder ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -7043,7 +6990,7 @@ static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainA InkAction* inky = ink_action_new( "ConnectorGraphAction", _("Graph"), _("Nicely arrange selected connector network"), - "graph_layout", + INKSCAPE_ICON_DISTRIBUTE_GRAPH, secondarySize ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_graph_layout), holder ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -7066,7 +7013,7 @@ static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainA InkToggleAction* act = ink_toggle_action_new( "ConnectorDirectedAction", _("Downwards"), _("Make connectors with end-markers (arrows) point downwards"), - "directed_graph", + INKSCAPE_ICON_DISTRIBUTE_GRAPH_DIRECTED, Inkscape::ICON_SIZE_DECORATION ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); @@ -7081,7 +7028,7 @@ static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainA InkToggleAction* act = ink_toggle_action_new( "ConnectorOverlapAction", _("Remove overlaps"), _("Do not allow overlapping shapes"), - "remove_overlaps", + INKSCAPE_ICON_DISTRIBUTE_REMOVE_OVERLAPS, Inkscape::ICON_SIZE_DECORATION ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );