X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fwidgets%2Ftoolbox.cpp;h=87b9595322cf3c3fd1386491668fa185461be2c4;hb=4e93dc3d5909be7bce5445a5939a0b56f32197c0;hp=d4282bd663ac3afb529f79e09374938b9b348f13;hpb=90c46394788ffd7d97ab36d1848876ccd1568789;p=inkscape.git diff --git a/src/widgets/toolbox.cpp b/src/widgets/toolbox.cpp index d4282bd66..87b959532 100644 --- a/src/widgets/toolbox.cpp +++ b/src/widgets/toolbox.cpp @@ -15,10 +15,11 @@ * John Cliff * David Turner * Josh Andler +* Jon A. Cruz * * Copyright (C) 2004 David Turner * Copyright (C) 2003 MenTaLguY -* Copyright (C) 1999-2005 authors +* Copyright (C) 1999-2006 authors * Copyright (C) 2001-2002 Ximian, Inc. * * Released under GNU GPL, read the file 'COPYING' for more information @@ -82,6 +83,11 @@ #include "toolbox.h" +#include "flood-context.h" + +#include "ink-action.h" +#include "ege-adjustment-action.h" + typedef void (*SetupFunction)(GtkWidget *toolbox, SPDesktop *desktop); typedef void (*UpdateFunction)(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox); @@ -97,6 +103,7 @@ static GtkWidget *sp_calligraphy_toolbox_new(SPDesktop *desktop); static GtkWidget *sp_dropper_toolbox_new(SPDesktop *desktop); static GtkWidget *sp_empty_toolbox_new(SPDesktop *desktop); static GtkWidget *sp_connector_toolbox_new(SPDesktop *desktop); +static GtkWidget *sp_paintbucket_toolbox_new(SPDesktop *desktop); namespace { GtkWidget *sp_text_toolbox_new (SPDesktop *desktop); } @@ -117,6 +124,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 }, + { "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 }, { "SPGradientContext", "gradient_tool", SP_VERB_CONTEXT_GRADIENT, SP_VERB_CONTEXT_GRADIENT_PREFS }, @@ -143,6 +151,7 @@ static struct { { "SPDropperContext", "dropper_toolbox", sp_dropper_toolbox_new }, { "SPGradientContext", "gradient_toolbox", sp_gradient_toolbox_new }, { "SPConnectorContext", "connector_toolbox", sp_connector_toolbox_new }, + { "SPFloodContext", "paintbucket_toolbox", sp_paintbucket_toolbox_new }, { NULL, NULL, NULL } }; @@ -811,16 +820,60 @@ sp_tb_spinbutton( return hb; } +static EgeAdjustmentAction * create_adjustment_action( gchar const *name, + gchar const *label, gchar const *tooltip, + gchar const *path, gchar const *data, gdouble def, + GtkWidget *focusTarget, + GtkWidget *us, + GtkWidget *dataKludge, + gboolean altx, gchar const *altx_mark, + gdouble lower, gdouble upper, gdouble step, gdouble page, + gchar const** descrLabels, gdouble const* descrValues, guint descrCount, + void (*callback)(GtkAdjustment *, GtkWidget *), + gdouble climb = 0.1, guint digits = 3, double factor = 1.0 ) +{ + GtkAdjustment* adj = GTK_ADJUSTMENT( gtk_adjustment_new( prefs_get_double_attribute(path, data, def) * factor, + lower, upper, step, page, page ) ); + if (us) { + sp_unit_selector_add_adjustment( SP_UNIT_SELECTOR(us), adj ); + } + + gtk_signal_connect( GTK_OBJECT(adj), "value-changed", GTK_SIGNAL_FUNC(callback), dataKludge ); + + EgeAdjustmentAction* act = ege_adjustment_action_new( adj, name, label, tooltip, 0, climb, digits ); + + if ( (descrCount > 0) && descrLabels && descrValues ) { + ege_adjustment_action_set_descriptions( act, descrLabels, descrValues, descrCount ); + } + + if ( focusTarget ) { + ege_adjustment_action_set_focuswidget( act, focusTarget ); + } + + if ( altx && altx_mark ) { + g_object_set( G_OBJECT(act), "self-id", altx_mark, NULL ); + } + + if ( dataKludge ) { + gtk_object_set_data( GTK_OBJECT(dataKludge), data, adj ); + } + + // Using a cast just to make sure we pass in the right kind of function pointer + g_object_set( G_OBJECT(act), "tool-post", static_cast(sp_set_font_size_smaller), NULL ); + + return act; +} + + #define MODE_LABEL_WIDTH 70 //######################## //## Star ## //######################## -static void -sp_stb_magnitude_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void sp_stb_magnitude_value_changed( GtkAdjustment *adj, GtkWidget *dataKludge ) { - SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop"); + SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(dataKludge), "desktop"); if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) { // do not remember prefs if this call is initiated by an undo change, because undoing object @@ -829,12 +882,12 @@ sp_stb_magnitude_value_changed(GtkAdjustment *adj, GtkWidget *tbl) } // quit if run by the attr_changed listener - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { + if (g_object_get_data(G_OBJECT(dataKludge), "freeze")) { return; } // in turn, prevent listener from responding - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE)); + g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(TRUE)); bool modmade = false; @@ -852,29 +905,26 @@ sp_stb_magnitude_value_changed(GtkAdjustment *adj, GtkWidget *tbl) } } if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR, - /* TODO: annotate */ "toolbox.cpp:854"); - - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); + _("Star: Change number of corners")); - spinbutton_defocus(GTK_OBJECT(tbl)); + g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(FALSE)); } -static void -sp_stb_proportion_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void sp_stb_proportion_value_changed( GtkAdjustment *adj, GtkWidget *dataKludge ) { - SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop"); + SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(dataKludge), "desktop"); if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) { prefs_set_double_attribute("tools.shapes.star", "proportion", adj->value); } // quit if run by the attr_changed listener - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { + if (g_object_get_data(G_OBJECT(dataKludge), "freeze")) { return; } // in turn, prevent listener from responding - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE)); + g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(TRUE)); bool modmade = false; Inkscape::Selection *selection = sp_desktop_selection(desktop); @@ -897,83 +947,67 @@ sp_stb_proportion_value_changed(GtkAdjustment *adj, GtkWidget *tbl) } if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR, - /* TODO: annotate */ "toolbox.cpp:899"); + _("Star: Change spoke ratio")); - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); - - spinbutton_defocus(GTK_OBJECT(tbl)); + g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(FALSE)); } -static void -sp_stb_sides_flat_state_changed(GtkWidget *widget, GtkObject *tbl) +static void sp_stb_sides_flat_state_changed( GtkToggleAction *act, GtkObject *dataKludge ) { - SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop"); + SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(dataKludge), "desktop"); + bool flat = gtk_toggle_action_get_active(act); if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) { - if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) { - prefs_set_string_attribute("tools.shapes.star", "isflatsided", "true"); - } else { - prefs_set_string_attribute("tools.shapes.star", "isflatsided", "false"); - } + prefs_set_string_attribute( "tools.shapes.star", "isflatsided", + flat ? "true" : "false" ); } // quit if run by the attr_changed listener - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { + if (g_object_get_data(G_OBJECT(dataKludge), "freeze")) { return; } // in turn, prevent listener from responding - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE)); + g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(TRUE)); Inkscape::Selection *selection = sp_desktop_selection(desktop); GSList const *items = selection->itemList(); - GtkWidget *prop_widget = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "prop_widget"); + GtkAction* prop_action = GTK_ACTION( g_object_get_data(G_OBJECT(dataKludge), "prop_action") ); bool modmade = false; - if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) { - gtk_widget_set_sensitive(GTK_WIDGET(prop_widget), FALSE); - for (; items != NULL; items = items->next) { - if (SP_IS_STAR((SPItem *) items->data)) { - Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data); - repr->setAttribute("inkscape:flatsided", "true"); - SP_OBJECT((SPItem *) items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT); - modmade = true; - } - } - } else { - gtk_widget_set_sensitive(GTK_WIDGET(prop_widget), TRUE); - for (; items != NULL; items = items->next) { - if (SP_IS_STAR((SPItem *) items->data)) { - Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data); - repr->setAttribute("inkscape:flatsided", "false"); - SP_OBJECT(items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT); - modmade = true; - } + + gtk_action_set_sensitive( prop_action, !flat ); + for (; items != NULL; items = items->next) { + 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); + modmade = true; } } - if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR, - /* TODO: annotate */ "toolbox.cpp:953"); - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); + if (modmade) { + sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR, + flat ? _("Make polygon") : _("Make star")); + } - spinbutton_defocus(GTK_OBJECT(tbl)); + g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(FALSE)); } -static void -sp_stb_rounded_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void sp_stb_rounded_value_changed( GtkAdjustment *adj, GtkWidget *dataKludge ) { - SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop"); + SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(dataKludge), "desktop"); if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) { prefs_set_double_attribute("tools.shapes.star", "rounded", (gdouble) adj->value); } // quit if run by the attr_changed listener - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { + if (g_object_get_data(G_OBJECT(dataKludge), "freeze")) { return; } // in turn, prevent listener from responding - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE)); + g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(TRUE)); bool modmade = false; @@ -988,30 +1022,26 @@ sp_stb_rounded_value_changed(GtkAdjustment *adj, GtkWidget *tbl) } } if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR, - /* TODO: annotate */ "toolbox.cpp:990"); + _("Star: Change rounding")); - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); - - spinbutton_defocus(GTK_OBJECT(tbl)); + g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(FALSE)); } - -static void -sp_stb_randomized_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void sp_stb_randomized_value_changed( GtkAdjustment *adj, GtkWidget *dataKludge ) { - SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop"); + SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(dataKludge), "desktop"); if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) { prefs_set_double_attribute("tools.shapes.star", "randomized", (gdouble) adj->value); } // quit if run by the attr_changed listener - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { + if (g_object_get_data(G_OBJECT(dataKludge), "freeze")) { return; } // in turn, prevent listener from responding - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE)); + g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(TRUE)); bool modmade = false; @@ -1026,11 +1056,9 @@ sp_stb_randomized_value_changed(GtkAdjustment *adj, GtkWidget *tbl) } } if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR, - /* TODO: annotate */ "toolbox.cpp:1028"); - - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); + _("Star: Change randomization")); - spinbutton_defocus(GTK_OBJECT(tbl)); + g_object_set_data(G_OBJECT(dataKludge), "freeze", GINT_TO_POINTER(FALSE)); } @@ -1048,24 +1076,24 @@ static void star_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const *n // in turn, prevent callbacks from responding g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE)); - GtkAdjustment *adj; + GtkAdjustment *adj = 0; if (!strcmp(name, "inkscape:randomized")) { - adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "randomized"); + adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(tbl), "randomized") ); gtk_adjustment_set_value(adj, sp_repr_get_double_attribute(repr, "inkscape:randomized", 0.0)); } else if (!strcmp(name, "inkscape:rounded")) { - adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "rounded"); + adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(tbl), "rounded") ); gtk_adjustment_set_value(adj, sp_repr_get_double_attribute(repr, "inkscape:rounded", 0.0)); } else if (!strcmp(name, "inkscape:flatsided")) { - GtkWidget *fscb = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "flat_checkbox"); - GtkWidget *prop_widget = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "prop_widget"); + GtkToggleAction* flat_action = GTK_TOGGLE_ACTION( g_object_get_data( G_OBJECT(tbl), "flat_action" ) ); + GtkAction* prop_action = GTK_ACTION( g_object_get_data(G_OBJECT(tbl), "prop_action") ); char const *flatsides = repr->attribute("inkscape:flatsided"); if (flatsides && !strcmp(flatsides,"false" )) { - gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(fscb), FALSE); - gtk_widget_set_sensitive(GTK_WIDGET(prop_widget), TRUE); + gtk_toggle_action_set_active( flat_action, FALSE ); + gtk_action_set_sensitive( prop_action, TRUE ); } else { - gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(fscb), TRUE); - gtk_widget_set_sensitive(GTK_WIDGET(prop_widget), FALSE); + gtk_toggle_action_set_active( flat_action, TRUE ); + gtk_action_set_sensitive( prop_action, FALSE ); } } else if (!strcmp(name, "sodipodi:r1") || !strcmp(name, "sodipodi:r2")) { adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "proportion"); @@ -1115,12 +1143,12 @@ sp_star_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl } } - GtkWidget *l = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(tbl), "mode_label")); + //GtkWidget *l = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(tbl), "mode_label")); if (n_selected == 0) { - gtk_label_set_markup(GTK_LABEL(l), _("New:")); + //gtk_label_set_markup(GTK_LABEL(l), _("New:")); } else if (n_selected == 1) { - gtk_label_set_markup(GTK_LABEL(l), _("Change:")); + //gtk_label_set_markup(GTK_LABEL(l), _("Change:")); oldrepr = (Inkscape::XML::Node *) gtk_object_get_data(GTK_OBJECT(tbl), "repr"); if (oldrepr) { // remove old listener @@ -1139,18 +1167,17 @@ sp_star_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl } else { // FIXME: implement averaging of all parameters for multiple selected stars //gtk_label_set_markup(GTK_LABEL(l), _("Average:")); - gtk_label_set_markup(GTK_LABEL(l), _("Change:")); + //gtk_label_set_markup(GTK_LABEL(l), _("Change:")); } } -static void -sp_stb_defaults(GtkWidget *widget, GtkWidget *tbl) +static void sp_stb_defaults( GtkWidget *widget, GtkWidget *dataKludge ) { // FIXME: in this and all other _default functions, set some flag telling the value_changed // callbacks to lump all the changes for all selected objects in one undo step - GtkAdjustment *adj; + GtkAdjustment *adj = 0; // fixme: make settable in prefs! gint mag = 5; @@ -1159,28 +1186,27 @@ sp_stb_defaults(GtkWidget *widget, GtkWidget *tbl) gdouble randomized = 0; gdouble rounded = 0; - GtkWidget *fscb = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "flat_checkbox"); - gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(fscb), flat); - GtkWidget *sb2 = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "prop_widget"); - gtk_widget_set_sensitive(GTK_WIDGET(sb2), !flat); + GtkToggleAction* flat_action = GTK_TOGGLE_ACTION( g_object_get_data( G_OBJECT(dataKludge), "flat_action" ) ); + gtk_toggle_action_set_active( flat_action, flat ); + + GtkAction* sb2 = GTK_ACTION( g_object_get_data(G_OBJECT(dataKludge), "prop_action") ); + gtk_action_set_sensitive( sb2, !flat ); - adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "magnitude"); + adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(dataKludge), "magnitude") ); gtk_adjustment_set_value(adj, mag); gtk_adjustment_value_changed(adj); - adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "proportion"); + adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(dataKludge), "proportion") ); gtk_adjustment_set_value(adj, prop); gtk_adjustment_value_changed(adj); - adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "rounded"); + adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(dataKludge), "rounded") ); gtk_adjustment_set_value(adj, rounded); gtk_adjustment_value_changed(adj); - adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "randomized"); + adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(dataKludge), "randomized") ); gtk_adjustment_set_value(adj, randomized); gtk_adjustment_value_changed(adj); - - spinbutton_defocus(GTK_OBJECT(tbl)); } @@ -1200,112 +1226,151 @@ sp_toolbox_add_label(GtkWidget *tbl, gchar const *title, bool wide) static GtkWidget * sp_star_toolbox_new(SPDesktop *desktop) { - GtkWidget *tbl = gtk_hbox_new(FALSE, 0); + GtkWidget *toolBar = 0; + GtkWidget* holder = gtk_table_new( 1, 2, FALSE ); + + gchar const * descr = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + ""; + GtkUIManager* mgr = gtk_ui_manager_new(); + GError* errVal = 0; + GtkActionGroup* mainActions = gtk_action_group_new("main"); +// sp_toolbox_add_label(tbl, _("New:")); - gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas); - gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop); - - GtkTooltips *tt = gtk_tooltips_new(); - - sp_toolbox_add_label(tbl, _("New:")); - - gchar const *flatsidedstr = NULL; - - /* Flatsided checkbox */ { - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - GtkWidget *fscb = gtk_check_button_new_with_label(_("Polygon")); - gtk_widget_set_sensitive(GTK_WIDGET(fscb), TRUE); - flatsidedstr = prefs_get_string_attribute("tools.shapes.star", "isflatsided"); - if (!flatsidedstr || (flatsidedstr && !strcmp(flatsidedstr, "false"))) - gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(fscb), FALSE); - else - gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(fscb), TRUE); - gtk_tooltips_set_tip(tt, fscb, _("Regular polygon (with one handle) instead of a star"), NULL); - gtk_widget_show(fscb); - gtk_object_set_data(GTK_OBJECT(tbl), "flat_checkbox", fscb); - gtk_container_add(GTK_CONTAINER(hb), fscb); - g_signal_connect(G_OBJECT(fscb), "toggled", GTK_SIGNAL_FUNC(sp_stb_sides_flat_state_changed ), tbl); - gtk_box_pack_start(GTK_BOX(tbl),hb, FALSE, FALSE, AUX_SPACING); - } + gtk_object_set_data(GTK_OBJECT(holder), "dtw", desktop->canvas); + gtk_object_set_data(GTK_OBJECT(holder), "desktop", desktop); - aux_toolbox_space(tbl, AUX_BETWEEN_BUTTON_GROUPS); + //EgeAdjustmentAction* calligraphy_angle = 0; + EgeAdjustmentAction* eact = 0; + gchar const *flatsidedstr = prefs_get_string_attribute( "tools.shapes.star", "isflatsided" ); - /* Magnitude */ - { - GtkWidget *hb = sp_tb_spinbutton(_("Corners:"), _("Number of corners of a polygon or star"), - "tools.shapes.star", "magnitude", 3, - NULL, tbl, TRUE, "altx-star", - 3, 1024, 1, 1, - sp_stb_magnitude_value_changed, 1, 0); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING); - } + /* Flatsided checkbox */ + { + InkToggleAction* act = ink_toggle_action_new( "FlatAction", + _("Polygon"), + _("Regular polygon (with one handle) instead of a star"), + NULL, + Inkscape::ICON_SIZE_DECORATION ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_stb_sides_flat_state_changed), holder); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.shapes.star", "isflatsided", 1 ) ); + gtk_object_set_data( GTK_OBJECT(holder), "flat_action", act ); + } - /* Spoke ratio */ - { - GtkWidget *hb = sp_tb_spinbutton(_("Spoke ratio:"), + /* Magnitude */ + //gchar const* labels[] = {_("tri (default)"), _("quad"), _("pent")}; + //gdouble values[] = {3, 4, 5}; + eact = create_adjustment_action( "MagnitudeAction", + _("Corners:"), _("Number of corners of a polygon or star"), + "tools.shapes.star", "magnitude", 3, + GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, + 3, 1024, 1, 5, + 0, 0, 0, // labels, values, G_N_ELEMENTS(labels), + sp_stb_magnitude_value_changed, + 1.0, 0 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + + /* Spoke ratio */ + //gchar const* labels2[] = {_("(left edge up)"), _("(horizontal)"), _("(default)"), _("(right edge up)")}; + //gdouble values2[] = {-90, 0, 30, 90}; + eact = create_adjustment_action( "SpokeAction", + _("Spoke ratio:"), // TRANSLATORS: Tip radius of a star is the distance from the center to the farthest handle. // Base radius is the same for the closest handle. _("Base radius to tip radius ratio"), "tools.shapes.star", "proportion", 0.5, - NULL, tbl, FALSE, NULL, + GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, 0.01, 1.0, 0.01, 0.1, - sp_stb_proportion_value_changed); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING); - g_object_set_data(G_OBJECT(tbl), "prop_widget", hb); - if (!flatsidedstr || (flatsidedstr && !strcmp(flatsidedstr, "false"))) - gtk_widget_set_sensitive(GTK_WIDGET(hb), TRUE); - else - gtk_widget_set_sensitive(GTK_WIDGET(hb), FALSE); - } + 0, 0, 0, // labels2, values2, G_N_ELEMENTS(labels2), + sp_stb_proportion_value_changed ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + g_object_set_data(G_OBJECT(holder), "prop_action", eact); - /* Roundedness */ - { - GtkWidget *hb = sp_tb_spinbutton(_("Rounded:"), _("How much rounded are the corners (0 for sharp)"), + if ( !flatsidedstr || (flatsidedstr && !strcmp(flatsidedstr, "false")) ) { + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } else { + gtk_action_set_sensitive( GTK_ACTION(eact), FALSE ); + } + + /* Roundedness */ + //gchar const* labels3[] = {_("(left edge up)"), _("(horizontal)"), _("(default)"), _("(right edge up)")}; + //gdouble values3[] = {-90, 0, 30, 90}; + eact = create_adjustment_action( "RoundednessAction", + _("Rounded:"), _("How much rounded are the corners (0 for sharp)"), "tools.shapes.star", "rounded", 0.0, - NULL, tbl, FALSE, NULL, + GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, -100.0, 100.0, 0.01, 0.1, - sp_stb_rounded_value_changed); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING); - } - - /* Randomization */ - { - GtkWidget *hb = sp_tb_spinbutton(_("Randomized:"), _("Scatter randomly the corners and angles"), + 0, 0, 0, // labels3, values3, G_N_ELEMENTS(labels3), + sp_stb_rounded_value_changed ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + + /* Randomization */ + //gchar const* labels4[] = {_("(left edge up)"), _("(horizontal)"), _("(default)"), _("(right edge up)")}; + //gdouble values4[] = {-90, 0, 30, 90}; + eact = create_adjustment_action( "RandomizationAction", + _("Randomized:"), _("Scatter randomly the corners and angles"), "tools.shapes.star", "randomized", 0.0, - NULL, tbl, FALSE, NULL, + GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, -10.0, 10.0, 0.001, 0.01, - sp_stb_randomized_value_changed, 0.1, 3); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING); + 0, 0, 0, // labels4, values4, G_N_ELEMENTS(labels4), + sp_stb_randomized_value_changed, 0.1, 3 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); } - aux_toolbox_space(tbl, AUX_SPACING); - - /* Reset */ { - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - GtkWidget *b = gtk_button_new_with_label(_("Defaults")); - gtk_tooltips_set_tip(tt, b, _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"), NULL); - gtk_widget_show(b); - gtk_container_add(GTK_CONTAINER(hb), b); - gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(sp_stb_defaults), tbl); - gtk_box_pack_start(GTK_BOX(tbl),hb, FALSE, FALSE, AUX_SPACING); + /* Reset */ + { + GtkAction* act = gtk_action_new( "ResetAction", + _("Defaults"), + _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"), + GTK_STOCK_CLEAR ); + g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(sp_stb_defaults), holder ); + gtk_action_group_add_action( mainActions, act ); + gtk_action_set_sensitive( act, TRUE ); + } } - Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL); - swatch->setWatchedTool ("tools.shapes.star", true); + gtk_ui_manager_insert_action_group( mgr, mainActions, 0 ); + gtk_ui_manager_add_ui_from_string( mgr, descr, -1, &errVal ); + + toolBar = gtk_ui_manager_get_widget( mgr, "/ui/StarToolbar" ); + gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS ); + gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), GTK_ICON_SIZE_SMALL_TOOLBAR ); + + + gtk_table_attach( GTK_TABLE(holder), toolBar, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0 ); + + Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL, _("Style of new stars")); + swatch->setDesktop( desktop ); + swatch->setClickVerb( SP_VERB_CONTEXT_STAR_PREFS ); + swatch->setWatchedTool( "tools.shapes.star", true ); GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj()); - gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0); + gtk_table_attach( GTK_TABLE(holder), swatch_, 1, 2, 0, 1, (GtkAttachOptions)(GTK_SHRINK | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), AUX_BETWEEN_BUTTON_GROUPS, 0 ); - gtk_widget_show_all(tbl); - sp_set_font_size_smaller (tbl); + gtk_widget_show_all(holder); + //sp_set_font_size_smaller (tbl); sigc::connection *connection = new sigc::connection( - sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_star_toolbox_selection_changed), (GtkObject *)tbl)) + sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_star_toolbox_selection_changed), (GtkObject *)holder)) ); - g_signal_connect(G_OBJECT(tbl), "destroy", G_CALLBACK(delete_connection), connection); + g_signal_connect(G_OBJECT(holder), "destroy", G_CALLBACK(delete_connection), connection); - return tbl; + return holder; } @@ -1366,7 +1431,7 @@ sp_rtb_value_changed(GtkAdjustment *adj, GtkWidget *tbl, gchar const *value_name if (modmade) { sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_RECT, - /* TODO: annotate */ "toolbox.cpp:1368"); + _("Change rectangle")); } g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); @@ -1624,7 +1689,9 @@ sp_rect_toolbox_new(SPDesktop *desktop) gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); } - Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL); + Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL, _("Style of new rectangles")); + swatch->setDesktop (desktop); + swatch->setClickVerb (SP_VERB_CONTEXT_RECT_PREFS); swatch->setWatchedTool ("tools.shapes.rect", true); GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj()); gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0); @@ -1683,7 +1750,7 @@ sp_spl_tb_value_changed(GtkAdjustment *adj, GtkWidget *tbl, gchar const *value_n if (modmade) { sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_SPIRAL, - /* TODO: annotate */ "toolbox.cpp:1685"); + _("Change spiral")); } g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); @@ -1873,7 +1940,9 @@ sp_spiral_toolbox_new(SPDesktop *desktop) gtk_box_pack_start(GTK_BOX(tbl),hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); } - Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL); + Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL, _("Style of new spirals")); + swatch->setDesktop (desktop); + swatch->setClickVerb (SP_VERB_CONTEXT_SPIRAL_PREFS); swatch->setWatchedTool ("tools.shapes.spiral", true); GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj()); gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0); @@ -1901,7 +1970,9 @@ sp_pen_toolbox_new(SPDesktop *desktop) gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas); gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop); - Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL); + Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL, _("Style of new paths created by Pen")); + swatch->setDesktop (desktop); + swatch->setClickVerb (SP_VERB_CONTEXT_PEN_PREFS); swatch->setWatchedTool ("tools.freehand.pen", true); GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj()); gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0); @@ -1919,7 +1990,9 @@ sp_pencil_toolbox_new(SPDesktop *desktop) gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas); gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop); - Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL); + Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL, _("Style of new paths created by Pencil")); + swatch->setDesktop (desktop); + swatch->setClickVerb (SP_VERB_CONTEXT_PENCIL_PREFS); swatch->setWatchedTool ("tools.freehand.pencil", true); GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj()); gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0); @@ -1935,77 +2008,59 @@ sp_pencil_toolbox_new(SPDesktop *desktop) //## Calligraphy ## //######################## -static void -sp_ddc_mass_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void sp_ddc_mass_value_changed( GtkAdjustment *adj, GtkWidget *tbl ) { - prefs_set_double_attribute("tools.calligraphic", "mass", adj->value); - spinbutton_defocus(GTK_OBJECT(tbl)); + prefs_set_double_attribute( "tools.calligraphic", "mass", adj->value ); } -static void -sp_ddc_drag_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void sp_ddc_wiggle_value_changed( GtkAdjustment *adj, GtkWidget *tbl ) { - prefs_set_double_attribute("tools.calligraphic", "drag", adj->value); - spinbutton_defocus(GTK_OBJECT(tbl)); + prefs_set_double_attribute( "tools.calligraphic", "wiggle", adj->value ); } -static void -sp_ddc_angle_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void sp_ddc_angle_value_changed( GtkAdjustment *adj, GtkWidget *tbl ) { - prefs_set_double_attribute("tools.calligraphic", "angle", adj->value); - spinbutton_defocus(GTK_OBJECT(tbl)); + prefs_set_double_attribute( "tools.calligraphic", "angle", adj->value ); } -static void -sp_ddc_width_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void sp_ddc_width_value_changed( GtkAdjustment *adj, GtkWidget *tbl ) { - prefs_set_double_attribute("tools.calligraphic", "width", adj->value * 0.01); - spinbutton_defocus(GTK_OBJECT(tbl)); + prefs_set_double_attribute( "tools.calligraphic", "width", adj->value * 0.01 ); } -static void -sp_ddc_velthin_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void sp_ddc_velthin_value_changed( GtkAdjustment *adj, GtkWidget *tbl ) { prefs_set_double_attribute("tools.calligraphic", "thinning", adj->value); - spinbutton_defocus(GTK_OBJECT(tbl)); } -static void -sp_ddc_flatness_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void sp_ddc_flatness_value_changed( GtkAdjustment *adj, GtkWidget *tbl ) { - prefs_set_double_attribute("tools.calligraphic", "flatness", adj->value); - spinbutton_defocus(GTK_OBJECT(tbl)); + prefs_set_double_attribute( "tools.calligraphic", "flatness", adj->value ); } -static void -sp_ddc_tremor_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void sp_ddc_tremor_value_changed( GtkAdjustment *adj, GtkWidget *tbl ) { - prefs_set_double_attribute("tools.calligraphic", "tremor", adj->value); - spinbutton_defocus(GTK_OBJECT(tbl)); + prefs_set_double_attribute( "tools.calligraphic", "tremor", adj->value ); } -static void -sp_ddc_cap_rounding_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void sp_ddc_cap_rounding_value_changed( GtkAdjustment *adj, GtkWidget *tbl ) { - prefs_set_double_attribute("tools.calligraphic", "cap_rounding", adj->value); - spinbutton_defocus(GTK_OBJECT(tbl)); + prefs_set_double_attribute( "tools.calligraphic", "cap_rounding", adj->value ); } -static void -sp_ddc_pressure_state_changed(GtkWidget *button, gpointer data) +static void sp_ddc_pressure_state_changed( GtkToggleAction *act, gpointer data ) { - prefs_set_int_attribute ("tools.calligraphic", "usepressure", gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)) ? 1 : 0); + prefs_set_int_attribute( "tools.calligraphic", "usepressure", gtk_toggle_action_get_active( act ) ? 1 : 0); } -static void -sp_ddc_tilt_state_changed(GtkWidget *button, GtkWidget *calligraphy_angle) +static void sp_ddc_tilt_state_changed( GtkToggleAction *act, GtkAction *calligraphy_angle ) { - prefs_set_int_attribute ("tools.calligraphic", "usetilt", gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)) ? 1 : 0); + prefs_set_int_attribute( "tools.calligraphic", "usetilt", gtk_toggle_action_get_active( act ) ? 1 : 0 ); - gtk_widget_set_sensitive(GTK_WIDGET(calligraphy_angle), !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))); + gtk_action_set_sensitive( calligraphy_angle, !gtk_toggle_action_get_active( act ) ); } -static void sp_ddc_defaults(GtkWidget *, GtkWidget *tbl) +static void sp_ddc_defaults(GtkWidget *, GtkWidget *dataKludge) { // FIXME: make defaults settable via Inkscape Options struct KeyValue { @@ -2013,7 +2068,7 @@ static void sp_ddc_defaults(GtkWidget *, GtkWidget *tbl) double value; } const key_values[] = { {"mass", 0.02}, - {"drag", 1.0}, + {"wiggle", 0.0}, {"angle", 30.0}, {"width", 15}, {"thinning", 0.1}, @@ -2024,171 +2079,230 @@ static void sp_ddc_defaults(GtkWidget *, GtkWidget *tbl) for (unsigned i = 0; i < G_N_ELEMENTS(key_values); ++i) { KeyValue const &kv = key_values[i]; - GtkAdjustment &adj = *static_cast(gtk_object_get_data(GTK_OBJECT(tbl), kv.key)); - gtk_adjustment_set_value(&adj, kv.value); + GtkAdjustment* adj = static_cast(gtk_object_get_data(GTK_OBJECT(dataKludge), kv.key)); + if ( adj ) { + gtk_adjustment_set_value(adj, kv.value); + } } - - spinbutton_defocus(GTK_OBJECT(tbl)); } + static GtkWidget * sp_calligraphy_toolbox_new(SPDesktop *desktop) { - GtkWidget *tbl = gtk_hbox_new(FALSE, 0); - gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas); - gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop); - - GtkTooltips *tt = gtk_tooltips_new(); - GtkWidget *calligraphy_angle; - - // interval - gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + GtkWidget *toolBar = 0; + GtkWidget* holder = gtk_table_new( 1, 2, FALSE ); + + gchar const * descr = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + ""; + GtkUIManager* mgr = gtk_ui_manager_new(); + GError* errVal = 0; + GtkActionGroup* mainActions = gtk_action_group_new("main"); - /* Width */ { - GtkWidget *hb = sp_tb_spinbutton(_("Width:"), _("The width of the calligraphic pen (relative to the visible canvas area)"), + EgeAdjustmentAction* calligraphy_angle = 0; + + { + /* 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( "WidthAction", + _("Width:"), _("The width of the calligraphic pen (relative to the visible canvas area)"), "tools.calligraphic", "width", 15, - NULL, tbl, TRUE, "altx-calligraphy", + GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-calligraphy", 1, 100, 1.0, 10.0, - sp_ddc_width_value_changed, 0.01, 0, 100); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING); - } + labels, values, G_N_ELEMENTS(labels), + sp_ddc_width_value_changed, 0.01, 0, 100 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } - /* Thinning */ - { - GtkWidget *hb = sp_tb_spinbutton(_("Thinning:"), _("How much velocity thins the stroke (> 0 makes fast strokes thinner, < 0 makes them broader, 0 makes width independent of velocity)"), + { + /* 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}; + EgeAdjustmentAction* eact = create_adjustment_action( "ThinningAction", + _("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, - NULL, tbl, FALSE, NULL, + GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, -1.0, 1.0, 0.01, 0.1, + labels, values, G_N_ELEMENTS(labels), sp_ddc_velthin_value_changed, 0.01, 2); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING); - } - - // interval - gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } - /* Angle */ - { - calligraphy_angle = sp_tb_spinbutton(_("Angle:"), _("The angle of the pen's nib (in degrees; 0 = horizontal; has no effect if fixation = 0)"), - "tools.calligraphic", "angle", 30, - NULL, tbl, TRUE, "calligraphy-angle", - -90.0, 90.0, 1.0, 10.0, - sp_ddc_angle_value_changed, 1, 0); - gtk_box_pack_start(GTK_BOX(tbl), calligraphy_angle, FALSE, FALSE, AUX_SPACING); - } + { + /* Angle */ + gchar const* labels[] = {_("(left edge up)"), 0, 0, _("(horizontal)"), _("(default)"), 0, _("(right edge up)")}; + gdouble values[] = {-90, -60, -30, 0, 30, 60, 90}; + EgeAdjustmentAction* eact = create_adjustment_action( "AngleAction", + _("Angle:"), _("The angle of the pen's nib (in degrees; 0 = horizontal; has no effect if fixation = 0)"), + "tools.calligraphic", "angle", 30, + GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "calligraphy-angle", + -90.0, 90.0, 1.0, 10.0, + labels, values, G_N_ELEMENTS(labels), + sp_ddc_angle_value_changed, 1, 0 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + calligraphy_angle = eact; + } - /* Fixation */ - { - GtkWidget *hb = sp_tb_spinbutton(_("Fixation:"), _("How fixed is the pen angle (0 = always perpendicular to stroke direction, 1 = fixed)"), + { + /* 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}; + EgeAdjustmentAction* eact = create_adjustment_action( "FixationAction", + _("Fixation:"), _("Angle behavior (0 = nib always perpendicular to stroke direction, 1 = fixed angle)"), "tools.calligraphic", "flatness", 0.9, - NULL, tbl, FALSE, NULL, + GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, 0.0, 1.0, 0.01, 0.1, - sp_ddc_flatness_value_changed, 0.01, 2); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING); - } + labels, values, G_N_ELEMENTS(labels), + sp_ddc_flatness_value_changed, 0.01, 2 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } - /* Cap Rounding */ - { + { + /* Cap Rounding */ + gchar const* labels[] = {_("(blunt caps, default)"), _("(slightly bulging)"), 0, 0, _("(approximately round)"), _("(long protruding caps)")}; + gdouble values[] = {0, 0.3, 0.5, 1.0, 1.4, 5.0}; // TRANSLATORS: "cap" means "end" (both start and finish) here - GtkWidget *hb = sp_tb_spinbutton(_("Round:"), _("How much the ends of a stroke are rounded"), + EgeAdjustmentAction* eact = create_adjustment_action( "CapRoundingAction", + _("Caps:"), _("Increase to make caps at the ends of strokes protrude more (0 = no caps, 1 = round caps)"), "tools.calligraphic", "cap_rounding", 0.0, - NULL, tbl, FALSE, NULL, + GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, + 0.0, 5.0, 0.01, 0.1, + labels, values, G_N_ELEMENTS(labels), + sp_ddc_cap_rounding_value_changed, 0.01, 2 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } + + { + /* 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}; + EgeAdjustmentAction* eact = create_adjustment_action( "TremorAction", + _("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, - sp_ddc_cap_rounding_value_changed, 0.01, 2); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING); - } + labels, values, G_N_ELEMENTS(labels), + sp_ddc_tremor_value_changed, 0.01, 2 ); - // interval - gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } - /* Tremor */ - { - GtkWidget *hb = sp_tb_spinbutton(_("Tremor:"), _("How uneven or trembling is the pen stroke"), - "tools.calligraphic", "tremor", 0.0, - NULL, tbl, FALSE, NULL, + { + /* 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}; + EgeAdjustmentAction* eact = create_adjustment_action( "WiggleAction", + _("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, - sp_ddc_tremor_value_changed, 0.01, 2); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING); - } + labels, values, G_N_ELEMENTS(labels), + sp_ddc_wiggle_value_changed, 0.01, 2 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } - /* Mass */ - { - GtkWidget *hb = sp_tb_spinbutton(_("Mass:"), _("How much inertia affects the movement of the pen"), + { + /* 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}; + EgeAdjustmentAction* eact = create_adjustment_action( "MassAction", + _("Mass:"), _("Increase to make the pen drag behind, as if slowed by inertia"), "tools.calligraphic", "mass", 0.02, - NULL, tbl, FALSE, NULL, + GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, 0.0, 1.0, 0.01, 0.1, - sp_ddc_mass_value_changed, 0.01, 2); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING); - } + labels, values, G_N_ELEMENTS(labels), + sp_ddc_mass_value_changed, 0.01, 2 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } - /* Drag */ - { - // TRANSLATORS: "drag" means "resistance" here - GtkWidget *hb = sp_tb_spinbutton(_("Drag:"), _("How much resistance affects the movement of the pen"), - "tools.calligraphic", "drag", 1, - NULL, tbl, FALSE, NULL, - 0.0, 1.0, 0.01, 0.1, - sp_ddc_drag_value_changed, 0.01, 2); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING); - } - // interval - gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + /* Use Pressure button */ + { + InkToggleAction* act = ink_toggle_action_new( "PressureAction", + _("Pressure"), + _("Use the pressure of the input device to alter the width of the pen"), + "use_pressure", + Inkscape::ICON_SIZE_DECORATION ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_ddc_pressure_state_changed), NULL); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.calligraphic", "usepressure", 1 ) ); + } - GtkWidget *cvbox = gtk_vbox_new (FALSE, 0); - GtkWidget *cbox = gtk_hbox_new (FALSE, 0); + /* Use Tilt button */ + { + InkToggleAction* act = ink_toggle_action_new( "TiltAction", + _("Tilt"), + _("Use the tilt of the input device to alter the angle of the pen's nib"), + "use_tilt", + Inkscape::ICON_SIZE_DECORATION ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_ddc_tilt_state_changed), calligraphy_angle ); + gtk_action_set_sensitive( GTK_ACTION(calligraphy_angle), !prefs_get_int_attribute( "tools.calligraphic", "usetilt", 1 ) ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.calligraphic", "usetilt", 1 ) ); + } - /* Use Pressure button */ - { - GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION, - SP_BUTTON_TYPE_TOGGLE, - NULL, - "use_pressure", - _("Use the pressure of the input device to alter the width of the pen"), - tt); - g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (sp_ddc_pressure_state_changed), NULL); - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), prefs_get_int_attribute ("tools.calligraphic", "usepressure", 1)); - gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0); + /* Reset */ + { + GtkAction* act = gtk_action_new( "ResetAction", + _("Defaults"), + _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"), + GTK_STOCK_CLEAR ); + g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(sp_ddc_defaults), holder ); + gtk_action_group_add_action( mainActions, act ); + gtk_action_set_sensitive( act, TRUE ); + } } - /* Use Tilt button */ - { - GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION, - SP_BUTTON_TYPE_TOGGLE, - NULL, - "use_tilt", - _("Use the tilt of the input device to alter the angle of the pen's nib"), - tt); - g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (sp_ddc_tilt_state_changed), calligraphy_angle); - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), prefs_get_int_attribute ("tools.calligraphic", "usetilt", 1)); - gtk_widget_set_sensitive(GTK_WIDGET(calligraphy_angle), !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))); - gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0); - } - gtk_box_pack_start(GTK_BOX(cvbox), cbox, TRUE, FALSE, 0); - gtk_box_pack_start(GTK_BOX(tbl), cvbox, FALSE, FALSE, 0); + gtk_ui_manager_insert_action_group( mgr, mainActions, 0 ); + gtk_ui_manager_add_ui_from_string( mgr, descr, -1, &errVal ); + + toolBar = gtk_ui_manager_get_widget( mgr, "/ui/CalligraphyToolbar" ); + gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS ); + gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), GTK_ICON_SIZE_SMALL_TOOLBAR ); - /* Reset */ - { - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - GtkWidget *b = gtk_button_new_with_label(_("Defaults")); - gtk_tooltips_set_tip(tt, b, _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"), NULL); - gtk_widget_show(b); - gtk_container_add(GTK_CONTAINER(hb), b); - gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(sp_ddc_defaults), tbl); - gtk_box_pack_start(GTK_BOX(tbl),hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); - } + gtk_table_attach( GTK_TABLE(holder), toolBar, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0 ); - Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL); + Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL, _("Style of new calligraphic strokes")); + swatch->setDesktop (desktop); + swatch->setClickVerb (SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS); swatch->setWatchedTool ("tools.calligraphic", true); GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj()); - gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0); + gtk_table_attach( GTK_TABLE(holder), swatch_, 1, 2, 0, 1, (GtkAttachOptions)(GTK_SHRINK | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), AUX_BETWEEN_BUTTON_GROUPS, 0 ); - gtk_widget_show_all(tbl); - sp_set_font_size_smaller (tbl); + gtk_widget_show_all(holder); + //sp_set_font_size_smaller (tbl); - return tbl; + return holder; } @@ -2265,7 +2379,7 @@ sp_arctb_startend_value_changed(GtkAdjustment *adj, GtkWidget *tbl, gchar const if (modmade) { sp_document_maybe_done(sp_desktop_document(desktop), value_name, SP_VERB_CONTEXT_ARC, - /* TODO: annotate */ "toolbox.cpp:2247"); + _("Arc: Change start/end")); } // defocus spinbuttons by moving focus to the canvas, unless "stay" is on @@ -2338,7 +2452,7 @@ sp_arctb_open_state_changed(GtkWidget *widget, GtkObject *tbl) if (modmade) { sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_ARC, - /* TODO: annotate */ "toolbox.cpp:2320"); + _("Arc: Change open/closed")); } g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); @@ -2536,7 +2650,9 @@ sp_arc_toolbox_new(SPDesktop *desktop) ); g_signal_connect(G_OBJECT(tbl), "destroy", G_CALLBACK(delete_connection), connection); - Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL); + Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL, _("Style of new ellipses")); + swatch->setDesktop (desktop); + swatch->setClickVerb (SP_VERB_CONTEXT_ARC_PREFS); swatch->setWatchedTool ("tools.shapes.arc", true); GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj()); gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0); @@ -2567,11 +2683,13 @@ static void toggle_dropper_pick_alpha (GtkWidget *button, gpointer tbl) { gtk_widget_set_sensitive (GTK_WIDGET (set_checkbox), FALSE); } } + spinbutton_defocus(GTK_OBJECT(tbl)); } -static void toggle_dropper_set_alpha (GtkWidget *button, gpointer data) { +static void toggle_dropper_set_alpha (GtkWidget *button, gpointer tbl) { prefs_set_int_attribute ("tools.dropper", "setalpha", gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)) ? 1 : 0); + spinbutton_defocus(GTK_OBJECT(tbl)); } @@ -3071,7 +3189,7 @@ sp_text_toolbox_family_changed (GtkTreeSelection *selection, } sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT, - /* TODO: annotate */ "toolbox.cpp:3024"); + _("Text: Change font family")); sp_repr_css_attr_unref (css); free (family); gtk_widget_hide (GTK_WIDGET (g_object_get_data (G_OBJECT(tbl), "warning-image"))); @@ -3154,7 +3272,7 @@ sp_text_toolbox_anchoring_toggled (GtkRadioButton *button, sp_desktop_set_style (desktop, css, true, true); sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT, - /* TODO: annotate */ "toolbox.cpp:3107"); + _("Text: Change alignment")); sp_repr_css_attr_unref (css); gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); @@ -3200,7 +3318,7 @@ sp_text_toolbox_style_toggled (GtkToggleButton *button, sp_desktop_set_style (desktop, css, true, true); sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT, - /* TODO: annotate */ "toolbox.cpp:3153"); + _("Text: Change font style")); sp_repr_css_attr_unref (css); gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); @@ -3247,7 +3365,7 @@ sp_text_toolbox_orientation_toggled (GtkRadioButton *button, sp_desktop_set_style (desktop, css, true, true); sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT, - /* TODO: annotate */ "toolbox.cpp:3200"); + _("Text: Change orientation")); sp_repr_css_attr_unref (css); gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); @@ -3343,7 +3461,7 @@ sp_text_toolbox_size_changed (GtkComboBox *cbox, sp_desktop_set_style (desktop, css, true, true); sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:size", SP_VERB_NONE, - /* TODO: annotate */ "toolbox.cpp:3296"); + _("Text: Change font size")); sp_repr_css_attr_unref (css); @@ -3909,7 +4027,7 @@ static void connector_spacing_changed(GtkAdjustment *adj, GtkWidget *tbl) } sp_document_done(doc, SP_VERB_CONTEXT_CONNECTOR, - _("Change connector spacing distance")); + _("Change connector spacing")); g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); @@ -3928,7 +4046,7 @@ static void sp_connector_graph_layout(void) prefs_set_int_attribute("options.clonecompensation", "value", saved_compensation); - sp_document_done(sp_desktop_document(SP_ACTIVE_DESKTOP), SP_VERB_DIALOG_ALIGN_DISTRIBUTE, /* TODO: annotate */ "toolbox.cpp:129"); + sp_document_done(sp_desktop_document(SP_ACTIVE_DESKTOP), SP_VERB_DIALOG_ALIGN_DISTRIBUTE, _("Arrange connector network")); } static void @@ -4101,6 +4219,95 @@ sp_connector_toolbox_new(SPDesktop *desktop) } // end of sp_connector_toolbox_new() +static void paintbucket_threshold_changed(GtkAdjustment *adj, GtkWidget *tbl) +{ + prefs_set_int_attribute("tools.paintbucket", "threshold", (gint)adj->value); + spinbutton_defocus(GTK_OBJECT(tbl)); +} + +static void paintbucket_offset_changed(GtkAdjustment *adj, GtkWidget *tbl) +{ + GtkWidget *us = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(tbl), "units"); + SPUnit const *unit = sp_unit_selector_get_unit(SP_UNIT_SELECTOR(us)); + + prefs_set_double_attribute("tools.paintbucket", "offset", (gdouble)sp_units_get_pixels(adj->value, *unit)); + spinbutton_defocus(GTK_OBJECT(tbl)); +} + +static GtkWidget * +sp_paintbucket_toolbox_new(SPDesktop *desktop) +{ + GtkWidget *tbl = gtk_hbox_new(FALSE, 0); + + // interval + gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + + { + sp_toolbox_add_label(tbl, _("Fill by:"), false); + + GtkWidget *channels = gtk_combo_box_new_text(); + + GList *items = flood_channels_dropdown_items_list(); + + for ( ; items ; items = items->next ) + { + gtk_combo_box_append_text(GTK_COMBO_BOX(channels), (char*)items->data); + } + + gtk_combo_box_set_active (GTK_COMBO_BOX(channels), prefs_get_int_attribute("tools.paintbucket", "channels", 0)); + gtk_box_pack_start (GTK_BOX (tbl), channels, FALSE, FALSE, 0); + g_signal_connect (G_OBJECT (channels), "changed", G_CALLBACK (flood_channels_changed), tbl); + } + + // interval + gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + + // Spacing spinbox + { + GtkWidget *threshold = sp_tb_spinbutton(_("Threshold:"), + _("The maximum allowed difference between the clicked pixel and the neighboring pixels to be counted in the fill"), + "tools.paintbucket", "threshold", 5, NULL, tbl, TRUE, + "inkscape:paintbucket-threshold", 0, 100, 1.0, 10.0, + paintbucket_threshold_changed, 1, 0); + + gtk_box_pack_start(GTK_BOX(tbl), threshold, FALSE, FALSE, + AUX_SPACING); + } + + // interval + gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + + // Create the units menu. + GtkWidget *us = sp_unit_selector_new(SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE); + sp_unit_selector_setsize(us, AUX_OPTION_MENU_WIDTH, AUX_OPTION_MENU_HEIGHT); + sp_unit_selector_set_unit (SP_UNIT_SELECTOR(us), sp_desktop_namedview(desktop)->doc_units); + + // Offset spinbox + { + GtkWidget *offset = sp_tb_spinbutton(_("Grow/shrink by:"), + _("The amount to grow (positive) or shrink (negative) the created fill path"), + "tools.paintbucket", "offset", 0, us, tbl, TRUE, + "inkscape:paintbucket-offset", -1e6, 1e6, 0.1, 0.5, + paintbucket_offset_changed, 1, 2); + + gtk_box_pack_start(GTK_BOX(tbl), offset, FALSE, FALSE, + AUX_SPACING); + + gtk_box_pack_start(GTK_BOX(tbl), us, FALSE, FALSE, AUX_SPACING); + gtk_object_set_data(GTK_OBJECT(tbl), "units", us); + } + + Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL, _("Style of Paint Bucket fill objects")); + swatch->setDesktop (desktop); + swatch->setClickVerb (SP_VERB_CONTEXT_PAINTBUCKET_PREFS); + swatch->setWatchedTool ("tools.paintbucket", true); + GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj()); + gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0); + + gtk_widget_show_all(tbl); + sp_set_font_size_smaller (tbl); + return tbl; +} /* Local Variables: