X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fwidgets%2Ftoolbox.cpp;h=87b9595322cf3c3fd1386491668fa185461be2c4;hb=4e93dc3d5909be7bce5445a5939a0b56f32197c0;hp=a45d57add8349535feb7d1f1f37c9b0b00771e4e;hpb=a32a511cd4cd2acc897109af56e52ada5db641bb;p=inkscape.git diff --git a/src/widgets/toolbox.cpp b/src/widgets/toolbox.cpp index a45d57add..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 @@ -28,12 +29,18 @@ # include "config.h" #endif +#include #include +#include +#include #include "widgets/button.h" #include "widgets/widget-sizes.h" #include "widgets/spw-utilities.h" #include "widgets/spinbutton-events.h" +#include "dialogs/text-edit.h" + +#include "ui/widget/style-swatch.h" #include "prefs-utils.h" #include "verbs.h" @@ -59,13 +66,28 @@ #include "sp-star.h" #include "sp-spiral.h" #include "sp-ellipse.h" +#include "sp-text.h" +#include "sp-flowtext.h" +#include "style.h" #include "selection.h" #include "document-private.h" +#include "desktop-style.h" +#include "../libnrtype/font-lister.h" +#include "../connection-pool.h" +#include "../prefs-utils.h" +#include "../inkscape-stock.h" +#include "icon.h" +#include "graphlayout/graphlayout.h" #include "mod360.h" #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); @@ -75,11 +97,15 @@ static GtkWidget *sp_star_toolbox_new(SPDesktop *desktop); static GtkWidget *sp_arc_toolbox_new(SPDesktop *desktop); static GtkWidget *sp_rect_toolbox_new(SPDesktop *desktop); static GtkWidget *sp_spiral_toolbox_new(SPDesktop *desktop); +static GtkWidget *sp_pencil_toolbox_new(SPDesktop *desktop); +static GtkWidget *sp_pen_toolbox_new(SPDesktop *desktop); 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_text_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); } static struct { @@ -98,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 }, @@ -117,24 +144,27 @@ static struct { { "SPRectContext", "rect_toolbox", sp_rect_toolbox_new }, { "SPArcContext", "arc_toolbox", sp_arc_toolbox_new }, { "SPSpiralContext", "spiral_toolbox", sp_spiral_toolbox_new }, - { "SPPencilContext", "pencil_toolbox", NULL }, - { "SPPenContext", "pen_toolbox", NULL }, + { "SPPencilContext", "pencil_toolbox", sp_pencil_toolbox_new }, + { "SPPenContext", "pen_toolbox", sp_pen_toolbox_new }, { "SPDynaDrawContext", "calligraphy_toolbox", sp_calligraphy_toolbox_new }, { "SPTextContext", "text_toolbox", sp_text_toolbox_new }, { "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 } }; -static void toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop, SetupFunction setup_func, UpdateFunction update_func, sigc::connection*); +static void toolbox_set_desktop (GtkWidget *toolbox, SPDesktop *desktop, SetupFunction setup_func, UpdateFunction update_func, sigc::connection*); -static void setup_tool_toolbox(GtkWidget *toolbox, SPDesktop *desktop); -static void update_tool_toolbox(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox); -static void setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop); -static void update_aux_toolbox(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox); -static void setup_commands_toolbox(GtkWidget *toolbox, SPDesktop *desktop); -static void update_commands_toolbox(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox); +static void setup_tool_toolbox (GtkWidget *toolbox, SPDesktop *desktop); +static void update_tool_toolbox (SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox); + +static void setup_aux_toolbox (GtkWidget *toolbox, SPDesktop *desktop); +static void update_aux_toolbox (SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox); + +static void setup_commands_toolbox (GtkWidget *toolbox, SPDesktop *desktop); +static void update_commands_toolbox (SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox); /* Global text entry widgets necessary for update */ /* GtkWidget *dropper_rgb_entry, @@ -158,7 +188,6 @@ sp_toolbox_button_new(GtkWidget *t, Inkscape::IconSize size, gchar const *pxname return b; } - GtkWidget * sp_toolbox_button_new_from_verb_with_doubleclick(GtkWidget *t, Inkscape::IconSize size, SPButtonType type, Inkscape::Verb *verb, Inkscape::Verb *doubleclick_verb, @@ -372,7 +401,11 @@ sp_node_path_edit_symmetrical(void) sp_node_selected_set_type(Inkscape::NodePath::NODE_SYMM); } - +static void toggle_show_handles (GtkWidget *button, gpointer data) { + bool show = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)); + prefs_set_int_attribute ("tools.nodes", "show_handles", show ? 1 : 0); + sp_nodepath_show_handles(show); +} //################################ //## Node Editing Toolbox ## @@ -431,6 +464,26 @@ sp_node_toolbox_new(SPDesktop *desktop) sp_toolbox_button_normal_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, Inkscape::Verb::get(SP_VERB_SELECTION_OUTLINE), view, tt); + aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS); + + GtkWidget *cvbox = gtk_vbox_new (FALSE, 0); + GtkWidget *cbox = gtk_hbox_new (FALSE, 0); + + { + GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION, + SP_BUTTON_TYPE_TOGGLE, + NULL, + "nodes_show_handles", + _("Show the Bezier handles of selected nodes"), + tt); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), prefs_get_int_attribute ("tools.nodes", "show_handles", 1)); + g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (toggle_show_handles), desktop); + 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(tb), cvbox, FALSE, FALSE, 0); + gtk_widget_show_all(tb); return tb; @@ -506,7 +559,6 @@ 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"))); } - static void toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop, SetupFunction setup_func, UpdateFunction update_func, sigc::connection *conn) { @@ -768,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 @@ -786,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; @@ -808,29 +904,27 @@ sp_stb_magnitude_value_changed(GtkAdjustment *adj, GtkWidget *tbl) modmade = true; } } - if (modmade) sp_document_done(sp_desktop_document(desktop)); - - 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, + _("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); @@ -852,82 +946,68 @@ sp_stb_proportion_value_changed(GtkAdjustment *adj, GtkWidget *tbl) } } - if (modmade) sp_document_done(sp_desktop_document(desktop)); - - 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, + _("Star: Change spoke ratio")); - 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)); - 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; @@ -941,30 +1021,27 @@ sp_stb_rounded_value_changed(GtkAdjustment *adj, GtkWidget *tbl) modmade = true; } } - if (modmade) sp_document_done(sp_desktop_document(desktop)); + if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR, + _("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; @@ -978,11 +1055,10 @@ sp_stb_randomized_value_changed(GtkAdjustment *adj, GtkWidget *tbl) modmade = true; } } - if (modmade) sp_document_done(sp_desktop_document(desktop)); + if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR, + _("Star: Change randomization")); - 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)); } @@ -1000,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"); @@ -1067,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 @@ -1086,22 +1162,22 @@ sp_star_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl g_object_set_data(G_OBJECT(tbl), "repr", repr); Inkscape::GC::anchor(repr); sp_repr_add_listener(repr, &star_tb_repr_events, tbl); + sp_repr_synthesize_events(repr, &star_tb_repr_events, 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; @@ -1110,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 ); - adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "magnitude"); + GtkAction* sb2 = GTK_ACTION( g_object_get_data(G_OBJECT(dataKludge), "prop_action") ); + gtk_action_set_sensitive( sb2, !flat ); + + 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)); } @@ -1151,107 +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); - - 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; + 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:")); - /* 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 ); + } } - gtk_widget_show_all(tbl); - sp_set_font_size_smaller (tbl); + 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_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(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; } @@ -1311,7 +1430,8 @@ sp_rtb_value_changed(GtkAdjustment *adj, GtkWidget *tbl, gchar const *value_name sp_rtb_sensitivize (tbl); if (modmade) { - sp_document_done(sp_desktop_document(desktop)); + sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_RECT, + _("Change rectangle")); } g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); @@ -1479,6 +1599,7 @@ sp_rect_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl g_object_set_data(G_OBJECT(tbl), "item", item); Inkscape::GC::anchor(repr); sp_repr_add_listener(repr, &rect_tb_repr_events, tbl); + sp_repr_synthesize_events(repr, &rect_tb_repr_events, tbl); } } else { // FIXME: implement averaging of all parameters for multiple selected @@ -1568,6 +1689,13 @@ 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, _("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); + g_object_set_data(G_OBJECT(tbl), "single", GINT_TO_POINTER(TRUE)); sp_rtb_sensitivize (tbl); @@ -1621,7 +1749,8 @@ sp_spl_tb_value_changed(GtkAdjustment *adj, GtkWidget *tbl, gchar const *value_n g_free(namespaced_name); if (modmade) { - sp_document_done(sp_desktop_document(desktop)); + sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_SPIRAL, + _("Change spiral")); } g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); @@ -1747,6 +1876,7 @@ sp_spiral_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *t g_object_set_data(G_OBJECT(tbl), "repr", repr); Inkscape::GC::anchor(repr); sp_repr_add_listener(repr, &spiral_tb_repr_events, tbl); + sp_repr_synthesize_events(repr, &spiral_tb_repr_events, tbl); } } else { // FIXME: implement averaging of all parameters for multiple selected @@ -1810,6 +1940,13 @@ 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, _("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); + gtk_widget_show_all(tbl); sp_set_font_size_smaller (tbl); @@ -1821,75 +1958,109 @@ sp_spiral_toolbox_new(SPDesktop *desktop) return tbl; } +//######################## +//## Pen/Pencil ## +//######################## + + +static GtkWidget * +sp_pen_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); + + 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); + + gtk_widget_show_all(tbl); + sp_set_font_size_smaller (tbl); + + return tbl; +} + +static GtkWidget * +sp_pencil_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); + + 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); + + gtk_widget_show_all(tbl); + sp_set_font_size_smaller (tbl); + + return tbl; +} + //######################## //## 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_pressure_state_changed(GtkWidget *button, gpointer data) +static void sp_ddc_cap_rounding_value_changed( GtkAdjustment *adj, GtkWidget *tbl ) { - prefs_set_int_attribute ("tools.calligraphic", "usepressure", gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)) ? 1 : 0); + prefs_set_double_attribute( "tools.calligraphic", "cap_rounding", adj->value ); } -static void -sp_ddc_tilt_state_changed(GtkWidget *button, GtkWidget *calligraphy_angle) +static void sp_ddc_pressure_state_changed( GtkToggleAction *act, gpointer data ) +{ + prefs_set_int_attribute( "tools.calligraphic", "usepressure", gtk_toggle_action_get_active( act ) ? 1 : 0); +} + +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 { @@ -1897,182 +2068,241 @@ 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}, {"tremor", 0.0}, - {"flatness", 0.9} + {"flatness", 0.9}, + {"cap_rounding", 0.0} }; 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); + 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"); - 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); - - /* 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); - } - - // interval - gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + 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 ); + } - /* Tremor */ - { - GtkWidget *hb = sp_tb_spinbutton(_("Tremor:"), _("How uneven or trembling is the pen stroke"), + { + /* 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 + 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, + 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, - NULL, tbl, FALSE, NULL, + 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); - } - /* Mass */ - { - GtkWidget *hb = sp_tb_spinbutton(_("Mass:"), _("How much inertia affects the movement of the pen"), - "tools.calligraphic", "mass", 0.02, - NULL, tbl, 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_tremor_value_changed, 0.01, 2 ); - /* 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); - } + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } - // interval - gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + { + /* 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, + 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 ); + } - GtkWidget *cvbox = gtk_vbox_new (FALSE, 0); - GtkWidget *cbox = gtk_hbox_new (FALSE, 0); + { + /* 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, + GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, + 0.0, 1.0, 0.01, 0.1, + 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 ); + } - /* 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); - } - /* 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); - } + /* 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 ) ); + } - gtk_box_pack_start(GTK_BOX(cvbox), cbox, TRUE, FALSE, 0); - gtk_box_pack_start(GTK_BOX(tbl), cvbox, FALSE, 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 ) ); + } - /* 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); + /* 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 ); + } } -/* - // Tablet features - { - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - GtkWidget *fscb = gtk_check_button_new_with_label(_("Tablet")); - gtk_widget_set_sensitive(GTK_WIDGET(fscb), 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/CalligraphyToolbar" ); + gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS ); + gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), GTK_ICON_SIZE_SMALL_TOOLBAR ); - gtk_tooltips_set_tip(tt, fscb, _("Enable/Disable drawing tablet features"), NULL); - gtk_widget_show(fscb); - gtk_object_set_data(GTK_OBJECT(tbl), "flat_checkbox", fscb); - gtk_container_add(GTK_CONTAINER(hb), fscb); + gtk_table_attach( GTK_TABLE(holder), toolBar, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0 ); - gtk_box_pack_start(GTK_BOX(tbl),hb, FALSE, FALSE, AUX_SPACING); - } -*/ + 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_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; } @@ -2148,7 +2378,8 @@ sp_arctb_startend_value_changed(GtkAdjustment *adj, GtkWidget *tbl, gchar const sp_arctb_sensitivize (tbl, adj->value, other->value); if (modmade) { - sp_document_maybe_done(sp_desktop_document(desktop), value_name); + sp_document_maybe_done(sp_desktop_document(desktop), value_name, SP_VERB_CONTEXT_ARC, + _("Arc: Change start/end")); } // defocus spinbuttons by moving focus to the canvas, unless "stay" is on @@ -2220,7 +2451,8 @@ sp_arctb_open_state_changed(GtkWidget *widget, GtkObject *tbl) } if (modmade) { - sp_document_done(sp_desktop_document(desktop)); + sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_ARC, + _("Arc: Change open/closed")); } g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); @@ -2330,6 +2562,7 @@ sp_arc_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl) g_object_set_data(G_OBJECT(tbl), "repr", repr); Inkscape::GC::anchor(repr); sp_repr_add_listener(repr, &arc_tb_repr_events, tbl); + sp_repr_synthesize_events(repr, &arc_tb_repr_events, tbl); } } else { // FIXME: implement averaging of all parameters for multiple selected @@ -2417,6 +2650,13 @@ 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, _("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); + gtk_widget_show_all(tbl); sp_set_font_size_smaller (tbl); @@ -2432,10 +2672,24 @@ sp_arc_toolbox_new(SPDesktop *desktop) //## Dropper ## //######################## -static void toggle_dropper_color_pick (GtkWidget *button, gpointer data) { +static void toggle_dropper_pick_alpha (GtkWidget *button, gpointer tbl) { prefs_set_int_attribute ("tools.dropper", "pick", - // 0 and 1 are backwards here because of pref - gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)) ? 0 : 1); + gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))); + GtkWidget *set_checkbox = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "set_checkbox"); + if (set_checkbox) { + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) { + gtk_widget_set_sensitive (GTK_WIDGET (set_checkbox), TRUE); + } else { + gtk_widget_set_sensitive (GTK_WIDGET (set_checkbox), FALSE); + } + } + spinbutton_defocus(GTK_OBJECT(tbl)); +} + +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)); } @@ -2618,26 +2872,43 @@ sp_dropper_toolbox_new(SPDesktop *desktop) { GtkWidget *hb = gtk_hbox_new(FALSE, 1); - - GtkWidget *button = - sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION, - SP_BUTTON_TYPE_TOGGLE, - NULL, - "pick_color", - _("When pressed, picks visible color " - "without alpha and when not pressed, " - "picks color including its " - "alpha"), - tt); + GtkWidget *button = gtk_check_button_new_with_label(_("Pick alpha")); + gtk_tooltips_set_tip(tt, button, _("Pick both the color and the alpha (transparency) under cursor; otherwise, pick only the visible color premultiplied by alpha"), NULL); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), + prefs_get_int_attribute ("tools.dropper", + "pick", 1)); gtk_widget_show(button); gtk_container_add (GTK_CONTAINER (hb), button); + gtk_object_set_data(GTK_OBJECT(tbl), "pick_checkbox", button); + g_signal_connect (G_OBJECT (button), "toggled", G_CALLBACK (toggle_dropper_pick_alpha), tbl); + gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, + AUX_BETWEEN_BUTTON_GROUPS); + } + + { + GtkWidget *hb = gtk_hbox_new(FALSE, 1); - g_signal_connect_after (G_OBJECT (button), "clicked", - G_CALLBACK (toggle_dropper_color_pick), NULL); + GtkWidget *button = gtk_check_button_new_with_label(_("Set alpha")); + gtk_tooltips_set_tip(tt, button, _("If alpha was picked, assign it to selection as fill or stroke transparency"), NULL); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), - !prefs_get_int_attribute ("tools.dropper", - "pick", 0)); + prefs_get_int_attribute ("tools.dropper", + "setalpha", 1)); + gtk_widget_show(button); + gtk_container_add (GTK_CONTAINER (hb), button); + gtk_object_set_data(GTK_OBJECT(tbl), "set_checkbox", button); + g_signal_connect (G_OBJECT (button), "toggled", G_CALLBACK (toggle_dropper_set_alpha), tbl); + + // make sure it's disabled if we're not picking alpha + GtkWidget *pick_checkbox = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "pick_checkbox"); + if (pick_checkbox) { + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pick_checkbox))) { + gtk_widget_set_sensitive (GTK_WIDGET (button), TRUE); + } else { + gtk_widget_set_sensitive (GTK_WIDGET (button), FALSE); + } + } + gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); } @@ -2696,166 +2967,876 @@ sp_text_letter_rotation_changed(GtkAdjustment *adj, GtkWidget *tbl) { //Call back for letter rotation spinbutton }*/ -static GtkWidget * -sp_text_toolbox_new(SPDesktop *desktop) + +namespace { + +bool visible = false; + +void +sp_text_toolbox_selection_changed (Inkscape::Selection *selection, GObject *tbl) { - GtkWidget *tbl = gtk_hbox_new(FALSE, 0); -/* GtkWidget *us = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(tbl), "units"); - GtkTooltips *tt = gtk_tooltips_new(); - GtkWidget *group; - //Font Family + SPStyle *query = + sp_style_new (); + + 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); + + 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) + { + Inkscape::XML::Node *repr = inkscape_get_repr (INKSCAPE, "tools.text"); + + if (repr) { - GtkWidget *c = gtk_combo_new (); - gtk_combo_set_value_in_list ((GtkCombo *) c, FALSE, FALSE); - gtk_combo_set_use_arrows ((GtkCombo *) c, TRUE); - gtk_combo_set_use_arrows_always ((GtkCombo *) c, TRUE); - gtk_widget_set_size_request (c, 144, -1); - aux_toolbox_space(tbl, 1); - gtk_box_pack_start (GTK_BOX (tbl), c, FALSE, FALSE, 0); + sp_style_read_from_repr (query, repr); } + else + { + return; + } + } + + if (query->text) + { + if (result_family == QUERY_STYLE_MULTIPLE_DIFFERENT) { + GtkWidget *entry = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "family-entry")); + gtk_entry_set_text (GTK_ENTRY (entry), ""); + + } else if (query->text->font_family.value) { - //Font Style + GtkWidget *entry = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "family-entry")); + gtk_entry_set_text (GTK_ENTRY (entry), query->text->font_family.value); + + Gtk::TreePath path; + try { + path = Inkscape::FontLister::get_instance()->get_row_for_font (query->text->font_family.value); + } catch (...) { + return; + } + + GtkTreeSelection *tselection = GTK_TREE_SELECTION (g_object_get_data (G_OBJECT(tbl), "family-tree-selection")); + GtkTreeView *treeview = GTK_TREE_VIEW (g_object_get_data (G_OBJECT(tbl), "family-tree-view")); + + g_object_set_data (G_OBJECT (tselection), "block", gpointer(1)); + + gtk_tree_selection_select_path (tselection, path.gobj()); + gtk_tree_view_scroll_to_cell (treeview, path.gobj(), NULL, TRUE, 0.5, 0.0); + + g_object_set_data (G_OBJECT (tselection), "block", gpointer(0)); + } + + //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); + + //Anchor + if (query->text_align.computed == SP_CSS_TEXT_ALIGN_JUSTIFY) + { + GtkWidget *button = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "text-fill")); + g_object_set_data (G_OBJECT (button), "block", gpointer(1)); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + g_object_set_data (G_OBJECT (button), "block", gpointer(0)); + } + else { - GtkWidget *c = gtk_combo_new (); - gtk_combo_set_value_in_list ((GtkCombo *) c, FALSE, FALSE); - gtk_combo_set_use_arrows ((GtkCombo *) c, TRUE); - gtk_combo_set_use_arrows_always ((GtkCombo *) c, TRUE); - gtk_widget_set_size_request (c, 88, -1); - aux_toolbox_space(tbl, 1); - gtk_box_pack_start (GTK_BOX (tbl), c, FALSE, FALSE, 0); + if (query->text_anchor.computed == SP_CSS_TEXT_ANCHOR_START) + { + GtkWidget *button = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "text-start")); + g_object_set_data (G_OBJECT (button), "block", gpointer(1)); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + g_object_set_data (G_OBJECT (button), "block", gpointer(0)); + } + else if (query->text_anchor.computed == SP_CSS_TEXT_ANCHOR_MIDDLE) + { + GtkWidget *button = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "text-middle")); + g_object_set_data (G_OBJECT (button), "block", gpointer(1)); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + g_object_set_data (G_OBJECT (button), "block", gpointer(0)); + } + else if (query->text_anchor.computed == SP_CSS_TEXT_ANCHOR_END) + { + GtkWidget *button = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "text-end")); + g_object_set_data (G_OBJECT (button), "block", gpointer(1)); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + g_object_set_data (G_OBJECT (button), "block", gpointer(0)); + } } - //Font Size + //Style { - GtkWidget *c = gtk_combo_new (); - gtk_combo_set_value_in_list ((GtkCombo *) c, FALSE, FALSE); - gtk_combo_set_use_arrows ((GtkCombo *) c, TRUE); - gtk_combo_set_use_arrows_always ((GtkCombo *) c, TRUE); - gtk_widget_set_size_request (c, 64, -1); - aux_toolbox_space(tbl, 1); - gtk_box_pack_start (GTK_BOX (tbl), c, FALSE, FALSE, 0); + GtkToggleButton *button = GTK_TOGGLE_BUTTON (g_object_get_data (G_OBJECT (tbl), "style-bold")); + + gboolean active = gtk_toggle_button_get_active (button); + gboolean check = (query->font_weight.computed >= SP_CSS_FONT_WEIGHT_700); + + if (active != check) + { + g_object_set_data (G_OBJECT (button), "block", gpointer(1)); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), check); + g_object_set_data (G_OBJECT (button), "block", gpointer(0)); + } } - aux_toolbox_space(tbl, AUX_BETWEEN_BUTTON_GROUPS); - //Bold { - GtkWidget *px = gtk_image_new_from_stock(GTK_STOCK_BOLD, Inkscape::ICON_SIZE_SMALL_TOOLBAR); - GtkWidget *button = gtk_toggle_button_new (); - gtk_container_add (GTK_CONTAINER (button), px); - gtk_widget_show(button); - gtk_tooltips_set_tip (tt, button, _("Bold"), NULL); - gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); - gtk_widget_set_sensitive(button, TRUE); - gtk_box_pack_start (GTK_BOX (tbl), button, FALSE, FALSE, 0); + GtkToggleButton *button = GTK_TOGGLE_BUTTON (g_object_get_data (G_OBJECT (tbl), "style-italic")); + + gboolean active = gtk_toggle_button_get_active (button); + gboolean check = (query->font_style.computed != SP_CSS_FONT_STYLE_NORMAL); + + if (active != check) + { + g_object_set_data (G_OBJECT (button), "block", gpointer(1)); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), check); + g_object_set_data (G_OBJECT (button), "block", gpointer(0)); + } } + //Orientation + //locking both buttons, changing one affect all group (both) + GtkWidget *button = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "orientation-horizontal")); + g_object_set_data (G_OBJECT (button), "block", gpointer(1)); + + GtkWidget *button1 = GTK_WIDGET (g_object_get_data (G_OBJECT (tbl), "orientation-vertical")); + g_object_set_data (G_OBJECT (button1), "block", gpointer(1)); + + if (query->writing_mode.computed == SP_CSS_WRITING_MODE_LR_TB) + { + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + } + else + { + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button1), TRUE); + } + g_object_set_data (G_OBJECT (button), "block", gpointer(0)); + g_object_set_data (G_OBJECT (button1), "block", gpointer(0)); + } +} - //Italic +void +sp_text_toolbox_selection_modified (Inkscape::Selection *selection, guint flags, GObject *tbl) +{ + sp_text_toolbox_selection_changed (selection, tbl); +} + +void +sp_text_toolbox_subselection_changed (gpointer dragger, GObject *tbl) +{ + sp_text_toolbox_selection_changed (NULL, tbl); +} + +void +sp_text_toolbox_family_changed (GtkTreeSelection *selection, + GObject *tbl) +{ + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + GtkTreeModel *model = 0; + GtkWidget *popdown = GTK_WIDGET (g_object_get_data (tbl, "family-popdown-window")); + GtkWidget *entry = GTK_WIDGET (g_object_get_data (tbl, "family-entry")); + GtkTreeIter iter; + char *family = 0; + + gdk_pointer_ungrab (GDK_CURRENT_TIME); + gdk_keyboard_ungrab (GDK_CURRENT_TIME); + + if ( !gtk_tree_selection_get_selected( selection, &model, &iter ) ) { + return; + } + + gtk_tree_model_get (model, &iter, 0, &family, -1); + + if (g_object_get_data (G_OBJECT (selection), "block")) + { + gtk_entry_set_text (GTK_ENTRY (entry), family); + return; + } + + gtk_widget_hide (popdown); + visible = false; + + gtk_entry_set_text (GTK_ENTRY (entry), family); + + SPStyle *query = + sp_style_new (); + + int result_numbers = + sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + + SPCSSAttr *css = sp_repr_css_attr_new (); + sp_repr_css_set_property (css, "font-family", family); + + // If querying returned nothing, read the style from the text tool prefs (default style for new texts) + if (result_numbers == QUERY_STYLE_NOTHING) + { + sp_repr_css_change (inkscape_get_repr (INKSCAPE, "tools.text"), css, "style"); + sp_text_edit_dialog_default_set_insensitive (); //FIXME: Replace trough a verb + } + else + { + sp_desktop_set_style (desktop, css, true, true); + } + + 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); + gtk_widget_hide (GTK_WIDGET (g_object_get_data (G_OBJECT(tbl), "warning-image"))); + + gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); +} + +void +sp_text_toolbox_family_entry_activate (GtkEntry *entry, + GObject *tbl) +{ + const char *family = gtk_entry_get_text (entry); + + try { + Gtk::TreePath path = Inkscape::FontLister::get_instance()->get_row_for_font (family); + GtkTreeSelection *selection = GTK_TREE_SELECTION (g_object_get_data (G_OBJECT(tbl), "family-tree-selection")); + GtkTreeView *treeview = GTK_TREE_VIEW (g_object_get_data (G_OBJECT(tbl), "family-tree-view")); + gtk_tree_selection_select_path (selection, path.gobj()); + gtk_tree_view_scroll_to_cell (treeview, path.gobj(), NULL, TRUE, 0.5, 0.0); + gtk_widget_hide (GTK_WIDGET (g_object_get_data (G_OBJECT(tbl), "warning-image"))); + } catch (...) { + if (family && strlen (family)) { - GtkWidget *px = gtk_image_new_from_stock(GTK_STOCK_ITALIC, Inkscape::ICON_SIZE_SMALL_TOOLBAR); - GtkWidget *button = gtk_toggle_button_new (); - gtk_container_add (GTK_CONTAINER (button), px); - gtk_widget_show(button); - gtk_tooltips_set_tip (tt, button, _("Italics"), NULL); - gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); - gtk_widget_set_sensitive(button, TRUE); - gtk_box_pack_start (GTK_BOX (tbl), button, FALSE, FALSE, 0); + gtk_widget_show_all (GTK_WIDGET (g_object_get_data (G_OBJECT(tbl), "warning-image"))); } + } +} + +void +sp_text_toolbox_anchoring_toggled (GtkRadioButton *button, + gpointer data) +{ + if (g_object_get_data (G_OBJECT (button), "block")) return; + if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) return; + int prop = GPOINTER_TO_INT(data); - //Underline + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + SPCSSAttr *css = sp_repr_css_attr_new (); + + switch (prop) + { + case 0: { - GtkWidget *px = gtk_image_new_from_stock(GTK_STOCK_UNDERLINE, Inkscape::ICON_SIZE_SMALL_TOOLBAR); - GtkWidget *button = gtk_toggle_button_new (); - gtk_container_add (GTK_CONTAINER (button), px); - gtk_widget_show(button); - gtk_tooltips_set_tip (tt, button, _("Underline"), NULL); - gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); - gtk_widget_set_sensitive(button, FALSE); - gtk_box_pack_start (GTK_BOX (tbl), button, FALSE, FALSE, 0); + sp_repr_css_set_property (css, "text-anchor", "start"); + sp_repr_css_set_property (css, "text-align", "start"); + break; + } + case 1: + { + sp_repr_css_set_property (css, "text-anchor", "middle"); + sp_repr_css_set_property (css, "text-align", "center"); + break; } - aux_toolbox_space(tbl, AUX_BETWEEN_BUTTON_GROUPS); - // align left + case 2: { - GtkWidget *px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_LEFT, Inkscape::ICON_SIZE_SMALL_TOOLBAR); - GtkWidget *b = group = gtk_radio_button_new (NULL); - gtk_container_add (GTK_CONTAINER (b), px); - gtk_tooltips_set_tip (tt, b, _("Align lines left"), NULL); - gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE); - gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE ); - gtk_box_pack_start (GTK_BOX (tbl), b, FALSE, FALSE, 0); + sp_repr_css_set_property (css, "text-anchor", "end"); + sp_repr_css_set_property (css, "text-align", "end"); + break; } - // align center + case 3: { - GtkWidget *px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_CENTER, Inkscape::ICON_SIZE_SMALL_TOOLBAR); - GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group))); - gtk_container_add (GTK_CONTAINER (b), px); - // TRANSLATORS: `Center' here is a verb. - gtk_tooltips_set_tip (tt, b, _("Center lines"), NULL); - gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE); - gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE ); - gtk_box_pack_start (GTK_BOX (tbl), b, FALSE, FALSE, 0); + sp_repr_css_set_property (css, "text-anchor", "start"); + sp_repr_css_set_property (css, "text-align", "justify"); + break; } + } + + SPStyle *query = + sp_style_new (); + int result_numbers = + sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + + // If querying returned nothing, read the style from the text tool prefs (default style for new texts) + if (result_numbers == QUERY_STYLE_NOTHING) + { + sp_repr_css_change (inkscape_get_repr (INKSCAPE, "tools.text"), css, "style"); + } + + sp_desktop_set_style (desktop, css, true, true); + sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT, + _("Text: Change alignment")); + sp_repr_css_attr_unref (css); + + gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); +} + +void +sp_text_toolbox_style_toggled (GtkToggleButton *button, + gpointer data) +{ + if (g_object_get_data (G_OBJECT (button), "block")) return; - // align right + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + SPCSSAttr *css = sp_repr_css_attr_new (); + int prop = GPOINTER_TO_INT(data); + bool active = gtk_toggle_button_get_active (button); + + + switch (prop) + { + case 0: { - GtkWidget *px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_RIGHT, Inkscape::ICON_SIZE_SMALL_TOOLBAR); - GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group))); - gtk_container_add (GTK_CONTAINER (b), px); - gtk_tooltips_set_tip (tt, b, _("Align lines right"), NULL); - gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE); - gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE ); - gtk_box_pack_start (GTK_BOX (tbl), b, FALSE, FALSE, 0); + sp_repr_css_set_property (css, "font-weight", active ? "bold" : "normal" ); + break; } - // full justification + case 1: { - GtkWidget *px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_FILL, Inkscape::ICON_SIZE_SMALL_TOOLBAR); - GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group))); - gtk_container_add (GTK_CONTAINER (b), px); - gtk_tooltips_set_tip (tt, b, _("Full justification"), NULL); - gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE); - gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE ); - gtk_box_pack_start (GTK_BOX (tbl), b, FALSE, FALSE, 0); + sp_repr_css_set_property (css, "font-style", active ? "italic" : "normal"); + break; } - - - aux_toolbox_space(tbl, AUX_BETWEEN_BUTTON_GROUPS); - - // horizontal + } + + SPStyle *query = + sp_style_new (); + int result_numbers = + sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + + // If querying returned nothing, read the style from the text tool prefs (default style for new texts) + if (result_numbers == QUERY_STYLE_NOTHING) + { + sp_repr_css_change (inkscape_get_repr (INKSCAPE, "tools.text"), css, "style"); + } + + sp_desktop_set_style (desktop, css, true, true); + sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT, + _("Text: Change font style")); + sp_repr_css_attr_unref (css); + + gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); +} + +void +sp_text_toolbox_orientation_toggled (GtkRadioButton *button, + gpointer data) +{ + if (g_object_get_data (G_OBJECT (button), "block")) { + g_object_set_data (G_OBJECT (button), "block", gpointer(0)); + return; + } + + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + SPCSSAttr *css = sp_repr_css_attr_new (); + int prop = GPOINTER_TO_INT(data); + + switch (prop) + { + case 0: { + sp_repr_css_set_property (css, "writing-mode", "lr"); + break; + } + + case 1: + { + sp_repr_css_set_property (css, "writing-mode", "tb"); + break; + } + } + + SPStyle *query = + sp_style_new (); + int result_numbers = + sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + + // If querying returned nothing, read the style from the text tool prefs (default style for new texts) + if (result_numbers == QUERY_STYLE_NOTHING) + { + sp_repr_css_change (inkscape_get_repr (INKSCAPE, "tools.text"), css, "style"); + } + + sp_desktop_set_style (desktop, css, true, true); + sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT, + _("Text: Change orientation")); + sp_repr_css_attr_unref (css); + + gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); +} + +gboolean +sp_text_toolbox_size_keypress (GtkWidget *w, GdkEventKey *event, gpointer data) +{ + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + if (!desktop) return FALSE; + + switch (get_group0_keyval (event)) { + case GDK_Escape: // defocus + gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); + return TRUE; // I consumed the event + break; + case GDK_Return: // defocus + case GDK_KP_Enter: + gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); + return TRUE; // I consumed the event + break; + } + return FALSE; +} + +gboolean +sp_text_toolbox_family_keypress (GtkWidget *w, GdkEventKey *event, GObject *tbl) +{ + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + if (!desktop) return FALSE; + + switch (get_group0_keyval (event)) { + case GDK_Escape: // defocus + gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); + sp_text_toolbox_selection_changed (NULL, tbl); // update + return TRUE; // I consumed the event + break; + } + return FALSE; +} + +gboolean +sp_text_toolbox_family_list_keypress (GtkWidget *w, GdkEventKey *event, GObject *tbl) +{ + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + if (!desktop) return FALSE; + + switch (get_group0_keyval (event)) { + case GDK_Escape: // defocus + gtk_widget_hide (w); + visible = false; + gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); + return TRUE; // I consumed the event + break; + } + return FALSE; +} + + +void +sp_text_toolbox_size_changed (GtkComboBox *cbox, + GObject *tbl) +{ + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + + if (g_object_get_data (tbl, "size-block")) return; + +#if GTK_CHECK_VERSION(2,6,0) + char *text = gtk_combo_box_get_active_text (cbox); +#else // GTK_CHECK_VERSION(2,6,0) + GtkTreeModel *model = gtk_combo_box_get_model (cbox); + GtkTreeIter iter; + char *text = NULL; + + if (gtk_combo_box_get_active_iter (cbox, &iter) && model) + gtk_tree_model_get (model, &iter, 0, &text, -1); +#endif // GTK_CHECK_VERSION(2,6,0) + + SPCSSAttr *css = sp_repr_css_attr_new (); + sp_repr_css_set_property (css, "font-size", text); + free (text); + + SPStyle *query = + sp_style_new (); + int result_numbers = + sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + + // If querying returned nothing, read the style from the text tool prefs (default style for new texts) + if (result_numbers == QUERY_STYLE_NOTHING) + { + sp_repr_css_change (inkscape_get_repr (INKSCAPE, "tools.text"), css, "style"); + } + + sp_desktop_set_style (desktop, css, true, true); + sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:size", SP_VERB_NONE, + _("Text: Change font size")); + sp_repr_css_attr_unref (css); + + + if (gtk_combo_box_get_active (cbox) > 0) // if this was from drop-down (as opposed to type-in), defocus + gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); +} + +void +sp_text_toolbox_text_popdown_clicked (GtkButton *button, + GObject *tbl) +{ + GtkWidget *popdown = GTK_WIDGET (g_object_get_data (tbl, "family-popdown-window")); + GtkWidget *widget = GTK_WIDGET (g_object_get_data (tbl, "family-entry")); + int x, y; + + if (!visible) + { + gdk_window_get_origin (widget->window, &x, &y); + gtk_window_move (GTK_WINDOW (popdown), x, y + widget->allocation.height + 2); //2px of grace space + gtk_widget_show_all (popdown); + + gdk_pointer_grab (widget->window, TRUE, + GdkEventMask (GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | + GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | + GDK_POINTER_MOTION_MASK), + NULL, NULL, GDK_CURRENT_TIME); + + gdk_keyboard_grab (widget->window, TRUE, GDK_CURRENT_TIME); + + visible = true; + } + else + { + gdk_pointer_ungrab (GDK_CURRENT_TIME); + gdk_keyboard_ungrab (GDK_CURRENT_TIME); + gtk_widget_hide (popdown); + visible = false; + } +} + +gboolean +sp_text_toolbox_entry_focus_in (GtkWidget *entry, + GdkEventFocus *event, + GObject *tbl) +{ + gtk_entry_select_region (GTK_ENTRY (entry), 0, -1); + return FALSE; +} + +gboolean +sp_text_toolbox_popdown_focus_out (GtkWidget *popdown, + GdkEventFocus *event, + GObject *tbl) +{ + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + + gtk_widget_hide (popdown); + visible = false; + gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); + return TRUE; +} + +void +cell_data_func (GtkTreeViewColumn *column, + GtkCellRenderer *cell, + GtkTreeModel *tree_model, + GtkTreeIter *iter, + gpointer data) +{ + char *family, + *family_escaped, + *sample_escaped; + + 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); + + std::stringstream markup; + 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); +} + +static void delete_completion(GObject *obj, GtkWidget *entry) { + GObject *completion = (GObject *) gtk_object_get_data(GTK_OBJECT(entry), "completion"); + if (completion) { + gtk_entry_set_completion (GTK_ENTRY(entry), NULL); + g_object_unref (completion); + } +} + +GtkWidget* +sp_text_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(); + Glib::RefPtr store = Inkscape::FontLister::get_instance()->get_font_list(); + + ////////////Family + //Window + GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_decorated (GTK_WINDOW (window), FALSE); + + //Entry + GtkWidget *entry = gtk_entry_new (); + gtk_object_set_data(GTK_OBJECT(entry), "altx-text", entry); + GtkEntryCompletion *completion = gtk_entry_completion_new (); + gtk_entry_completion_set_model (completion, GTK_TREE_MODEL (Glib::unwrap(store))); + gtk_entry_completion_set_text_column (completion, 0); + gtk_entry_completion_set_minimum_key_length (completion, 1); + 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); + 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); + + //Popdown + GtkWidget *sw = gtk_scrolled_window_new (NULL, NULL); + GtkWidget *treeview = gtk_tree_view_new (); + + GtkCellRenderer *cell = gtk_cell_renderer_text_new (); + GtkTreeViewColumn *column = gtk_tree_view_column_new (); + gtk_tree_view_column_pack_start (column, cell, FALSE); + gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); + gtk_tree_view_column_set_cell_data_func (column, cell, GtkTreeCellDataFunc (cell_data_func), NULL, NULL); + gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); + + gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (Glib::unwrap(store))); + gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); +#if GTK_CHECK_VERSION(2,6,0) + gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (treeview), TRUE); +#endif // GTK_CHECK_VERSION(2,6,0) + + //gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview), TRUE); + + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); + gtk_container_add (GTK_CONTAINER (sw), treeview); + + gtk_container_add (GTK_CONTAINER (window), sw); + gtk_widget_set_size_request (window, 300, 450); + + g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (sp_text_toolbox_family_entry_activate), tbl); + g_signal_connect (G_OBJECT (entry), "focus-in-event", G_CALLBACK (sp_text_toolbox_entry_focus_in), tbl); + g_signal_connect (G_OBJECT (entry), "key-press-event", G_CALLBACK(sp_text_toolbox_family_keypress), tbl); + + g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (sp_text_toolbox_text_popdown_clicked), tbl); + + g_signal_connect (G_OBJECT (window), "focus-out-event", G_CALLBACK (sp_text_toolbox_popdown_focus_out), tbl); + g_signal_connect (G_OBJECT (window), "key-press-event", G_CALLBACK(sp_text_toolbox_family_list_keypress), tbl); + + GtkTreeSelection *tselection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); + g_signal_connect (G_OBJECT (tselection), "changed", G_CALLBACK (sp_text_toolbox_family_changed), tbl); + + g_object_set_data (G_OBJECT (tbl), "family-entry", entry); + g_object_set_data (G_OBJECT (tbl), "family-popdown-button", button); + g_object_set_data (G_OBJECT (tbl), "family-popdown-window", window); + 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 *box = gtk_event_box_new (); + gtk_container_add (GTK_CONTAINER (box), image); + gtk_box_pack_start (GTK_BOX (tbl), box, FALSE, FALSE, 4); + 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."), ""); + gtk_widget_hide (GTK_WIDGET (box)); + g_signal_connect_swapped (G_OBJECT (tbl), "show", G_CALLBACK (gtk_widget_hide), box); + + ////////////Size + const char *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++])); + gtk_widget_set_size_request (cbox, 80, -1); + aux_toolbox_space (tbl, 1); + gtk_box_pack_start (GTK_BOX (tbl), cbox, FALSE, FALSE, 0); + 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(cbox), "key-press-event", GTK_SIGNAL_FUNC(sp_text_toolbox_size_keypress), NULL); + + //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); + g_object_set_data (G_OBJECT (tbl), "anchor-group", group); + + // 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_toggle_button_set_mode (GTK_TOGGLE_BUTTON (rbutton), FALSE); + + gtk_box_pack_start (GTK_BOX (row), rbutton, FALSE, FALSE, 0); + g_object_set_data (G_OBJECT (tbl), "text-start", rbutton); + g_signal_connect (G_OBJECT (rbutton), "toggled", G_CALLBACK (sp_text_toolbox_anchoring_toggled), gpointer(0)); + gtk_tooltips_set_tip(tt, rbutton, _("Align left"), NULL); + + // 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_toggle_button_set_mode (GTK_TOGGLE_BUTTON (rbutton), FALSE); + + gtk_box_pack_start (GTK_BOX (row), rbutton, FALSE, FALSE, 0); + g_object_set_data (G_OBJECT (tbl), "text-middle", rbutton); + g_signal_connect (G_OBJECT (rbutton), "toggled", G_CALLBACK (sp_text_toolbox_anchoring_toggled), gpointer (1)); + gtk_tooltips_set_tip(tt, rbutton, _("Center"), NULL); + + // 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_toggle_button_set_mode (GTK_TOGGLE_BUTTON (rbutton), FALSE); + + gtk_box_pack_start (GTK_BOX (row), rbutton, FALSE, FALSE, 0); + g_object_set_data (G_OBJECT (tbl), "text-end", rbutton); + g_signal_connect (G_OBJECT (rbutton), "toggled", G_CALLBACK (sp_text_toolbox_anchoring_toggled), gpointer(2)); + gtk_tooltips_set_tip(tt, rbutton, _("Align right"), NULL); + + // 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_toggle_button_set_mode (GTK_TOGGLE_BUTTON (rbutton), FALSE); + + gtk_box_pack_start (GTK_BOX (row), rbutton, FALSE, FALSE, 0); + g_object_set_data (G_OBJECT (tbl), "text-fill", rbutton); + 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); + + //spacer + gtk_box_pack_start (GTK_BOX (tbl), gtk_vseparator_new (), FALSE, FALSE, 4); + + ////////////Text style + row = gtk_hbox_new (FALSE, 4); + + // 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_toggle_button_set_mode (GTK_TOGGLE_BUTTON (rbutton), FALSE); + gtk_tooltips_set_tip(tt, rbutton, _("Bold"), NULL); + + gtk_box_pack_start (GTK_BOX (row), rbutton, FALSE, FALSE, 0); + g_object_set_data (G_OBJECT (tbl), "style-bold", rbutton); + g_signal_connect (G_OBJECT (rbutton), "toggled", G_CALLBACK (sp_text_toolbox_style_toggled), gpointer(0)); + + // 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_toggle_button_set_mode (GTK_TOGGLE_BUTTON (rbutton), FALSE); + gtk_tooltips_set_tip(tt, rbutton, _("Italic"), NULL); + + gtk_box_pack_start (GTK_BOX (row), rbutton, FALSE, FALSE, 0); + 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); + + //spacer + gtk_box_pack_start (GTK_BOX (tbl), gtk_vseparator_new (), FALSE, FALSE, 4); + + ////////////Text orientation + group = gtk_radio_button_new (NULL); + row = gtk_hbox_new (FALSE, 4); + g_object_set_data (G_OBJECT (tbl), "orientation-group", group); + + // 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_toggle_button_set_mode (GTK_TOGGLE_BUTTON (rbutton), FALSE); + gtk_tooltips_set_tip(tt, rbutton, _("Horizontal text"), NULL); + + gtk_box_pack_start (GTK_BOX (row), rbutton, FALSE, FALSE, 0); + g_object_set_data (G_OBJECT (tbl), "orientation-horizontal", rbutton); + g_signal_connect (G_OBJECT (rbutton), "toggled", G_CALLBACK (sp_text_toolbox_orientation_toggled), gpointer(0)); + + // 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_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); + + + //watch selection + Inkscape::ConnectionPool* pool = Inkscape::ConnectionPool::new_connection_pool ("ISTextToolbox"); + + sigc::connection *c_selection_changed = + new sigc::connection (sp_desktop_selection (desktop)->connectChanged + (sigc::bind (sigc::ptr_fun (sp_text_toolbox_selection_changed), (GObject*)tbl))); + pool->add_connection ("selection-changed", c_selection_changed); + + sigc::connection *c_selection_modified = + new sigc::connection (sp_desktop_selection (desktop)->connectModified + (sigc::bind (sigc::ptr_fun (sp_text_toolbox_selection_modified), (GObject*)tbl))); + pool->add_connection ("selection-modified", c_selection_modified); + + sigc::connection *c_subselection_changed = + new sigc::connection (desktop->connectToolSubselectionChanged + (sigc::bind (sigc::ptr_fun (sp_text_toolbox_subselection_changed), (GObject*)tbl))); + pool->add_connection ("tool-subselection-changed", c_subselection_changed); + + Inkscape::ConnectionPool::connect_destroy (G_OBJECT (tbl), pool); + + +#if 0 + // horizontal + { GtkWidget *px= sp_icon_new(Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_WRITING_MODE_LR); GtkWidget *b = group = gtk_radio_button_new (NULL); - gtk_container_add (GTK_CONTAINER (b), px); + gtk_container_add (GTK_CONTAINER (b), px); gtk_tooltips_set_tip (tt, b, _("Horizontal text"), NULL); gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE ); gtk_box_pack_start (GTK_BOX (tbl), b, FALSE, FALSE, 0); - } + } - // vertical - { + // vertical + { GtkWidget *px = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_WRITING_MODE_TB); GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group))); - gtk_container_add (GTK_CONTAINER (b), px); + gtk_container_add (GTK_CONTAINER (b), px); gtk_tooltips_set_tip (tt, b, _("Vertical text"), NULL); gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE ); gtk_box_pack_start (GTK_BOX (tbl), b, FALSE, FALSE, 0); - } + } - aux_toolbox_space(tbl, AUX_BETWEEN_BUTTON_GROUPS); + aux_toolbox_space(tbl, AUX_BETWEEN_BUTTON_GROUPS); - // letter spacing + // letter spacing { { - GtkWidget *image = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_TEXT_LETTER_SPACING); - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - gtk_container_add (GTK_CONTAINER (hb), image); - gtk_widget_show(image); - gtk_box_pack_start (GTK_BOX (tbl), hb, FALSE, FALSE, 0); + GtkWidget *image = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_TEXT_LETTER_SPACING); + GtkWidget *hb = gtk_hbox_new(FALSE, 1); + gtk_container_add (GTK_CONTAINER (hb), image); + gtk_widget_show(image); + gtk_box_pack_start (GTK_BOX (tbl), hb, FALSE, FALSE, 0); } { @@ -2869,14 +3850,14 @@ sp_text_toolbox_new(SPDesktop *desktop) } } - // line spacing + // line spacing { { - GtkWidget *image = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_TEXT_LINE_SPACING); - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - gtk_container_add (GTK_CONTAINER (hb), image); - gtk_widget_show(image); - gtk_box_pack_start (GTK_BOX (tbl), hb, FALSE, FALSE, 0); + GtkWidget *image = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_TEXT_LINE_SPACING); + GtkWidget *hb = gtk_hbox_new(FALSE, 1); + gtk_container_add (GTK_CONTAINER (hb), image); + gtk_widget_show(image); + gtk_box_pack_start (GTK_BOX (tbl), hb, FALSE, FALSE, 0); } { @@ -2890,71 +3871,71 @@ sp_text_toolbox_new(SPDesktop *desktop) } } -{ - // horizontal kerning/vertical kerning units menu: create - 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), desktop->namedview->doc_units); + { + // horizontal kerning/vertical kerning units menu: create + 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), desktop->namedview->doc_units); - aux_toolbox_space(tbl, AUX_BETWEEN_BUTTON_GROUPS); + aux_toolbox_space(tbl, AUX_BETWEEN_BUTTON_GROUPS); - // horizontal kerning - { + // horizontal kerning { - GtkWidget *image = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_TEXT_HORZ_KERN); - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - gtk_container_add (GTK_CONTAINER (hb), image); - gtk_widget_show(image); - gtk_box_pack_start (GTK_BOX (tbl), hb, FALSE, FALSE, 0); - } + { + GtkWidget *image = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_TEXT_HORZ_KERN); + GtkWidget *hb = gtk_hbox_new(FALSE, 1); + gtk_container_add (GTK_CONTAINER (hb), image); + gtk_widget_show(image); + gtk_box_pack_start (GTK_BOX (tbl), hb, FALSE, FALSE, 0); + } - { - GtkWidget *hb = sp_tb_spinbutton(_(""), _("Horizontal kerning"), - "tools.text", "horizontal_kerning", 0, - us, tbl, FALSE, NULL, - -100.00, 100.00, 0.01, 0.1, - sp_text_horiz_kern_changed); - gtk_widget_set_size_request (hb, 45, 0); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, 6); + { + GtkWidget *hb = sp_tb_spinbutton(_(""), _("Horizontal kerning"), + "tools.text", "horizontal_kerning", 0, + us, tbl, FALSE, NULL, + -100.00, 100.00, 0.01, 0.1, + sp_text_horiz_kern_changed); + gtk_widget_set_size_request (hb, 45, 0); + gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, 6); + } } - } - // vertical kerning - { + // vertical kerning { - GtkWidget *image = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_TEXT_VERT_KERN); - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - gtk_container_add (GTK_CONTAINER (hb), image); - gtk_widget_show(image); - gtk_box_pack_start (GTK_BOX (tbl), hb, FALSE, FALSE, 0); - } + { + GtkWidget *image = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_TEXT_VERT_KERN); + GtkWidget *hb = gtk_hbox_new(FALSE, 1); + gtk_container_add (GTK_CONTAINER (hb), image); + gtk_widget_show(image); + gtk_box_pack_start (GTK_BOX (tbl), hb, FALSE, FALSE, 0); + } - { - GtkWidget *hb = sp_tb_spinbutton(_(""), _("Vertical kerning"), - "tools.text", "vertical_kerning", 0, - us, tbl, FALSE, NULL, - -100.00, 100.00, 0.01, 0.1, - sp_text_vert_kern_changed); - gtk_widget_set_size_request (hb, 45, 0); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, 5); + { + GtkWidget *hb = sp_tb_spinbutton(_(""), _("Vertical kerning"), + "tools.text", "vertical_kerning", 0, + us, tbl, FALSE, NULL, + -100.00, 100.00, 0.01, 0.1, + sp_text_vert_kern_changed); + gtk_widget_set_size_request (hb, 45, 0); + gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, 5); + } } - } - // add the units menu - gtk_widget_show(us); - gtk_box_pack_start(GTK_BOX(tbl), us, FALSE, FALSE, 1); - gtk_object_set_data(GTK_OBJECT(tbl), "units", us); + // add the units menu + gtk_widget_show(us); + gtk_box_pack_start(GTK_BOX(tbl), us, FALSE, FALSE, 1); + gtk_object_set_data(GTK_OBJECT(tbl), "units", us); } - // letter rotation + // letter rotation aux_toolbox_space(tbl, AUX_BETWEEN_BUTTON_GROUPS); { { - GtkWidget *image = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_TEXT_ROTATION); - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - gtk_container_add (GTK_CONTAINER (hb), image); - gtk_widget_show(image); - gtk_box_pack_start (GTK_BOX (tbl), hb, FALSE, FALSE, 0); + GtkWidget *image = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_TEXT_ROTATION); + GtkWidget *hb = gtk_hbox_new(FALSE, 1); + gtk_container_add (GTK_CONTAINER (hb), image); + gtk_widget_show(image); + gtk_box_pack_start (GTK_BOX (tbl), hb, FALSE, FALSE, 0); } { GtkWidget *hb = sp_tb_spinbutton(_(""), _("Letter rotation"), @@ -2967,13 +3948,13 @@ sp_text_toolbox_new(SPDesktop *desktop) } // rotation degree label { - GtkWidget *label = gtk_widget_new (GTK_TYPE_LABEL, "label", "\302\260", "xalign", 0.0, NULL); - gtk_box_pack_start(GTK_BOX(tbl), label, FALSE, FALSE, 0); + GtkWidget *label = gtk_widget_new (GTK_TYPE_LABEL, "label", "\302\260", "xalign", 0.0, NULL); + gtk_box_pack_start(GTK_BOX(tbl), label, FALSE, FALSE, 0); } } - // Remove Manual Kerns - { + // Remove Manual Kerns + { GtkWidget *px = sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_TEXT_REMOVE_KERNS); GtkWidget *button = gtk_button_new (); gtk_container_add (GTK_CONTAINER (button), px); @@ -2982,15 +3963,16 @@ sp_text_toolbox_new(SPDesktop *desktop) gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_widget_set_sensitive(button, TRUE); gtk_box_pack_start (GTK_BOX (tbl), button, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); - } - - gtk_widget_show_all(tbl); - sp_set_font_size_smaller (tbl); + } +#endif -*/ return tbl; + gtk_widget_show_all (tbl); + return tbl; } // end of sp_text_toolbox_new() +}// namespace + //######################### //## Connector Toolbox ## @@ -3008,6 +3990,7 @@ static void sp_connector_path_set_ignore(void) } + static void connector_spacing_changed(GtkAdjustment *adj, GtkWidget *tbl) { // quit if run by the _changed callbacks @@ -3043,13 +4026,58 @@ static void connector_spacing_changed(GtkAdjustment *adj, GtkWidget *tbl) g_slist_free(items); } - sp_document_done(doc); + sp_document_done(doc, SP_VERB_CONTEXT_CONNECTOR, + _("Change connector spacing")); g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); spinbutton_defocus(GTK_OBJECT(tbl)); } +static void sp_connector_graph_layout(void) +{ + if (!SP_ACTIVE_DESKTOP) return; + + // hack for clones, see comment in align-and-distribute.cpp + int saved_compensation = prefs_get_int_attribute("options.clonecompensation", "value", SP_CLONE_COMPENSATION_UNMOVED); + prefs_set_int_attribute("options.clonecompensation", "value", SP_CLONE_COMPENSATION_UNMOVED); + + graphlayout(sp_desktop_selection(SP_ACTIVE_DESKTOP)->itemList()); + + prefs_set_int_attribute("options.clonecompensation", "value", saved_compensation); + + sp_document_done(sp_desktop_document(SP_ACTIVE_DESKTOP), SP_VERB_DIALOG_ALIGN_DISTRIBUTE, _("Arrange connector network")); +} + +static void +sp_directed_graph_layout_toggled(GtkWidget *widget, GtkObject *tbl) +{ + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) { + prefs_set_string_attribute("tools.connector", "directedlayout", + "true"); + } else { + prefs_set_string_attribute("tools.connector", "directedlayout", + "false"); + } +} +static void +sp_nooverlaps_graph_layout_toggled(GtkWidget *widget, GtkObject *tbl) +{ + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) { + prefs_set_string_attribute("tools.connector", "avoidoverlaplayout", + "true"); + } else { + prefs_set_string_attribute("tools.connector", "avoidoverlaplayout", + "false"); + } +} + + +static void connector_length_changed(GtkAdjustment *adj, GtkWidget *tbl) +{ + prefs_set_double_attribute("tools.connector", "length", adj->value); + spinbutton_defocus(GTK_OBJECT(tbl)); +} static void connector_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const *name, gchar const *old_value, gchar const *new_value, @@ -3094,11 +4122,11 @@ sp_connector_toolbox_new(SPDesktop *desktop) gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); - sp_toolbox_button_new(tbl, Inkscape::ICON_SIZE_DECORATION, + sp_toolbox_button_new(tbl, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "connector_avoid", GTK_SIGNAL_FUNC(sp_connector_path_set_avoid), tt, _("Make connectors avoid selected objects")); - sp_toolbox_button_new(tbl, Inkscape::ICON_SIZE_DECORATION, + sp_toolbox_button_new(tbl, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "connector_ignore", GTK_SIGNAL_FUNC(sp_connector_path_set_ignore), tt, _("Make connectors ignore selected objects")); @@ -3117,6 +4145,50 @@ sp_connector_toolbox_new(SPDesktop *desktop) gtk_box_pack_start(GTK_BOX(tbl), object_spacing, FALSE, FALSE, AUX_SPACING); } + // Graph (connector network) layout + sp_toolbox_button_new(tbl, Inkscape::ICON_SIZE_SMALL_TOOLBAR, + "graph_layout", GTK_SIGNAL_FUNC(sp_connector_graph_layout), + tt, _("Nicely arrange selected connector network")); + // Default connector length spinbox + { + GtkWidget *connector_length = sp_tb_spinbutton(_("Length:"), + _("Ideal length for connectors when layout is applied"), + "tools.connector", "length", 100, NULL, tbl, TRUE, + "inkscape:connector-length", 10, 1000, 10.0, 100.0, + connector_length_changed, 1, 0); + + gtk_box_pack_start(GTK_BOX(tbl), connector_length, FALSE, FALSE, + AUX_SPACING); + } + gchar const *tbuttonstate; + // Directed edges toggle button + { + GtkWidget *tbutton = gtk_toggle_button_new (); + gtk_button_set_relief (GTK_BUTTON (tbutton), GTK_RELIEF_NONE); + gtk_container_add (GTK_CONTAINER (tbutton), sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, "directed_graph")); + gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (tbutton), FALSE); + gtk_tooltips_set_tip(tt, tbutton, _("Make connectors with end-markers (arrows) point downwards"), NULL); + + gtk_box_pack_start (GTK_BOX (tbl), tbutton, FALSE, FALSE, 0); + g_signal_connect(G_OBJECT(tbutton), "toggled", GTK_SIGNAL_FUNC(sp_directed_graph_layout_toggled), tbl); + tbuttonstate = prefs_get_string_attribute("tools.connector", "directedlayout"); + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(tbutton), + (tbuttonstate && !strcmp(tbuttonstate, "true"))?TRUE:FALSE ); + } + // Avoid overlaps toggle button + { + GtkWidget *tbutton = gtk_toggle_button_new (); + gtk_button_set_relief (GTK_BUTTON (tbutton), GTK_RELIEF_NONE); + gtk_container_add (GTK_CONTAINER (tbutton), sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, "remove_overlaps")); + gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (tbutton), FALSE); + gtk_tooltips_set_tip(tt, tbutton, _("Do not allow overlapping shapes"), NULL); + + gtk_box_pack_start (GTK_BOX (tbl), tbutton, FALSE, FALSE, 0); + g_signal_connect(G_OBJECT(tbutton), "toggled", GTK_SIGNAL_FUNC(sp_nooverlaps_graph_layout_toggled), tbl); + tbuttonstate = prefs_get_string_attribute("tools.connector", "avoidoverlaplayout"); + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(tbutton), + (tbuttonstate && !strcmp(tbuttonstate, "true"))?TRUE:FALSE ); + } gtk_widget_show_all(tbl); sp_set_font_size_smaller (tbl); @@ -3140,12 +4212,102 @@ sp_connector_toolbox_new(SPDesktop *desktop) g_object_set_data(G_OBJECT(tbl), "repr", repr); Inkscape::GC::anchor(repr); sp_repr_add_listener(repr, &connector_tb_repr_events, tbl); + sp_repr_synthesize_events(repr, &connector_tb_repr_events, tbl); } return tbl; } // 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: