X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fwidgets%2Ftoolbox.cpp;h=07b388d140127087fdd2283e75babdc92a200168;hb=8b9a820756fdf348239872236be2257f854e094a;hp=c9413862082b4504c3a402ce711003cf848a3639;hpb=c710845cf7c0948006349cb0f3a5cc47de29ef0a;p=inkscape.git diff --git a/src/widgets/toolbox.cpp b/src/widgets/toolbox.cpp index c94138620..07b388d14 100644 --- a/src/widgets/toolbox.cpp +++ b/src/widgets/toolbox.cpp @@ -51,9 +51,11 @@ #include "desktop-handles.h" #include "xml/repr.h" #include "xml/node-event-vector.h" +#include "xml/attribute-record.h" #include #include "helper/unit-menu.h" #include "helper/units.h" +#include "live_effects/effect.h" #include "inkscape.h" #include "conn-avoid-ref.h" @@ -64,6 +66,7 @@ #include "connector-context.h" #include "node-context.h" +#include "pen-context.h" #include "shape-editor.h" #include "tweak-context.h" #include "sp-rect.h" @@ -77,6 +80,7 @@ #include "sp-clippath.h" #include "sp-mask.h" #include "style.h" +#include "tools-switch.h" #include "selection.h" #include "selection-chemistry.h" #include "document-private.h" @@ -88,6 +92,8 @@ #include "../inkscape-stock.h" #include "icon.h" #include "graphlayout/graphlayout.h" +#include "interface.h" +#include "shortcuts.h" #include "mod360.h" @@ -103,6 +109,8 @@ #include "svg/css-ostringstream.h" +#include "widgets/calligraphic-profile-rename.h" + using Inkscape::UnitTracker; typedef void (*SetupFunction)(GtkWidget *toolbox, SPDesktop *desktop); @@ -123,10 +131,21 @@ static void sp_dropper_toolbox_prep(SPDesktop *desktop, GtkActionGroup* ma static GtkWidget *sp_empty_toolbox_new(SPDesktop *desktop); static void sp_connector_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); static void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +static void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); namespace { GtkWidget *sp_text_toolbox_new (SPDesktop *desktop); } +Inkscape::IconSize prefToSize( gchar const *path, gchar const *attr, int base ) { + static Inkscape::IconSize sizeChoices[] = { + Inkscape::ICON_SIZE_LARGE_TOOLBAR, + Inkscape::ICON_SIZE_SMALL_TOOLBAR, + Inkscape::ICON_SIZE_MENU + }; + int index = prefs_get_int_attribute_limited( path, attr, base, 0, G_N_ELEMENTS(sizeChoices) ); + return sizeChoices[index]; +} + static struct { gchar const *type_name; gchar const *data_name; @@ -145,6 +164,7 @@ static struct { { "SPPencilContext", "pencil_tool", SP_VERB_CONTEXT_PENCIL, SP_VERB_CONTEXT_PENCIL_PREFS }, { "SPPenContext", "pen_tool", SP_VERB_CONTEXT_PEN, SP_VERB_CONTEXT_PEN_PREFS }, { "SPDynaDrawContext", "dyna_draw_tool", SP_VERB_CONTEXT_CALLIGRAPHIC, SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS }, + { "SPEraserContext", "eraser_tool", SP_VERB_CONTEXT_ERASER, SP_VERB_CONTEXT_ERASER_PREFS }, { "SPFloodContext", "paintbucket_tool", SP_VERB_CONTEXT_PAINTBUCKET, SP_VERB_CONTEXT_PAINTBUCKET_PREFS }, { "SPTextContext", "text_tool", SP_VERB_CONTEXT_TEXT, SP_VERB_CONTEXT_TEXT_PREFS }, { "SPConnectorContext","connector_tool", SP_VERB_CONTEXT_CONNECTOR, SP_VERB_CONTEXT_CONNECTOR_PREFS }, @@ -168,25 +188,27 @@ static struct { { "SPNodeContext", "node_toolbox", 0, sp_node_toolbox_prep, "NodeToolbar", SP_VERB_INVALID, 0, 0}, { "SPTweakContext", "tweak_toolbox", 0, sp_tweak_toolbox_prep, "TweakToolbar", - SP_VERB_CONTEXT_TWEAK_PREFS, "tools.tweak", _("Color/opacity used for color tweaking")}, + SP_VERB_CONTEXT_TWEAK_PREFS, "tools.tweak", N_("Color/opacity used for color tweaking")}, { "SPZoomContext", "zoom_toolbox", 0, sp_zoom_toolbox_prep, "ZoomToolbar", SP_VERB_INVALID, 0, 0}, { "SPStarContext", "star_toolbox", 0, sp_star_toolbox_prep, "StarToolbar", - SP_VERB_CONTEXT_STAR_PREFS, "tools.shapes.star", _("Style of new stars")}, + SP_VERB_CONTEXT_STAR_PREFS, "tools.shapes.star", N_("Style of new stars")}, { "SPRectContext", "rect_toolbox", 0, sp_rect_toolbox_prep, "RectToolbar", - SP_VERB_CONTEXT_RECT_PREFS, "tools.shapes.rect", _("Style of new rectangles")}, + SP_VERB_CONTEXT_RECT_PREFS, "tools.shapes.rect", N_("Style of new rectangles")}, { "Box3DContext", "3dbox_toolbox", 0, box3d_toolbox_prep, "3DBoxToolbar", - SP_VERB_CONTEXT_3DBOX_PREFS, "tools.shapes.3dbox", _("Style of new 3D boxes")}, + SP_VERB_CONTEXT_3DBOX_PREFS, "tools.shapes.3dbox", N_("Style of new 3D boxes")}, { "SPArcContext", "arc_toolbox", 0, sp_arc_toolbox_prep, "ArcToolbar", - SP_VERB_CONTEXT_ARC_PREFS, "tools.shapes.arc", _("Style of new ellipses")}, + SP_VERB_CONTEXT_ARC_PREFS, "tools.shapes.arc", N_("Style of new ellipses")}, { "SPSpiralContext", "spiral_toolbox", 0, sp_spiral_toolbox_prep, "SpiralToolbar", - SP_VERB_CONTEXT_SPIRAL_PREFS, "tools.shapes.spiral", _("Style of new spirals")}, + SP_VERB_CONTEXT_SPIRAL_PREFS, "tools.shapes.spiral", N_("Style of new spirals")}, { "SPPencilContext", "pencil_toolbox", 0, sp_pencil_toolbox_prep, "PencilToolbar", - SP_VERB_CONTEXT_PENCIL_PREFS, "tools.freehand.pencil", _("Style of new paths created by Pencil")}, + SP_VERB_CONTEXT_PENCIL_PREFS, "tools.freehand.pencil", N_("Style of new paths created by Pencil")}, { "SPPenContext", "pen_toolbox", 0, sp_pen_toolbox_prep, "PenToolbar", - SP_VERB_CONTEXT_PEN_PREFS, "tools.freehand.pen", _("Style of new paths created by Pen")}, + SP_VERB_CONTEXT_PEN_PREFS, "tools.freehand.pen", N_("Style of new paths created by Pen")}, { "SPDynaDrawContext", "calligraphy_toolbox", 0, sp_calligraphy_toolbox_prep,"CalligraphyToolbar", - SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS, "tools.calligraphic", _("Style of new calligraphic strokes")}, + SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS, "tools.calligraphic", N_("Style of new calligraphic strokes")}, + { "SPEraserContext", "eraser_toolbox", 0, sp_eraser_toolbox_prep,"EraserToolbar", + SP_VERB_CONTEXT_ERASER_PREFS, "tools.eraser", _("TBD")}, { "SPTextContext", "text_toolbox", sp_text_toolbox_new, 0, 0, SP_VERB_INVALID, 0, 0}, { "SPDropperContext", "dropper_toolbox", 0, sp_dropper_toolbox_prep, "DropperToolbar", @@ -196,10 +218,11 @@ static struct { { "SPConnectorContext", "connector_toolbox", 0, sp_connector_toolbox_prep, "ConnectorToolbar", SP_VERB_INVALID, 0, 0}, { "SPFloodContext", "paintbucket_toolbox", 0, sp_paintbucket_toolbox_prep, "PaintbucketToolbar", - SP_VERB_CONTEXT_PAINTBUCKET_PREFS, "tools.paintbucket", _("Style of Paint Bucket fill objects")}, + SP_VERB_CONTEXT_PAINTBUCKET_PREFS, "tools.paintbucket", N_("Style of Paint Bucket fill objects")}, { NULL, NULL, NULL, NULL, NULL, SP_VERB_INVALID, NULL, NULL } }; +#define TOOLBAR_SLIDER_HINT "full" static gchar const * ui_descr = "" @@ -237,9 +260,10 @@ static gchar const * ui_descr = " " " " " " + " " + " " " " " " - " " " " " " " " @@ -343,15 +367,24 @@ static gchar const * ui_descr = " " " " + " " + " " + " " " " " " + " " + " " + " " + " " + " " + " " + " " " " " " " " " " - " " " " " " " " @@ -395,6 +428,12 @@ static gchar const * ui_descr = " " " " + " " + " " + " " + " " + " " + " " " " " " @@ -414,7 +453,7 @@ static gchar const * ui_descr = "" ; -static GtkActionGroup* create_or_fetch_actions( SPDesktop* desktop ); +static Glib::RefPtr create_or_fetch_actions( SPDesktop* desktop ); static void toolbox_set_desktop (GtkWidget *toolbox, SPDesktop *desktop, SetupFunction setup_func, UpdateFunction update_func, sigc::connection*); @@ -427,6 +466,138 @@ static void update_aux_toolbox (SPDesktop *desktop, SPEventContext *eventcontext static void setup_commands_toolbox (GtkWidget *toolbox, SPDesktop *desktop); static void update_commands_toolbox (SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox); + +GtkWidget * sp_toolbox_button_new_from_verb_with_doubleclick( GtkWidget *t, Inkscape::IconSize size, SPButtonType type, + Inkscape::Verb *verb, Inkscape::Verb *doubleclick_verb, + Inkscape::UI::View::View *view, GtkTooltips *tt); + +class VerbAction : public Gtk::Action { +public: + static Glib::RefPtr create(Inkscape::Verb* verb, Inkscape::Verb* verb2, Inkscape::UI::View::View *view, GtkTooltips *tooltips); + + virtual ~VerbAction(); + virtual void set_active(bool active = true); + +protected: + virtual Gtk::Widget* create_menu_item_vfunc(); + virtual Gtk::Widget* create_tool_item_vfunc(); + + virtual void connect_proxy_vfunc(Gtk::Widget* proxy); + virtual void disconnect_proxy_vfunc(Gtk::Widget* proxy); + + virtual void on_activate(); + +private: + Inkscape::Verb* verb; + Inkscape::Verb* verb2; + Inkscape::UI::View::View *view; + GtkTooltips *tooltips; + bool active; + + VerbAction(Inkscape::Verb* verb, Inkscape::Verb* verb2, Inkscape::UI::View::View *view, GtkTooltips *tooltips); +}; + + +Glib::RefPtr VerbAction::create(Inkscape::Verb* verb, Inkscape::Verb* verb2, Inkscape::UI::View::View *view, GtkTooltips *tooltips) +{ + Glib::RefPtr result; + SPAction *action = verb->get_action(view); + if ( action ) { + //SPAction* action2 = verb2 ? verb2->get_action(view) : 0; + result = Glib::RefPtr(new VerbAction(verb, verb2, view, tooltips)); + } + + return result; +} + +VerbAction::VerbAction(Inkscape::Verb* verb, Inkscape::Verb* verb2, Inkscape::UI::View::View *view, GtkTooltips *tooltips) : + Gtk::Action(Glib::ustring(verb->get_id()), Gtk::StockID(verb->get_image()), Glib::ustring(_(verb->get_name())), Glib::ustring(_(verb->get_tip()))), + verb(verb), + verb2(verb2), + view(view), + tooltips(tooltips), + active(false) +{ +} + +VerbAction::~VerbAction() +{ +} + +Gtk::Widget* VerbAction::create_menu_item_vfunc() +{ +// First call in to get the icon rendered if present in SVG + Gtk::Widget *widget = sp_icon_get_icon( property_stock_id().get_value().get_string(), Inkscape::ICON_SIZE_MENU ); + delete widget; + widget = 0; + + Gtk::Widget* widg = Gtk::Action::create_menu_item_vfunc(); +// g_message("create_menu_item_vfunc() = %p for '%s'", widg, verb->get_id()); + return widg; +} + +Gtk::Widget* VerbAction::create_tool_item_vfunc() +{ +// Gtk::Widget* widg = Gtk::Action::create_tool_item_vfunc(); + Inkscape::IconSize toolboxSize = prefToSize("toolbox.tools", "small"); + GtkWidget* toolbox = 0; + GtkWidget *button = sp_toolbox_button_new_from_verb_with_doubleclick( toolbox, toolboxSize, + SP_BUTTON_TYPE_TOGGLE, + verb, + verb2, + view, + tooltips ); + if ( active ) { + sp_button_toggle_set_down( SP_BUTTON(button), active); + } + gtk_widget_show_all( button ); + Gtk::Widget* wrapped = Glib::wrap(button); + Gtk::ToolItem* holder = Gtk::manage(new Gtk::ToolItem()); + holder->add(*wrapped); + +// g_message("create_tool_item_vfunc() = %p for '%s'", holder, verb->get_id()); + return holder; +} + +void VerbAction::connect_proxy_vfunc(Gtk::Widget* proxy) +{ +// g_message("connect_proxy_vfunc(%p) for '%s'", proxy, verb->get_id()); + Gtk::Action::connect_proxy_vfunc(proxy); +} + +void VerbAction::disconnect_proxy_vfunc(Gtk::Widget* proxy) +{ +// g_message("disconnect_proxy_vfunc(%p) for '%s'", proxy, verb->get_id()); + Gtk::Action::disconnect_proxy_vfunc(proxy); +} + +void VerbAction::set_active(bool active) +{ + this->active = active; + Glib::SListHandle proxies = get_proxies(); + for ( Glib::SListHandle::iterator it = proxies.begin(); it != proxies.end(); ++it ) { + Gtk::ToolItem* ti = dynamic_cast(*it); + if (ti) { + // *should* have one child that is the SPButton + Gtk::Widget* child = ti->get_child(); + if ( child && SP_IS_BUTTON(child->gobj()) ) { + SPButton* button = SP_BUTTON(child->gobj()); + sp_button_toggle_set_down( button, active ); + } + } + } +} + +void VerbAction::on_activate() +{ + if ( verb ) { + SPAction *action = verb->get_action(view); + if ( action ) { + sp_action_perform(action, 0); + } + } +} + /* Global text entry widgets necessary for update */ /* GtkWidget *dropper_rgb_entry, *dropper_opacity_entry ; */ @@ -467,21 +638,24 @@ sp_toolbox_button_new_from_verb_with_doubleclick(GtkWidget *t, Inkscape::IconSiz /* fixme: Implement sp_button_new_from_action */ GtkWidget *b = sp_button_new(size, type, action, doubleclick_action, tt); gtk_widget_show(b); - gtk_box_pack_start(GTK_BOX(t), b, FALSE, FALSE, 0); - return b; -} -GtkWidget *sp_toolbox_button_new_from_verb(GtkWidget *t, Inkscape::IconSize size, SPButtonType type, Inkscape::Verb *verb, - Inkscape::UI::View::View *view, GtkTooltips *tt) -{ - return sp_toolbox_button_new_from_verb_with_doubleclick(t, size, type, verb, NULL, view, tt); -} + unsigned int shortcut = sp_shortcut_get_primary(verb); + if (shortcut) { + gchar key[256]; + sp_ui_shortcut_string(shortcut, key); + gchar *tip = g_strdup_printf ("%s (%s)", action->tip, key); + if ( t ) { + gtk_toolbar_append_widget( GTK_TOOLBAR(t), b, tip, 0 ); + } + g_free(tip); + } else { + if ( t ) { + gtk_toolbar_append_widget( GTK_TOOLBAR(t), b, action->tip, 0 ); + } + } -GtkWidget * sp_toolbox_button_normal_new_from_verb(GtkWidget *t, Inkscape::IconSize size, Inkscape::Verb *verb, - Inkscape::UI::View::View *view, GtkTooltips *tt) -{ - return sp_toolbox_button_new_from_verb(t, size, SP_BUTTON_TYPE_NORMAL, verb, view, tt); + return b; } @@ -527,7 +701,7 @@ static GtkAction* create_action_for_verb( Inkscape::Verb* verb, Inkscape::UI::Vi return act; } -GtkActionGroup* create_or_fetch_actions( SPDesktop* desktop ) +Glib::RefPtr create_or_fetch_actions( SPDesktop* desktop ) { Inkscape::UI::View::View *view = desktop; gint verbsToUse[] = { @@ -572,39 +746,68 @@ GtkActionGroup* create_or_fetch_actions( SPDesktop* desktop ) SP_VERB_ZOOM_SELECTION, }; - gint shrinkTop = prefs_get_int_attribute_limited( "toolbox", "small", 1, 0, 1 ); - Inkscape::IconSize toolboxSize = shrinkTop ? Inkscape::ICON_SIZE_SMALL_TOOLBAR : Inkscape::ICON_SIZE_LARGE_TOOLBAR; + Inkscape::IconSize toolboxSize = prefToSize("toolbox", "small"); - static std::map groups; - GtkActionGroup* mainActions = 0; + static std::map > groups; + Glib::RefPtr mainActions; if ( groups.find(desktop) != groups.end() ) { mainActions = groups[desktop]; } if ( !mainActions ) { - mainActions = gtk_action_group_new("main"); + mainActions = Gtk::ActionGroup::create("main"); groups[desktop] = mainActions; } for ( guint i = 0; i < G_N_ELEMENTS(verbsToUse); i++ ) { Inkscape::Verb* verb = Inkscape::Verb::get(verbsToUse[i]); if ( verb ) { - if ( !gtk_action_group_get_action( mainActions, verb->get_id() ) ) { + if (!mainActions->get_action(verb->get_id())) { GtkAction* act = create_action_for_verb( verb, view, toolboxSize ); - gtk_action_group_add_action( mainActions, act ); + mainActions->add(Glib::wrap(act)); + } + } + } + + if ( !mainActions->get_action("ToolZoom") ) { + GtkTooltips *tt = gtk_tooltips_new(); + for ( guint i = 0; i < G_N_ELEMENTS(tools) && tools[i].type_name; i++ ) { + Glib::RefPtr va = VerbAction::create(Inkscape::Verb::get(tools[i].verb), Inkscape::Verb::get(tools[i].doubleclick_verb), view, tt); + if ( va ) { + mainActions->add(va); + if ( i == 0 ) { + va->set_active(true); + } } } } + return mainActions; } +void handlebox_detached(GtkHandleBox* /*handlebox*/, GtkWidget* widget, gpointer /*userData*/) +{ + gtk_widget_set_size_request( widget, + widget->allocation.width, + widget->allocation.height ); +} + +void handlebox_attached(GtkHandleBox* /*handlebox*/, GtkWidget* widget, gpointer /*userData*/) +{ + gtk_widget_set_size_request( widget, -1, -1 ); +} + + + GtkWidget * sp_tool_toolbox_new() { GtkTooltips *tt = gtk_tooltips_new(); - GtkWidget *tb = gtk_vbox_new(FALSE, 0); + GtkWidget* tb = gtk_toolbar_new(); + gtk_toolbar_set_orientation(GTK_TOOLBAR(tb), GTK_ORIENTATION_VERTICAL); + gtk_toolbar_set_show_arrow(GTK_TOOLBAR(tb), TRUE); g_object_set_data(G_OBJECT(tb), "desktop", NULL); g_object_set_data(G_OBJECT(tb), "tooltips", tt); @@ -622,21 +825,10 @@ sp_tool_toolbox_new() sigc::connection* conn = new sigc::connection; g_object_set_data(G_OBJECT(hb), "event_context_connection", conn); - return hb; -} - -static void -aux_toolbox_attached(GtkHandleBox */*toolbox*/, GtkWidget *child) -{ - g_object_set_data(G_OBJECT(child), "is_detached", GINT_TO_POINTER(FALSE)); - gtk_widget_queue_resize(child); -} + g_signal_connect(G_OBJECT(hb), "child_detached", G_CALLBACK(handlebox_detached), static_cast(0)); + g_signal_connect(G_OBJECT(hb), "child_attached", G_CALLBACK(handlebox_attached), static_cast(0)); -static void -aux_toolbox_detached(GtkHandleBox */*toolbox*/, GtkWidget *child) -{ - g_object_set_data(G_OBJECT(child), "is_detached", GINT_TO_POINTER(TRUE)); - gtk_widget_queue_resize(child); + return hb; } GtkWidget * @@ -655,15 +847,15 @@ sp_aux_toolbox_new() gtk_handle_box_set_shadow_type(GTK_HANDLE_BOX(hb), GTK_SHADOW_OUT); gtk_handle_box_set_snap_edge(GTK_HANDLE_BOX(hb), GTK_POS_LEFT); - g_signal_connect(G_OBJECT(hb), "child_attached", G_CALLBACK(aux_toolbox_attached), (gpointer)tb); - g_signal_connect(G_OBJECT(hb), "child_detached", G_CALLBACK(aux_toolbox_detached), (gpointer)tb); - gtk_container_add(GTK_CONTAINER(hb), tb); gtk_widget_show(GTK_WIDGET(tb)); sigc::connection* conn = new sigc::connection; g_object_set_data(G_OBJECT(hb), "event_context_connection", conn); + g_signal_connect(G_OBJECT(hb), "child_detached", G_CALLBACK(handlebox_detached), static_cast(0)); + g_signal_connect(G_OBJECT(hb), "child_attached", G_CALLBACK(handlebox_attached), static_cast(0)); + return hb; } @@ -674,9 +866,7 @@ sp_aux_toolbox_new() GtkWidget * sp_commands_toolbox_new() { - GtkWidget *tb = gtk_vbox_new(FALSE, 0); - - gtk_box_set_spacing(GTK_BOX(tb), AUX_SPACING); + GtkWidget *tb = gtk_toolbar_new(); g_object_set_data(G_OBJECT(tb), "desktop", NULL); gtk_widget_set_sensitive(tb, FALSE); @@ -686,18 +876,19 @@ sp_commands_toolbox_new() gtk_handle_box_set_shadow_type(GTK_HANDLE_BOX(hb), GTK_SHADOW_OUT); gtk_handle_box_set_snap_edge(GTK_HANDLE_BOX(hb), GTK_POS_LEFT); - g_signal_connect(G_OBJECT(hb), "child_attached", G_CALLBACK(aux_toolbox_attached), (gpointer)tb); - g_signal_connect(G_OBJECT(hb), "child_detached", G_CALLBACK(aux_toolbox_detached), (gpointer)tb); - gtk_container_add(GTK_CONTAINER(hb), tb); gtk_widget_show(GTK_WIDGET(tb)); sigc::connection* conn = new sigc::connection; g_object_set_data(G_OBJECT(hb), "event_context_connection", conn); + g_signal_connect(G_OBJECT(hb), "child_detached", G_CALLBACK(handlebox_detached), static_cast(0)); + g_signal_connect(G_OBJECT(hb), "child_attached", G_CALLBACK(handlebox_attached), static_cast(0)); + return hb; } + static EgeAdjustmentAction * create_adjustment_action( gchar const *name, gchar const *label, gchar const *shortLabel, gchar const *tooltip, gchar const *path, gchar const *data, gdouble def, @@ -780,7 +971,7 @@ void sp_node_path_edit_delete(void) { ShapeEditor *shape_editor = get_current_shape_editor(); - if (shape_editor) shape_editor->delete_nodes(); + if (shape_editor) shape_editor->delete_nodes_preserving_shape(); } void @@ -906,18 +1097,18 @@ sp_node_toolbox_coord_changed(gpointer /*shape_editor*/, GObject *tbl) } else { gtk_action_set_sensitive(xact, TRUE); gtk_action_set_sensitive(yact, TRUE); - NR::Coord oldx = sp_units_get_pixels(gtk_adjustment_get_value(xadj), *unit); - NR::Coord oldy = sp_units_get_pixels(gtk_adjustment_get_value(xadj), *unit); + Geom::Coord oldx = sp_units_get_pixels(gtk_adjustment_get_value(xadj), *unit); + Geom::Coord oldy = sp_units_get_pixels(gtk_adjustment_get_value(xadj), *unit); if (n_selected == 1) { - NR::Point sel_node = nodepath->singleSelectedCoords(); - if (oldx != sel_node[NR::X] || oldy != sel_node[NR::Y]) { - gtk_adjustment_set_value(xadj, sp_pixels_get_units(sel_node[NR::X], *unit)); - gtk_adjustment_set_value(yadj, sp_pixels_get_units(sel_node[NR::Y], *unit)); + Geom::Point sel_node = nodepath->singleSelectedCoords(); + if (oldx != sel_node[Geom::X] || oldy != sel_node[Geom::Y]) { + gtk_adjustment_set_value(xadj, sp_pixels_get_units(sel_node[Geom::X], *unit)); + gtk_adjustment_set_value(yadj, sp_pixels_get_units(sel_node[Geom::Y], *unit)); } } else { - NR::Maybe x = sp_node_selected_common_coord(nodepath, NR::X); - NR::Maybe y = sp_node_selected_common_coord(nodepath, NR::Y); + boost::optional x = sp_node_selected_common_coord(nodepath, Geom::X); + boost::optional y = sp_node_selected_common_coord(nodepath, Geom::Y); if ((x && ((*x) != oldx)) || (y && ((*y) != oldy))) { /* Note: Currently x and y will always have a value, even if the coordinates of the selected nodes don't coincide (in this case we use the coordinates of the center @@ -962,10 +1153,10 @@ sp_node_path_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_ if (shape_editor && shape_editor->has_nodepath()) { double val = sp_units_get_pixels(gtk_adjustment_get_value(adj), *unit); if (!strcmp(value_name, "x")) { - sp_node_selected_move_absolute(shape_editor->get_nodepath(), val, NR::X); + sp_node_selected_move_absolute(shape_editor->get_nodepath(), val, Geom::X); } if (!strcmp(value_name, "y")) { - sp_node_selected_move_absolute(shape_editor->get_nodepath(), val, NR::Y); + sp_node_selected_move_absolute(shape_editor->get_nodepath(), val, Geom::Y); } } @@ -990,9 +1181,8 @@ sp_node_toolbox_sel_changed (Inkscape::Selection *selection, GObject *tbl) { GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "nodes_lpeedit" ) ); SPItem *item = selection->singleItem(); - if (item && SP_IS_SHAPE(item)) { - LivePathEffectObject *lpeobj = sp_shape_get_livepatheffectobject(SP_SHAPE(item)); - if (lpeobj) { + if (item && SP_IS_LPE_ITEM(item)) { + if (sp_lpe_item_has_path_effect(SP_LPE_ITEM(item))) { gtk_action_set_sensitive(w, TRUE); } else { gtk_action_set_sensitive(w, FALSE); @@ -1041,12 +1231,14 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions tracker->setActiveUnit( sp_desktop_namedview(desktop)->doc_units ); g_object_set_data( holder, "tracker", tracker ); + Inkscape::IconSize secondarySize = prefToSize("toolbox", "secondary", 1); + { InkAction* inky = ink_action_new( "NodeInsertAction", _("Insert node"), _("Insert new nodes into selected segments"), "node_insert", - Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + 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 ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -1057,7 +1249,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions _("Delete node"), _("Delete selected nodes"), "node_delete", - Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + 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 ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); @@ -1068,48 +1260,49 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions _("Join endnodes"), _("Join selected endnodes"), "node_join", - Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + 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 ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); } + { + InkAction* inky = ink_action_new( "NodeBreakAction", + _("Break nodes"), + _("Break path at selected nodes"), + "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) ); + } + + { InkAction* inky = ink_action_new( "NodeJoinSegmentAction", - _("Join Segment"), + _("Join with segment"), _("Join selected endnodes with a new segment"), "node_join_segment", - Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + 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) ); } { InkAction* inky = ink_action_new( "NodeDeleteSegmentAction", - _("Delete Segment"), - _("Split path between two non-endpoint nodes"), + _("Delete segment"), + _("Delete segment between two non-endpoint nodes"), "node_delete_segment", - Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + 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) ); } - { - InkAction* inky = ink_action_new( "NodeBreakAction", - _("Node Break"), - _("Break path at selected nodes"), - "node_break", - Inkscape::ICON_SIZE_SMALL_TOOLBAR ); - 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) ); - } - { InkAction* inky = ink_action_new( "NodeCuspAction", _("Node Cusp"), _("Make selected nodes corner"), "node_cusp", - Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + 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) ); } @@ -1119,7 +1312,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions _("Node Smooth"), _("Make selected nodes smooth"), "node_smooth", - Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + 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) ); } @@ -1129,7 +1322,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions _("Node Symmetric"), _("Make selected nodes symmetric"), "node_symmetric", - Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + 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) ); } @@ -1139,7 +1332,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions _("Node Line"), _("Make selected segments lines"), "node_line", - Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + 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) ); } @@ -1149,7 +1342,7 @@ static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions _("Node Curve"), _("Make selected segments curves"), "node_curve", - Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + 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) ); } @@ -1290,20 +1483,35 @@ static void sp_zoom_toolbox_prep(SPDesktop */*desktop*/, GtkActionGroup* /*mainA void sp_tool_toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop) { - toolbox_set_desktop(gtk_bin_get_child(GTK_BIN(toolbox)), desktop, setup_tool_toolbox, update_tool_toolbox, static_cast(g_object_get_data(G_OBJECT(toolbox), "event_context_connection"))); + toolbox_set_desktop(toolbox, + desktop, + setup_tool_toolbox, + update_tool_toolbox, + static_cast(g_object_get_data(G_OBJECT(toolbox), + "event_context_connection"))); } void sp_aux_toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop) { - toolbox_set_desktop(gtk_bin_get_child(GTK_BIN(toolbox)), desktop, setup_aux_toolbox, update_aux_toolbox, static_cast(g_object_get_data(G_OBJECT(toolbox), "event_context_connection"))); + toolbox_set_desktop(gtk_bin_get_child(GTK_BIN(toolbox)), + desktop, + setup_aux_toolbox, + update_aux_toolbox, + static_cast(g_object_get_data(G_OBJECT(toolbox), + "event_context_connection"))); } void sp_commands_toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop) { - toolbox_set_desktop(gtk_bin_get_child(GTK_BIN(toolbox)), desktop, setup_commands_toolbox, update_commands_toolbox, static_cast(g_object_get_data(G_OBJECT(toolbox), "event_context_connection"))); + toolbox_set_desktop(toolbox, + desktop, + setup_commands_toolbox, + update_commands_toolbox, + static_cast(g_object_get_data(G_OBJECT(toolbox), + "event_context_connection"))); } static void @@ -1340,41 +1548,75 @@ toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop, SetupFunction setup_ static void setup_tool_toolbox(GtkWidget *toolbox, SPDesktop *desktop) { - GtkTooltips *tooltips=GTK_TOOLTIPS(g_object_get_data(G_OBJECT(toolbox), "tooltips")); - gint shrinkLeft = prefs_get_int_attribute_limited( "toolbox.tools", "small", 0, 0, 1 ); - if ( (shrinkLeft == 0) && (prefs_get_int_attribute_limited( "toolbox.tools", "small", 1, 0, 1 ) == 1) ) { - // "toolbox.tools" was not set. Fallback to older value - shrinkLeft = prefs_get_int_attribute_limited( "toolbox.left", "small", 0, 0, 1 ); + gchar const * descr = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + ""; + Glib::RefPtr mainActions = create_or_fetch_actions( desktop ); + GtkUIManager* mgr = gtk_ui_manager_new(); + GError* errVal = 0; + + gtk_ui_manager_insert_action_group( mgr, mainActions->gobj(), 0 ); + gtk_ui_manager_add_ui_from_string( mgr, descr, -1, &errVal ); - // Copy the setting forwards - prefs_set_int_attribute( "toolbox.tools", "small", shrinkLeft ); + GtkWidget* toolBar = gtk_ui_manager_get_widget( mgr, "/ui/ToolToolbar" ); + if ( prefs_get_int_attribute_limited( "toolbox", "icononly", 1, 0, 1 ) ) { + gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS ); } - Inkscape::IconSize toolboxSize = shrinkLeft ? Inkscape::ICON_SIZE_SMALL_TOOLBAR : Inkscape::ICON_SIZE_LARGE_TOOLBAR; + Inkscape::IconSize toolboxSize = prefToSize("toolbox.tools", "small"); + gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), (GtkIconSize)toolboxSize ); - for (int i = 0 ; tools[i].type_name ; i++ ) { - GtkWidget *button = - sp_toolbox_button_new_from_verb_with_doubleclick( toolbox, toolboxSize, - SP_BUTTON_TYPE_TOGGLE, - Inkscape::Verb::get(tools[i].verb), - Inkscape::Verb::get(tools[i].doubleclick_verb), - desktop, - tooltips ); + gtk_toolbar_set_orientation(GTK_TOOLBAR(toolBar), GTK_ORIENTATION_VERTICAL); + gtk_toolbar_set_show_arrow(GTK_TOOLBAR(toolBar), TRUE); + + g_object_set_data(G_OBJECT(toolBar), "desktop", NULL); - g_object_set_data( G_OBJECT(toolbox), tools[i].data_name, - (gpointer)button ); + GtkWidget* child = gtk_bin_get_child(GTK_BIN(toolbox)); + if ( child ) { + gtk_container_remove( GTK_CONTAINER(toolbox), child ); } + + gtk_container_add( GTK_CONTAINER(toolbox), toolBar ); +// Inkscape::IconSize toolboxSize = prefToSize("toolbox.tools", "small"); } static void -update_tool_toolbox( SPDesktop */*desktop*/, SPEventContext *eventcontext, GtkWidget *toolbox ) +update_tool_toolbox( SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget */*toolbox*/ ) { gchar const *const tname = ( eventcontext ? gtk_type_name(GTK_OBJECT_TYPE(eventcontext)) : NULL ); + Glib::RefPtr mainActions = create_or_fetch_actions( desktop ); + for (int i = 0 ; tools[i].type_name ; i++ ) { - SPButton *button = SP_BUTTON(g_object_get_data(G_OBJECT(toolbox), tools[i].data_name)); - sp_button_toggle_set_down(button, tname && !strcmp(tname, tools[i].type_name)); + Glib::RefPtr act = mainActions->get_action( Inkscape::Verb::get(tools[i].verb)->get_id() ); + if ( act ) { + bool setActive = tname && !strcmp(tname, tools[i].type_name); + Glib::RefPtr verbAct = Glib::RefPtr::cast_dynamic(act); + if ( verbAct ) { + verbAct->set_active(setActive); + } + } } } @@ -1382,10 +1624,10 @@ static void setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop) { GtkSizeGroup* grouper = gtk_size_group_new( GTK_SIZE_GROUP_BOTH ); - GtkActionGroup* mainActions = create_or_fetch_actions( desktop ); + Glib::RefPtr mainActions = create_or_fetch_actions( desktop ); GtkUIManager* mgr = gtk_ui_manager_new(); GError* errVal = 0; - gtk_ui_manager_insert_action_group( mgr, mainActions, 0 ); + gtk_ui_manager_insert_action_group( mgr, mainActions->gobj(), 0 ); gtk_ui_manager_add_ui_from_string( mgr, ui_descr, -1, &errVal ); std::map dataHolders; @@ -1394,11 +1636,11 @@ setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop) if ( aux_toolboxes[i].prep_func ) { // converted to GtkActions and UIManager - GtkWidget* kludge = gtk_hbox_new( FALSE, 0 ); + GtkWidget* kludge = gtk_toolbar_new(); g_object_set_data( G_OBJECT(kludge), "dtw", desktop->canvas); g_object_set_data( G_OBJECT(kludge), "desktop", desktop); dataHolders[aux_toolboxes[i].type_name] = kludge; - aux_toolboxes[i].prep_func( desktop, mainActions, G_OBJECT(kludge) ); + aux_toolboxes[i].prep_func( desktop, mainActions->gobj(), G_OBJECT(kludge) ); } else { GtkWidget *sub_toolbox = 0; @@ -1431,8 +1673,7 @@ setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop) g_free( tmp ); tmp = 0; - gint shrinkTop = prefs_get_int_attribute_limited( "toolbox", "small", 1, 0, 1 ); - Inkscape::IconSize toolboxSize = shrinkTop ? Inkscape::ICON_SIZE_SMALL_TOOLBAR : Inkscape::ICON_SIZE_LARGE_TOOLBAR; + Inkscape::IconSize toolboxSize = prefToSize("toolbox", "small"); if ( prefs_get_int_attribute_limited( "toolbox", "icononly", 1, 0, 1 ) ) { gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS ); } @@ -1442,7 +1683,7 @@ setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop) gtk_table_attach( GTK_TABLE(holder), toolBar, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0 ); if ( aux_toolboxes[i].swatch_verb_id != SP_VERB_INVALID ) { - Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch( NULL, aux_toolboxes[i].swatch_tip ); + Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch( NULL, _(aux_toolboxes[i].swatch_tip) ); swatch->setDesktop( desktop ); swatch->setClickVerb( aux_toolboxes[i].swatch_verb_id ); swatch->setWatchedTool( aux_toolboxes[i].swatch_tool, true ); @@ -1521,23 +1762,33 @@ setup_commands_toolbox(GtkWidget *toolbox, SPDesktop *desktop) " " " " ""; - GtkActionGroup* mainActions = create_or_fetch_actions( desktop ); + Glib::RefPtr mainActions = create_or_fetch_actions( desktop ); GtkUIManager* mgr = gtk_ui_manager_new(); GError* errVal = 0; - gtk_ui_manager_insert_action_group( mgr, mainActions, 0 ); + gtk_ui_manager_insert_action_group( mgr, mainActions->gobj(), 0 ); gtk_ui_manager_add_ui_from_string( mgr, descr, -1, &errVal ); GtkWidget* toolBar = gtk_ui_manager_get_widget( mgr, "/ui/CommandsToolbar" ); if ( prefs_get_int_attribute_limited( "toolbox", "icononly", 1, 0, 1 ) ) { gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS ); } - gint shrinkTop = prefs_get_int_attribute_limited( "toolbox", "small", 1, 0, 1 ); - Inkscape::IconSize toolboxSize = shrinkTop ? Inkscape::ICON_SIZE_SMALL_TOOLBAR : Inkscape::ICON_SIZE_LARGE_TOOLBAR; + + Inkscape::IconSize toolboxSize = prefToSize("toolbox", "small"); gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), (GtkIconSize)toolboxSize ); + gtk_toolbar_set_orientation(GTK_TOOLBAR(toolBar), GTK_ORIENTATION_HORIZONTAL); + gtk_toolbar_set_show_arrow(GTK_TOOLBAR(toolBar), TRUE); + + + g_object_set_data(G_OBJECT(toolBar), "desktop", NULL); + + GtkWidget* child = gtk_bin_get_child(GTK_BIN(toolbox)); + if ( child ) { + gtk_container_remove( GTK_CONTAINER(toolbox), child ); + } gtk_container_add( GTK_CONTAINER(toolbox), toolBar ); } @@ -1561,16 +1812,10 @@ void show_aux_toolbox(GtkWidget *toolbox_toplevel) gtk_widget_show_all(shown_toolbox); } -void -aux_toolbox_space(GtkWidget *tb, gint space) -{ - gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, space); -} - static GtkWidget * sp_empty_toolbox_new(SPDesktop *desktop) { - GtkWidget *tbl = gtk_hbox_new(FALSE, 0); + GtkWidget *tbl = gtk_toolbar_new(); gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas); gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop); @@ -1580,50 +1825,6 @@ sp_empty_toolbox_new(SPDesktop *desktop) return tbl; } -// helper UI functions - -GtkWidget * -sp_tb_spinbutton( - gchar *label, gchar const *tooltip, - gchar const *path, gchar const *data, gdouble def, - GtkWidget *us, - GtkWidget *tbl, - gboolean altx, gchar const *altx_mark, - gdouble lower, gdouble upper, gdouble step, gdouble page, - void (*callback)(GtkAdjustment *, GtkWidget *), - gdouble climb = 0.1, guint digits = 3, double factor = 1.0) -{ - GtkTooltips *tt = gtk_tooltips_new(); - - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - - GtkWidget *l = gtk_label_new(label); - gtk_widget_show(l); - gtk_misc_set_alignment(GTK_MISC(l), 1.0, 0.5); - gtk_container_add(GTK_CONTAINER(hb), l); - - GtkObject *a = gtk_adjustment_new(prefs_get_double_attribute(path, data, def) * factor, - lower, upper, step, page, page); - gtk_object_set_data(GTK_OBJECT(tbl), data, a); - if (us) - sp_unit_selector_add_adjustment(SP_UNIT_SELECTOR(us), GTK_ADJUSTMENT(a)); - - GtkWidget *sb = gtk_spin_button_new(GTK_ADJUSTMENT(a), climb, digits); - gtk_tooltips_set_tip(tt, sb, tooltip, NULL); - if (altx) - gtk_object_set_data(GTK_OBJECT(sb), altx_mark, sb); - gtk_widget_set_size_request(sb, - (upper <= 1.0 || digits == 0)? AUX_SPINBUTTON_WIDTH_SMALL - 10: AUX_SPINBUTTON_WIDTH_SMALL, - AUX_SPINBUTTON_HEIGHT); - gtk_widget_show(sb); - gtk_signal_connect(GTK_OBJECT(sb), "focus-in-event", GTK_SIGNAL_FUNC(spinbutton_focus_in), tbl); - gtk_signal_connect(GTK_OBJECT(sb), "key-press-event", GTK_SIGNAL_FUNC(spinbutton_keypress), tbl); - gtk_container_add(GTK_CONTAINER(hb), sb); - gtk_signal_connect(GTK_OBJECT(a), "value_changed", GTK_SIGNAL_FUNC(callback), tbl); - - return hb; -} - #define MODE_LABEL_WIDTH 70 //######################## @@ -1659,7 +1860,7 @@ static void sp_stb_magnitude_value_changed( GtkAdjustment *adj, GObject *dataKlu sp_repr_set_svg_double(repr, "sodipodi:arg2", (sp_repr_get_double_attribute(repr, "sodipodi:arg1", 0.5) + M_PI / (gint)adj->value)); - SP_OBJECT((SPItem *) items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT); + SP_OBJECT((SPItem *) items->data)->updateRepr(); modmade = true; } } @@ -1700,7 +1901,7 @@ static void sp_stb_proportion_value_changed( GtkAdjustment *adj, GObject *dataKl sp_repr_set_svg_double(repr, "sodipodi:r1", r2*adj->value); } - SP_OBJECT((SPItem *) items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT); + SP_OBJECT((SPItem *) items->data)->updateRepr(); modmade = true; } } @@ -1742,7 +1943,7 @@ static void sp_stb_sides_flat_state_changed( EgeSelectOneAction *act, GObject *d if (SP_IS_STAR((SPItem *) items->data)) { Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data); repr->setAttribute("inkscape:flatsided", flat ? "true" : "false" ); - SP_OBJECT((SPItem *) items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT); + SP_OBJECT((SPItem *) items->data)->updateRepr(); modmade = true; } } @@ -1779,7 +1980,7 @@ static void sp_stb_rounded_value_changed( GtkAdjustment *adj, GObject *dataKludg if (SP_IS_STAR((SPItem *) items->data)) { Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data); sp_repr_set_svg_double(repr, "inkscape:rounded", (gdouble) adj->value); - SP_OBJECT(items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT); + SP_OBJECT(items->data)->updateRepr(); modmade = true; } } @@ -1813,7 +2014,7 @@ static void sp_stb_randomized_value_changed( GtkAdjustment *adj, GObject *dataKl if (SP_IS_STAR((SPItem *) items->data)) { Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data); sp_repr_set_svg_double(repr, "inkscape:randomized", (gdouble) adj->value); - SP_OBJECT(items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT); + SP_OBJECT(items->data)->updateRepr(); modmade = true; } } @@ -1976,13 +2177,19 @@ sp_toolbox_add_label(GtkWidget *tbl, gchar const *title, bool wide) GtkWidget *l = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(l), title); gtk_box_pack_end(GTK_BOX(boxl), l, FALSE, FALSE, 0); - gtk_box_pack_start(GTK_BOX(tbl), boxl, FALSE, FALSE, 0); + if ( GTK_IS_TOOLBAR(tbl) ) { + gtk_toolbar_append_widget( GTK_TOOLBAR(tbl), boxl, "", "" ); + } else { + gtk_box_pack_start(GTK_BOX(tbl), boxl, FALSE, FALSE, 0); + } gtk_object_set_data(GTK_OBJECT(tbl), "mode_label", l); } static void sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) { + Inkscape::IconSize secondarySize = prefToSize("toolbox", "secondary", 1); + { EgeOutputAction* act = ege_output_action_new( "StarStateAction", _("New:"), "", 0 ); ege_output_action_set_use_markup( act, TRUE ); @@ -2022,6 +2229,7 @@ static void sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE ); g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL ); ege_select_one_action_set_icon_column( act, 2 ); + ege_select_one_action_set_icon_size( act, secondarySize ); ege_select_one_action_set_tooltip_column( act, 1 ); ege_select_one_action_set_active( act, isFlatSided ? 0 : 1 ); @@ -2348,6 +2556,7 @@ sp_rect_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl) static void sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) { EgeAdjustmentAction* eact = 0; + Inkscape::IconSize secondarySize = prefToSize("toolbox", "secondary", 1); { EgeOutputAction* act = ege_output_action_new( "RectStateAction", _("New:"), "", 0 ); @@ -2439,7 +2648,7 @@ static void sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions _("Not rounded"), _("Make corners sharp"), "squared_corner", - Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + secondarySize ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_rtb_defaults), holder ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); gtk_action_set_sensitive( GTK_ACTION(inky), TRUE ); @@ -2846,7 +3055,7 @@ sp_spl_tb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_nam if (SP_IS_SPIRAL((SPItem *) items->data)) { Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data); sp_repr_set_svg_double( repr, namespaced_name, adj->value ); - SP_OBJECT((SPItem *) items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT); + SP_OBJECT((SPItem *) items->data)->updateRepr(); modmade = true; } } @@ -2985,6 +3194,7 @@ sp_spiral_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl static void sp_spiral_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) { EgeAdjustmentAction* eact = 0; + Inkscape::IconSize secondarySize = prefToSize("toolbox", "secondary", 1); { EgeOutputAction* act = ege_output_action_new( "SpiralStateAction", _("New:"), "", 0 ); @@ -3041,7 +3251,7 @@ static void sp_spiral_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActio _("Defaults"), _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"), GTK_STOCK_CLEAR, - Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + secondarySize ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_spl_tb_defaults), holder ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); } @@ -3055,20 +3265,264 @@ static void sp_spiral_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActio } //######################## -//## Pen/Pencil ## +//## Pen/Pencil ## //######################## +/* This is used in generic functions below to share large portions of code between pen and pencil tool */ +static char const * +freehand_tool_name(GObject *dataKludge) +{ + SPDesktop *desktop = (SPDesktop *) g_object_get_data(dataKludge, "desktop"); + return ( tools_isactive(desktop, TOOLS_FREEHAND_PEN) + ? "tools.freehand.pen" + : "tools.freehand.pencil" ); +} + +static void freehand_mode_changed(EgeSelectOneAction* act, GObject* tbl) +{ + gint mode = ege_select_one_action_get_active(act); + + prefs_set_int_attribute(freehand_tool_name(tbl), "freehand-mode", mode); -static void sp_pen_toolbox_prep(SPDesktop */*desktop*/, GtkActionGroup* /*mainActions*/, GObject* /*holder*/) + SPDesktop *desktop = (SPDesktop *) g_object_get_data(tbl, "desktop"); + + // in pen tool we have more options than in pencil tool; if one of them was chosen, we do any + // preparatory work here + if (SP_IS_PEN_CONTEXT(desktop->event_context)) { + SPPenContext *pc = SP_PEN_CONTEXT(desktop->event_context); + pc->polylines_only = (mode == 2); + } +} + +static void sp_add_freehand_mode_toggle(GtkActionGroup* mainActions, GObject* holder, bool tool_is_pencil) { - // Put stuff here + /* Freehand mode toggle buttons */ + { + guint freehandMode = prefs_get_int_attribute(tool_is_pencil ? "tools.freehand.pencil" : "tools.freehand.pen", "freehand-mode", 0); + Inkscape::IconSize secondarySize = prefToSize("toolbox", "secondary", 1); + + { + GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); + + GtkTreeIter iter; + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, + 0, _("Bezier"), + 1, _("Create regular Bezier path"), + 2, "bezier_mode", + -1 ); + + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, + 0, _("Spiro"), + 1, _("Create Spiro path"), + 2, "spiro_splines_mode", + -1 ); + + if (!tool_is_pencil) { + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, + 0, _("Zigzag"), + 1, _("Create a sequence of straight line segments"), + 2, "polylines_mode", + -1 ); + } + + EgeSelectOneAction* act = ege_select_one_action_new(tool_is_pencil ? + "FreehandModeActionPencil" : + "FreehandModeActionPen", + (_("Mode:")), ("Mode"), NULL, GTK_TREE_MODEL(model) ); + gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); + + ege_select_one_action_set_appearance( act, "full" ); + ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE ); + g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL ); + ege_select_one_action_set_icon_column( act, 2 ); + ege_select_one_action_set_icon_size( act, secondarySize ); + ege_select_one_action_set_tooltip_column( act, 1 ); + + ege_select_one_action_set_active( act, freehandMode); + g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(freehand_mode_changed), holder); + } + } } -static void sp_pencil_toolbox_prep(SPDesktop */*desktop*/, GtkActionGroup* /*mainActions*/, GObject* /*holder*/) +static void freehand_change_shape(EgeSelectOneAction* act, GObject *dataKludge) { + gint shape = ege_select_one_action_get_active( act ); + prefs_set_int_attribute(freehand_tool_name(dataKludge), "shape", shape); +} + +/** + * \brief Generate the list of freehand advanced shape option entries. + */ +GList * freehand_shape_dropdown_items_list() { + GList *glist = NULL; + + glist = g_list_append (glist, _("None")); + glist = g_list_append (glist, _("Triangle in")); + glist = g_list_append (glist, _("Triangle out")); + glist = g_list_append (glist, _("Ellipse")); + glist = g_list_append (glist, _("From clipboard")); + + return glist; +} + +static void +freehand_add_advanced_shape_options(GtkActionGroup* mainActions, GObject* holder, bool tool_is_pencil) { + /*advanced shape options */ + { + GtkListStore* model = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_INT ); + + GList* items = 0; + gint count = 0; + for ( items = freehand_shape_dropdown_items_list(); items ; items = g_list_next(items) ) + { + GtkTreeIter iter; + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, 0, reinterpret_cast(items->data), 1, count, -1 ); + count++; + } + g_list_free( items ); + items = 0; + EgeSelectOneAction* act1 = ege_select_one_action_new( + tool_is_pencil ? "SetPencilShapeAction" : "SetPenShapeAction", + _("Shape:"), ("Shape"), NULL, GTK_TREE_MODEL(model)); + g_object_set( act1, "short_label", _("Shape:"), NULL ); + ege_select_one_action_set_appearance( act1, "compact" ); + ege_select_one_action_set_active( act1, prefs_get_int_attribute(tool_is_pencil ? "tools.freehand.pencil" : "tools.freehand.pen", "shape", 0) ); + g_signal_connect( G_OBJECT(act1), "changed", G_CALLBACK(freehand_change_shape), holder ); + gtk_action_group_add_action( mainActions, GTK_ACTION(act1) ); + g_object_set_data( holder, "shape_action", act1 ); + } +} + +static void sp_pen_toolbox_prep(SPDesktop */*desktop*/, GtkActionGroup* mainActions, GObject* holder) { - // Put stuff here + sp_add_freehand_mode_toggle(mainActions, holder, false); + freehand_add_advanced_shape_options(mainActions, holder, false); } + +static void +sp_pencil_tb_defaults(GtkWidget */*widget*/, GtkObject *obj) +{ + GtkWidget *tbl = GTK_WIDGET(obj); + + GtkAdjustment *adj; + + // fixme: make settable + gdouble tolerance = 4; + + adj = (GtkAdjustment*)gtk_object_get_data(obj, "tolerance"); + gtk_adjustment_set_value(adj, tolerance); + gtk_adjustment_value_changed(adj); + + spinbutton_defocus(GTK_OBJECT(tbl)); +} + +static void +sp_pencil_tb_tolerance_value_changed(GtkAdjustment *adj, GObject *tbl) +{ + + // quit if run by the attr_changed listener + if (g_object_get_data( tbl, "freeze" )) { + return; + } + // in turn, prevent listener from responding + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + prefs_set_double_attribute("tools.freehand.pencil", + "tolerance", adj->value); + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + +} + + + +static void +sp_pencil_tb_tolerance_value_changed_external(Inkscape::XML::Node */*repr*/, + const gchar */*key*/, + const gchar */*oldval*/, + const gchar */*newval*/, + bool /*is_interactive*/, + void * data) +{ + GObject* tbl = G_OBJECT(data); + if (g_object_get_data( tbl, "freeze" )) { + return; + } + + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + + GtkAdjustment * adj = (GtkAdjustment*)g_object_get_data(tbl, + "tolerance"); + + double v = prefs_get_double_attribute("tools.freehand.pencil", + "tolerance", adj->value); + gtk_adjustment_set_value(adj, v); + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + +} + +static Inkscape::XML::NodeEventVector pencil_node_events = +{ + NULL, + NULL, + sp_pencil_tb_tolerance_value_changed_external, + NULL, + NULL, +}; + + +static void sp_pencil_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) +{ + sp_add_freehand_mode_toggle(mainActions, holder, true); + + EgeAdjustmentAction* eact = 0; + + /* Tolerance */ + { + gchar const* labels[] = {_("(many nodes, rough)"), ("(default)"), 0, 0, 0, 0, ("(few nodes, smooth)")}; + gdouble values[] = {1, 10, 20, 30, 50, 75, 100}; + eact = create_adjustment_action( "PencilToleranceAction", + _("Smoothing:"), _("Smoothing: "), + _("How much smoothing (simplifying) is applied to the line"), + "tools.freehand.pencil", "tolerance", + 3.0, + GTK_WIDGET(desktop->canvas), NULL, + holder, TRUE, "altx-pencil", + 1, 100.0, 0.5, 0, + labels, values, G_N_ELEMENTS(labels), + sp_pencil_tb_tolerance_value_changed, + 1, 2); + ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + + Inkscape::XML::Node *repr = inkscape_get_repr(INKSCAPE, + "tools.freehand.pencil"); + repr->addListener(&pencil_node_events, G_OBJECT(holder)); + g_object_set_data(G_OBJECT(holder), "repr", repr); + + } + + /* advanced shape options */ + freehand_add_advanced_shape_options(mainActions, holder, true); + + /* Reset */ + { + InkAction* inky = ink_action_new( "PencilResetAction", + _("Defaults"), + _("Reset pencil parameters to defaults (use Inkscape Preferences > Tools to change defaults)"), + GTK_STOCK_CLEAR, + Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_pencil_tb_defaults), holder ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } + + g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder ); + +} + + //######################## //## Tweak ## //######################## @@ -3140,6 +3594,8 @@ static void tweak_toggle_doo (GtkToggleAction *act, gpointer /*data*/) { static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) { + Inkscape::IconSize secondarySize = prefToSize("toolbox", "secondary", 1); + { /* Width */ gchar const* labels[] = {_("(pinch tweak)"), 0, 0, 0, _("(default)"), 0, 0, 0, 0, _("(broad tweak)")}; @@ -3148,9 +3604,10 @@ static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction _("Width"), _("Width:"), _("The width of the tweak area (relative to the visible canvas area)"), "tools.tweak", "width", 15, GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-tweak", - 1, 100, 1.0, 10.0, + 1, 100, 1.0, 0.0, labels, values, G_N_ELEMENTS(labels), sp_tweak_width_value_changed, 0.01, 0, 100 ); + ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); } @@ -3164,9 +3621,10 @@ static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction _("Force"), _("Force:"), _("The force of the tweak action"), "tools.tweak", "force", 20, GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "tweak-force", - 1, 100, 1.0, 10.0, + 1, 100, 1.0, 0.0, labels, values, G_N_ELEMENTS(labels), sp_tweak_force_value_changed, 0.01, 0, 100 ); + ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); } @@ -3241,6 +3699,7 @@ static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE ); g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL ); ege_select_one_action_set_icon_column( act, 2 ); + ege_select_one_action_set_icon_size( act, secondarySize ); ege_select_one_action_set_tooltip_column( act, 1 ); gint mode = prefs_get_int_attribute("tools.tweak", "mode", 0); @@ -3267,6 +3726,7 @@ static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction _("In color mode, act on objects' hue"), NULL, Inkscape::ICON_SIZE_DECORATION ); + //TRANSLATORS: "H" here stands for hue g_object_set( act, "short_label", _("H"), NULL ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_doh), desktop ); @@ -3281,6 +3741,7 @@ static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction _("In color mode, act on objects' saturation"), NULL, Inkscape::ICON_SIZE_DECORATION ); + //TRANSLATORS: "S" here stands for Saturation g_object_set( act, "short_label", _("S"), NULL ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_dos), desktop ); @@ -3295,6 +3756,7 @@ static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction _("In color mode, act on objects' lightness"), NULL, Inkscape::ICON_SIZE_DECORATION ); + //TRANSLATORS: "L" here stands for Lightness g_object_set( act, "short_label", _("L"), NULL ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_dol), desktop ); @@ -3309,6 +3771,7 @@ static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction _("In color mode, act on objects' opacity"), NULL, Inkscape::ICON_SIZE_DECORATION ); + //TRANSLATORS: "O" here stands for Opacity g_object_set( act, "short_label", _("O"), NULL ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_doo), desktop ); @@ -3355,22 +3818,75 @@ static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainAction //######################## //## Calligraphy ## //######################## -static void update_presets_list(GObject *dataKludge ){ - EgeSelectOneAction *sel = static_cast(g_object_get_data(dataKludge, "profile_selector")); - if (sel) { - ege_select_one_action_set_active(sel, 0 ); +static void update_presets_list (GObject *tbl) +{ + if (g_object_get_data(tbl, "presets_blocked")) + return; + + EgeSelectOneAction *sel = static_cast(g_object_get_data(tbl, "profile_selector")); + if (!sel) { + ege_select_one_action_set_active(sel, 0); + return; } + + int total_prefs = pref_path_number_of_children("tools.calligraphic.preset"); + + for (int i = 1; i <= total_prefs; i++) { + gchar *preset_path = get_pref_nth_child("tools.calligraphic.preset", i); + Inkscape::XML::Node *preset_repr = inkscape_get_repr(INKSCAPE, preset_path); + + bool match = true; + + for ( Inkscape::Util::List iter = preset_repr->attributeList(); + iter; + ++iter ) { + const gchar *attr_name = g_quark_to_string(iter->key); + if (!strcmp(attr_name, "id") || !strcmp(attr_name, "name")) + continue; + void *widget = g_object_get_data(tbl, attr_name); + if (widget) { + if (GTK_IS_ADJUSTMENT(widget)) { + double v = prefs_get_double_attribute(preset_path, attr_name, 0); // fixme: no min/max checks here, add? + GtkAdjustment* adj = static_cast(widget); + //std::cout << "compared adj " << attr_name << gtk_adjustment_get_value(adj) << " to " << v << "\n"; + if (fabs(gtk_adjustment_get_value(adj) - v) > 1e-6) { + match = false; + break; + } + } else if (GTK_IS_TOGGLE_ACTION(widget)) { + int v = prefs_get_int_attribute(preset_path, attr_name, 0); // fixme: no min/max checks here, add? + GtkToggleAction* toggle = static_cast(widget); + //std::cout << "compared toggle " << attr_name << gtk_toggle_action_get_active(toggle) << " to " << v << "\n"; + if (gtk_toggle_action_get_active(toggle) != v) { + match = false; + break; + } + } + } + } + + if (match) { + // newly added item is at the same index as the + // save command, so we need to change twice for it to take effect + ege_select_one_action_set_active(sel, 0); + ege_select_one_action_set_active(sel, i); + return; + } + } + + // no match found + ege_select_one_action_set_active(sel, 0); } static void sp_ddc_mass_value_changed( GtkAdjustment *adj, GObject* tbl ) { - prefs_set_double_attribute( "tools.calligraphic", "mass", adj->value ); + prefs_set_double_attribute( "tools.calligraphic", "mass", adj->value * 0.01 ); update_presets_list(tbl); } static void sp_ddc_wiggle_value_changed( GtkAdjustment *adj, GObject* tbl ) { - prefs_set_double_attribute( "tools.calligraphic", "wiggle", adj->value ); + prefs_set_double_attribute( "tools.calligraphic", "wiggle", adj->value * 0.01 ); update_presets_list(tbl); } @@ -3388,19 +3904,19 @@ static void sp_ddc_width_value_changed( GtkAdjustment *adj, GObject *tbl ) static void sp_ddc_velthin_value_changed( GtkAdjustment *adj, GObject* tbl ) { - prefs_set_double_attribute("tools.calligraphic", "thinning", adj->value); + prefs_set_double_attribute("tools.calligraphic", "thinning", adj->value * 0.01 ); update_presets_list(tbl); } static void sp_ddc_flatness_value_changed( GtkAdjustment *adj, GObject* tbl ) { - prefs_set_double_attribute( "tools.calligraphic", "flatness", adj->value ); + prefs_set_double_attribute( "tools.calligraphic", "flatness", adj->value * 0.01); update_presets_list(tbl); } static void sp_ddc_tremor_value_changed( GtkAdjustment *adj, GObject* tbl ) { - prefs_set_double_attribute( "tools.calligraphic", "tremor", adj->value ); + prefs_set_double_attribute( "tools.calligraphic", "tremor", adj->value * 0.01 ); update_presets_list(tbl); } @@ -3424,7 +3940,7 @@ static void sp_ddc_trace_background_changed( GtkToggleAction *act, GObject* tbl static void sp_ddc_tilt_state_changed( GtkToggleAction *act, GObject* tbl ) { - GtkAction * calligraphy_angle = static_cast (g_object_get_data(tbl,"angle")); + GtkAction * calligraphy_angle = static_cast (g_object_get_data(tbl,"angle_action")); prefs_set_int_attribute( "tools.calligraphic", "usetilt", gtk_toggle_action_get_active( act ) ? 1 : 0 ); update_presets_list(tbl); if (calligraphy_angle ) @@ -3432,92 +3948,185 @@ static void sp_ddc_tilt_state_changed( GtkToggleAction *act, GObject* tbl ) } -#define PROFILE_FLOAT_SIZE 8 -#define PROFILE_BOOL_SIZE 3 -struct ProfileFloatElement { - char const *name; - double def; - double min; - double max; -}; -struct ProfileBoolElement { - char const *name; - bool def; +static gchar const *const widget_names[] = { + "width", + "mass", + "wiggle", + "angle", + "thinning", + "tremor", + "flatness", + "cap_rounding", + "usepressure", + "tracebackground", + "usetilt" }; -static ProfileFloatElement f_profile[PROFILE_FLOAT_SIZE] = { - {"mass",0.02, 0.0, 1.0}, - {"wiggle",0.0, 0.0, 1.0}, - {"angle",30.0, -90.0, 90.0}, - {"width",15.0, 1.0, 100.0}, - {"thinning",0.1, -1.0, 1.0}, - {"tremor",0.0, 0.0, 1.0}, - {"flatness",0.9, 0.0, 1.0}, - {"cap_rounding",0.0, 0.0, 5.0} -}; -static ProfileBoolElement b_profile[PROFILE_BOOL_SIZE] = { - {"usepressure",true}, - {"tracebackground",false}, - {"usetilt",true}, -}; +static void sp_dcc_build_presets_list(GObject *tbl) +{ + g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(TRUE)); + + EgeSelectOneAction* selector = static_cast(g_object_get_data(tbl, "profile_selector")); + GtkListStore* model = GTK_LIST_STORE(ege_select_one_action_get_model(selector)); + gtk_list_store_clear (model); + + { + GtkTreeIter iter; + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, 0, _("No preset"), 1, 0, -1 ); + } + + //TODO: switch back to prefs API + Inkscape::XML::Node *repr = inkscape_get_repr(INKSCAPE, "tools.calligraphic.preset" ); + Inkscape::XML::Node *child_repr = sp_repr_children(repr); + int ii=1; + while (child_repr) { + GtkTreeIter iter; + char *preset_name = (char *) child_repr->attribute("name"); + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, 0, preset_name, 1, ++ii, -1 ); + child_repr = sp_repr_next(child_repr); + } + + { + GtkTreeIter iter; + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, 0, _("Save..."), 1, ii, -1 ); + g_object_set_data(tbl, "save_presets_index", GINT_TO_POINTER(ii)); + } + g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE)); -static void sp_dcc_save_profile( GtkWidget */*widget*/, GObject *dataKludge ){ + update_presets_list (tbl); +} + +static void sp_dcc_save_profile (GtkWidget */*widget*/, GObject *tbl) +{ + SPDesktop *desktop = (SPDesktop *) g_object_get_data(tbl, "desktop" ); + if (! desktop) return; + + if (g_object_get_data(tbl, "presets_blocked")) + return; - unsigned int new_index = pref_path_number_of_children("tools.calligraphic.preset"); - gchar *profile_id = g_strdup_printf("dcc%d", new_index); - gchar *profile_name = g_strdup_printf("Profile %d", new_index); - gchar *pref_path = create_pref("tools.calligraphic.preset",profile_id); + Inkscape::UI::Dialogs::CalligraphicProfileDialog::show(desktop); + if ( ! Inkscape::UI::Dialogs::CalligraphicProfileDialog::applied()) { + // dialog cancelled + update_presets_list (tbl); + return; + } + Glib::ustring profile_name = Inkscape::UI::Dialogs::CalligraphicProfileDialog::getProfileName(); - for (unsigned i = 0; i < PROFILE_FLOAT_SIZE; ++i) { - ProfileFloatElement const &pe = f_profile[i]; - double v = prefs_get_double_attribute_limited("tools.calligraphic",pe.name, pe.def, pe.min, pe.max); - prefs_set_double_attribute(pref_path,pe.name,v); - } - for (unsigned i = 0; i < PROFILE_BOOL_SIZE; ++i) { - ProfileBoolElement const &pe = b_profile[i]; - int v = prefs_get_int_attribute_limited("tools.calligraphic",pe.name, pe.def?1:0 ,0,1); - prefs_set_int_attribute(pref_path,pe.name,v); + if (!profile_name.c_str() || *profile_name.c_str() == 0) { + // empty name entered + update_presets_list (tbl); + return; + } + + g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(TRUE)); + + int new_index = -1; + gchar *pref_path = NULL; + int total_prefs = pref_path_number_of_children("tools.calligraphic.preset"); + + for (int i = 1; i <= total_prefs; i++) { + gchar *path = get_pref_nth_child("tools.calligraphic.preset", i); + const gchar *name = prefs_get_string_attribute(path, "name"); + if (name && !strcmp(name, profile_name.c_str())) { + // we already have preset with this name, replace its values + new_index = i; + pref_path = g_strdup(path); + break; } - prefs_set_string_attribute(pref_path,"name",profile_name); + } - EgeSelectOneAction* selector = static_cast(g_object_get_data(dataKludge, "profile_selector")); - GtkListStore* model = GTK_LIST_STORE(ege_select_one_action_get_model(selector)); - GtkTreeIter iter; - gtk_list_store_append( model, &iter ); - gtk_list_store_set( model, &iter, 0, profile_name, 1, new_index, -1 ); - - free(profile_id); - free(profile_name); - free(pref_path); -} - -static void sp_ddc_change_profile(EgeSelectOneAction* act, GObject *dataKludge) { - - gint preset_index = ege_select_one_action_get_active( act ); - gchar *profile_name = get_pref_nth_child("tools.calligraphic.preset", preset_index); - - if ( profile_name) { - g_object_set_data(dataKludge, "profile_selector",NULL); //temporary hides the selector so no one will updadte it - for (unsigned i = 0; i < PROFILE_FLOAT_SIZE; ++i) { - ProfileFloatElement const &pe = f_profile[i]; - double v = prefs_get_double_attribute_limited(profile_name, pe.name, pe.def, pe.min, pe.max); - GtkAdjustment* adj = static_cast(g_object_get_data(dataKludge, pe.name)); - if ( adj ) { - gtk_adjustment_set_value(adj, v); + if (new_index == -1) { + // no preset with this name, create + new_index = total_prefs + 1; + gchar *profile_id = g_strdup_printf("dcc%d", new_index); + pref_path = create_pref("tools.calligraphic.preset", profile_id); + g_free(profile_id); + } + + for (unsigned i = 0; i < G_N_ELEMENTS(widget_names); ++i) { + gchar const *const widget_name = widget_names[i]; + void *widget = g_object_get_data(tbl, widget_name); + if (widget) { + if (GTK_IS_ADJUSTMENT(widget)) { + GtkAdjustment* adj = static_cast(widget); + double v = gtk_adjustment_get_value(adj); + prefs_set_double_attribute(pref_path, widget_name, v); + //std::cout << "wrote adj " << widget_name << ": " << v << "\n"; + } else if (GTK_IS_TOGGLE_ACTION(widget)) { + GtkToggleAction* toggle = static_cast(widget); + int v = gtk_toggle_action_get_active(toggle); + prefs_set_int_attribute(pref_path, widget_name, v); + //std::cout << "wrote tog " << widget_name << ": " << v << "\n"; + } else { + g_warning("Unknown widget type for preset: %s\n", widget_name); + } + } else { + g_warning("Bad key when writing preset: %s\n", widget_name); + } + } + prefs_set_string_attribute(pref_path, "name", profile_name.c_str()); + + g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE)); + + sp_dcc_build_presets_list (tbl); + + g_free(pref_path); +} + + +static void sp_ddc_change_profile(EgeSelectOneAction* act, GObject* tbl) { + + gint preset_index = ege_select_one_action_get_active( act ); + gint save_presets_index = GPOINTER_TO_INT(g_object_get_data(tbl, "save_presets_index")); + + if (preset_index == save_presets_index) { + // this is the Save command + sp_dcc_save_profile(NULL, tbl); + return; + } + + if (g_object_get_data(tbl, "presets_blocked")) + return; + + gchar *const preset_path = get_pref_nth_child("tools.calligraphic.preset", preset_index); + + if (preset_path) { + g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(TRUE)); //temporarily block the selector so no one will updadte it while we're reading it + + Inkscape::XML::Node *preset_repr = inkscape_get_repr(INKSCAPE, preset_path); + + for ( Inkscape::Util::List iter = preset_repr->attributeList(); + iter; + ++iter ) { + const gchar *attr_name = g_quark_to_string(iter->key); + if (!strcmp(attr_name, "id") || !strcmp(attr_name, "name")) + continue; + void *widget = g_object_get_data(tbl, attr_name); + if (widget) { + if (GTK_IS_ADJUSTMENT(widget)) { + double v = prefs_get_double_attribute(preset_path, attr_name, 0); // fixme: no min/max checks here, add? + GtkAdjustment* adj = static_cast(widget); + gtk_adjustment_set_value(adj, v); + //std::cout << "set adj " << attr_name << " to " << v << "\n"; + } else if (GTK_IS_TOGGLE_ACTION(widget)) { + int v = prefs_get_int_attribute(preset_path, attr_name, 0); // fixme: no min/max checks here, add? + GtkToggleAction* toggle = static_cast(widget); + gtk_toggle_action_set_active(toggle, v); + //std::cout << "set toggle " << attr_name << " to " << v << "\n"; + } else { + g_warning("Unknown widget type for preset: %s\n", attr_name); + } + } else { + g_warning("Bad key found in a preset record: %s\n", attr_name); } - } - for (unsigned i = 0; i < PROFILE_BOOL_SIZE; ++i) { - ProfileBoolElement const &pe = b_profile[i]; - int v = prefs_get_int_attribute_limited(profile_name, pe.name, pe.def, 0, 1); - GtkToggleAction* toggle = static_cast(g_object_get_data(dataKludge, pe.name)); - if ( toggle ) { - gtk_toggle_action_set_active(toggle, v); - } else printf("No toggle"); } - free(profile_name); - g_object_set_data(dataKludge, "profile_selector",act); //restor selector visibility + g_free(preset_path); + g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE)); } } @@ -3526,6 +4135,8 @@ static void sp_ddc_change_profile(EgeSelectOneAction* act, GObject *dataKludge) static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) { { + g_object_set_data(holder, "presets_blocked", GINT_TO_POINTER(TRUE)); + EgeAdjustmentAction* calligraphy_angle = 0; { @@ -3537,9 +4148,10 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main _("The width of the calligraphic pen (relative to the visible canvas area)"), "tools.calligraphic", "width", 15, GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-calligraphy", - 1, 100, 1.0, 10.0, + 1, 100, 1.0, 0.0, labels, values, G_N_ELEMENTS(labels), sp_ddc_width_value_changed, 0.01, 0, 100 ); + ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); } @@ -3547,15 +4159,15 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main { /* Thinning */ gchar const* labels[] = {_("(speed blows up stroke)"), 0, 0, _("(slight widening)"), _("(constant width)"), _("(slight thinning, default)"), 0, 0, _("(speed deflates stroke)")}; - gdouble values[] = {-1, -0.4, -0.2, -0.1, 0, 0.1, 0.2, 0.4, 1}; + gdouble values[] = {-100, -40, -20, -10, 0, 10, 20, 40, 100}; EgeAdjustmentAction* eact = create_adjustment_action( "ThinningAction", _("Stroke Thinning"), _("Thinning:"), _("How much velocity thins the stroke (> 0 makes fast strokes thinner, < 0 makes them broader, 0 makes width independent of velocity)"), - "tools.calligraphic", "thinning", 0.1, + "tools.calligraphic", "thinning", 10, GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, - -1.0, 1.0, 0.01, 0.1, + -100, 100, 1, 0.1, labels, values, G_N_ELEMENTS(labels), - sp_ddc_velthin_value_changed, 0.01, 2); + sp_ddc_velthin_value_changed, 0.01, 0, 100); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); } @@ -3573,23 +4185,23 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main labels, values, G_N_ELEMENTS(labels), sp_ddc_angle_value_changed, 1, 0 ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + g_object_set_data( holder, "angle_action", eact ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); - g_object_set_data( holder, "angle", eact ); calligraphy_angle = eact; } { /* Fixation */ gchar const* labels[] = {_("(perpendicular to stroke, \"brush\")"), 0, 0, 0, _("(almost fixed, default)"), _("(fixed by Angle, \"pen\")")}; - gdouble values[] = {0, 0.2, 0.4, 0.6, 0.9, 1.0}; + gdouble values[] = {0, 20, 40, 60, 90, 100}; EgeAdjustmentAction* eact = create_adjustment_action( "FixationAction", _("Fixation"), _("Fixation:"), _("Angle behavior (0 = nib always perpendicular to stroke direction, 1 = fixed angle)"), - "tools.calligraphic", "flatness", 0.9, + "tools.calligraphic", "flatness", 90, GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, - 0.0, 1.0, 0.01, 0.1, + 0.0, 100, 1.0, 10.0, labels, values, G_N_ELEMENTS(labels), - sp_ddc_flatness_value_changed, 0.01, 2 ); + sp_ddc_flatness_value_changed, 0.01, 0, 100 ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); } @@ -3614,16 +4226,17 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main { /* Tremor */ gchar const* labels[] = {_("(smooth line)"), _("(slight tremor)"), _("(noticeable tremor)"), 0, 0, _("(maximum tremor)")}; - gdouble values[] = {0, 0.1, 0.2, 0.4, 0.6, 1.0}; + gdouble values[] = {0, 10, 20, 40, 60, 100}; EgeAdjustmentAction* eact = create_adjustment_action( "TremorAction", _("Stroke Tremor"), _("Tremor:"), _("Increase to make strokes rugged and trembling"), "tools.calligraphic", "tremor", 0.0, GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, - 0.0, 1.0, 0.01, 0.1, + 0.0, 100, 1, 0.0, labels, values, G_N_ELEMENTS(labels), - sp_ddc_tremor_value_changed, 0.01, 2 ); + sp_ddc_tremor_value_changed, 0.01, 0, 100 ); + ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); } @@ -3631,15 +4244,16 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main { /* Wiggle */ gchar const* labels[] = {_("(no wiggle)"), _("(slight deviation)"), 0, 0, _("(wild waves and curls)")}; - gdouble values[] = {0, 0.2, 0.4, 0.6, 1.0}; + gdouble values[] = {0, 20, 40, 60, 100}; EgeAdjustmentAction* eact = create_adjustment_action( "WiggleAction", _("Pen Wiggle"), _("Wiggle:"), _("Increase to make the pen waver and wiggle"), "tools.calligraphic", "wiggle", 0.0, GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, - 0.0, 1.0, 0.01, 0.1, + 0.0, 100, 1, 0.0, labels, values, G_N_ELEMENTS(labels), - sp_ddc_wiggle_value_changed, 0.01, 2 ); + sp_ddc_wiggle_value_changed, 0.01, 0, 100 ); + ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); } @@ -3647,15 +4261,16 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main { /* Mass */ gchar const* labels[] = {_("(no inertia)"), _("(slight smoothing, default)"), _("(noticeable lagging)"), 0, 0, _("(maximum inertia)")}; - gdouble values[] = {0.0, 0.02, 0.1, 0.2, 0.5, 1.0}; + gdouble values[] = {0.0, 2, 10, 20, 50, 100}; EgeAdjustmentAction* eact = create_adjustment_action( "MassAction", _("Pen Mass"), _("Mass:"), _("Increase to make the pen drag behind, as if slowed by inertia"), - "tools.calligraphic", "mass", 0.02, + "tools.calligraphic", "mass", 2.0, GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, - 0.0, 1.0, 0.01, 0.1, + 0.0, 100, 1, 0.0, labels, values, G_N_ELEMENTS(labels), - sp_ddc_mass_value_changed, 0.01, 2 ); + sp_ddc_mass_value_changed, 0.01, 0, 100 ); + ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); } @@ -3703,46 +4318,19 @@ static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main /*calligraphic profile */ { - GtkListStore* model = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_INT ); - gchar *pref_path; + GtkListStore* model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT); + EgeSelectOneAction* act1 = ege_select_one_action_new ("SetProfileAction", "" , (_("Choose a preset")), NULL, GTK_TREE_MODEL(model)); + ege_select_one_action_set_appearance (act1, "compact"); + g_object_set_data (holder, "profile_selector", act1 ); + g_object_set_data(holder, "presets_blocked", GINT_TO_POINTER(FALSE)); - GtkTreeIter iter; - gtk_list_store_append( model, &iter ); - gtk_list_store_set( model, &iter, 0, _("No preset"), 1, 0, -1 ); - - //TODO: switch back to prefs API - Inkscape::XML::Node *repr = inkscape_get_repr(INKSCAPE, "tools.calligraphic.preset" ); - Inkscape::XML::Node *child_repr = sp_repr_children(repr); - int ii=1; - while (child_repr) { - GtkTreeIter iter; - char *preset_name = (char *) child_repr->attribute("name"); - gtk_list_store_append( model, &iter ); - gtk_list_store_set( model, &iter, 0, preset_name, 1, ++ii, -1 ); - child_repr = sp_repr_next(child_repr); - } - - pref_path = NULL; - EgeSelectOneAction* act1 = ege_select_one_action_new( "SetProfileAction", "" , ("Change calligraphic profile"), NULL, GTK_TREE_MODEL(model) ); - ege_select_one_action_set_appearance( act1, "compact" ); - g_signal_connect( G_OBJECT(act1), "changed", G_CALLBACK(sp_ddc_change_profile), holder ); - gtk_action_group_add_action( mainActions, GTK_ACTION(act1) ); - g_object_set_data( holder, "profile_selector", act1 ); - } + sp_dcc_build_presets_list (holder); - /*Save or delete calligraphic profile */ - { - GtkAction* act = gtk_action_new( "SaveDeleteProfileAction", - _("Defaults"), - _("Save current settings as new profile"), - GTK_STOCK_SAVE ); - g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(sp_dcc_save_profile), holder ); - gtk_action_group_add_action( mainActions, act ); - gtk_action_set_sensitive( act, TRUE ); - g_object_set_data( holder, "profile_save_delete", act ); + g_signal_connect(G_OBJECT(act1), "changed", G_CALLBACK(sp_ddc_change_profile), holder); + gtk_action_group_add_action(mainActions, GTK_ACTION(act1)); } - } + } } @@ -3835,6 +4423,29 @@ static void sp_arctb_end_value_changed(GtkAdjustment *adj, GObject *tbl) sp_arctb_startend_value_changed(adj, tbl, "end", "start"); } + +static void sp_erasertb_mode_changed( EgeSelectOneAction *act, GObject *tbl ) +{ + SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" ); + gint eraserMode = (ege_select_one_action_get_active( act ) != 0) ? 1 : 0; + if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) { + prefs_set_int_attribute( "tools.eraser", "mode", eraserMode ); + } + + // only take action if run by the attr_changed listener + if (!g_object_get_data( tbl, "freeze" )) { + // in turn, prevent listener from responding + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + + if ( eraserMode != 0 ) { + } else { + } + // TODO finish implementation + + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + } +} + static void sp_arctb_open_state_changed( EgeSelectOneAction *act, GObject *tbl ) { SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" ); @@ -3864,7 +4475,7 @@ static void sp_arctb_open_state_changed( EgeSelectOneAction *act, GObject *tbl ) if (SP_IS_ARC((SPItem *) items->data)) { Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data); repr->setAttribute("sodipodi:open", "true"); - SP_OBJECT((SPItem *) items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT); + SP_OBJECT((SPItem *) items->data)->updateRepr(); modmade = true; } } @@ -3876,7 +4487,7 @@ static void sp_arctb_open_state_changed( EgeSelectOneAction *act, GObject *tbl ) if (SP_IS_ARC((SPItem *) items->data)) { Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data); repr->setAttribute("sodipodi:open", NULL); - SP_OBJECT((SPItem *) items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT); + SP_OBJECT((SPItem *) items->data)->updateRepr(); modmade = true; } } @@ -3995,6 +4606,7 @@ static void sp_arc_toolbox_selection_changed(Inkscape::Selection *selection, GOb static void sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) { EgeAdjustmentAction* eact = 0; + Inkscape::IconSize secondarySize = prefToSize("toolbox", "secondary", 1); { @@ -4057,6 +4669,7 @@ static void sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE ); g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL ); ege_select_one_action_set_icon_column( act, 2 ); + ege_select_one_action_set_icon_size( act, secondarySize ); ege_select_one_action_set_tooltip_column( act, 1 ); gchar const *openstr = prefs_get_string_attribute("tools.shapes.arc", "open"); @@ -4071,7 +4684,7 @@ static void sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, _("Make whole"), _("Make the shape a whole ellipse, not arc or segment"), "reset_circle", - Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + secondarySize ); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_arctb_defaults), holder ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); gtk_action_set_sensitive( GTK_ACTION(inky), TRUE ); @@ -4170,6 +4783,61 @@ static void sp_dropper_toolbox_prep(SPDesktop */*desktop*/, GtkActionGroup* main } + +static void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) +{ + { + /* Width */ + gchar const* labels[] = {_("(hairline)"), 0, 0, 0, _("(default)"), 0, 0, 0, 0, _("(broad stroke)")}; + gdouble values[] = {1, 3, 5, 10, 15, 20, 30, 50, 75, 100}; + EgeAdjustmentAction *eact = create_adjustment_action( "EraserWidthAction", + _("Pen Width"), _("Width:"), + _("The width of the eraser pen (relative to the visible canvas area)"), + "tools.eraser", "width", 15, + GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-eraser", + 1, 100, 1.0, 0.0, + labels, values, G_N_ELEMENTS(labels), + sp_ddc_width_value_changed, 0.01, 0, 100 ); + ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } + + { + GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); + + GtkTreeIter iter; + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, + 0, _("Delete"), + 1, _("Delete objects touched by the eraser"), + 2, "delete_object", + -1 ); + + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, + 0, _("Cut"), + 1, _("Cut out from objects"), + 2, "difference", + -1 ); + + EgeSelectOneAction* act = ege_select_one_action_new( "EraserModeAction", (""), (""), NULL, GTK_TREE_MODEL(model) ); + gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); + g_object_set_data( holder, "eraser_mode_action", act ); + + ege_select_one_action_set_appearance( act, "full" ); + ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE ); + g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL ); + ege_select_one_action_set_icon_column( act, 2 ); + ege_select_one_action_set_tooltip_column( act, 1 ); + + gint eraserMode = (prefs_get_int_attribute("tools.eraser", "mode", 0) != 0) ? 1 : 0; + ege_select_one_action_set_active( act, eraserMode ); + g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_erasertb_mode_changed), holder ); + } + +} + //######################## //## Text Toolbox ## //######################## @@ -4215,8 +4883,7 @@ sp_text_toolbox_selection_changed (Inkscape::Selection */*selection*/, GObject * SPStyle *query = sp_style_new (SP_ACTIVE_DOCUMENT); - int result_fontspec = - sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONT_SPECIFICATION); +// int result_fontspec = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONT_SPECIFICATION); int result_family = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTFAMILY); @@ -4230,18 +4897,24 @@ sp_text_toolbox_selection_changed (Inkscape::Selection */*selection*/, GObject * gtk_widget_hide (GTK_WIDGET (g_object_get_data (G_OBJECT(tbl), "warning-image"))); // If querying returned nothing, read the style from the text tool prefs (default style for new texts) - if (result_family == QUERY_STYLE_NOTHING || result_style == QUERY_STYLE_NOTHING || result_numbers == QUERY_STYLE_NOTHING) - { + if (result_family == QUERY_STYLE_NOTHING || result_style == QUERY_STYLE_NOTHING || result_numbers == QUERY_STYLE_NOTHING) { + // there are no texts in selection, read from prefs + Inkscape::XML::Node *repr = inkscape_get_repr (INKSCAPE, "tools.text"); - - if (repr) - { + if (repr) { sp_style_read_from_repr (query, repr); - } - else - { + if (g_object_get_data(tbl, "text_style_from_prefs")) { + // do not reset the toolbar style from prefs if we already did it last time + sp_style_unref(query); + return; + } + g_object_set_data(tbl, "text_style_from_prefs", GINT_TO_POINTER(TRUE)); + } else { + sp_style_unref(query); return; } + } else { + g_object_set_data(tbl, "text_style_from_prefs", GINT_TO_POINTER(FALSE)); } if (query->text) @@ -4271,6 +4944,7 @@ sp_text_toolbox_selection_changed (Inkscape::Selection */*selection*/, GObject * path = Inkscape::FontLister::get_instance()->get_row_for_font (familyName); } catch (...) { g_warning("Family name %s does not have an entry in the font lister.", familyName.c_str()); + sp_style_unref(query); return; } @@ -4286,12 +4960,14 @@ sp_text_toolbox_selection_changed (Inkscape::Selection */*selection*/, GObject * } //Size - GtkWidget *cbox = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "combo-box-size")); - char *str = g_strdup_printf ("%.5g", query->font_size.computed); - g_object_set_data (tbl, "size-block", gpointer(1)); - gtk_entry_set_text (GTK_ENTRY(GTK_BIN (cbox)->child), str); - g_object_set_data (tbl, "size-block", gpointer(0)); - free (str); + { + GtkWidget *cbox = GTK_WIDGET(g_object_get_data(G_OBJECT(tbl), "combo-box-size")); + gchar *const str = g_strdup_printf("%.5g", query->font_size.computed); + g_object_set_data(tbl, "size-block", gpointer(1)); + gtk_entry_set_text(GTK_ENTRY(GTK_BIN(cbox)->child), str); + g_object_set_data(tbl, "size-block", gpointer(0)); + g_free(str); + } //Anchor if (query->text_align.computed == SP_CSS_TEXT_ALIGN_JUSTIFY) @@ -4423,7 +5099,7 @@ sp_text_toolbox_family_changed (GtkTreeSelection *selection, int result_fontspec = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONT_SPECIFICATION); - font_instance * fontFromStyle = font_factory::Default()->FaceFromStyle(query); + //font_instance * fontFromStyle = font_factory::Default()->FaceFromStyle(query); SPCSSAttr *css = sp_repr_css_attr_new (); @@ -4486,7 +5162,7 @@ sp_text_toolbox_family_changed (GtkTreeSelection *selection, sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT, _("Text: Change font family")); sp_repr_css_attr_unref (css); - free (family); + g_free(family); gtk_widget_hide (GTK_WIDGET (g_object_get_data (G_OBJECT(tbl), "warning-image"))); gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); @@ -4592,14 +5268,9 @@ sp_text_toolbox_style_toggled (GtkToggleButton *button, int result_fontspec = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONT_SPECIFICATION); - int result_family = - sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTFAMILY); - - int result_style = - sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTSTYLE); - - int result_numbers = - sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + //int result_family = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTFAMILY); + //int result_style = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTSTYLE); + //int result_numbers = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS); Glib::ustring fontSpec = query->text->font_specification.set ? query->text->font_specification.value : ""; Glib::ustring newFontSpec = ""; @@ -4765,14 +5436,17 @@ sp_text_toolbox_size_changed (GtkComboBox *cbox, if (gtk_combo_box_get_active (cbox) < 0 && !g_object_get_data (tbl, "enter-pressed")) return; - gchar *endptr; gdouble value = -1; - char *text = gtk_combo_box_get_active_text (cbox); - if (text) { - value = g_strtod (text, &endptr); - if (endptr == text) // conversion failed, non-numeric input - value = -1; - free (text); + { + gchar *endptr; + gchar *const text = gtk_combo_box_get_active_text(cbox); + if (text) { + value = g_strtod(text, &endptr); + if (endptr == text) { // Conversion failed, non-numeric input. + value = -1; + } + g_free(text); + } } if (value <= 0) { return; // could not parse value @@ -4925,24 +5599,21 @@ cell_data_func (GtkTreeViewColumn */*column*/, GtkTreeIter *iter, gpointer /*data*/) { - char *family, - *family_escaped, - *sample_escaped; + gchar *family; + gtk_tree_model_get(tree_model, iter, 0, &family, -1); + gchar *const family_escaped = g_markup_escape_text(family, -1); - static const char *sample = _("AaBbCcIiPpQq12369$\342\202\254\302\242?.;/()"); - - gtk_tree_model_get (tree_model, iter, 0, &family, -1); - - family_escaped = g_markup_escape_text (family, -1); - sample_escaped = g_markup_escape_text (sample, -1); + static char const *const sample = _("AaBbCcIiPpQq12369$\342\202\254\302\242?.;/()"); + gchar *const sample_escaped = g_markup_escape_text(sample, -1); std::stringstream markup; - markup << family_escaped << " " << sample_escaped << ""; + markup << family_escaped << " " << sample_escaped << ""; g_object_set (G_OBJECT (cell), "markup", markup.str().c_str(), NULL); - free (family); - free (family_escaped); - free (sample_escaped); + g_free(family); + g_free(family_escaped); + g_free(sample_escaped); } static void delete_completion(GObject */*obj*/, GtkWidget *entry) { @@ -4956,7 +5627,8 @@ static void delete_completion(GObject */*obj*/, GtkWidget *entry) { GtkWidget* sp_text_toolbox_new (SPDesktop *desktop) { - GtkWidget *tbl = gtk_hbox_new (FALSE, 0); + GtkToolbar *tbl = GTK_TOOLBAR(gtk_toolbar_new()); + GtkIconSize secondarySize = static_cast(prefToSize("toolbox", "secondary", 1)); gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas); gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop); @@ -4979,14 +5651,13 @@ sp_text_toolbox_new (SPDesktop *desktop) g_object_set (G_OBJECT(completion), "inline-completion", TRUE, "popup-completion", TRUE, NULL); gtk_entry_set_completion (GTK_ENTRY(entry), completion); gtk_object_set_data(GTK_OBJECT(entry), "completion", completion); - aux_toolbox_space (tbl, 1); - gtk_box_pack_start (GTK_BOX (tbl), entry, FALSE, FALSE, 0); + gtk_toolbar_append_widget( tbl, entry, "", "" ); g_signal_connect(G_OBJECT(tbl), "destroy", G_CALLBACK(delete_completion), entry); //Button GtkWidget *button = gtk_button_new (); gtk_container_add (GTK_CONTAINER (button), gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE)); - gtk_box_pack_start (GTK_BOX (tbl), button, FALSE, FALSE, 0); + gtk_toolbar_append_widget( tbl, button, "", ""); //Popdown GtkWidget *sw = gtk_scrolled_window_new (NULL, NULL); @@ -5030,11 +5701,10 @@ sp_text_toolbox_new (SPDesktop *desktop) g_object_set_data (G_OBJECT (tbl), "family-tree-selection", tselection); g_object_set_data (G_OBJECT (tbl), "family-tree-view", treeview); - GtkWidget *image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_SMALL_TOOLBAR); - aux_toolbox_space (tbl, 1); + GtkWidget *image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, secondarySize); GtkWidget *box = gtk_event_box_new (); gtk_container_add (GTK_CONTAINER (box), image); - gtk_box_pack_start (GTK_BOX (tbl), box, FALSE, FALSE, 4); + gtk_toolbar_append_widget( tbl, box, "", ""); g_object_set_data (G_OBJECT (tbl), "warning-image", box); GtkTooltips *tooltips = gtk_tooltips_new (); gtk_tooltips_set_tip (tooltips, box, _("This font is currently not installed on your system. Inkscape will use the default font instead."), ""); @@ -5042,26 +5712,23 @@ sp_text_toolbox_new (SPDesktop *desktop) g_signal_connect_swapped (G_OBJECT (tbl), "show", G_CALLBACK (gtk_widget_hide), box); ////////////Size - const char *sizes[] = { + gchar const *const sizes[] = { "4", "6", "8", "9", "10", "11", "12", "13", "14", "16", "18", "20", "22", "24", "28", "32", "36", "40", "48", "56", "64", "72", "144" }; GtkWidget *cbox = gtk_combo_box_entry_new_text (); - for (unsigned int n = 0; n < G_N_ELEMENTS (sizes); gtk_combo_box_append_text (GTK_COMBO_BOX(cbox), sizes[n++])); + for (unsigned int i = 0; i < G_N_ELEMENTS(sizes); ++i) { + gtk_combo_box_append_text(GTK_COMBO_BOX(cbox), sizes[i]); + } gtk_widget_set_size_request (cbox, 80, -1); - aux_toolbox_space (tbl, 1); - gtk_box_pack_start (GTK_BOX (tbl), cbox, FALSE, FALSE, 0); + gtk_toolbar_append_widget( tbl, cbox, "", ""); g_object_set_data (G_OBJECT (tbl), "combo-box-size", cbox); g_signal_connect (G_OBJECT (cbox), "changed", G_CALLBACK (sp_text_toolbox_size_changed), tbl); gtk_signal_connect(GTK_OBJECT(gtk_bin_get_child(GTK_BIN(cbox))), "key-press-event", GTK_SIGNAL_FUNC(sp_text_toolbox_size_keypress), tbl); gtk_signal_connect(GTK_OBJECT(gtk_bin_get_child(GTK_BIN(cbox))), "focus-out-event", GTK_SIGNAL_FUNC(sp_text_toolbox_size_focusout), tbl); - //spacer - aux_toolbox_space (tbl, 4); - gtk_box_pack_start (GTK_BOX (tbl), gtk_vseparator_new (), FALSE, FALSE, 4); - ////////////Text anchor GtkWidget *group = gtk_radio_button_new (NULL); GtkWidget *row = gtk_hbox_new (FALSE, 4); @@ -5070,7 +5737,7 @@ sp_text_toolbox_new (SPDesktop *desktop) // left GtkWidget *rbutton = group; gtk_button_set_relief (GTK_BUTTON (rbutton), GTK_RELIEF_NONE); - gtk_container_add (GTK_CONTAINER (rbutton), gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_LEFT, GTK_ICON_SIZE_SMALL_TOOLBAR)); + gtk_container_add (GTK_CONTAINER (rbutton), gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_LEFT, secondarySize)); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (rbutton), FALSE); gtk_box_pack_start (GTK_BOX (row), rbutton, FALSE, FALSE, 0); @@ -5081,7 +5748,7 @@ sp_text_toolbox_new (SPDesktop *desktop) // center 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), gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_CENTER, GTK_ICON_SIZE_SMALL_TOOLBAR)); + gtk_container_add (GTK_CONTAINER (rbutton), gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_CENTER, secondarySize)); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (rbutton), FALSE); gtk_box_pack_start (GTK_BOX (row), rbutton, FALSE, FALSE, 0); @@ -5092,7 +5759,7 @@ sp_text_toolbox_new (SPDesktop *desktop) // right 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), gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_RIGHT, GTK_ICON_SIZE_SMALL_TOOLBAR)); + gtk_container_add (GTK_CONTAINER (rbutton), gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_RIGHT, secondarySize)); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (rbutton), FALSE); gtk_box_pack_start (GTK_BOX (row), rbutton, FALSE, FALSE, 0); @@ -5103,7 +5770,7 @@ sp_text_toolbox_new (SPDesktop *desktop) // fill 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), gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_FILL, GTK_ICON_SIZE_SMALL_TOOLBAR)); + gtk_container_add (GTK_CONTAINER (rbutton), gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_FILL, secondarySize)); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (rbutton), FALSE); gtk_box_pack_start (GTK_BOX (row), rbutton, FALSE, FALSE, 0); @@ -5111,11 +5778,10 @@ sp_text_toolbox_new (SPDesktop *desktop) g_signal_connect (G_OBJECT (rbutton), "toggled", G_CALLBACK (sp_text_toolbox_anchoring_toggled), gpointer(3)); gtk_tooltips_set_tip(tt, rbutton, _("Justify"), NULL); - aux_toolbox_space (tbl, 1); - gtk_box_pack_start (GTK_BOX (tbl), row, FALSE, FALSE, 4); + gtk_toolbar_append_widget( tbl, row, "", ""); //spacer - gtk_box_pack_start (GTK_BOX (tbl), gtk_vseparator_new (), FALSE, FALSE, 4); + gtk_toolbar_append_widget( tbl, gtk_vseparator_new(), "", "" ); ////////////Text style row = gtk_hbox_new (FALSE, 4); @@ -5123,7 +5789,7 @@ sp_text_toolbox_new (SPDesktop *desktop) // bold rbutton = gtk_toggle_button_new (); gtk_button_set_relief (GTK_BUTTON (rbutton), GTK_RELIEF_NONE); - gtk_container_add (GTK_CONTAINER (rbutton), gtk_image_new_from_stock (GTK_STOCK_BOLD, GTK_ICON_SIZE_SMALL_TOOLBAR)); + gtk_container_add (GTK_CONTAINER (rbutton), gtk_image_new_from_stock (GTK_STOCK_BOLD, secondarySize)); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (rbutton), FALSE); gtk_tooltips_set_tip(tt, rbutton, _("Bold"), NULL); @@ -5134,7 +5800,7 @@ sp_text_toolbox_new (SPDesktop *desktop) // italic rbutton = gtk_toggle_button_new (); gtk_button_set_relief (GTK_BUTTON (rbutton), GTK_RELIEF_NONE); - gtk_container_add (GTK_CONTAINER (rbutton), gtk_image_new_from_stock (GTK_STOCK_ITALIC, GTK_ICON_SIZE_SMALL_TOOLBAR)); + gtk_container_add (GTK_CONTAINER (rbutton), gtk_image_new_from_stock (GTK_STOCK_ITALIC, secondarySize)); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (rbutton), FALSE); gtk_tooltips_set_tip(tt, rbutton, _("Italic"), NULL); @@ -5142,11 +5808,10 @@ sp_text_toolbox_new (SPDesktop *desktop) g_object_set_data (G_OBJECT (tbl), "style-italic", rbutton); g_signal_connect (G_OBJECT (rbutton), "toggled", G_CALLBACK (sp_text_toolbox_style_toggled), gpointer (1)); - aux_toolbox_space (tbl, 1); - gtk_box_pack_start (GTK_BOX (tbl), row, FALSE, FALSE, 4); + gtk_toolbar_append_widget( tbl, row, "", ""); //spacer - gtk_box_pack_start (GTK_BOX (tbl), gtk_vseparator_new (), FALSE, FALSE, 4); + gtk_toolbar_append_widget( tbl, gtk_vseparator_new(), "", "" ); ////////////Text orientation group = gtk_radio_button_new (NULL); @@ -5156,7 +5821,8 @@ sp_text_toolbox_new (SPDesktop *desktop) // horizontal rbutton = group; gtk_button_set_relief (GTK_BUTTON (rbutton), GTK_RELIEF_NONE); - gtk_container_add (GTK_CONTAINER (rbutton), sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_WRITING_MODE_LR)); + gtk_container_add (GTK_CONTAINER (rbutton), + sp_icon_new (static_cast(secondarySize), INKSCAPE_STOCK_WRITING_MODE_LR)); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (rbutton), FALSE); gtk_tooltips_set_tip(tt, rbutton, _("Horizontal text"), NULL); @@ -5167,14 +5833,15 @@ sp_text_toolbox_new (SPDesktop *desktop) // vertical 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 (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_WRITING_MODE_TB)); + gtk_container_add (GTK_CONTAINER (rbutton), + sp_icon_new (static_cast(secondarySize), INKSCAPE_STOCK_WRITING_MODE_TB)); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (rbutton), FALSE); gtk_tooltips_set_tip(tt, rbutton, _("Vertical text"), NULL); gtk_box_pack_start (GTK_BOX (row), rbutton, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (tbl), "orientation-vertical", rbutton); g_signal_connect (G_OBJECT (rbutton), "toggled", G_CALLBACK (sp_text_toolbox_orientation_toggled), gpointer (1)); - gtk_box_pack_start (GTK_BOX (tbl), row, FALSE, FALSE, 4); + gtk_toolbar_append_widget( tbl, row, "", "" ); //watch selection @@ -5198,9 +5865,9 @@ sp_text_toolbox_new (SPDesktop *desktop) Inkscape::ConnectionPool::connect_destroy (G_OBJECT (tbl), pool); - gtk_widget_show_all (tbl); - return tbl; + gtk_widget_show_all( GTK_WIDGET(tbl) ); + return GTK_WIDGET(tbl); } // end of sp_text_toolbox_new() }// namespace @@ -5352,12 +6019,14 @@ static Inkscape::XML::NodeEventVector connector_tb_repr_events = { static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder ) { + Inkscape::IconSize secondarySize = prefToSize("toolbox", "secondary", 1); + { InkAction* inky = ink_action_new( "ConnectorAvoidAction", _("Avoid"), _("Make connectors avoid selected objects"), "connector_avoid", - Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + 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) ); } @@ -5367,7 +6036,7 @@ static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainA _("Ignore"), _("Make connectors ignore selected objects"), "connector_ignore", - Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + 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) ); } @@ -5391,7 +6060,7 @@ static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainA _("Graph"), _("Nicely arrange selected connector network"), "graph_layout", - Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + 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) ); } @@ -5486,7 +6155,7 @@ static void paintbucket_offset_changed(GtkAdjustment *adj, GObject *tbl) prefs_set_string_attribute("tools.paintbucket", "offsetunits", sp_unit_get_abbreviation(unit)); } -static void paintbucket_defaults(GtkWidget *, GObject *dataKludge) +static void paintbucket_defaults (GtkWidget *, GObject *tbl) { // FIXME: make defaults settable via Inkscape Options struct KeyValue { @@ -5499,15 +6168,15 @@ static void paintbucket_defaults(GtkWidget *, GObject *dataKludge) for (unsigned i = 0; i < G_N_ELEMENTS(key_values); ++i) { KeyValue const &kv = key_values[i]; - GtkAdjustment* adj = static_cast(g_object_get_data(dataKludge, kv.key)); + GtkAdjustment* adj = static_cast(g_object_get_data(tbl, kv.key)); if ( adj ) { gtk_adjustment_set_value(adj, kv.value); } } - EgeSelectOneAction* channels_action = EGE_SELECT_ONE_ACTION( g_object_get_data( dataKludge, "channels_action" ) ); + EgeSelectOneAction* channels_action = EGE_SELECT_ONE_ACTION( g_object_get_data (tbl, "channels_action" ) ); ege_select_one_action_set_active( channels_action, FLOOD_CHANNELS_RGB ); - EgeSelectOneAction* autogap_action = EGE_SELECT_ONE_ACTION( g_object_get_data( dataKludge, "autogap_action" ) ); + EgeSelectOneAction* autogap_action = EGE_SELECT_ONE_ACTION( g_object_get_data (tbl, "autogap_action" ) ); ege_select_one_action_set_active( autogap_action, 0 ); } @@ -5545,10 +6214,11 @@ static void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* main _("Fill Threshold"), _("Threshold:"), _("The maximum allowed difference between the clicked pixel and the neighboring pixels to be counted in the fill"), "tools.paintbucket", "threshold", 5, GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, - "inkscape:paintbucket-threshold", 0, 100.0, 1.0, 10.0, + "inkscape:paintbucket-threshold", 0, 100.0, 1.0, 0.0, 0, 0, 0, paintbucket_threshold_changed, 1, 0 ); + ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); }