X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fwidgets%2Ftoolbox.cpp;h=fcf3e0ce6bd874917ee2b0730179a33b326adf6e;hb=72aa7310f3a87958233d5cb4bf1386ff999be0ac;hp=975a8cbdac708ec55c3fc3e3739336030eb615a6;hpb=5f320e669222a58f8d1e3cc7ebac98f81c108e31;p=inkscape.git diff --git a/src/widgets/toolbox.cpp b/src/widgets/toolbox.cpp index 975a8cbda..fcf3e0ce6 100644 --- a/src/widgets/toolbox.cpp +++ b/src/widgets/toolbox.cpp @@ -1,7 +1,5 @@ -#define __SP_MAINTOOLBOX_C__ - /** \file - * Controls bars for some of Inkscape's tools + * Controls bars for some of Inkscape's tools * (for some tools, they are in their own files) */ @@ -29,6 +27,9 @@ # include "config.h" #endif +#include +#include + #include #include #include @@ -39,6 +40,7 @@ #include "widgets/spw-utilities.h" #include "widgets/spinbutton-events.h" #include "dialogs/text-edit.h" +#include "dialogs/dialog-events.h" #include "ui/widget/style-swatch.h" @@ -47,7 +49,6 @@ #include "sp-namedview.h" #include "desktop.h" #include "desktop-handles.h" -#include "nodepath.h" #include "xml/repr.h" #include "xml/node-event-vector.h" #include @@ -62,7 +63,12 @@ #include "gradient-toolbar.h" #include "connector-context.h" +#include "node-context.h" +#include "shape-editor.h" +#include "tweak-context.h" #include "sp-rect.h" +#include "box3d.h" +#include "box3d-context.h" #include "sp-star.h" #include "sp-spiral.h" #include "sp-ellipse.h" @@ -70,9 +76,11 @@ #include "sp-flowtext.h" #include "style.h" #include "selection.h" +#include "selection-chemistry.h" #include "document-private.h" #include "desktop-style.h" #include "../libnrtype/font-lister.h" +#include "../libnrtype/font-instance.h" #include "../connection-pool.h" #include "../prefs-utils.h" #include "../inkscape-stock.h" @@ -87,23 +95,32 @@ #include "ink-action.h" #include "ege-adjustment-action.h" +#include "ege-output-action.h" +#include "ege-select-one-action.h" +#include "helper/unit-tracker.h" + +#include "svg/css-ostringstream.h" + +using Inkscape::UnitTracker; typedef void (*SetupFunction)(GtkWidget *toolbox, SPDesktop *desktop); typedef void (*UpdateFunction)(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox); -static GtkWidget *sp_node_toolbox_new(SPDesktop *desktop); -static GtkWidget *sp_zoom_toolbox_new(SPDesktop *desktop); -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 void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +static void sp_zoom_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +static void sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +static void sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +static void sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +static void sp_spiral_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +static void sp_pencil_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +static void sp_pen_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +static void sp_dropper_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); static GtkWidget *sp_empty_toolbox_new(SPDesktop *desktop); -static GtkWidget *sp_connector_toolbox_new(SPDesktop *desktop); -static GtkWidget *sp_paintbucket_toolbox_new(SPDesktop *desktop); +static void sp_connector_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +static void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); namespace { GtkWidget *sp_text_toolbox_new (SPDesktop *desktop); } @@ -116,8 +133,10 @@ static struct { } const tools[] = { { "SPSelectContext", "select_tool", SP_VERB_CONTEXT_SELECT, SP_VERB_CONTEXT_SELECT_PREFS}, { "SPNodeContext", "node_tool", SP_VERB_CONTEXT_NODE, SP_VERB_CONTEXT_NODE_PREFS }, + { "SPTweakContext", "tweak_tool", SP_VERB_CONTEXT_TWEAK, SP_VERB_CONTEXT_TWEAK_PREFS }, { "SPZoomContext", "zoom_tool", SP_VERB_CONTEXT_ZOOM, SP_VERB_CONTEXT_ZOOM_PREFS }, { "SPRectContext", "rect_tool", SP_VERB_CONTEXT_RECT, SP_VERB_CONTEXT_RECT_PREFS }, + { "Box3DContext", "3dbox_tool", SP_VERB_CONTEXT_3DBOX, SP_VERB_CONTEXT_3DBOX_PREFS }, { "SPArcContext", "arc_tool", SP_VERB_CONTEXT_ARC, SP_VERB_CONTEXT_ARC_PREFS }, { "SPStarContext", "star_tool", SP_VERB_CONTEXT_STAR, SP_VERB_CONTEXT_STAR_PREFS }, { "SPSpiralContext", "spiral_tool", SP_VERB_CONTEXT_SPIRAL, SP_VERB_CONTEXT_SPIRAL_PREFS }, @@ -136,25 +155,260 @@ static struct { gchar const *type_name; gchar const *data_name; GtkWidget *(*create_func)(SPDesktop *desktop); + void (*prep_func)(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); + gchar const *ui_name; + gint swatch_verb_id; + gchar const *swatch_tool; + gchar const *swatch_tip; } const aux_toolboxes[] = { - { "SPSelectContext", "select_toolbox", sp_select_toolbox_new }, - { "SPNodeContext", "node_toolbox", sp_node_toolbox_new }, - { "SPZoomContext", "zoom_toolbox", sp_zoom_toolbox_new }, - { "SPStarContext", "star_toolbox", sp_star_toolbox_new }, - { "SPRectContext", "rect_toolbox", sp_rect_toolbox_new }, - { "SPArcContext", "arc_toolbox", sp_arc_toolbox_new }, - { "SPSpiralContext", "spiral_toolbox", sp_spiral_toolbox_new }, - { "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 } + { "SPSelectContext", "select_toolbox", 0, sp_select_toolbox_prep, "SelectToolbar", + SP_VERB_INVALID, 0, 0}, + { "SPNodeContext", "node_toolbox", 0, sp_node_toolbox_prep, "NodeToolbar", + SP_VERB_INVALID, 0, 0}, + { "SPTweakContext", "tweak_toolbox", 0, sp_tweak_toolbox_prep, "TweakToolbar", + SP_VERB_CONTEXT_TWEAK_PREFS, "tools.tweak", _("Color/opacity used for color tweaking")}, + { "SPZoomContext", "zoom_toolbox", 0, sp_zoom_toolbox_prep, "ZoomToolbar", + SP_VERB_INVALID, 0, 0}, + { "SPStarContext", "star_toolbox", 0, sp_star_toolbox_prep, "StarToolbar", + SP_VERB_CONTEXT_STAR_PREFS, "tools.shapes.star", _("Style of new stars")}, + { "SPRectContext", "rect_toolbox", 0, sp_rect_toolbox_prep, "RectToolbar", + SP_VERB_CONTEXT_RECT_PREFS, "tools.shapes.rect", _("Style of new rectangles")}, + { "Box3DContext", "3dbox_toolbox", 0, box3d_toolbox_prep, "3DBoxToolbar", + SP_VERB_CONTEXT_3DBOX_PREFS, "tools.shapes.3dbox", _("Style of new 3D boxes")}, + { "SPArcContext", "arc_toolbox", 0, sp_arc_toolbox_prep, "ArcToolbar", + SP_VERB_CONTEXT_ARC_PREFS, "tools.shapes.arc", _("Style of new ellipses")}, + { "SPSpiralContext", "spiral_toolbox", 0, sp_spiral_toolbox_prep, "SpiralToolbar", + SP_VERB_CONTEXT_SPIRAL_PREFS, "tools.shapes.spiral", _("Style of new spirals")}, + { "SPPencilContext", "pencil_toolbox", 0, sp_pencil_toolbox_prep, "PencilToolbar", + SP_VERB_CONTEXT_PENCIL_PREFS, "tools.freehand.pencil", _("Style of new paths created by Pencil")}, + { "SPPenContext", "pen_toolbox", 0, sp_pen_toolbox_prep, "PenToolbar", + SP_VERB_CONTEXT_PEN_PREFS, "tools.freehand.pen", _("Style of new paths created by Pen")}, + { "SPDynaDrawContext", "calligraphy_toolbox", 0, sp_calligraphy_toolbox_prep,"CalligraphyToolbar", + SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS, "tools.calligraphic", _("Style of new calligraphic strokes")}, + { "SPTextContext", "text_toolbox", sp_text_toolbox_new, 0, 0, + SP_VERB_INVALID, 0, 0}, + { "SPDropperContext", "dropper_toolbox", 0, sp_dropper_toolbox_prep, "DropperToolbar", + SP_VERB_INVALID, 0, 0}, + { "SPGradientContext", "gradient_toolbox", sp_gradient_toolbox_new, 0, 0, + SP_VERB_INVALID, 0, 0}, + { "SPConnectorContext", "connector_toolbox", 0, sp_connector_toolbox_prep, "ConnectorToolbar", + SP_VERB_INVALID, 0, 0}, + { "SPFloodContext", "paintbucket_toolbox", 0, sp_paintbucket_toolbox_prep, "PaintbucketToolbar", + SP_VERB_CONTEXT_PAINTBUCKET_PREFS, "tools.paintbucket", _("Style of Paint Bucket fill objects")}, + { NULL, NULL, NULL, NULL, NULL, SP_VERB_INVALID, NULL, NULL } }; + +static gchar const * ui_descr = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + + " " + " " + " " + " " + " " + " " + " " + " " + + " " + " " + + " " + " " + + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + + " " + " " + " " + " " + + " " + " " + " " + " " + " " + " " + " " + " " + " " + + "" +; + +static GtkActionGroup* create_or_fetch_actions( SPDesktop* desktop ); + 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); @@ -167,25 +421,25 @@ 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, +/* GtkWidget *dropper_rgb_entry, *dropper_opacity_entry ; */ // should be made a private member once this is converted to class -static void delete_connection(GObject *obj, sigc::connection *connection) { +static void delete_connection(GObject */*obj*/, sigc::connection *connection) { connection->disconnect(); delete connection; } -static GtkWidget * -sp_toolbox_button_new(GtkWidget *t, Inkscape::IconSize size, gchar const *pxname, GtkSignalFunc handler, - GtkTooltips *tt, gchar const *tip) +static void purge_repr_listener( GObject* obj, GObject* tbl ) { - GtkWidget *b = sp_button_new_from_data(size, SP_BUTTON_TYPE_NORMAL, NULL, pxname, tip, tt); - gtk_widget_show(b); - if (handler) gtk_signal_connect(GTK_OBJECT(b), "clicked", handler, NULL); - gtk_box_pack_start(GTK_BOX(t), b, FALSE, FALSE, 0); - - return b; + (void)obj; + Inkscape::XML::Node* oldrepr = reinterpret_cast( g_object_get_data( tbl, "repr" ) ); + if (oldrepr) { // remove old listener + sp_repr_remove_listener_by_data(oldrepr, tbl); + Inkscape::GC::release(oldrepr); + oldrepr = 0; + g_object_set_data( tbl, "repr", NULL ); + } } GtkWidget * @@ -223,6 +477,122 @@ GtkWidget * sp_toolbox_button_normal_new_from_verb(GtkWidget *t, Inkscape::IconS return sp_toolbox_button_new_from_verb(t, size, SP_BUTTON_TYPE_NORMAL, verb, view, tt); } + +static void trigger_sp_action( GtkAction* /*act*/, gpointer user_data ) +{ + SPAction* targetAction = SP_ACTION(user_data); + if ( targetAction ) { + sp_action_perform( targetAction, NULL ); + } +} + +static void sp_action_action_set_sensitive (SPAction */*action*/, unsigned int sensitive, void *data) +{ + if ( data ) { + GtkAction* act = GTK_ACTION(data); + gtk_action_set_sensitive( act, sensitive ); + } +} + +static SPActionEventVector action_event_vector = { + {NULL}, + NULL, + NULL, + sp_action_action_set_sensitive, + NULL, + NULL +}; + +static GtkAction* create_action_for_verb( Inkscape::Verb* verb, Inkscape::UI::View::View* view, Inkscape::IconSize size ) +{ + GtkAction* act = 0; + + SPAction* targetAction = verb->get_action(view); + InkAction* inky = ink_action_new( verb->get_id(), _(verb->get_name()), verb->get_tip(), verb->get_image(), size ); + act = GTK_ACTION(inky); + gtk_action_set_sensitive( act, targetAction->sensitive ); + + g_signal_connect( G_OBJECT(inky), "activate", GTK_SIGNAL_FUNC(trigger_sp_action), targetAction ); + + SPAction*rebound = dynamic_cast( nr_object_ref( dynamic_cast(targetAction) ) ); + nr_active_object_add_listener( (NRActiveObject *)rebound, (NRObjectEventVector *)&action_event_vector, sizeof(SPActionEventVector), inky ); + + return act; +} + +GtkActionGroup* create_or_fetch_actions( SPDesktop* desktop ) +{ + Inkscape::UI::View::View *view = desktop; + gint verbsToUse[] = { + // disabled until we have icons for them: + //find + //SP_VERB_EDIT_TILE, + //SP_VERB_EDIT_UNTILE, + SP_VERB_DIALOG_ALIGN_DISTRIBUTE, + SP_VERB_DIALOG_DISPLAY, + SP_VERB_DIALOG_FILL_STROKE, + SP_VERB_DIALOG_NAMEDVIEW, + SP_VERB_DIALOG_TEXT, + SP_VERB_DIALOG_XML_EDITOR, + SP_VERB_EDIT_CLONE, + SP_VERB_EDIT_COPY, + SP_VERB_EDIT_CUT, + SP_VERB_EDIT_DUPLICATE, + SP_VERB_EDIT_PASTE, + SP_VERB_EDIT_REDO, + SP_VERB_EDIT_UNDO, + SP_VERB_EDIT_UNLINK_CLONE, + SP_VERB_FILE_EXPORT, + SP_VERB_FILE_IMPORT, + SP_VERB_FILE_NEW, + SP_VERB_FILE_OPEN, + SP_VERB_FILE_PRINT, + SP_VERB_FILE_SAVE, + SP_VERB_OBJECT_TO_CURVE, + SP_VERB_SELECTION_GROUP, + SP_VERB_SELECTION_OUTLINE, + SP_VERB_SELECTION_UNGROUP, + SP_VERB_ZOOM_1_1, + SP_VERB_ZOOM_1_2, + SP_VERB_ZOOM_2_1, + SP_VERB_ZOOM_DRAWING, + SP_VERB_ZOOM_IN, + SP_VERB_ZOOM_NEXT, + SP_VERB_ZOOM_OUT, + SP_VERB_ZOOM_PAGE, + SP_VERB_ZOOM_PAGE_WIDTH, + SP_VERB_ZOOM_PREV, + SP_VERB_ZOOM_SELECTION, + }; + + gint shrinkTop = prefs_get_int_attribute_limited( "toolbox", "small", 1, 0, 1 ); + Inkscape::IconSize toolboxSize = shrinkTop ? Inkscape::ICON_SIZE_SMALL_TOOLBAR : Inkscape::ICON_SIZE_LARGE_TOOLBAR; + + static std::map groups; + GtkActionGroup* mainActions = 0; + if ( groups.find(desktop) != groups.end() ) { + mainActions = groups[desktop]; + } + + if ( !mainActions ) { + mainActions = gtk_action_group_new("main"); + groups[desktop] = mainActions; + } + + for ( guint i = 0; i < G_N_ELEMENTS(verbsToUse); i++ ) { + Inkscape::Verb* verb = Inkscape::Verb::get(verbsToUse[i]); + if ( verb ) { + if ( !gtk_action_group_get_action( mainActions, verb->get_id() ) ) { + GtkAction* act = create_action_for_verb( verb, view, toolboxSize ); + gtk_action_group_add_action( mainActions, act ); + } + } + } + + return mainActions; +} + + GtkWidget * sp_tool_toolbox_new() { @@ -249,14 +619,14 @@ sp_tool_toolbox_new() } static void -aux_toolbox_attached(GtkHandleBox *toolbox, GtkWidget *child) +aux_toolbox_attached(GtkHandleBox */*toolbox*/, GtkWidget *child) { g_object_set_data(G_OBJECT(child), "is_detached", GINT_TO_POINTER(FALSE)); gtk_widget_queue_resize(child); } static void -aux_toolbox_detached(GtkHandleBox *toolbox, GtkWidget *child) +aux_toolbox_detached(GtkHandleBox */*toolbox*/, GtkWidget *child) { g_object_set_data(G_OBJECT(child), "is_detached", GINT_TO_POINTER(TRUE)); gtk_widget_queue_resize(child); @@ -267,14 +637,9 @@ sp_aux_toolbox_new() { GtkWidget *tb = gtk_vbox_new(FALSE, 0); - GtkWidget *tb_s = gtk_vbox_new(FALSE, 0); - GtkWidget *tb_e = gtk_vbox_new(FALSE, 0); gtk_box_set_spacing(GTK_BOX(tb), AUX_SPACING); - gtk_box_pack_start(GTK_BOX(tb), GTK_WIDGET(tb_s), FALSE, FALSE, 0); - gtk_box_pack_end(GTK_BOX(tb), GTK_WIDGET(tb_e), FALSE, FALSE, 0); g_object_set_data(G_OBJECT(tb), "desktop", NULL); - g_object_set_data(G_OBJECT(tb), "top_spacer", tb_s); gtk_widget_set_sensitive(tb, FALSE); @@ -304,11 +669,7 @@ sp_commands_toolbox_new() { GtkWidget *tb = gtk_vbox_new(FALSE, 0); - GtkWidget *tb_s = gtk_vbox_new(FALSE, 0); - GtkWidget *tb_e = gtk_vbox_new(FALSE, 0); gtk_box_set_spacing(GTK_BOX(tb), AUX_SPACING); - gtk_box_pack_start(GTK_BOX(tb), GTK_WIDGET(tb_s), FALSE, FALSE, 0); - gtk_box_pack_end(GTK_BOX(tb), GTK_WIDGET(tb_e), FALSE, FALSE, 0); g_object_set_data(G_OBJECT(tb), "desktop", NULL); gtk_widget_set_sensitive(tb, FALSE); @@ -330,215 +691,498 @@ sp_commands_toolbox_new() return hb; } +static EgeAdjustmentAction * create_adjustment_action( gchar const *name, + gchar const *label, gchar const *shortLabel, gchar const *tooltip, + gchar const *path, gchar const *data, gdouble def, + GtkWidget *focusTarget, + GtkWidget *us, + GObject *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 *, GObject *), + 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 ( shortLabel ) { + g_object_set( act, "short_label", shortLabel, NULL ); + } + + 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 ) { + g_object_set_data( 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; +} + //#################################### //# node editing callbacks //#################################### +/** + * FIXME: Returns current shape_editor in context. // later eliminate this function at all! + */ +static ShapeEditor *get_current_shape_editor() +{ + if (!SP_ACTIVE_DESKTOP) { + return NULL; + } + + SPEventContext *event_context = (SP_ACTIVE_DESKTOP)->event_context; + + if (!SP_IS_NODE_CONTEXT(event_context)) { + return NULL; + } + + return SP_NODE_CONTEXT(event_context)->shape_editor; +} + + void sp_node_path_edit_add(void) { - sp_node_selected_add_node(); + ShapeEditor *shape_editor = get_current_shape_editor(); + if (shape_editor) shape_editor->add_node(); } void sp_node_path_edit_delete(void) { - sp_node_selected_delete(); + ShapeEditor *shape_editor = get_current_shape_editor(); + if (shape_editor) shape_editor->delete_nodes(); } void sp_node_path_edit_delete_segment(void) { - sp_node_selected_delete_segment(); + ShapeEditor *shape_editor = get_current_shape_editor(); + if (shape_editor) shape_editor->delete_segment(); } void sp_node_path_edit_break(void) { - sp_node_selected_break(); + ShapeEditor *shape_editor = get_current_shape_editor(); + if (shape_editor) shape_editor->break_at_nodes(); } void sp_node_path_edit_join(void) { - sp_node_selected_join(); + ShapeEditor *shape_editor = get_current_shape_editor(); + if (shape_editor) shape_editor->join_nodes(); } void sp_node_path_edit_join_segment(void) { - sp_node_selected_join_segment(); + ShapeEditor *shape_editor = get_current_shape_editor(); + if (shape_editor) shape_editor->join_segments(); } void sp_node_path_edit_toline(void) { - sp_node_selected_set_line_type(NR_LINETO); + ShapeEditor *shape_editor = get_current_shape_editor(); + if (shape_editor) shape_editor->set_type_of_segments(NR_LINETO); } void sp_node_path_edit_tocurve(void) { - sp_node_selected_set_line_type(NR_CURVETO); + ShapeEditor *shape_editor = get_current_shape_editor(); + if (shape_editor) shape_editor->set_type_of_segments(NR_CURVETO); } void sp_node_path_edit_cusp(void) { - sp_node_selected_set_type(Inkscape::NodePath::NODE_CUSP); + ShapeEditor *shape_editor = get_current_shape_editor(); + if (shape_editor) shape_editor->set_node_type(Inkscape::NodePath::NODE_CUSP); } void sp_node_path_edit_smooth(void) { - sp_node_selected_set_type(Inkscape::NodePath::NODE_SMOOTH); + ShapeEditor *shape_editor = get_current_shape_editor(); + if (shape_editor) shape_editor->set_node_type(Inkscape::NodePath::NODE_SMOOTH); } void sp_node_path_edit_symmetrical(void) { - sp_node_selected_set_type(Inkscape::NodePath::NODE_SYMM); + ShapeEditor *shape_editor = get_current_shape_editor(); + if (shape_editor) shape_editor->set_node_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)); +static void toggle_show_handles (GtkToggleAction *act, gpointer /*data*/) { + bool show = gtk_toggle_action_get_active( act ); prefs_set_int_attribute ("tools.nodes", "show_handles", show ? 1 : 0); - sp_nodepath_show_handles(show); + ShapeEditor *shape_editor = get_current_shape_editor(); + if (shape_editor) shape_editor->show_handles(show); } -//################################ -//## Node Editing Toolbox ## -//################################ +static void toggle_show_helperpath (GtkToggleAction *act, gpointer /*data*/) { + bool show = gtk_toggle_action_get_active( act ); + prefs_set_int_attribute ("tools.nodes", "show_helperpath", show ? 1 : 0); + ShapeEditor *shape_editor = get_current_shape_editor(); + if (shape_editor) shape_editor->show_helperpath(show); +} -static GtkWidget * -sp_node_toolbox_new(SPDesktop *desktop) +void sp_node_path_edit_nextLPEparam (GtkAction */*act*/, gpointer data) { + sp_selection_next_patheffect_param( reinterpret_cast(data) ); +} + +/* is called when the node selection is modified */ +static void +sp_node_toolbox_coord_changed(gpointer /*shape_editor*/, GObject *tbl) { - Inkscape::UI::View::View *view = desktop; + GtkAction* xact = GTK_ACTION( g_object_get_data( tbl, "nodes_x_action" ) ); + GtkAction* yact = GTK_ACTION( g_object_get_data( tbl, "nodes_y_action" ) ); + GtkAdjustment *xadj = ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION(xact)); + GtkAdjustment *yadj = ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION(yact)); - GtkTooltips *tt = gtk_tooltips_new(); - GtkWidget *tb = gtk_hbox_new(FALSE, 0); + // quit if run by the attr_changed listener + if (g_object_get_data( tbl, "freeze" )) { + return; + } - gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + // in turn, prevent listener from responding + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE)); - sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_insert", - GTK_SIGNAL_FUNC(sp_node_path_edit_add), tt, _("Insert new nodes into selected segments")); - sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_delete", - GTK_SIGNAL_FUNC(sp_node_path_edit_delete), tt, _("Delete selected nodes")); + UnitTracker* tracker = reinterpret_cast( g_object_get_data( tbl, "tracker" ) ); + SPUnit const *unit = tracker->getActiveUnit(); - gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + ShapeEditor *shape_editor = get_current_shape_editor(); + if (shape_editor && shape_editor->has_nodepath()) { + Inkscape::NodePath::Path *nodepath = shape_editor->get_nodepath(); + int n_selected = 0; + if (nodepath) { + n_selected = nodepath->numSelected(); + } - sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_join", - GTK_SIGNAL_FUNC(sp_node_path_edit_join), tt, _("Join selected endnodes")); - sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_join_segment", - GTK_SIGNAL_FUNC(sp_node_path_edit_join_segment), tt, _("Join selected endnodes with a new segment")); + if (n_selected == 0) { + gtk_action_set_sensitive(xact, FALSE); + gtk_action_set_sensitive(yact, FALSE); + } else { + gtk_action_set_sensitive(xact, TRUE); + gtk_action_set_sensitive(yact, TRUE); + NR::Coord oldx = sp_units_get_pixels(gtk_adjustment_get_value(xadj), *unit); + NR::Coord oldy = sp_units_get_pixels(gtk_adjustment_get_value(xadj), *unit); + + if (n_selected == 1) { + NR::Point sel_node = nodepath->singleSelectedCoords(); + if (oldx != sel_node[NR::X] || oldy != sel_node[NR::Y]) { + gtk_adjustment_set_value(xadj, sp_pixels_get_units(sel_node[NR::X], *unit)); + gtk_adjustment_set_value(yadj, sp_pixels_get_units(sel_node[NR::Y], *unit)); + } + } else { + NR::Maybe x = sp_node_selected_common_coord(nodepath, NR::X); + NR::Maybe y = sp_node_selected_common_coord(nodepath, NR::Y); + if ((x && ((*x) != oldx)) || (y && ((*y) != oldy))) { + /* Note: Currently x and y will always have a value, even if the coordinates of the + selected nodes don't coincide (in this case we use the coordinates of the center + of the bounding box). So the entries are never set to zero. */ + // FIXME: Maybe we should clear the entry if several nodes are selected + // instead of providing a kind of average value + gtk_adjustment_set_value(xadj, sp_pixels_get_units(x ? (*x) : 0.0, *unit)); + gtk_adjustment_set_value(yadj, sp_pixels_get_units(y ? (*y) : 0.0, *unit)); + } + } + } + } else { + // no shape-editor or nodepath yet (when we just switched to the tool); coord entries must be inactive + gtk_action_set_sensitive(xact, FALSE); + gtk_action_set_sensitive(yact, FALSE); + } - sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_delete_segment", - GTK_SIGNAL_FUNC(sp_node_path_edit_delete_segment), tt, _("Split path between two non-endpoint nodes")); + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); +} - sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_break", - GTK_SIGNAL_FUNC(sp_node_path_edit_break), tt, _("Break path at selected nodes")); +static void +sp_node_path_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_name) +{ + SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" ); - gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + UnitTracker* tracker = reinterpret_cast(g_object_get_data( tbl, "tracker" )); + SPUnit const *unit = tracker->getActiveUnit(); - sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_cusp", - GTK_SIGNAL_FUNC(sp_node_path_edit_cusp), tt, _("Make selected nodes corner")); + if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) { + prefs_set_double_attribute("tools.nodes", value_name, sp_units_get_pixels(adj->value, *unit)); + } - sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_smooth", - GTK_SIGNAL_FUNC(sp_node_path_edit_smooth), tt, _("Make selected nodes smooth")); + // quit if run by the attr_changed listener + if (g_object_get_data( tbl, "freeze" )) { + return; + } - sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_symmetric", - GTK_SIGNAL_FUNC(sp_node_path_edit_symmetrical), tt, _("Make selected nodes symmetric")); + // in turn, prevent listener from responding + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE)); - gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + ShapeEditor *shape_editor = get_current_shape_editor(); + if (shape_editor && shape_editor->has_nodepath()) { + double val = sp_units_get_pixels(gtk_adjustment_get_value(adj), *unit); + if (!strcmp(value_name, "x")) { + sp_node_selected_move_absolute(shape_editor->get_nodepath(), val, NR::X); + } + if (!strcmp(value_name, "y")) { + sp_node_selected_move_absolute(shape_editor->get_nodepath(), val, NR::Y); + } + } - sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_line", - GTK_SIGNAL_FUNC(sp_node_path_edit_toline), tt, _("Make selected segments lines")); + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); +} - sp_toolbox_button_new(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, "node_curve", - GTK_SIGNAL_FUNC(sp_node_path_edit_tocurve), tt, _("Make selected segments curves")); +static void +sp_node_path_x_value_changed(GtkAdjustment *adj, GObject *tbl) +{ + sp_node_path_value_changed(adj, tbl, "x"); +} - gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); +static void +sp_node_path_y_value_changed(GtkAdjustment *adj, GObject *tbl) +{ + sp_node_path_value_changed(adj, tbl, "y"); +} - sp_toolbox_button_normal_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, Inkscape::Verb::get(SP_VERB_OBJECT_TO_CURVE), view, tt); +//################################ +//## Node Editing Toolbox ## +//################################ - sp_toolbox_button_normal_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, Inkscape::Verb::get(SP_VERB_SELECTION_OUTLINE), view, tt); +static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) +{ + UnitTracker* tracker = new UnitTracker( SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE ); + tracker->setActiveUnit( sp_desktop_namedview(desktop)->doc_units ); + g_object_set_data( holder, "tracker", tracker ); - aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS); + { + InkAction* inky = ink_action_new( "NodeInsertAction", + _("Insert node"), + _("Insert new nodes into selected segments"), + "node_insert", + Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + g_object_set( inky, "short_label", _("Insert"), NULL ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_add), 0 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } - GtkWidget *cvbox = gtk_vbox_new (FALSE, 0); - GtkWidget *cbox = gtk_hbox_new (FALSE, 0); + { + InkAction* inky = ink_action_new( "NodeDeleteAction", + _("Delete node"), + _("Delete selected nodes"), + "node_delete", + Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + g_object_set( inky, "short_label", _("Delete"), NULL ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_delete), 0 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } { - 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); + InkAction* inky = ink_action_new( "NodeJoinAction", + _("Join endnodes"), + _("Join selected endnodes"), + "node_join", + Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + g_object_set( inky, "short_label", _("Join"), NULL ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_join), 0 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); } - gtk_box_pack_start(GTK_BOX(cvbox), cbox, TRUE, FALSE, 0); - gtk_box_pack_start(GTK_BOX(tb), cvbox, FALSE, FALSE, 0); + { + InkAction* inky = ink_action_new( "NodeJoinSegmentAction", + _("Join Segment"), + _("Join selected endnodes with a new segment"), + "node_join_segment", + Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_join_segment), 0 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } - gtk_widget_show_all(tb); + { + InkAction* inky = ink_action_new( "NodeDeleteSegmentAction", + _("Delete Segment"), + _("Split path between two non-endpoint nodes"), + "node_delete_segment", + Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_delete_segment), 0 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } - return tb; + { + InkAction* inky = ink_action_new( "NodeBreakAction", + _("Node Break"), + _("Break path at selected nodes"), + "node_break", + Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_break), 0 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } -} // end of sp_node_toolbox_new() + { + InkAction* inky = ink_action_new( "NodeCuspAction", + _("Node Cusp"), + _("Make selected nodes corner"), + "node_cusp", + Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_cusp), 0 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } + { + InkAction* inky = ink_action_new( "NodeSmoothAction", + _("Node Smooth"), + _("Make selected nodes smooth"), + "node_smooth", + Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_smooth), 0 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } -//######################## -//## Zoom Toolbox ## -//######################## + { + InkAction* inky = ink_action_new( "NodeSymmetricAction", + _("Node Symmetric"), + _("Make selected nodes symmetric"), + "node_symmetric", + Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_symmetrical), 0 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } -static GtkWidget * -sp_zoom_toolbox_new(SPDesktop *desktop) -{ - Inkscape::UI::View::View *view=desktop; + { + InkAction* inky = ink_action_new( "NodeLineAction", + _("Node Line"), + _("Make selected segments lines"), + "node_line", + Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_toline), 0 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } - GtkTooltips *tt = gtk_tooltips_new(); - GtkWidget *tb = gtk_hbox_new(FALSE, 0); + { + InkAction* inky = ink_action_new( "NodeCurveAction", + _("Node Curve"), + _("Make selected segments curves"), + "node_curve", + Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_tocurve), 0 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } - gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), - FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + { + InkToggleAction* act = ink_toggle_action_new( "NodesShowHandlesAction", + _("Show Handles"), + _("Show the Bezier handles of selected nodes"), + "nodes_show_handles", + Inkscape::ICON_SIZE_DECORATION ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_show_handles), desktop ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.nodes", "show_handles", 1 ) ); + } - sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_IN), view, tt); + { + InkToggleAction* act = ink_toggle_action_new( "NodesShowHelperpath", + _("Show Outline"), + _("Show the outline of the path"), + "nodes_show_helperpath", + Inkscape::ICON_SIZE_DECORATION ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_show_helperpath), desktop ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.nodes", "show_helperpath", 0 ) ); + } - sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_OUT), view, tt); + { + InkAction* inky = ink_action_new( "EditNextLPEParameterAction", + _("Next Path Effect Parameter"), + _("Show next Path Effect parameter for editing"), + "edit_next_parameter", + Inkscape::ICON_SIZE_DECORATION ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_nextLPEparam), desktop ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } - gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); - - sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_SELECTION), view, tt); - - sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_DRAWING), view, tt); - - sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_PAGE), view, tt); - - sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_PAGE_WIDTH), view, tt); - - gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); - - sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_PREV), view, tt); - - sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_NEXT), view, tt); + /* X coord of selected node(s) */ + { + EgeAdjustmentAction* eact = 0; + gchar const* labels[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500}; + eact = create_adjustment_action( "NodeXAction", + _("X coordinate:"), _("X:"), _("X coordinate of selected node(s)"), + "tools.nodes", "Xcoord", 0, + GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, TRUE, "altx-nodes", + -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP, + labels, values, G_N_ELEMENTS(labels), + sp_node_path_x_value_changed ); + tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) ); + g_object_set_data( holder, "nodes_x_action", eact ); + gtk_action_set_sensitive( GTK_ACTION(eact), FALSE ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + } - gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + /* Y coord of selected node(s) */ + { + EgeAdjustmentAction* eact = 0; + gchar const* labels[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500}; + eact = create_adjustment_action( "NodeYAction", + _("Y coordinate:"), _("Y:"), _("Y coordinate of selected node(s)"), + "tools.nodes", "Ycoord", 0, + GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL, + -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP, + labels, values, G_N_ELEMENTS(labels), + sp_node_path_y_value_changed ); + tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) ); + g_object_set_data( holder, "nodes_y_action", eact ); + gtk_action_set_sensitive( GTK_ACTION(eact), FALSE ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + } - sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_1_1), view, tt); + // add the units menu + { + GtkAction* act = tracker->createAction( "NodeUnitsAction", _("Units"), ("") ); + gtk_action_group_add_action( mainActions, act ); + } - sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_1_2), view, tt); + sigc::connection *connection = new sigc::connection ( + desktop->connectToolSubselectionChanged(sigc::bind (sigc::ptr_fun(sp_node_toolbox_coord_changed), (GObject *)holder)) + ); - sp_toolbox_button_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_2_1), view, tt); + g_signal_connect( holder, "destroy", G_CALLBACK(delete_connection), connection ); + g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder ); +} // end of sp_node_toolbox_prep() - gtk_widget_show_all(tb); - return tb; +//######################## +//## Zoom Toolbox ## +//######################## -} // end of sp_zoom_toolbox_new() +static void sp_zoom_toolbox_prep(SPDesktop */*desktop*/, GtkActionGroup* /*mainActions*/, GObject* /*holder*/) +{ + // no custom GtkAction setup needed +} // end of sp_zoom_toolbox_prep() void sp_tool_toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop) @@ -581,7 +1225,7 @@ toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop, SetupFunction setup_ gtk_widget_set_sensitive(toolbox, TRUE); setup_func(toolbox, desktop); update_func(desktop, desktop->event_context, toolbox); - *conn = desktop->connectEventContextChanged + *conn = desktop->connectEventContextChanged (sigc::bind (sigc::ptr_fun(update_func), toolbox)); } else { gtk_widget_set_sensitive(toolbox, FALSE); @@ -594,7 +1238,14 @@ static void setup_tool_toolbox(GtkWidget *toolbox, SPDesktop *desktop) { GtkTooltips *tooltips=GTK_TOOLTIPS(g_object_get_data(G_OBJECT(toolbox), "tooltips")); - gint shrinkLeft = prefs_get_int_attribute_limited( "toolbox.left", "small", 0, 0, 1 ); + gint shrinkLeft = prefs_get_int_attribute_limited( "toolbox.tools", "small", 0, 0, 1 ); + if ( (shrinkLeft == 0) && (prefs_get_int_attribute_limited( "toolbox.tools", "small", 1, 0, 1 ) == 1) ) { + // "toolbox.tools" was not set. Fallback to older value + shrinkLeft = prefs_get_int_attribute_limited( "toolbox.left", "small", 0, 0, 1 ); + + // Copy the setting forwards + prefs_set_int_attribute( "toolbox.tools", "small", shrinkLeft ); + } Inkscape::IconSize toolboxSize = shrinkLeft ? Inkscape::ICON_SIZE_SMALL_TOOLBAR : Inkscape::ICON_SIZE_LARGE_TOOLBAR; for (int i = 0 ; tools[i].type_name ; i++ ) { @@ -613,7 +1264,7 @@ setup_tool_toolbox(GtkWidget *toolbox, SPDesktop *desktop) static void -update_tool_toolbox( SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox ) +update_tool_toolbox( SPDesktop */*desktop*/, SPEventContext *eventcontext, GtkWidget *toolbox ) { gchar const *const tname = ( eventcontext ? gtk_type_name(GTK_OBJECT_TYPE(eventcontext)) @@ -628,24 +1279,89 @@ static void setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop) { GtkSizeGroup* grouper = gtk_size_group_new( GTK_SIZE_GROUP_BOTH ); + GtkActionGroup* mainActions = create_or_fetch_actions( desktop ); + GtkUIManager* mgr = gtk_ui_manager_new(); + GError* errVal = 0; + gtk_ui_manager_insert_action_group( mgr, mainActions, 0 ); + gtk_ui_manager_add_ui_from_string( mgr, ui_descr, -1, &errVal ); + + std::map dataHolders; for (int i = 0 ; aux_toolboxes[i].type_name ; i++ ) { - GtkWidget *sub_toolbox; - if (aux_toolboxes[i].create_func == NULL) - sub_toolbox = sp_empty_toolbox_new(desktop); - else - sub_toolbox = aux_toolboxes[i].create_func(desktop); + if ( aux_toolboxes[i].prep_func ) { + // converted to GtkActions and UIManager + + GtkWidget* kludge = gtk_hbox_new( FALSE, 0 ); + g_object_set_data( G_OBJECT(kludge), "dtw", desktop->canvas); + g_object_set_data( G_OBJECT(kludge), "desktop", desktop); + dataHolders[aux_toolboxes[i].type_name] = kludge; + aux_toolboxes[i].prep_func( desktop, mainActions, G_OBJECT(kludge) ); + } else { + + GtkWidget *sub_toolbox = 0; + if (aux_toolboxes[i].create_func == NULL) + sub_toolbox = sp_empty_toolbox_new(desktop); + else { + sub_toolbox = aux_toolboxes[i].create_func(desktop); + } + + gtk_size_group_add_widget( grouper, sub_toolbox ); + + gtk_container_add(GTK_CONTAINER(toolbox), sub_toolbox); + g_object_set_data(G_OBJECT(toolbox), aux_toolboxes[i].data_name, sub_toolbox); + + } + } + + // Second pass to create toolbars *after* all GtkActions are created + for (int i = 0 ; aux_toolboxes[i].type_name ; i++ ) { + if ( aux_toolboxes[i].prep_func ) { + // converted to GtkActions and UIManager + + GtkWidget* kludge = dataHolders[aux_toolboxes[i].type_name]; + + GtkWidget* holder = gtk_table_new( 1, 3, FALSE ); + gtk_table_attach( GTK_TABLE(holder), kludge, 2, 3, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0 ); + + gchar* tmp = g_strdup_printf( "/ui/%s", aux_toolboxes[i].ui_name ); + GtkWidget* toolBar = gtk_ui_manager_get_widget( mgr, tmp ); + g_free( tmp ); + tmp = 0; + + gint shrinkTop = prefs_get_int_attribute_limited( "toolbox", "small", 1, 0, 1 ); + Inkscape::IconSize toolboxSize = shrinkTop ? Inkscape::ICON_SIZE_SMALL_TOOLBAR : Inkscape::ICON_SIZE_LARGE_TOOLBAR; + if ( prefs_get_int_attribute_limited( "toolbox", "icononly", 1, 0, 1 ) ) { + gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS ); + } + gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), static_cast(toolboxSize) ); + + + gtk_table_attach( GTK_TABLE(holder), toolBar, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0 ); + + if ( aux_toolboxes[i].swatch_verb_id != SP_VERB_INVALID ) { + Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch( NULL, aux_toolboxes[i].swatch_tip ); + swatch->setDesktop( desktop ); + swatch->setClickVerb( aux_toolboxes[i].swatch_verb_id ); + swatch->setWatchedTool( aux_toolboxes[i].swatch_tool, 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( holder ); - gtk_size_group_add_widget( grouper, sub_toolbox ); + gtk_size_group_add_widget( grouper, holder ); - gtk_container_add(GTK_CONTAINER(toolbox), sub_toolbox); - g_object_set_data(G_OBJECT(toolbox), aux_toolboxes[i].data_name, sub_toolbox); + gtk_container_add( GTK_CONTAINER(toolbox), holder ); + g_object_set_data( G_OBJECT(toolbox), aux_toolboxes[i].data_name, holder ); + } } + g_object_unref( G_OBJECT(grouper) ); } static void -update_aux_toolbox(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox) +update_aux_toolbox(SPDesktop */*desktop*/, SPEventContext *eventcontext, GtkWidget *toolbox) { gchar const *tname = ( eventcontext ? gtk_type_name(GTK_OBJECT_TYPE(eventcontext)) @@ -664,78 +1380,67 @@ update_aux_toolbox(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget * static void setup_commands_toolbox(GtkWidget *toolbox, SPDesktop *desktop) { - Inkscape::UI::View::View *view = desktop; - - GtkTooltips *tt = gtk_tooltips_new(); - GtkWidget *tb = gtk_hbox_new(FALSE, 0); - - gint shrinkTop = prefs_get_int_attribute_limited( "toolbox", "small", 1, 0, 1 ); - Inkscape::IconSize toolboxSize = shrinkTop ? Inkscape::ICON_SIZE_SMALL_TOOLBAR : Inkscape::ICON_SIZE_LARGE_TOOLBAR; - - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_FILE_NEW), view, tt); - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_FILE_OPEN), view, tt); - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_FILE_SAVE), view, tt); - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_FILE_PRINT), view, tt); - - aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS); - - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_FILE_IMPORT), view, tt); - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_FILE_EXPORT), view, tt); - - aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS); - - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_UNDO), view, tt); - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_REDO), view, tt); - - aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS); - - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_COPY), view, tt); - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_CUT), view, tt); - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_PASTE), view, tt); - - aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS); - - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_SELECTION), view, tt); - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_DRAWING), view, tt); - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_ZOOM_PAGE), view, tt); - - aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS); - - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_DUPLICATE), view, tt); - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_CLONE), view, tt); - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_UNLINK_CLONE), view, tt); - - aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS); - - sp_toolbox_button_normal_new_from_verb(tb, toolboxSize, Inkscape::Verb::get(SP_VERB_SELECTION_GROUP), view, tt); - sp_toolbox_button_normal_new_from_verb(tb, toolboxSize, Inkscape::Verb::get(SP_VERB_SELECTION_UNGROUP), view, tt); - - // disabled until we have icons for them: - - //find - - //sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_TILE), view, tt); - //sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_EDIT_UNTILE), view, tt); + gchar const * descr = + "" + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + " " + ""; + GtkActionGroup* mainActions = create_or_fetch_actions( desktop ); - aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS); - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_DIALOG_FILL_STROKE), view, tt); - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_DIALOG_TEXT), view, tt); - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_DIALOG_XML_EDITOR), view, tt); - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_DIALOG_ALIGN_DISTRIBUTE), view, tt); + GtkUIManager* mgr = gtk_ui_manager_new(); + GError* errVal = 0; - aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS); + gtk_ui_manager_insert_action_group( mgr, mainActions, 0 ); + gtk_ui_manager_add_ui_from_string( mgr, descr, -1, &errVal ); - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_DIALOG_DISPLAY), view, tt); - sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_DIALOG_NAMEDVIEW), view, tt); + GtkWidget* toolBar = gtk_ui_manager_get_widget( mgr, "/ui/CommandsToolbar" ); + if ( prefs_get_int_attribute_limited( "toolbox", "icononly", 1, 0, 1 ) ) { + gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS ); + } + gint shrinkTop = prefs_get_int_attribute_limited( "toolbox", "small", 1, 0, 1 ); + Inkscape::IconSize toolboxSize = shrinkTop ? Inkscape::ICON_SIZE_SMALL_TOOLBAR : Inkscape::ICON_SIZE_LARGE_TOOLBAR; + gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), (GtkIconSize)toolboxSize ); - gtk_widget_show_all(tb); - gtk_container_add(GTK_CONTAINER(toolbox), tb); + gtk_container_add( GTK_CONTAINER(toolbox), toolBar ); } static void -update_commands_toolbox(SPDesktop *desktop, SPEventContext *eventcontext, GtkWidget *toolbox) +update_commands_toolbox(SPDesktop */*desktop*/, SPEventContext */*eventcontext*/, GtkWidget */*toolbox*/) { } @@ -750,10 +1455,6 @@ void show_aux_toolbox(GtkWidget *toolbox_toplevel) } gtk_widget_show(toolbox); - // need to show the spacer, or the padding will be off - GtkWidget *spacer = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbox), "top_spacer")); - gtk_widget_show(spacer); - gtk_widget_show_all(shown_toolbox); } @@ -808,7 +1509,7 @@ sp_tb_spinbutton( gtk_tooltips_set_tip(tt, sb, tooltip, NULL); if (altx) gtk_object_set_data(GTK_OBJECT(sb), altx_mark, sb); - gtk_widget_set_size_request(sb, + gtk_widget_set_size_request(sb, (upper <= 1.0 || digits == 0)? AUX_SPINBUTTON_WIDTH_SMALL - 10: AUX_SPINBUTTON_WIDTH_SMALL, AUX_SPINBUTTON_HEIGHT); gtk_widget_show(sb); @@ -820,56 +1521,15 @@ 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, - 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 ( 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, GObject *dataKludge ) { - SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop"); + SPDesktop *desktop = (SPDesktop *) g_object_get_data( 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 @@ -878,12 +1538,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( 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( dataKludge, "freeze", GINT_TO_POINTER(TRUE) ); bool modmade = false; @@ -900,30 +1560,27 @@ sp_stb_magnitude_value_changed(GtkAdjustment *adj, GtkWidget *tbl) modmade = true; } } - if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR, + if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR, _("Star: Change number of corners")); - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); - - spinbutton_defocus(GTK_OBJECT(tbl)); + g_object_set_data( 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, GObject *dataKludge ) { - SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop"); + SPDesktop *desktop = (SPDesktop *) g_object_get_data( 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( 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( dataKludge, "freeze", GINT_TO_POINTER(TRUE) ); bool modmade = false; Inkscape::Selection *selection = sp_desktop_selection(desktop); @@ -945,84 +1602,71 @@ sp_stb_proportion_value_changed(GtkAdjustment *adj, GtkWidget *tbl) } } - if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR, + if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR, _("Star: Change spoke ratio")); - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); - - spinbutton_defocus(GTK_OBJECT(tbl)); + g_object_set_data( 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( EgeSelectOneAction *act, GObject *dataKludge ) { - SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop"); + SPDesktop *desktop = (SPDesktop *) g_object_get_data( dataKludge, "desktop" ); + bool flat = ege_select_one_action_get_active( act ) == 0; 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( 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( 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( 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; - } + + if ( prop_action ) { + gtk_action_set_sensitive( prop_action, !flat ); + } + + for (; items != NULL; items = items->next) { + if (SP_IS_STAR((SPItem *) items->data)) { + Inkscape::XML::Node *repr = SP_OBJECT_REPR((SPItem *) items->data); + repr->setAttribute("inkscape:flatsided", flat ? "true" : "false" ); + SP_OBJECT((SPItem *) items->data)->updateRepr(repr, SP_OBJECT_WRITE_EXT); + modmade = true; } } - if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR, - gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))? _("Make polygon") : _("Make star")); - 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( 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, GObject *dataKludge ) { - SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop"); + SPDesktop *desktop = (SPDesktop *) g_object_get_data( 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( 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( dataKludge, "freeze", GINT_TO_POINTER(TRUE) ); bool modmade = false; @@ -1036,31 +1680,27 @@ sp_stb_rounded_value_changed(GtkAdjustment *adj, GtkWidget *tbl) modmade = true; } } - if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR, + 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( 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, GObject *dataKludge ) { - SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop"); + SPDesktop *desktop = (SPDesktop *) g_object_get_data( 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( 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( dataKludge, "freeze", GINT_TO_POINTER(TRUE) ); bool modmade = false; @@ -1074,18 +1714,16 @@ sp_stb_randomized_value_changed(GtkAdjustment *adj, GtkWidget *tbl) modmade = true; } } - if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR, + 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( dataKludge, "freeze", GINT_TO_POINTER(FALSE) ); } static void star_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const *name, - gchar const *old_value, gchar const *new_value, - bool is_interactive, gpointer data) + gchar const */*old_value*/, gchar const */*new_value*/, + bool /*is_interactive*/, gpointer data) { GtkWidget *tbl = GTK_WIDGET(data); @@ -1097,26 +1735,29 @@ 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; + + gchar const *flatsidedstr = prefs_get_string_attribute( "tools.shapes.star", "isflatsided" ); + bool isFlatSided = flatsidedstr ? (strcmp(flatsidedstr, "false") != 0) : true; 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"); + 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); + EgeSelectOneAction* flat_action = EGE_SELECT_ONE_ACTION( g_object_get_data( G_OBJECT(tbl), "flat_action" ) ); + if ( flatsides && !strcmp(flatsides,"false") ) { + ege_select_one_action_set_active( flat_action, 1 ); + 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); + ege_select_one_action_set_active( flat_action, 0 ); + gtk_action_set_sensitive( prop_action, FALSE ); } - } else if (!strcmp(name, "sodipodi:r1") || !strcmp(name, "sodipodi:r2")) { + } else if ((!strcmp(name, "sodipodi:r1") || !strcmp(name, "sodipodi:r2")) && (!isFlatSided) ) { adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "proportion"); gdouble r1 = sp_repr_get_double_attribute(repr, "sodipodi:r1", 1.0); gdouble r2 = sp_repr_get_double_attribute(repr, "sodipodi:r2", 1.0); @@ -1148,11 +1789,12 @@ static Inkscape::XML::NodeEventVector star_tb_repr_events = * \param selection Should not be NULL. */ static void -sp_star_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl) +sp_star_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl) { int n_selected = 0; Inkscape::XML::Node *repr = NULL; - Inkscape::XML::Node *oldrepr = NULL; + + purge_repr_listener( tbl, tbl ); for (GSList const *items = selection->itemList(); items != NULL; @@ -1164,23 +1806,15 @@ sp_star_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl } } - GtkWidget *l = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(tbl), "mode_label")); + EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) ); if (n_selected == 0) { - gtk_label_set_markup(GTK_LABEL(l), _("New:")); + g_object_set( G_OBJECT(act), "label", _("New:"), NULL ); } else if (n_selected == 1) { - 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 - sp_repr_remove_listener_by_data(oldrepr, tbl); - Inkscape::GC::release(oldrepr); - oldrepr = 0; - g_object_set_data(G_OBJECT(tbl), "repr", NULL); - } + g_object_set( G_OBJECT(act), "label", _("Change:"), NULL ); if (repr) { - g_object_set_data(G_OBJECT(tbl), "repr", repr); + g_object_set_data( 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); @@ -1188,18 +1822,17 @@ sp_star_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl } else { // FIXME: implement averaging of all parameters for multiple selected stars //gtk_label_set_markup(GTK_LABEL(l), _("Average:")); - gtk_label_set_markup(GTK_LABEL(l), _("Change:")); + //gtk_label_set_markup(GTK_LABEL(l), _("Change:")); } } -static void -sp_stb_defaults(GtkWidget *widget, GtkWidget *tbl) +static void sp_stb_defaults( GtkWidget */*widget*/, GObject *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; @@ -1208,28 +1841,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); + EgeSelectOneAction* flat_action = EGE_SELECT_ONE_ACTION( g_object_get_data( dataKludge, "flat_action" ) ); + ege_select_one_action_set_active( flat_action, flat ? 0 : 1 ); + + GtkAction* sb2 = GTK_ACTION( g_object_get_data( dataKludge, "prop_action" ) ); + gtk_action_set_sensitive( sb2, !flat ); - adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "magnitude"); + adj = GTK_ADJUSTMENT( g_object_get_data( 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( g_object_get_data( 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( g_object_get_data( 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( g_object_get_data( dataKludge, "randomized" ) ); gtk_adjustment_set_value(adj, randomized); gtk_adjustment_value_changed(adj); - - spinbutton_defocus(GTK_OBJECT(tbl)); } @@ -1246,117 +1878,142 @@ sp_toolbox_add_label(GtkWidget *tbl, gchar const *title, bool wide) } -static GtkWidget * -sp_star_toolbox_new(SPDesktop *desktop) +static void sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) { - 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; - - /* 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); + EgeOutputAction* act = ege_output_action_new( "StarStateAction", _("New:"), "", 0 ); + ege_output_action_set_use_markup( act, TRUE ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_object_set_data( holder, "mode_action", act ); } - aux_toolbox_space(tbl, AUX_BETWEEN_BUTTON_GROUPS); - - /* Magnitude */ { - GtkWidget *hb = sp_tb_spinbutton(_("Corners:"), _("Number of corners of a polygon or star"), + EgeAdjustmentAction* eact = 0; + gchar const *flatsidedstr = prefs_get_string_attribute( "tools.shapes.star", "isflatsided" ); + bool isFlatSided = flatsidedstr ? (strcmp(flatsidedstr, "false") != 0) : true; + + /* Flatsided checkbox */ + { + GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); + + GtkTreeIter iter; + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, + 0, _("Polygon"), + 1, _("Regular polygon (with one handle) instead of a star"), + 2, "star_flat", + -1 ); + + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, + 0, _("Star"), + 1, _("Star instead of a regular polygon (with one handle)"), + 2, "star_angled", + -1 ); + + EgeSelectOneAction* act = ege_select_one_action_new( "FlatAction", (""), (""), NULL, GTK_TREE_MODEL(model) ); + gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); + g_object_set_data( holder, "flat_action", act ); + + ege_select_one_action_set_appearance( act, "full" ); + ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE ); + g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL ); + ege_select_one_action_set_icon_column( act, 2 ); + ege_select_one_action_set_tooltip_column( act, 1 ); + + ege_select_one_action_set_active( act, isFlatSided ? 0 : 1 ); + g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_stb_sides_flat_state_changed), holder); + } + + /* Magnitude */ + { + gchar const* labels[] = {_("triangle/tri-star"), _("square/quad-star"), _("pentagon/five-pointed star"), _("hexagon/six-pointed star"), 0, 0, 0, 0, 0}; + gdouble values[] = {3, 4, 5, 6, 7, 8, 10, 12, 20}; + eact = create_adjustment_action( "MagnitudeAction", + _("Corners"), _("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); - } + GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, + 3, 1024, 1, 5, + 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 */ - { - GtkWidget *hb = sp_tb_spinbutton(_("Spoke ratio:"), + /* Spoke ratio */ + { + gchar const* labels[] = {_("thin-ray star"), 0, _("pentagram"), _("hexagram"), _("heptagram"), _("octagram"), _("regular polygon")}; + gdouble values[] = {0.01, 0.2, 0.382, 0.577, 0.692, 0.765, 1}; + eact = create_adjustment_action( "SpokeAction", + _("Spoke ratio"), _("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); - } + labels, values, G_N_ELEMENTS(labels), + sp_stb_proportion_value_changed ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + g_object_set_data( holder, "prop_action", eact ); + } - /* Roundedness */ - { - GtkWidget *hb = sp_tb_spinbutton(_("Rounded:"), _("How much rounded are the corners (0 for sharp)"), + if ( !isFlatSided ) { + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } else { + gtk_action_set_sensitive( GTK_ACTION(eact), FALSE ); + } + + /* Roundedness */ + { + gchar const* labels[] = {_("stretched"), _("twisted"), _("slightly pinched"), _("NOT rounded"), _("slightly rounded"), _("visibly rounded"), _("well rounded"), _("amply rounded"), 0, _("stretched"), _("blown up")}; + gdouble values[] = {-1, -0.2, -0.03, 0, 0.05, 0.1, 0.2, 0.3, 0.5, 1, 10}; + eact = create_adjustment_action( "RoundednessAction", + _("Rounded"), _("Rounded:"), _("How much rounded are the corners (0 for sharp)"), "tools.shapes.star", "rounded", 0.0, - NULL, tbl, 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); - } + GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, + -10.0, 10.0, 0.01, 0.1, + labels, values, G_N_ELEMENTS(labels), + sp_stb_rounded_value_changed ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } - /* Randomization */ - { - GtkWidget *hb = sp_tb_spinbutton(_("Randomized:"), _("Scatter randomly the corners and angles"), + /* Randomization */ + { + gchar const* labels[] = {_("NOT randomized"), _("slightly irregular"), _("visibly randomized"), _("strongly randomized"), _("blown up")}; + gdouble values[] = {0, 0.01, 0.1, 0.5, 10}; + eact = create_adjustment_action( "RandomizationAction", + _("Randomized"), _("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); + labels, values, G_N_ELEMENTS(labels), + 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); - } - - Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL, _("Style of new stars")); - swatch->setDesktop (desktop); - swatch->setClickVerb (SP_VERB_CONTEXT_STAR_PREFS); - swatch->setWatchedTool ("tools.shapes.star", true); - GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj()); - gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0); - - gtk_widget_show_all(tbl); - sp_set_font_size_smaller (tbl); + /* Reset */ + { + GtkAction* act = gtk_action_new( "StarResetAction", + _("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 ); + } + } 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), (GObject *)holder)) ); - g_signal_connect(G_OBJECT(tbl), "destroy", G_CALLBACK(delete_connection), connection); - - return tbl; + g_signal_connect( holder, "destroy", G_CALLBACK(delete_connection), connection ); + g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder ); } @@ -1364,41 +2021,40 @@ sp_star_toolbox_new(SPDesktop *desktop) //## Rect ## //######################## -static void -sp_rtb_sensitivize (GtkWidget *tbl) +static void sp_rtb_sensitivize( GObject *tbl ) { - GtkAdjustment *adj1 = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(tbl), "rx")); - GtkAdjustment *adj2 = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(tbl), "ry")); - GtkWidget *not_rounded = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "not_rounded"); + GtkAdjustment *adj1 = GTK_ADJUSTMENT( g_object_get_data(tbl, "rx") ); + GtkAdjustment *adj2 = GTK_ADJUSTMENT( g_object_get_data(tbl, "ry") ); + GtkAction* not_rounded = GTK_ACTION( g_object_get_data(tbl, "not_rounded") ); - if (adj1->value == 0 && adj2->value == 0 && gtk_object_get_data(GTK_OBJECT(tbl), "single")) { // only for a single selected rect (for now) - gtk_widget_set_sensitive(GTK_WIDGET(not_rounded), FALSE); + if (adj1->value == 0 && adj2->value == 0 && g_object_get_data(tbl, "single")) { // only for a single selected rect (for now) + gtk_action_set_sensitive( not_rounded, FALSE ); } else { - gtk_widget_set_sensitive(GTK_WIDGET(not_rounded), TRUE); + gtk_action_set_sensitive( not_rounded, TRUE ); } } static void -sp_rtb_value_changed(GtkAdjustment *adj, GtkWidget *tbl, gchar const *value_name, +sp_rtb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_name, void (*setter)(SPRect *, gdouble)) { - SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop"); + SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" ); - GtkWidget *us = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(tbl), "units"); - SPUnit const *unit = sp_unit_selector_get_unit(SP_UNIT_SELECTOR(us)); + UnitTracker* tracker = reinterpret_cast(g_object_get_data( tbl, "tracker" )); + SPUnit const *unit = tracker->getActiveUnit(); if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) { prefs_set_double_attribute("tools.shapes.rect", value_name, sp_units_get_pixels(adj->value, *unit)); } // quit if run by the attr_changed listener - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { + if (g_object_get_data( tbl, "freeze" )) { return; } // in turn, prevent listener from responding - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE)); + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE)); bool modmade = false; Inkscape::Selection *selection = sp_desktop_selection(desktop); @@ -1413,39 +2069,36 @@ sp_rtb_value_changed(GtkAdjustment *adj, GtkWidget *tbl, gchar const *value_name } } - sp_rtb_sensitivize (tbl); + sp_rtb_sensitivize( tbl ); if (modmade) { - sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_RECT, + 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)); - - // defocus spinbuttons by moving focus to the canvas, unless "stay" is on - spinbutton_defocus(GTK_OBJECT(tbl)); -} + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); +} static void -sp_rtb_rx_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +sp_rtb_rx_value_changed(GtkAdjustment *adj, GObject *tbl) { sp_rtb_value_changed(adj, tbl, "rx", sp_rect_set_visible_rx); } static void -sp_rtb_ry_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +sp_rtb_ry_value_changed(GtkAdjustment *adj, GObject *tbl) { sp_rtb_value_changed(adj, tbl, "ry", sp_rect_set_visible_ry); } static void -sp_rtb_width_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +sp_rtb_width_value_changed(GtkAdjustment *adj, GObject *tbl) { sp_rtb_value_changed(adj, tbl, "width", sp_rect_set_visible_width); } static void -sp_rtb_height_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +sp_rtb_height_value_changed(GtkAdjustment *adj, GObject *tbl) { sp_rtb_value_changed(adj, tbl, "height", sp_rect_set_visible_height); } @@ -1453,73 +2106,69 @@ sp_rtb_height_value_changed(GtkAdjustment *adj, GtkWidget *tbl) static void -sp_rtb_defaults( GtkWidget *widget, GtkObject *obj) +sp_rtb_defaults( GtkWidget */*widget*/, GObject *obj) { - GtkWidget *tbl = GTK_WIDGET(obj); - - GtkAdjustment *adj; + GtkAdjustment *adj = 0; - adj = (GtkAdjustment*)gtk_object_get_data(obj, "rx"); + adj = GTK_ADJUSTMENT( g_object_get_data(obj, "rx") ); gtk_adjustment_set_value(adj, 0.0); // this is necessary if the previous value was 0, but we still need to run the callback to change all selected objects gtk_adjustment_value_changed(adj); - adj = (GtkAdjustment*)gtk_object_get_data(obj, "ry"); + adj = GTK_ADJUSTMENT( g_object_get_data(obj, "ry") ); gtk_adjustment_set_value(adj, 0.0); gtk_adjustment_value_changed(adj); - sp_rtb_sensitivize (tbl); - - spinbutton_defocus(GTK_OBJECT(tbl)); + sp_rtb_sensitivize( obj ); } -static void rect_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const *name, - gchar const *old_value, gchar const *new_value, - bool is_interactive, gpointer data) +static void rect_tb_event_attr_changed(Inkscape::XML::Node */*repr*/, gchar const */*name*/, + gchar const */*old_value*/, gchar const */*new_value*/, + bool /*is_interactive*/, gpointer data) { - GtkWidget *tbl = GTK_WIDGET(data); + GObject *tbl = G_OBJECT(data); // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { + if (g_object_get_data( tbl, "freeze" )) { return; } // in turn, prevent callbacks from responding - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE)); + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); - GtkWidget *us = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(tbl), "units"); - SPUnit const *unit = sp_unit_selector_get_unit(SP_UNIT_SELECTOR(us)); + UnitTracker* tracker = reinterpret_cast( g_object_get_data( tbl, "tracker" ) ); + SPUnit const *unit = tracker->getActiveUnit(); - SPItem *item = SP_ITEM(g_object_get_data(G_OBJECT(tbl), "item")); - if (SP_IS_RECT(item)) { + gpointer item = g_object_get_data( tbl, "item" ); + if (item && SP_IS_RECT(item)) { { - GtkAdjustment *adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "rx"); + GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "rx" ) ); gdouble rx = sp_rect_get_visible_rx(SP_RECT(item)); gtk_adjustment_set_value(adj, sp_pixels_get_units(rx, *unit)); } { - GtkAdjustment *adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "ry"); + GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "ry" ) ); gdouble ry = sp_rect_get_visible_ry(SP_RECT(item)); gtk_adjustment_set_value(adj, sp_pixels_get_units(ry, *unit)); } { - GtkAdjustment *adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "width"); + GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "width" ) ); gdouble width = sp_rect_get_visible_width (SP_RECT(item)); gtk_adjustment_set_value(adj, sp_pixels_get_units(width, *unit)); } { - GtkAdjustment *adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "height"); + GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "height" ) ); gdouble height = sp_rect_get_visible_height (SP_RECT(item)); gtk_adjustment_set_value(adj, sp_pixels_get_units(height, *unit)); } } - sp_rtb_sensitivize (tbl); + sp_rtb_sensitivize( tbl ); - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); } @@ -1535,12 +2184,16 @@ static Inkscape::XML::NodeEventVector rect_tb_repr_events = { * \param selection should not be NULL. */ static void -sp_rect_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl) +sp_rect_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl) { int n_selected = 0; Inkscape::XML::Node *repr = NULL; SPItem *item = NULL; - Inkscape::XML::Node *oldrepr = NULL; + + if ( g_object_get_data( tbl, "repr" ) ) { + g_object_set_data( tbl, "item", NULL ); + } + purge_repr_listener( tbl, tbl ); for (GSList const *items = selection->itemList(); items != NULL; @@ -1552,37 +2205,30 @@ sp_rect_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl } } - GtkWidget *l = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(tbl), "mode_label")); + EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) ); - g_object_set_data(G_OBJECT(tbl), "single", GINT_TO_POINTER(FALSE)); + g_object_set_data( tbl, "single", GINT_TO_POINTER(FALSE) ); if (n_selected == 0) { - gtk_label_set_markup(GTK_LABEL(l), _("New:")); + g_object_set( G_OBJECT(act), "label", _("New:"), NULL ); - GtkWidget *w = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(tbl), "width_sb"); - gtk_widget_set_sensitive(w, FALSE); - GtkWidget *h = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(tbl), "height_sb"); - gtk_widget_set_sensitive(h, FALSE); + GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "width_action" ) ); + gtk_action_set_sensitive(w, FALSE); + GtkAction* h = GTK_ACTION( g_object_get_data( tbl, "height_action" ) ); + gtk_action_set_sensitive(h, FALSE); } else if (n_selected == 1) { - gtk_label_set_markup(GTK_LABEL(l), _("Change:")); - g_object_set_data(G_OBJECT(tbl), "single", GINT_TO_POINTER(TRUE)); - - GtkWidget *w = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(tbl), "width_sb"); - gtk_widget_set_sensitive(w, TRUE); - GtkWidget *h = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(tbl), "height_sb"); - gtk_widget_set_sensitive(h, TRUE); - - oldrepr = (Inkscape::XML::Node *) gtk_object_get_data(GTK_OBJECT(tbl), "repr"); - if (oldrepr) { // remove old listener - sp_repr_remove_listener_by_data(oldrepr, tbl); - Inkscape::GC::release(oldrepr); - oldrepr = 0; - g_object_set_data(G_OBJECT(tbl), "repr", NULL); - } + g_object_set( G_OBJECT(act), "label", _("Change:"), NULL ); + g_object_set_data( tbl, "single", GINT_TO_POINTER(TRUE) ); + + GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "width_action" ) ); + gtk_action_set_sensitive(w, TRUE); + GtkAction* h = GTK_ACTION( g_object_get_data( tbl, "height_action" ) ); + gtk_action_set_sensitive(h, TRUE); + if (repr) { - g_object_set_data(G_OBJECT(tbl), "repr", repr); - g_object_set_data(G_OBJECT(tbl), "item", item); + g_object_set_data( tbl, "repr", repr ); + g_object_set_data( 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); @@ -1590,110 +2236,480 @@ sp_rect_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl } else { // FIXME: implement averaging of all parameters for multiple selected //gtk_label_set_markup(GTK_LABEL(l), _("Average:")); - gtk_label_set_markup(GTK_LABEL(l), _("Change:")); - sp_rtb_sensitivize (GTK_WIDGET(tbl)); + g_object_set( G_OBJECT(act), "label", _("Change:"), NULL ); + sp_rtb_sensitivize( tbl ); } } -static GtkWidget * -sp_rect_toolbox_new(SPDesktop *desktop) +static void sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) { - 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(); + EgeAdjustmentAction* eact = 0; - sp_toolbox_add_label(tbl, _("New:")); + { + EgeOutputAction* act = ege_output_action_new( "RectStateAction", _("New:"), "", 0 ); + ege_output_action_set_use_markup( act, TRUE ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_object_set_data( holder, "mode_action", act ); + } // rx/ry 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); + UnitTracker* tracker = new UnitTracker( SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE ); + //tracker->addUnit( SP_UNIT_PERCENT, 0 ); // fixme: add % meaning per cent of the width/height + tracker->setActiveUnit( sp_desktop_namedview(desktop)->doc_units ); + g_object_set_data( holder, "tracker", tracker ); /* W */ { - GtkWidget *hb = sp_tb_spinbutton(_("W:"), _("Width of rectangle"), + gchar const* labels[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500}; + eact = create_adjustment_action( "RectWidthAction", + _("Width"), _("W:"), _("Width of rectangle"), "tools.shapes.rect", "width", 0, - us, tbl, TRUE, "altx-rect", + GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, TRUE, "altx-rect", 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP, - sp_rtb_width_value_changed); - gtk_object_set_data(GTK_OBJECT(tbl), "width_sb", hb); - gtk_widget_set_sensitive(hb, FALSE); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + labels, values, G_N_ELEMENTS(labels), + sp_rtb_width_value_changed ); + tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) ); + g_object_set_data( holder, "width_action", eact ); + gtk_action_set_sensitive( GTK_ACTION(eact), FALSE ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); } /* H */ { - GtkWidget *hb = sp_tb_spinbutton(_("H:"), _("Height of rectangle"), + gchar const* labels[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500}; + eact = create_adjustment_action( "RectHeightAction", + _("Height"), _("H:"), _("Height of rectangle"), "tools.shapes.rect", "height", 0, - us, tbl, FALSE, NULL, + GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL, 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP, - sp_rtb_height_value_changed); - gtk_object_set_data(GTK_OBJECT(tbl), "height_sb", hb); - gtk_widget_set_sensitive(hb, FALSE); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + labels, values, G_N_ELEMENTS(labels), + sp_rtb_height_value_changed ); + tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) ); + g_object_set_data( holder, "height_action", eact ); + gtk_action_set_sensitive( GTK_ACTION(eact), FALSE ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); } /* rx */ { - GtkWidget *hb = sp_tb_spinbutton(_("Rx:"), _("Horizontal radius of rounded corners"), + gchar const* labels[] = {_("not rounded"), 0, 0, 0, 0, 0, 0, 0, 0}; + gdouble values[] = {0.5, 1, 2, 3, 5, 10, 20, 50, 100}; + eact = create_adjustment_action( "RadiusXAction", + _("Horizontal radius"), _("Rx:"), _("Horizontal radius of rounded corners"), "tools.shapes.rect", "rx", 0, - us, tbl, FALSE, NULL, + GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL, 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP, + labels, values, G_N_ELEMENTS(labels), sp_rtb_rx_value_changed); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); } /* ry */ { - GtkWidget *hb = sp_tb_spinbutton(_("Ry:"), _("Vertical radius of rounded corners"), + gchar const* labels[] = {_("not rounded"), 0, 0, 0, 0, 0, 0, 0, 0}; + gdouble values[] = {0.5, 1, 2, 3, 5, 10, 20, 50, 100}; + eact = create_adjustment_action( "RadiusYAction", + _("Vertical radius"), _("Ry:"), _("Vertical radius of rounded corners"), "tools.shapes.rect", "ry", 0, - us, tbl, FALSE, NULL, + GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL, 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP, + labels, values, G_N_ELEMENTS(labels), sp_rtb_ry_value_changed); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); } // add the units menu - gtk_widget_show(us); - gtk_box_pack_start(GTK_BOX(tbl), us, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); - gtk_object_set_data(GTK_OBJECT(tbl), "units", us); + { + GtkAction* act = tracker->createAction( "RectUnitsAction", _("Units"), ("") ); + gtk_action_group_add_action( mainActions, act ); + } /* Reset */ { - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - GtkWidget *b = gtk_button_new_with_label(_("Not rounded")); - gtk_object_set_data(GTK_OBJECT(tbl), "not_rounded", b); - gtk_tooltips_set_tip(tt, b, _("Make corners sharp"), NULL); - gtk_widget_show(b); - gtk_container_add(GTK_CONTAINER(hb), b); - gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(sp_rtb_defaults), tbl); - 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); + InkAction* inky = ink_action_new( "RectResetAction", + _("Not rounded"), + _("Make corners sharp"), + "squared_corner", + Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_rtb_defaults), holder ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + gtk_action_set_sensitive( GTK_ACTION(inky), TRUE ); + g_object_set_data( holder, "not_rounded", inky ); + } - gtk_widget_show_all(tbl); - sp_set_font_size_smaller (tbl); + g_object_set_data( holder, "single", GINT_TO_POINTER(TRUE) ); + sp_rtb_sensitivize( holder ); sigc::connection *connection = new sigc::connection( - sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_rect_toolbox_selection_changed), (GtkObject *)tbl)) + sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_rect_toolbox_selection_changed), (GObject *)holder)) ); - g_signal_connect(G_OBJECT(tbl), "destroy", G_CALLBACK(delete_connection), connection); + g_signal_connect( holder, "destroy", G_CALLBACK(delete_connection), connection ); + g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder ); +} - return tbl; +//######################## +//## 3D Box ## +//######################## + +// normalize angle so that it lies in the interval [0,360] +static double box3d_normalize_angle (double a) { + double angle = a + ((int) (a/360.0))*360; + if (angle < 0) { + angle += 360.0; + } + return angle; +} + +static void +box3d_set_button_and_adjustment(Persp3D *persp, Proj::Axis axis, + GtkAdjustment *adj, GtkAction *act, GtkToggleAction *tact) { + // TODO: Take all selected perspectives into account but don't touch the state button if not all of them + // have the same state (otherwise a call to box3d_vp_z_state_changed() is triggered and the states + // are reset). + bool is_infinite = !persp3d_VP_is_finite(persp, axis); + + if (is_infinite) { + gtk_toggle_action_set_active(tact, TRUE); + gtk_action_set_sensitive(act, TRUE); + + double angle = persp3d_get_infinite_angle(persp, axis); + if (angle != NR_HUGE) { // FIXME: We should catch this error earlier (don't show the spinbutton at all) + gtk_adjustment_set_value(adj, box3d_normalize_angle(angle)); + } + } else { + gtk_toggle_action_set_active(tact, FALSE); + gtk_action_set_sensitive(act, FALSE); + } +} + +static void +box3d_resync_toolbar(Inkscape::XML::Node *persp_repr, GObject *data) { + if (!persp_repr) { + g_print ("No perspective given to box3d_resync_toolbar().\n"); + return; + } + + GtkWidget *tbl = GTK_WIDGET(data); + GtkAdjustment *adj = 0; + GtkAction *act = 0; + GtkToggleAction *tact = 0; + Persp3D *persp = persp3d_get_from_repr(persp_repr); + { + adj = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(tbl), "box3d_angle_x")); + act = GTK_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_angle_x_action")); + tact = &INK_TOGGLE_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_vp_x_state_action"))->action; + + box3d_set_button_and_adjustment(persp, Proj::X, adj, act, tact); + } + { + adj = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(tbl), "box3d_angle_y")); + act = GTK_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_angle_y_action")); + tact = &INK_TOGGLE_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_vp_y_state_action"))->action; + + box3d_set_button_and_adjustment(persp, Proj::Y, adj, act, tact); + } + { + adj = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(tbl), "box3d_angle_z")); + act = GTK_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_angle_z_action")); + tact = &INK_TOGGLE_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_vp_z_state_action"))->action; + + box3d_set_button_and_adjustment(persp, Proj::Z, adj, act, tact); + } +} + +static void box3d_persp_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const *name, + gchar const */*old_value*/, gchar const */*new_value*/, + bool /*is_interactive*/, gpointer data) +{ + GtkWidget *tbl = GTK_WIDGET(data); + + // quit if run by the attr_changed listener + // note: it used to work without the differently called freeze_ attributes (here and in + // box3d_angle_value_changed()) but I now it doesn't so I'm leaving them in for now + if (g_object_get_data(G_OBJECT(tbl), "freeze_angle")) { + return; + } + + // set freeze so that it can be caught in box3d_angle_z_value_changed() (to avoid calling + // sp_document_maybe_done() when the document is undo insensitive) + g_object_set_data(G_OBJECT(tbl), "freeze_attr", GINT_TO_POINTER(TRUE)); + + // TODO: Only update the appropriate part of the toolbar +// if (!strcmp(name, "inkscape:vp_z")) { + box3d_resync_toolbar(repr, G_OBJECT(tbl)); +// } + + Persp3D *persp = persp3d_get_from_repr(repr); + persp3d_update_box_reprs(persp); + + g_object_set_data(G_OBJECT(tbl), "freeze_attr", GINT_TO_POINTER(FALSE)); +} + +static Inkscape::XML::NodeEventVector box3d_persp_tb_repr_events = +{ + NULL, /* child_added */ + NULL, /* child_removed */ + box3d_persp_tb_event_attr_changed, + NULL, /* content_changed */ + NULL /* order_changed */ +}; + +/** + * \param selection Should not be NULL. + */ +// FIXME: This should rather be put into persp3d-reference.cpp or something similar so that it reacts upon each +// Change of the perspective, and not of the current selection (but how to refer to the toolbar then?) +static void +box3d_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl) +{ + // Here the following should be done: If all selected boxes have finite VPs in a certain direction, + // disable the angle entry fields for this direction (otherwise entering a value in them should only + // update the perspectives with infinite VPs and leave the other ones untouched). + + Inkscape::XML::Node *persp_repr = NULL; + purge_repr_listener(tbl, tbl); + + SPItem *item = selection->singleItem(); + if (item && SP_IS_BOX3D(item)) { + // FIXME: Also deal with multiple selected boxes + SPBox3D *box = SP_BOX3D(item); + Persp3D *persp = box3d_get_perspective(box); + persp_repr = SP_OBJECT_REPR(persp); + if (persp_repr) { + g_object_set_data(tbl, "repr", persp_repr); + Inkscape::GC::anchor(persp_repr); + sp_repr_add_listener(persp_repr, &box3d_persp_tb_repr_events, tbl); + sp_repr_synthesize_events(persp_repr, &box3d_persp_tb_repr_events, tbl); + } + + inkscape_active_document()->current_persp3d = persp3d_get_from_repr(persp_repr); + prefs_set_string_attribute("tools.shapes.3dbox", "persp", persp_repr->attribute("id")); + + box3d_resync_toolbar(persp_repr, tbl); + } +} + +static void +box3d_angle_value_changed(GtkAdjustment *adj, GObject *dataKludge, Proj::Axis axis) +{ + SPDesktop *desktop = (SPDesktop *) g_object_get_data( dataKludge, "desktop" ); + SPDocument *document = sp_desktop_document(desktop); + + // quit if run by the attr_changed listener + // note: it used to work without the differently called freeze_ attributes (here and in + // box3d_persp_tb_event_attr_changed()) but I now it doesn't so I'm leaving them in for now + if (g_object_get_data( dataKludge, "freeze_attr" )) { + return; + } + + // in turn, prevent listener from responding + g_object_set_data(dataKludge, "freeze_angle", GINT_TO_POINTER(TRUE)); + + //Persp3D *persp = document->current_persp3d; + std::set sel_persps = persp3d_currently_selected_persps (inkscape_active_event_context()); + if (sel_persps.empty()) { + // this can happen when the document is created; we silently ignore it + return; + } + Persp3D *persp = *(sel_persps.begin()); + + persp->tmat.set_infinite_direction (axis, adj->value); + SP_OBJECT(persp)->updateRepr(); + + // TODO: use the correct axis here, too + sp_document_maybe_done(document, "perspangle", SP_VERB_CONTEXT_3DBOX, _("3D Box: Change perspective (angle of infinite axis)")); + + g_object_set_data( dataKludge, "freeze_angle", GINT_TO_POINTER(FALSE) ); +} + + +static void +box3d_angle_x_value_changed(GtkAdjustment *adj, GObject *dataKludge) +{ + box3d_angle_value_changed(adj, dataKludge, Proj::X); +} + +static void +box3d_angle_y_value_changed(GtkAdjustment *adj, GObject *dataKludge) +{ + box3d_angle_value_changed(adj, dataKludge, Proj::Y); +} + +static void +box3d_angle_z_value_changed(GtkAdjustment *adj, GObject *dataKludge) +{ + box3d_angle_value_changed(adj, dataKludge, Proj::Z); +} + + +static void box3d_vp_state_changed( GtkToggleAction *act, GtkAction *box3d_angle, Proj::Axis axis ) +{ + // TODO: Take all selected perspectives into account + std::set sel_persps = persp3d_currently_selected_persps (inkscape_active_event_context()); + if (sel_persps.empty()) { + // this can happen when the document is created; we silently ignore it + return; + } + Persp3D *persp = *(sel_persps.begin()); + + bool set_infinite = gtk_toggle_action_get_active(act); + persp3d_set_VP_state (persp, axis, set_infinite ? Proj::VP_INFINITE : Proj::VP_FINITE); +} + +static void box3d_vp_x_state_changed( GtkToggleAction *act, GtkAction *box3d_angle ) +{ + box3d_vp_state_changed(act, box3d_angle, Proj::X); +} + +static void box3d_vp_y_state_changed( GtkToggleAction *act, GtkAction *box3d_angle ) +{ + box3d_vp_state_changed(act, box3d_angle, Proj::Y); +} + +static void box3d_vp_z_state_changed( GtkToggleAction *act, GtkAction *box3d_angle ) +{ + box3d_vp_state_changed(act, box3d_angle, Proj::Z); +} + +static void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) +{ + EgeAdjustmentAction* eact = 0; + SPDocument *document = sp_desktop_document (desktop); + Persp3D *persp = document->current_persp3d; + + EgeAdjustmentAction* box3d_angle_x = 0; + EgeAdjustmentAction* box3d_angle_y = 0; + EgeAdjustmentAction* box3d_angle_z = 0; + + /* Angle X */ + { + gchar const* labels[] = { 0, 0, 0, 0, 0, 0, 0 }; + gdouble values[] = {-90, -60, -30, 0, 30, 60, 90}; + eact = create_adjustment_action( "3DBoxAngleXAction", + _("Angle in X direction"), _("Angle X:"), + // Translators: PL is short for 'perspective line' + _("Angle of PLs in X direction"), + "tools.shapes.3dbox", "box3d_angle_x", 30, + GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-box3d", + -360.0, 360.0, 1.0, 10.0, + labels, values, G_N_ELEMENTS(labels), + box3d_angle_x_value_changed ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + g_object_set_data( holder, "box3d_angle_x_action", eact ); + box3d_angle_x = eact; + } + + if (!persp3d_VP_is_finite(persp, Proj::X)) { + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } else { + gtk_action_set_sensitive( GTK_ACTION(eact), FALSE ); + } + + + /* VP X state */ + { + InkToggleAction* act = ink_toggle_action_new( "3DBoxVPXStateAction", + // Translators: VP is short for 'vanishing point' + _("State of VP in X direction"), + _("Toggle VP in X direction between 'finite' and 'infinite' (=parallel)"), + "toggle_vp_x", + Inkscape::ICON_SIZE_DECORATION ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_object_set_data( holder, "box3d_vp_x_state_action", act ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(box3d_vp_x_state_changed), box3d_angle_x ); + gtk_action_set_sensitive( GTK_ACTION(box3d_angle_x), !prefs_get_int_attribute( "tools.shapes.3dbox", "vp_x_state", 1 ) ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.shapes.3dbox", "vp_x_state", 1 ) ); + } + + /* Angle Y */ + { + gchar const* labels[] = { 0, 0, 0, 0, 0, 0, 0 }; + gdouble values[] = {-90, -60, -30, 0, 30, 60, 90}; + eact = create_adjustment_action( "3DBoxAngleYAction", + _("Angle in Y direction"), _("Angle Y:"), + // Translators: PL is short for 'perspective line' + _("Angle of PLs in Y direction"), + "tools.shapes.3dbox", "box3d_angle_y", 30, + GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, + -360.0, 360.0, 1.0, 10.0, + labels, values, G_N_ELEMENTS(labels), + box3d_angle_y_value_changed ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + g_object_set_data( holder, "box3d_angle_y_action", eact ); + box3d_angle_y = eact; + } + + if (!persp3d_VP_is_finite(persp, Proj::Y)) { + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } else { + gtk_action_set_sensitive( GTK_ACTION(eact), FALSE ); + } + + /* VP Y state */ + { + InkToggleAction* act = ink_toggle_action_new( "3DBoxVPYStateAction", + // Translators: VP is short for 'vanishing point' + _("State of VP in Y direction"), + _("Toggle VP in Y direction between 'finite' and 'infinite' (=parallel)"), + "toggle_vp_y", + Inkscape::ICON_SIZE_DECORATION ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_object_set_data( holder, "box3d_vp_y_state_action", act ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(box3d_vp_y_state_changed), box3d_angle_y ); + gtk_action_set_sensitive( GTK_ACTION(box3d_angle_y), !prefs_get_int_attribute( "tools.shapes.3dbox", "vp_y_state", 1 ) ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.shapes.3dbox", "vp_y_state", 1 ) ); + } + + /* Angle Z */ + { + gchar const* labels[] = { 0, 0, 0, 0, 0, 0, 0 }; + gdouble values[] = {-90, -60, -30, 0, 30, 60, 90}; + eact = create_adjustment_action( "3DBoxAngleZAction", + _("Angle in Z direction"), _("Angle Z:"), + // Translators: PL is short for 'perspective line' + _("Angle of PLs in Z direction"), + "tools.shapes.3dbox", "box3d_angle_z", 30, + GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, + -360.0, 360.0, 1.0, 10.0, + labels, values, G_N_ELEMENTS(labels), + box3d_angle_z_value_changed ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + g_object_set_data( holder, "box3d_angle_z_action", eact ); + box3d_angle_z = eact; + } + + if (!persp3d_VP_is_finite(persp, Proj::Z)) { + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } else { + gtk_action_set_sensitive( GTK_ACTION(eact), FALSE ); + } + + /* VP Z state */ + { + InkToggleAction* act = ink_toggle_action_new( "3DBoxVPZStateAction", + // Translators: VP is short for 'vanishing point' + _("State of VP in Z direction"), + _("Toggle VP in Z direction between 'finite' and 'infinite' (=parallel)"), + "toggle_vp_z", + Inkscape::ICON_SIZE_DECORATION ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_object_set_data( holder, "box3d_vp_z_state_action", act ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(box3d_vp_z_state_changed), box3d_angle_z ); + gtk_action_set_sensitive( GTK_ACTION(box3d_angle_z), !prefs_get_int_attribute( "tools.shapes.3dbox", "vp_z_state", 1 ) ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.shapes.3dbox", "vp_z_state", 1 ) ); + } + + sigc::connection *connection = new sigc::connection( + sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(box3d_toolbox_selection_changed), (GObject *)holder)) + ); + g_signal_connect(holder, "destroy", G_CALLBACK(delete_connection), connection); + g_signal_connect(holder, "destroy", G_CALLBACK(purge_repr_listener), holder); } //######################## @@ -1701,21 +2717,21 @@ sp_rect_toolbox_new(SPDesktop *desktop) //######################## static void -sp_spl_tb_value_changed(GtkAdjustment *adj, GtkWidget *tbl, gchar const *value_name) +sp_spl_tb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_name) { - SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop"); + SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" ); if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) { prefs_set_double_attribute("tools.shapes.spiral", value_name, adj->value); } // quit if run by the attr_changed listener - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { + if (g_object_get_data( tbl, "freeze" )) { return; } // in turn, prevent listener from responding - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE)); + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); gchar* namespaced_name = g_strconcat("sodipodi:", value_name, NULL); @@ -1735,35 +2751,33 @@ 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_VERB_CONTEXT_SPIRAL, + 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)); - - spinbutton_defocus(GTK_OBJECT(tbl)); + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); } static void -sp_spl_tb_revolution_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +sp_spl_tb_revolution_value_changed(GtkAdjustment *adj, GObject *tbl) { sp_spl_tb_value_changed(adj, tbl, "revolution"); } static void -sp_spl_tb_expansion_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +sp_spl_tb_expansion_value_changed(GtkAdjustment *adj, GObject *tbl) { sp_spl_tb_value_changed(adj, tbl, "expansion"); } static void -sp_spl_tb_t0_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +sp_spl_tb_t0_value_changed(GtkAdjustment *adj, GObject *tbl) { sp_spl_tb_value_changed(adj, tbl, "t0"); } static void -sp_spl_tb_defaults(GtkWidget *widget, GtkObject *obj) +sp_spl_tb_defaults(GtkWidget */*widget*/, GtkObject *obj) { GtkWidget *tbl = GTK_WIDGET(obj); @@ -1790,9 +2804,9 @@ sp_spl_tb_defaults(GtkWidget *widget, GtkObject *obj) } -static void spiral_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const *name, - gchar const *old_value, gchar const *new_value, - bool is_interactive, gpointer data) +static void spiral_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const */*name*/, + gchar const */*old_value*/, gchar const */*new_value*/, + bool /*is_interactive*/, gpointer data) { GtkWidget *tbl = GTK_WIDGET(data); @@ -1827,11 +2841,12 @@ static Inkscape::XML::NodeEventVector spiral_tb_repr_events = { }; static void -sp_spiral_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl) +sp_spiral_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl) { int n_selected = 0; Inkscape::XML::Node *repr = NULL; - Inkscape::XML::Node *oldrepr = NULL; + + purge_repr_listener( tbl, tbl ); for (GSList const *items = selection->itemList(); items != NULL; @@ -1843,23 +2858,15 @@ sp_spiral_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *t } } - GtkWidget *l = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(tbl), "mode_label")); + EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) ); if (n_selected == 0) { - gtk_label_set_markup(GTK_LABEL(l), _("New:")); + g_object_set( G_OBJECT(act), "label", _("New:"), NULL ); } else if (n_selected == 1) { - 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 - sp_repr_remove_listener_by_data(oldrepr, tbl); - Inkscape::GC::release(oldrepr); - oldrepr = 0; - g_object_set_data(G_OBJECT(tbl), "repr", NULL); - } + g_object_set( G_OBJECT(act), "label", _("Change:"), NULL ); if (repr) { - g_object_set_data(G_OBJECT(tbl), "repr", repr); + g_object_set_data( 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); @@ -1867,81 +2874,81 @@ sp_spiral_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *t } else { // FIXME: implement averaging of all parameters for multiple selected //gtk_label_set_markup(GTK_LABEL(l), _("Average:")); - gtk_label_set_markup(GTK_LABEL(l), _("Change:")); + g_object_set( G_OBJECT(act), "label", _("Change:"), NULL ); } } -static GtkWidget * -sp_spiral_toolbox_new(SPDesktop *desktop) +static void sp_spiral_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) { - 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); + EgeAdjustmentAction* eact = 0; - GtkTooltips *tt = gtk_tooltips_new(); - - sp_toolbox_add_label(tbl, _("New:")); + { + EgeOutputAction* act = ege_output_action_new( "SpiralStateAction", _("New:"), "", 0 ); + ege_output_action_set_use_markup( act, TRUE ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_object_set_data( holder, "mode_action", act ); + } /* Revolution */ { - GtkWidget *hb = sp_tb_spinbutton(_("Turns:"), _("Number of revolutions"), + gchar const* labels[] = {_("just a curve"), 0, _("one full revolution"), 0, 0, 0, 0, 0, 0}; + gdouble values[] = {0.01, 0.5, 1, 2, 3, 5, 10, 20, 50, 100}; + eact = create_adjustment_action( "SpiralRevolutionAction", + _("Number of turns"), _("Turns:"), _("Number of revolutions"), "tools.shapes.spiral", "revolution", 3.0, - NULL, tbl, TRUE, "altx-spiral", + GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-spiral", 0.01, 1024.0, 0.1, 1.0, + labels, values, G_N_ELEMENTS(labels), sp_spl_tb_revolution_value_changed, 1, 2); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); } /* Expansion */ { - GtkWidget *hb = sp_tb_spinbutton(_("Divergence:"), _("How much denser/sparser are outer revolutions; 1 = uniform"), + gchar const* labels[] = {_("circle"), _("edge is much denser"), _("edge is denser"), _("even"), _("center is denser"), _("center is much denser"), 0}; + gdouble values[] = {0, 0.1, 0.5, 1, 1.5, 5, 20}; + eact = create_adjustment_action( "SpiralExpansionAction", + _("Divergence"), _("Divergence:"), _("How much denser/sparser are outer revolutions; 1 = uniform"), "tools.shapes.spiral", "expansion", 1.0, - NULL, tbl, FALSE, NULL, + GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, 0.0, 1000.0, 0.01, 1.0, + labels, values, G_N_ELEMENTS(labels), sp_spl_tb_expansion_value_changed); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); } /* T0 */ { - GtkWidget *hb = sp_tb_spinbutton(_("Inner radius:"), _("Radius of the innermost revolution (relative to the spiral size)"), + gchar const* labels[] = {_("starts from center"), _("starts mid-way"), _("starts near edge")}; + gdouble values[] = {0, 0.5, 0.9}; + eact = create_adjustment_action( "SpiralT0Action", + _("Inner radius"), _("Inner radius:"), _("Radius of the innermost revolution (relative to the spiral size)"), "tools.shapes.spiral", "t0", 0.0, - NULL, tbl, FALSE, NULL, + GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, 0.0, 0.999, 0.01, 1.0, + labels, values, G_N_ELEMENTS(labels), sp_spl_tb_t0_value_changed); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); } - 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_spl_tb_defaults), tbl); - 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); + InkAction* inky = ink_action_new( "SpiralResetAction", + _("Defaults"), + _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"), + GTK_STOCK_CLEAR, + Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_spl_tb_defaults), holder ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } - gtk_widget_show_all(tbl); - sp_set_font_size_smaller (tbl); sigc::connection *connection = new sigc::connection( - sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_spiral_toolbox_selection_changed), (GtkObject *)tbl)) + sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_spiral_toolbox_selection_changed), (GObject *)holder)) ); - g_signal_connect(G_OBJECT(tbl), "destroy", G_CALLBACK(delete_connection), connection); - - return tbl; + g_signal_connect( holder, "destroy", G_CALLBACK(delete_connection), connection ); + g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder ); } //######################## @@ -1949,210 +2956,361 @@ sp_spiral_toolbox_new(SPDesktop *desktop) //######################## -static GtkWidget * -sp_pen_toolbox_new(SPDesktop *desktop) +static void sp_pen_toolbox_prep(SPDesktop */*desktop*/, GtkActionGroup* /*mainActions*/, GObject* /*holder*/) { - 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; + // Put stuff here } -static GtkWidget * -sp_pencil_toolbox_new(SPDesktop *desktop) +static void sp_pencil_toolbox_prep(SPDesktop */*desktop*/, GtkActionGroup* /*mainActions*/, GObject* /*holder*/) { - 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; + // Put stuff here } - //######################## -//## Calligraphy ## +//## Tweak ## //######################## -static void sp_ddc_mass_value_changed2( GtkAdjustment *adj, GtkWidget *tbl ) +static void sp_tweak_width_value_changed( GtkAdjustment *adj, GObject */*tbl*/ ) { - prefs_set_double_attribute( "tools.calligraphic", "mass", adj->value ); - //spinbutton_defocus(GTK_OBJECT(tbl)); + prefs_set_double_attribute( "tools.tweak", "width", adj->value * 0.01 ); } -static void sp_ddc_wiggle_value_changed2( GtkAdjustment *adj, GtkWidget *tbl ) +static void sp_tweak_force_value_changed( GtkAdjustment *adj, GObject */*tbl*/ ) { - prefs_set_double_attribute( "tools.calligraphic", "wiggle", adj->value ); -// spinbutton_defocus(GTK_OBJECT(tbl)); + prefs_set_double_attribute( "tools.tweak", "force", adj->value * 0.01 ); } -static void sp_ddc_angle_value_changed2( GtkAdjustment *adj, GtkWidget *tbl ) +static void sp_tweak_pressure_state_changed( GtkToggleAction *act, gpointer /*data*/ ) { - prefs_set_double_attribute( "tools.calligraphic", "angle", adj->value ); -// spinbutton_defocus(GTK_OBJECT(tbl)); + prefs_set_int_attribute( "tools.tweak", "usepressure", gtk_toggle_action_get_active( act ) ? 1 : 0); } -static void sp_ddc_width_value_changed2( GtkAdjustment *adj, GtkWidget *tbl ) +static void sp_tweak_mode_changed( EgeSelectOneAction *act, GObject *tbl ) { - prefs_set_double_attribute( "tools.calligraphic", "width", adj->value * 0.01 ); -// spinbutton_defocus(GTK_OBJECT(tbl)); -} + int mode = ege_select_one_action_get_active( act ); + prefs_set_int_attribute("tools.tweak", "mode", mode); -static void sp_ddc_velthin_value_changed2( GtkAdjustment *adj, GtkWidget *tbl ) -{ - prefs_set_double_attribute("tools.calligraphic", "thinning", adj->value); -// spinbutton_defocus(GTK_OBJECT(tbl)); + GtkAction *doh = GTK_ACTION(g_object_get_data( tbl, "tweak_doh")); + GtkAction *dos = GTK_ACTION(g_object_get_data( tbl, "tweak_dos")); + GtkAction *dol = GTK_ACTION(g_object_get_data( tbl, "tweak_dol")); + GtkAction *doo = GTK_ACTION(g_object_get_data( tbl, "tweak_doo")); + GtkAction *fid = GTK_ACTION(g_object_get_data( tbl, "tweak_fidelity")); + GtkAction *dolabel = GTK_ACTION(g_object_get_data( tbl, "tweak_channels_label")); + if (mode == TWEAK_MODE_COLORPAINT || mode == TWEAK_MODE_COLORJITTER) { + if (doh) gtk_action_set_sensitive (doh, TRUE); + if (dos) gtk_action_set_sensitive (dos, TRUE); + if (dol) gtk_action_set_sensitive (dol, TRUE); + if (doo) gtk_action_set_sensitive (doo, TRUE); + if (dolabel) gtk_action_set_sensitive (dolabel, TRUE); + if (fid) gtk_action_set_sensitive (fid, FALSE); + } else { + if (doh) gtk_action_set_sensitive (doh, FALSE); + if (dos) gtk_action_set_sensitive (dos, FALSE); + if (dol) gtk_action_set_sensitive (dol, FALSE); + if (doo) gtk_action_set_sensitive (doo, FALSE); + if (dolabel) gtk_action_set_sensitive (dolabel, FALSE); + if (fid) gtk_action_set_sensitive (fid, TRUE); + } } -static void sp_ddc_flatness_value_changed2( GtkAdjustment *adj, GtkWidget *tbl ) +static void sp_tweak_fidelity_value_changed( GtkAdjustment *adj, GObject */*tbl*/ ) { - prefs_set_double_attribute( "tools.calligraphic", "flatness", adj->value ); -// spinbutton_defocus(GTK_OBJECT(tbl)); + prefs_set_double_attribute( "tools.tweak", "fidelity", adj->value * 0.01 ); } -static void sp_ddc_tremor_value_changed2( GtkAdjustment *adj, GtkWidget *tbl ) -{ - prefs_set_double_attribute( "tools.calligraphic", "tremor", adj->value ); -// spinbutton_defocus(GTK_OBJECT(tbl)); +static void tweak_toggle_doh (GtkToggleAction *act, gpointer /*data*/) { + bool show = gtk_toggle_action_get_active( act ); + prefs_set_int_attribute ("tools.tweak", "doh", show ? 1 : 0); } - -static void sp_ddc_cap_rounding_value_changed2( GtkAdjustment *adj, GtkWidget *tbl ) -{ - prefs_set_double_attribute( "tools.calligraphic", "cap_rounding", adj->value ); -// spinbutton_defocus(GTK_OBJECT(tbl)); +static void tweak_toggle_dos (GtkToggleAction *act, gpointer /*data*/) { + bool show = gtk_toggle_action_get_active( act ); + prefs_set_int_attribute ("tools.tweak", "dos", show ? 1 : 0); } - -static void sp_ddc_pressure_state_changed2( GtkToggleAction *act, gpointer data ) -{ - prefs_set_int_attribute( "tools.calligraphic", "usepressure", gtk_toggle_action_get_active( act ) ? 1 : 0); +static void tweak_toggle_dol (GtkToggleAction *act, gpointer /*data*/) { + bool show = gtk_toggle_action_get_active( act ); + prefs_set_int_attribute ("tools.tweak", "dol", show ? 1 : 0); +} +static void tweak_toggle_doo (GtkToggleAction *act, gpointer /*data*/) { + bool show = gtk_toggle_action_get_active( act ); + prefs_set_int_attribute ("tools.tweak", "doo", show ? 1 : 0); } -static void sp_ddc_tilt_state_changed2( GtkToggleAction *act, GtkAction *calligraphy_angle ) +static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) { - prefs_set_int_attribute( "tools.calligraphic", "usetilt", gtk_toggle_action_get_active( act ) ? 1 : 0 ); + { + /* Width */ + gchar const* labels[] = {_("(pinch tweak)"), 0, 0, 0, _("(default)"), 0, 0, 0, 0, _("(broad tweak)")}; + gdouble values[] = {1, 3, 5, 10, 15, 20, 30, 50, 75, 100}; + EgeAdjustmentAction *eact = create_adjustment_action( "TweakWidthAction", + _("Width"), _("Width:"), _("The width of the tweak area (relative to the visible canvas area)"), + "tools.tweak", "width", 15, + GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-tweak", + 1, 100, 1.0, 10.0, + labels, values, G_N_ELEMENTS(labels), + sp_tweak_width_value_changed, 0.01, 0, 100 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } - gtk_action_set_sensitive( calligraphy_angle, !gtk_toggle_action_get_active( act ) ); -} -static void sp_ddc_defaults2(GtkWidget *, GtkWidget *dataKludge) -{ - // FIXME: make defaults settable via Inkscape Options - struct KeyValue { - char const *key; - double value; - } const key_values[] = { - {"mass", 0.02}, - {"wiggle", 0.0}, - {"angle", 30.0}, - {"width", 15}, - {"thinning", 0.1}, - {"tremor", 0.0}, - {"flatness", 0.9}, - {"cap_rounding", 0.0} - }; + { + /* Force */ + gchar const* labels[] = {_("(minimum force)"), 0, 0, _("(default)"), 0, 0, 0, _("(maximum force)")}; + gdouble values[] = {1, 5, 10, 20, 30, 50, 70, 100}; + EgeAdjustmentAction *eact = create_adjustment_action( "TweakForceAction", + _("Force"), _("Force:"), _("The force of the tweak action"), + "tools.tweak", "force", 20, + GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "tweak-force", + 1, 100, 1.0, 10.0, + labels, values, G_N_ELEMENTS(labels), + sp_tweak_force_value_changed, 0.01, 0, 100 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } - 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(dataKludge), kv.key)); - if ( adj ) { - gtk_adjustment_set_value(adj, kv.value); - } + /* Mode */ + { + GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); + + GtkTreeIter iter; + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, + 0, _("Push mode"), + 1, _("Push parts of paths in any direction"), + 2, "tweak_push_mode", + -1 ); + + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, + 0, _("Shrink mode"), + 1, _("Shrink (inset) parts of paths"), + 2, "tweak_shrink_mode", + -1 ); + + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, + 0, _("Grow mode"), + 1, _("Grow (outset) parts of paths"), + 2, "tweak_grow_mode", + -1 ); + + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, + 0, _("Attract mode"), + 1, _("Attract parts of paths towards cursor"), + 2, "tweak_attract_mode", + -1 ); + + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, + 0, _("Repel mode"), + 1, _("Repel parts of paths from cursor"), + 2, "tweak_repel_mode", + -1 ); + + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, + 0, _("Roughen mode"), + 1, _("Roughen parts of paths"), + 2, "tweak_roughen_mode", + -1 ); + + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, + 0, _("Color paint mode"), + 1, _("Paint the tool's color upon selected objects"), + 2, "tweak_colorpaint_mode", + -1 ); + + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, + 0, _("Color jitter mode"), + 1, _("Jitter the colors of selected objects"), + 2, "tweak_colorjitter_mode", + -1 ); + + EgeSelectOneAction* act = ege_select_one_action_new( "TweakModeAction", _("Mode"), (""), NULL, GTK_TREE_MODEL(model) ); + g_object_set( act, "short_label", _("Mode:"), NULL ); + gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); + g_object_set_data( holder, "mode_action", act ); + + ege_select_one_action_set_appearance( act, "full" ); + ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE ); + g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL ); + ege_select_one_action_set_icon_column( act, 2 ); + ege_select_one_action_set_tooltip_column( act, 1 ); + + gint mode = prefs_get_int_attribute("tools.tweak", "mode", 0); + ege_select_one_action_set_active( act, mode ); + g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_tweak_mode_changed), holder ); + + g_object_set_data( G_OBJECT(holder), "tweak_tool_mode", act); + } + + guint mode = prefs_get_int_attribute("tools.tweak", "mode", 0); + + { + EgeOutputAction* act = ege_output_action_new( "TweakChannelsLabel", _("Channels:"), "", 0 ); + ege_output_action_set_use_markup( act, TRUE ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + if (mode != TWEAK_MODE_COLORPAINT && mode != TWEAK_MODE_COLORJITTER) + gtk_action_set_sensitive (GTK_ACTION(act), FALSE); + g_object_set_data( holder, "tweak_channels_label", act); + } + + { + InkToggleAction* act = ink_toggle_action_new( "TweakDoH", + _("Hue"), + _("In color mode, act on objects' hue"), + NULL, + Inkscape::ICON_SIZE_DECORATION ); + g_object_set( act, "short_label", _("H"), NULL ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_doh), desktop ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.tweak", "doh", 1 ) ); + if (mode != TWEAK_MODE_COLORPAINT && mode != TWEAK_MODE_COLORJITTER) + gtk_action_set_sensitive (GTK_ACTION(act), FALSE); + g_object_set_data( holder, "tweak_doh", act); + } + { + InkToggleAction* act = ink_toggle_action_new( "TweakDoS", + _("Saturation"), + _("In color mode, act on objects' saturation"), + NULL, + Inkscape::ICON_SIZE_DECORATION ); + g_object_set( act, "short_label", _("S"), NULL ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_dos), desktop ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.tweak", "dos", 1 ) ); + if (mode != TWEAK_MODE_COLORPAINT && mode != TWEAK_MODE_COLORJITTER) + gtk_action_set_sensitive (GTK_ACTION(act), FALSE); + g_object_set_data( holder, "tweak_dos", act ); + } + { + InkToggleAction* act = ink_toggle_action_new( "TweakDoL", + _("Lightness"), + _("In color mode, act on objects' lightness"), + NULL, + Inkscape::ICON_SIZE_DECORATION ); + g_object_set( act, "short_label", _("L"), NULL ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_dol), desktop ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.tweak", "dol", 1 ) ); + if (mode != TWEAK_MODE_COLORPAINT && mode != TWEAK_MODE_COLORJITTER) + gtk_action_set_sensitive (GTK_ACTION(act), FALSE); + g_object_set_data( holder, "tweak_dol", act ); + } + { + InkToggleAction* act = ink_toggle_action_new( "TweakDoO", + _("Opacity"), + _("In color mode, act on objects' opacity"), + NULL, + Inkscape::ICON_SIZE_DECORATION ); + g_object_set( act, "short_label", _("O"), NULL ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_doo), desktop ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.tweak", "doo", 1 ) ); + if (mode != TWEAK_MODE_COLORPAINT && mode != TWEAK_MODE_COLORJITTER) + gtk_action_set_sensitive (GTK_ACTION(act), FALSE); + g_object_set_data( holder, "tweak_doo", act ); + } + + { /* Fidelity */ + gchar const* labels[] = {_("(rough, simplified)"), 0, 0, _("(default)"), 0, 0, _("(fine, but many nodes)")}; + gdouble values[] = {10, 25, 35, 50, 60, 80, 100}; + EgeAdjustmentAction *eact = create_adjustment_action( "TweakFidelityAction", + _("Fidelity"), _("Fidelity:"), + _("Low fidelity simplifies paths; high fidelity preserves path features but may generate a lot of new nodes"), + "tools.tweak", "fidelity", 50, + GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "tweak-fidelity", + 1, 100, 1.0, 10.0, + labels, values, G_N_ELEMENTS(labels), + sp_tweak_fidelity_value_changed, 0.01, 0, 100 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + if (mode == TWEAK_MODE_COLORPAINT || mode == TWEAK_MODE_COLORJITTER) + gtk_action_set_sensitive (GTK_ACTION(eact), FALSE); + g_object_set_data( holder, "tweak_fidelity", eact ); + } + + + /* Use Pressure button */ + { + InkToggleAction* act = ink_toggle_action_new( "TweakPressureAction", + _("Pressure"), + _("Use the pressure of the input device to alter the force of tweak action"), + "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_tweak_pressure_state_changed), NULL); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.tweak", "usepressure", 1 ) ); } -// spinbutton_defocus(GTK_OBJECT(tbl)); } -static void -sp_ddc_mass_value_changed(GtkAdjustment *adj, GtkWidget *tbl) + +//######################## +//## Calligraphy ## +//######################## + +static void sp_ddc_mass_value_changed( GtkAdjustment *adj, GObject* /*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_wiggle_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void sp_ddc_wiggle_value_changed( GtkAdjustment *adj, GObject* /*tbl*/ ) { - prefs_set_double_attribute("tools.calligraphic", "wiggle", 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, GObject* /*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, GObject */*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, GObject* /*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, GObject* /*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, GObject* /*tbl*/ ) { - prefs_set_double_attribute("tools.calligraphic", "tremor", adj->value); - spinbutton_defocus(GTK_OBJECT(tbl)); + prefs_set_double_attribute( "tools.calligraphic", "tremor", adj->value ); } -static void -sp_ddc_cap_rounding_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void sp_ddc_cap_rounding_value_changed( GtkAdjustment *adj, GObject* /*tbl*/ ) { - prefs_set_double_attribute("tools.calligraphic", "cap_rounding", adj->value); - spinbutton_defocus(GTK_OBJECT(tbl)); + prefs_set_double_attribute( "tools.calligraphic", "cap_rounding", adj->value ); } -static void -sp_ddc_pressure_state_changed(GtkWidget *button, gpointer data) +static void sp_ddc_pressure_state_changed( GtkToggleAction *act, gpointer /*data*/ ) { - prefs_set_int_attribute ("tools.calligraphic", "usepressure", gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)) ? 1 : 0); + prefs_set_int_attribute( "tools.calligraphic", "usepressure", gtk_toggle_action_get_active( act ) ? 1 : 0); } -static void -sp_ddc_tilt_state_changed(GtkWidget *button, GtkWidget *calligraphy_angle) +static void sp_ddc_trace_background_changed( GtkToggleAction *act, gpointer /*data*/ ) +{ + prefs_set_int_attribute( "tools.calligraphic", "tracebackground", 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 *, GObject *dataKludge) { // FIXME: make defaults settable via Inkscape Options struct KeyValue { @@ -2171,134 +3329,162 @@ static void sp_ddc_defaults(GtkWidget *, GtkWidget *tbl) for (unsigned i = 0; i < G_N_ELEMENTS(key_values); ++i) { KeyValue const &kv = key_values[i]; - GtkAdjustment &adj = *static_cast(gtk_object_get_data(GTK_OBJECT(tbl), kv.key)); - gtk_adjustment_set_value(&adj, kv.value); + GtkAdjustment* adj = static_cast(g_object_get_data(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) +static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) { - if ( prefs_get_int_attribute_limited( "options.stocktoolbars", "value", 1, 0, 1 ) ) { - 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"); - { EgeAdjustmentAction* calligraphy_angle = 0; - EgeAdjustmentAction* eact = 0; + { /* Width */ - eact = create_adjustment_action( "WidthAction", - _("Width:"), _("The width of the calligraphic pen (relative to the visible canvas area)"), - "tools.calligraphic", "width", 15, - GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-calligraphy", - 1, 100, 1.0, 10.0, - sp_ddc_width_value_changed2, 0.01, 0, 100 ); + 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( "CalligraphyWidthAction", + _("Pen Width"), _("Width:"), + _("The width of the calligraphic pen (relative to the visible canvas area)"), + "tools.calligraphic", "width", 15, + GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-calligraphy", + 1, 100, 1.0, 10.0, + 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 */ - 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, - GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, - -1.0, 1.0, 0.01, 0.1, - sp_ddc_velthin_value_changed2, 0.01, 2); + 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", + _("Stroke Thinning"), _("Thinning:"), + _("How much velocity thins the stroke (> 0 makes fast strokes thinner, < 0 makes them broader, 0 makes width independent of velocity)"), + "tools.calligraphic", "thinning", 0.1, + 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_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } + { /* Angle */ - 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, - sp_ddc_angle_value_changed2, 1, 0 ); + 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", + _("Pen Angle"), _("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 */ - eact = create_adjustment_action( "FixationAction", - _("Fixation:"), _("Angle behavior (0 = nib always perpendicular to stroke direction, 1 = fixed angle)"), - "tools.calligraphic", "flatness", 0.9, - GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, - 0.0, 1.0, 0.01, 0.1, - sp_ddc_flatness_value_changed2, 0.01, 2 ); + 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"), _("Fixation:"), + _("Angle behavior (0 = nib always perpendicular to stroke direction, 1 = fixed angle)"), + "tools.calligraphic", "flatness", 0.9, + GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, + 0.0, 1.0, 0.01, 0.1, + labels, values, G_N_ELEMENTS(labels), + sp_ddc_flatness_value_changed, 0.01, 2 ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } + { /* Cap Rounding */ + 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 - 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, - sp_ddc_cap_rounding_value_changed2, 0.01, 2 ); + EgeAdjustmentAction* eact = create_adjustment_action( "CapRoundingAction", + _("Cap rounding"), _("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 */ - eact = create_adjustment_action( "TremorAction", - _("Tremor:"), _("Increase to make strokes rugged and trembling"), - "tools.calligraphic", "tremor", 0.0, - GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, - 0.0, 1.0, 0.01, 0.1, - sp_ddc_tremor_value_changed2, 0.01, 2 ); + 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", + _("Stroke Tremor"), _("Tremor:"), + _("Increase to make strokes rugged and trembling"), + "tools.calligraphic", "tremor", 0.0, + GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, + 0.0, 1.0, 0.01, 0.1, + labels, values, G_N_ELEMENTS(labels), + sp_ddc_tremor_value_changed, 0.01, 2 ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } + { /* Wiggle */ - eact = create_adjustment_action( "WiggleAction", - _("Wiggle:"), _("Increase to make the pen waver and wiggle"), - "tools.calligraphic", "wiggle", 0.0, - GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, - 0.0, 1.0, 0.01, 0.1, - sp_ddc_wiggle_value_changed2, 0.01, 2 ); + 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", + _("Pen Wiggle"), _("Wiggle:"), + _("Increase to make the pen waver and wiggle"), + "tools.calligraphic", "wiggle", 0.0, + GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL, + 0.0, 1.0, 0.01, 0.1, + labels, values, G_N_ELEMENTS(labels), + sp_ddc_wiggle_value_changed, 0.01, 2 ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } + { /* Mass */ - 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, - sp_ddc_mass_value_changed2, 0.01, 2 ); + 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", + _("Pen Mass"), _("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 ); + } + + /* Trace Background button */ + { + InkToggleAction* act = ink_toggle_action_new( "TraceAction", + _("Trace Background"), + _("Trace the lightness of the background by the width of the pen (white - minimum width, black - maximum width)"), + "trace_background", + Inkscape::ICON_SIZE_DECORATION ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_ddc_trace_background_changed), NULL); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.calligraphic", "tracebackground", 0 ) ); + } /* Use Pressure button */ { @@ -2308,7 +3494,7 @@ sp_calligraphy_toolbox_new(SPDesktop *desktop) "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_changed2), NULL); + 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 ) ); } @@ -2320,204 +3506,22 @@ sp_calligraphy_toolbox_new(SPDesktop *desktop) "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_changed2), calligraphy_angle ); + 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 */ { - GtkAction* act = gtk_action_new( "ResetAction", + GtkAction* act = gtk_action_new( "CalligraphyResetAction", _("Defaults"), - _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"), + _("Reset all parameters to defaults"), GTK_STOCK_CLEAR ); - g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(sp_ddc_defaults2), holder ); + 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 ); } } - - - 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_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 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(holder); - //sp_set_font_size_smaller (tbl); - - return holder; - } else { - GtkWidget *tbl = gtk_hbox_new(FALSE, 0); - gtk_object_set_data(GTK_OBJECT(tbl), "dtw", desktop->canvas); - gtk_object_set_data(GTK_OBJECT(tbl), "desktop", desktop); - - GtkTooltips *tt = gtk_tooltips_new(); - GtkWidget *calligraphy_angle; - - // interval - gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); - - /* Width */ - { - GtkWidget *hb = sp_tb_spinbutton(_("Width:"), _("The width of the calligraphic pen (relative to the visible canvas area)"), - "tools.calligraphic", "width", 15, - NULL, tbl, 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); - } - - /* 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)"), - "tools.calligraphic", "thinning", 0.1, - NULL, tbl, FALSE, NULL, - -1.0, 1.0, 0.01, 0.1, - 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); - - /* 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); - } - - /* Fixation */ - { - GtkWidget *hb = sp_tb_spinbutton(_("Fixation:"), _("Angle behavior (0 = nib always perpendicular to stroke direction, 1 = fixed angle)"), - "tools.calligraphic", "flatness", 0.9, - NULL, tbl, 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); - } - - /* Cap Rounding */ - { - // TRANSLATORS: "cap" means "end" (both start and finish) here - GtkWidget *hb = sp_tb_spinbutton(_("Round:"), _("Increase to round the ends of strokes"), - "tools.calligraphic", "cap_rounding", 0.0, - NULL, tbl, FALSE, NULL, - 0.0, 1.0, 0.01, 0.1, - sp_ddc_cap_rounding_value_changed, 0.01, 2); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING); - } - - // interval - gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); - - /* Tremor */ - { - GtkWidget *hb = sp_tb_spinbutton(_("Tremor:"), _("Increase to make strokes rugged and trembling"), - "tools.calligraphic", "tremor", 0.0, - NULL, tbl, 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); - } - - /* Wiggle */ - { - GtkWidget *hb = sp_tb_spinbutton(_("Wiggle:"), _("Increase to make the pen waver and wiggle"), - "tools.calligraphic", "wiggle", 0.0, - NULL, tbl, FALSE, NULL, - 0.0, 1.0, 0.01, 0.1, - sp_ddc_wiggle_value_changed, 0.01, 2); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING); - } - - - /* Mass */ - { - GtkWidget *hb = sp_tb_spinbutton(_("Mass:"), _("Increase to make the pen drag behind, as if slowed by inertia"), - "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); - } - - // interval - gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); - - GtkWidget *cvbox = gtk_vbox_new (FALSE, 0); - GtkWidget *cbox = gtk_hbox_new (FALSE, 0); - - /* 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); - } - - gtk_box_pack_start(GTK_BOX(cvbox), cbox, TRUE, FALSE, 0); - gtk_box_pack_start(GTK_BOX(tbl), cvbox, FALSE, FALSE, 0); - - /* 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); - } - - - Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL, _("Style of new calligraphic strokes")); - swatch->setDesktop (desktop); - swatch->setClickVerb (SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS); - swatch->setWatchedTool ("tools.calligraphic", true); - GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj()); - gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0); - - gtk_widget_show_all(tbl); - sp_set_font_size_smaller (tbl); - - return tbl; - } } @@ -2525,39 +3529,38 @@ sp_calligraphy_toolbox_new(SPDesktop *desktop) //## Circle / Arc ## //######################## -static void -sp_arctb_sensitivize (GtkWidget *tbl, double v1, double v2) +static void sp_arctb_sensitivize( GObject *tbl, double v1, double v2 ) { - GtkWidget *ocb = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "open_checkbox"); - GtkWidget *make_whole = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "make_whole"); + GtkAction *ocb = GTK_ACTION( g_object_get_data( tbl, "open_action" ) ); + GtkAction *make_whole = GTK_ACTION( g_object_get_data( tbl, "make_whole" ) ); if (v1 == 0 && v2 == 0) { - if (gtk_object_get_data(GTK_OBJECT(tbl), "single")) { // only for a single selected ellipse (for now) - gtk_widget_set_sensitive(GTK_WIDGET(ocb), FALSE); - gtk_widget_set_sensitive(GTK_WIDGET(make_whole), FALSE); + if (g_object_get_data( tbl, "single" )) { // only for a single selected ellipse (for now) + gtk_action_set_sensitive( ocb, FALSE ); + gtk_action_set_sensitive( make_whole, FALSE ); } } else { - gtk_widget_set_sensitive(GTK_WIDGET(ocb), TRUE); - gtk_widget_set_sensitive(GTK_WIDGET(make_whole), TRUE); + gtk_action_set_sensitive( ocb, TRUE ); + gtk_action_set_sensitive( make_whole, TRUE ); } } static void -sp_arctb_startend_value_changed(GtkAdjustment *adj, GtkWidget *tbl, gchar const *value_name, gchar const *other_name) +sp_arctb_startend_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_name, gchar const *other_name) { - SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop"); + SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" ); if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) { prefs_set_double_attribute("tools.shapes.arc", value_name, (adj->value * M_PI)/ 180); } // quit if run by the attr_changed listener - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { + if (g_object_get_data( tbl, "freeze" )) { return; } // in turn, prevent listener from responding - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE)); + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); gchar* namespaced_name = g_strconcat("sodipodi:", value_name, NULL); @@ -2588,41 +3591,34 @@ sp_arctb_startend_value_changed(GtkAdjustment *adj, GtkWidget *tbl, gchar const g_free(namespaced_name); - GtkAdjustment *other = (GtkAdjustment *)gtk_object_get_data(GTK_OBJECT(tbl), other_name); + GtkAdjustment *other = GTK_ADJUSTMENT( g_object_get_data( tbl, other_name ) ); - sp_arctb_sensitivize (tbl, adj->value, other->value); + sp_arctb_sensitivize( tbl, adj->value, other->value ); if (modmade) { - sp_document_maybe_done(sp_desktop_document(desktop), value_name, SP_VERB_CONTEXT_ARC, + 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 - spinbutton_defocus(GTK_OBJECT(tbl)); - - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); } -static void -sp_arctb_start_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void sp_arctb_start_value_changed(GtkAdjustment *adj, GObject *tbl) { sp_arctb_startend_value_changed(adj, tbl, "start", "end"); } -static void -sp_arctb_end_value_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void sp_arctb_end_value_changed(GtkAdjustment *adj, GObject *tbl) { sp_arctb_startend_value_changed(adj, tbl, "end", "start"); } -static void -sp_arctb_open_state_changed(GtkWidget *widget, GtkObject *tbl) +static void sp_arctb_open_state_changed( EgeSelectOneAction *act, GObject *tbl ) { - SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop"); - + SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" ); if (sp_document_get_undo_sensitive(sp_desktop_document(desktop))) { - if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) { + if ( ege_select_one_action_get_active( act ) != 0 ) { prefs_set_string_attribute("tools.shapes.arc", "open", "true"); } else { prefs_set_string_attribute("tools.shapes.arc", "open", NULL); @@ -2630,16 +3626,16 @@ sp_arctb_open_state_changed(GtkWidget *widget, GtkObject *tbl) } // quit if run by the attr_changed listener - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { + if (g_object_get_data( tbl, "freeze" )) { return; } // in turn, prevent listener from responding - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE)); + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); bool modmade = false; - if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) { + if ( ege_select_one_action_get_active(act) != 0 ) { for (GSList const *items = sp_desktop_selection(desktop)->itemList(); items != NULL; items = items->next) @@ -2666,67 +3662,63 @@ sp_arctb_open_state_changed(GtkWidget *widget, GtkObject *tbl) } if (modmade) { - sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_ARC, + 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)); - - spinbutton_defocus(GTK_OBJECT(tbl)); + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); } -static void sp_arctb_defaults(GtkWidget *, GtkObject *obj) +static void sp_arctb_defaults(GtkWidget *, GObject *obj) { - GtkWidget *tbl = GTK_WIDGET(obj); - GtkAdjustment *adj; - adj = (GtkAdjustment*)gtk_object_get_data(obj, "start"); + adj = GTK_ADJUSTMENT( g_object_get_data(obj, "start") ); gtk_adjustment_set_value(adj, 0.0); gtk_adjustment_value_changed(adj); - adj = (GtkAdjustment*)gtk_object_get_data(obj, "end"); + adj = GTK_ADJUSTMENT( g_object_get_data(obj, "end") ); gtk_adjustment_set_value(adj, 0.0); gtk_adjustment_value_changed(adj); - spinbutton_defocus(GTK_OBJECT(tbl)); + spinbutton_defocus( GTK_OBJECT(obj) ); } -static void arc_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const *name, - gchar const *old_value, gchar const *new_value, - bool is_interactive, gpointer data) +static void arc_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const */*name*/, + gchar const */*old_value*/, gchar const */*new_value*/, + bool /*is_interactive*/, gpointer data) { - GtkWidget *tbl = GTK_WIDGET(data); + GObject *tbl = G_OBJECT(data); // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { + if (g_object_get_data( tbl, "freeze" )) { return; } // in turn, prevent callbacks from responding - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE)); + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); gdouble start = sp_repr_get_double_attribute(repr, "sodipodi:start", 0.0); gdouble end = sp_repr_get_double_attribute(repr, "sodipodi:end", 0.0); GtkAdjustment *adj1,*adj2; - adj1 = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "start"); + adj1 = GTK_ADJUSTMENT( g_object_get_data( tbl, "start" ) ); gtk_adjustment_set_value(adj1, mod360((start * 180)/M_PI)); - adj2 = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "end"); + adj2 = GTK_ADJUSTMENT( g_object_get_data( tbl, "end" ) ); gtk_adjustment_set_value(adj2, mod360((end * 180)/M_PI)); - sp_arctb_sensitivize (tbl, adj1->value, adj2->value); + sp_arctb_sensitivize( tbl, adj1->value, adj2->value ); char const *openstr = NULL; openstr = repr->attribute("sodipodi:open"); - GtkWidget *ocb = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "open_checkbox"); + EgeSelectOneAction *ocb = EGE_SELECT_ONE_ACTION( g_object_get_data( tbl, "open_action" ) ); if (openstr) { - gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(ocb), TRUE); + ege_select_one_action_set_active( ocb, 1 ); } else { - gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(ocb), FALSE); + ege_select_one_action_set_active( ocb, 0 ); } - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); } static Inkscape::XML::NodeEventVector arc_tb_repr_events = { @@ -2738,12 +3730,12 @@ static Inkscape::XML::NodeEventVector arc_tb_repr_events = { }; -static void -sp_arc_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl) +static void sp_arc_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl) { int n_selected = 0; Inkscape::XML::Node *repr = NULL; - Inkscape::XML::Node *oldrepr = NULL; + + purge_repr_listener( tbl, tbl ); for (GSList const *items = selection->itemList(); items != NULL; @@ -2755,26 +3747,17 @@ sp_arc_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl) } } - GtkWidget *l = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(tbl), "mode_label")); + EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) ); - g_object_set_data(G_OBJECT(tbl), "single", GINT_TO_POINTER(FALSE)); + g_object_set_data( tbl, "single", GINT_TO_POINTER(FALSE) ); if (n_selected == 0) { - gtk_label_set_markup(GTK_LABEL(l), _("New:")); + g_object_set( G_OBJECT(act), "label", _("New:"), NULL ); } else if (n_selected == 1) { - g_object_set_data(G_OBJECT(tbl), "single", GINT_TO_POINTER(TRUE)); - 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 - sp_repr_remove_listener_by_data(oldrepr, tbl); - Inkscape::GC::release(oldrepr); - oldrepr = 0; - g_object_set_data(G_OBJECT(tbl), "repr", NULL); - } + g_object_set_data( tbl, "single", GINT_TO_POINTER(TRUE) ); + g_object_set( G_OBJECT(act), "label", _("Change:"), NULL ); if (repr) { - g_object_set_data(G_OBJECT(tbl), "repr", repr); + g_object_set_data( 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); @@ -2782,100 +3765,112 @@ sp_arc_toolbox_selection_changed(Inkscape::Selection *selection, GtkObject *tbl) } else { // FIXME: implement averaging of all parameters for multiple selected //gtk_label_set_markup(GTK_LABEL(l), _("Average:")); - gtk_label_set_markup(GTK_LABEL(l), _("Change:")); - sp_arctb_sensitivize (GTK_WIDGET(tbl), 1, 0); + g_object_set( G_OBJECT(act), "label", _("Change:"), NULL ); + sp_arctb_sensitivize( tbl, 1, 0 ); } } -static GtkWidget * -sp_arc_toolbox_new(SPDesktop *desktop) +static void sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) { - GtkWidget *tbl = gtk_hbox_new(FALSE, 0); + EgeAdjustmentAction* eact = 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:")); + { + EgeOutputAction* act = ege_output_action_new( "ArcStateAction", _("New:"), "", 0 ); + ege_output_action_set_use_markup( act, TRUE ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_object_set_data( holder, "mode_action", act ); + } /* Start */ { - GtkWidget *hb = sp_tb_spinbutton(_("Start:"), _("The angle (in degrees) from the horizontal to the arc's start point"), + eact = create_adjustment_action( "ArcStartAction", + _("Start"), _("Start:"), + _("The angle (in degrees) from the horizontal to the arc's start point"), "tools.shapes.arc", "start", 0.0, - NULL, tbl, TRUE, "altx-arc", + GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, TRUE, "altx-arc", -360.0, 360.0, 1.0, 10.0, + 0, 0, 0, sp_arctb_start_value_changed); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); } /* End */ { - GtkWidget *hb = sp_tb_spinbutton(_("End:"), _("The angle (in degrees) from the horizontal to the arc's end point"), + eact = create_adjustment_action( "ArcEndAction", + _("End"), _("End:"), + _("The angle (in degrees) from the horizontal to the arc's end point"), "tools.shapes.arc", "end", 0.0, - NULL, tbl, FALSE, NULL, + GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, FALSE, NULL, -360.0, 360.0, 1.0, 10.0, + 0, 0, 0, sp_arctb_end_value_changed); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); } /* Segments / Pie checkbox */ { - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - GtkWidget *fscb = gtk_check_button_new_with_label(_("Open arc")); - gtk_tooltips_set_tip(tt, fscb, _("Switch between arc (unclosed shape) and segment (closed shape with two radii)"), NULL); - - gchar const *openstr = NULL; - openstr = prefs_get_string_attribute("tools.shapes.arc", "open"); - if (!openstr || (openstr && !strcmp(openstr, "false"))) - gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(fscb), FALSE); - else - gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(fscb), TRUE); - - gtk_widget_show(fscb); - gtk_object_set_data(GTK_OBJECT(tbl), "open_checkbox", fscb); - gtk_container_add(GTK_CONTAINER(hb), fscb); - g_signal_connect(G_OBJECT(fscb), "toggled", GTK_SIGNAL_FUNC(sp_arctb_open_state_changed ), tbl); - gtk_box_pack_start(GTK_BOX(tbl),hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + GtkListStore* model = gtk_list_store_new( 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); + + GtkTreeIter iter; + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, + 0, _("Closed arc"), + 1, _("Switch to segment (closed shape with two radii)"), + 2, "circle_closed_arc", + -1 ); + + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, + 0, _("Open Arc"), + 1, _("Switch to arc (unclosed shape)"), + 2, "circle_open_arc", + -1 ); + + EgeSelectOneAction* act = ege_select_one_action_new( "ArcOpenAction", (""), (""), NULL, GTK_TREE_MODEL(model) ); + gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); + g_object_set_data( holder, "open_action", act ); + + ege_select_one_action_set_appearance( act, "full" ); + ege_select_one_action_set_radio_action_type( act, INK_RADIO_ACTION_TYPE ); + g_object_set( G_OBJECT(act), "icon-property", "iconId", NULL ); + ege_select_one_action_set_icon_column( act, 2 ); + ege_select_one_action_set_tooltip_column( act, 1 ); + + gchar const *openstr = prefs_get_string_attribute("tools.shapes.arc", "open"); + bool isClosed = (!openstr || (openstr && !strcmp(openstr, "false"))); + ege_select_one_action_set_active( act, isClosed ? 0 : 1 ); + g_signal_connect_after( G_OBJECT(act), "changed", G_CALLBACK(sp_arctb_open_state_changed), holder ); } /* Make Whole */ { - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - GtkWidget *b = gtk_button_new_with_label(_("Make whole")); - gtk_object_set_data(GTK_OBJECT(tbl), "make_whole", b); - gtk_tooltips_set_tip(tt, b, _("Make the shape a whole ellipse, not arc or segment"), NULL); - gtk_widget_show(b); - gtk_container_add(GTK_CONTAINER(hb), b); - gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(sp_arctb_defaults), tbl); - gtk_box_pack_start(GTK_BOX(tbl),hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); - } - - g_object_set_data(G_OBJECT(tbl), "single", GINT_TO_POINTER(TRUE)); + InkAction* inky = ink_action_new( "ArcResetAction", + _("Make whole"), + _("Make the shape a whole ellipse, not arc or segment"), + "reset_circle", + Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_arctb_defaults), holder ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + gtk_action_set_sensitive( GTK_ACTION(inky), TRUE ); + g_object_set_data( holder, "make_whole", inky ); + } + + g_object_set_data( G_OBJECT(holder), "single", GINT_TO_POINTER(TRUE) ); // sensitivize make whole and open checkbox { - GtkAdjustment *adj1 = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(tbl), "start")); - GtkAdjustment *adj2 = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(tbl), "end")); - sp_arctb_sensitivize (tbl, adj1->value, adj2->value); + GtkAdjustment *adj1 = GTK_ADJUSTMENT( g_object_get_data( holder, "start" ) ); + GtkAdjustment *adj2 = GTK_ADJUSTMENT( g_object_get_data( holder, "end" ) ); + sp_arctb_sensitivize( holder, adj1->value, adj2->value ); } + sigc::connection *connection = new sigc::connection( - sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_arc_toolbox_selection_changed), (GtkObject *)tbl)) + sp_desktop_selection(desktop)->connectChanged(sigc::bind(sigc::ptr_fun(sp_arc_toolbox_selection_changed), (GObject *)holder)) ); - 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); - - return tbl; + g_signal_connect( holder, "destroy", G_CALLBACK(delete_connection), connection ); + g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder ); } @@ -2887,100 +3882,24 @@ sp_arc_toolbox_new(SPDesktop *desktop) //## Dropper ## //######################## -static void toggle_dropper_pick_alpha (GtkWidget *button, gpointer tbl) { - prefs_set_int_attribute ("tools.dropper", "pick", - 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); +static void toggle_dropper_pick_alpha( GtkToggleAction* act, gpointer tbl ) { + prefs_set_int_attribute( "tools.dropper", "pick", gtk_toggle_action_get_active( act ) ); + GtkAction* set_action = GTK_ACTION( g_object_get_data(G_OBJECT(tbl), "set_action") ); + if ( set_action ) { + if ( gtk_toggle_action_get_active( act ) ) { + gtk_action_set_sensitive( set_action, TRUE ); } else { - gtk_widget_set_sensitive (GTK_WIDGET (set_checkbox), FALSE); + gtk_action_set_sensitive( set_action, 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)); } - -/** - * Copy the current saved desktop color to the clipboard as full hex + alpha - * color representation. This is useful for passing values between various - * input boxes, or directly to xml. - */ -/* static void -sp_dropper_copy( GtkWidget *widget, GtkObject *obj) -{ - GtkWidget *tbl = GTK_WIDGET(obj); - - SPDesktop *desktop = - (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop"); - - - sp_dropper_c32_color_copy( sp_desktop_get_color(desktop, true) ); -}*/ - - -/** - * Copies currently saved desktop color to the clipboard as a hex value. This - * is useful for editing webpages and needing a value quickly for web - * colors. - * - * TODO: When the toggle of the dropper is set to not mix color against - * page background, this still just gets the color of the page and - * doesn't get the actual mixed against background which is needed - * for the hex value ppl. want for web pages, etc. - */ - -/* static void -sp_dropper_copy_as_hex ( GtkWidget *widget, GtkObject *obj) -{ - GtkWidget *tbl = GTK_WIDGET(obj); - - SPDesktop *desktop = - (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), "desktop"); - - sp_dropper_c32_color_copy_hex( sp_desktop_get_color(desktop, true) ); -}*/ - - -/** - * Sets the input boxes with the changed color and opacity. This is used as a - * callback for style changing. - */ -/* static bool -sp_style_changed (const SPCSSAttr *css, gpointer data) -{ - // GrDrag *drag = (GrDrag *) data; - - // set fill of text entry box - if (css->attribute("fill")) - gtk_entry_set_text((GtkEntry *)dropper_rgb_entry, - css->attribute("fill")); - - // set opacity of text entry box - if (css->attribute("fill-opacity")) - gtk_entry_set_text((GtkEntry *)dropper_opacity_entry, - css->attribute("fill-opacity")); - - // set fill of text entry box - if (css->attribute("stroke")) - gtk_entry_set_text((GtkEntry *)dropper_rgb_entry, - css->attribute("stroke")); - - // set opacity of text entry box - if (css->attribute("stroke-opacity")) - gtk_entry_set_text((GtkEntry *)dropper_opacity_entry, - css->attribute("stroke-opacity")); - return false; - +static void toggle_dropper_set_alpha( GtkToggleAction* act, gpointer tbl ) { + prefs_set_int_attribute( "tools.dropper", "setalpha", gtk_toggle_action_get_active( act ) ? 1 : 0 ); + spinbutton_defocus(GTK_OBJECT(tbl)); } -*/ /** @@ -2990,162 +3909,35 @@ sp_style_changed (const SPCSSAttr *css, gpointer data) * TODO: Add queue of last 5 or so colors selected with new swatches so that * can drag and drop places. Will provide a nice mixing palette. */ -static GtkWidget * -sp_dropper_toolbox_new(SPDesktop *desktop) +static void sp_dropper_toolbox_prep(SPDesktop */*desktop*/, GtkActionGroup* mainActions, GObject* holder) { - 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(); - - - gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, - AUX_BETWEEN_BUTTON_GROUPS); - // sp_toolbox_add_label(tbl, _("New:")); - + gint pickAlpha = prefs_get_int_attribute( "tools.dropper", "pick", 1 ); - - /* RGB Input Field */ - /* { - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - GtkWidget *dropper_rgba_label = gtk_label_new ("Color:"); - gtk_widget_show (dropper_rgba_label); - gtk_container_add(GTK_CONTAINER(hb), dropper_rgba_label); - - dropper_rgb_entry = gtk_entry_new (); - sp_dialog_defocus_on_enter (dropper_rgb_entry); - gtk_entry_set_max_length (GTK_ENTRY (dropper_rgb_entry), 7); - gtk_entry_set_width_chars (GTK_ENTRY (dropper_rgb_entry), 7); - gtk_tooltips_set_tip(tt, dropper_rgb_entry, - _("Hexidecimal representation of last selected " - "color"), - NULL); - gtk_widget_show (dropper_rgb_entry); - gtk_container_add(GTK_CONTAINER(hb), dropper_rgb_entry); - - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, - AUX_BETWEEN_BUTTON_GROUPS); - } */ - - /* Opacity Input Field */ -/* { - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - GtkWidget *dropper_opacity_label = gtk_label_new ( _("Opacity:") ); - gtk_widget_show (dropper_opacity_label); - gtk_container_add(GTK_CONTAINER(hb), dropper_opacity_label); - - dropper_opacity_entry = gtk_entry_new (); - sp_dialog_defocus_on_enter (dropper_opacity_entry); - gtk_entry_set_max_length (GTK_ENTRY (dropper_opacity_entry), 11); - gtk_entry_set_width_chars (GTK_ENTRY (dropper_opacity_entry), 11); - gtk_tooltips_set_tip(tt, dropper_opacity_entry, - _("Opacity of last selected color"), - NULL); - gtk_widget_show (dropper_opacity_entry); - gtk_container_add(GTK_CONTAINER(hb), dropper_opacity_entry); - - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, - AUX_BETWEEN_BUTTON_GROUPS); - } */ - - - /* Copy to Clipboard */ -/* { - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - GtkWidget *b = gtk_button_new_with_label(_("Copy as RGBA")); - gtk_tooltips_set_tip(tt, b, _("Copy last saved color as hexidecimal " - "RGB + Alpha (RGBA) to " - "clipboard"), - NULL); - gtk_widget_show(b); - gtk_container_add(GTK_CONTAINER(hb), b); - gtk_signal_connect(GTK_OBJECT(b), "clicked", - GTK_SIGNAL_FUNC(sp_dropper_copy), tbl); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, - AUX_BETWEEN_BUTTON_GROUPS); - } */ - - - /* Copy to Clipboard as HEX */ -/* { - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - GtkWidget *b = gtk_button_new_with_label(_("Copy as HEX")); - gtk_tooltips_set_tip(tt, b, _("Copy last saved color as " - "hexidecimal RGB without alpha " - "to clipboard"), NULL); - gtk_widget_show(b); - gtk_container_add(GTK_CONTAINER(hb), b); - gtk_signal_connect(GTK_OBJECT(b), "clicked", - GTK_SIGNAL_FUNC(sp_dropper_copy_as_hex), tbl); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, - AUX_BETWEEN_BUTTON_GROUPS); - } */ - - // aux_toolbox_space(tbl, AUX_BETWEEN_BUTTON_GROUPS); - { - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - - 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); + InkToggleAction* act = ink_toggle_action_new( "DropperPickAlphaAction", + _("Pick alpha"), + _("Pick both the color and the alpha (transparency) under cursor; otherwise, pick only the visible color premultiplied by alpha"), + "color_alpha_get", + Inkscape::ICON_SIZE_DECORATION ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_object_set_data( holder, "pick_action", act ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), pickAlpha ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_dropper_pick_alpha), holder ); } { - GtkWidget *hb = gtk_hbox_new(FALSE, 1); - - 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", - "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); - + InkToggleAction* act = ink_toggle_action_new( "DropperSetAlphaAction", + _("Set alpha"), + _("If alpha was picked, assign it to selection as fill or stroke transparency"), + "color_alpha_set", + Inkscape::ICON_SIZE_DECORATION ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + g_object_set_data( holder, "set_action", act ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.dropper", "setalpha", 1 ) ); // 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); + gtk_action_set_sensitive( GTK_ACTION(act), pickAlpha ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_dropper_set_alpha), holder ); } - - aux_toolbox_space(tbl, AUX_BETWEEN_BUTTON_GROUPS); - - - // where new gtkmm stuff should go - - gtk_widget_show_all(tbl); - sp_set_font_size_smaller (tbl); - - /* - sigc::connection *connection = new sigc::connection( - desktop->connectSetStyle( - sigc::bind(sigc::ptr_fun(sp_style_changed), - desktop)) ); - - g_signal_connect(G_OBJECT(tbl), "destroy", G_CALLBACK(delete_connection), - connection); */ - - return tbl; } @@ -3185,25 +3977,28 @@ sp_text_letter_rotation_changed(GtkAdjustment *adj, GtkWidget *tbl) namespace { -bool visible = false; +bool popdown_visible = false; +bool popdown_hasfocus = false; void -sp_text_toolbox_selection_changed (Inkscape::Selection *selection, GObject *tbl) +sp_text_toolbox_selection_changed (Inkscape::Selection */*selection*/, GObject *tbl) { - SPStyle *query = - sp_style_new (); + sp_style_new (SP_ACTIVE_DOCUMENT); + + int result_fontspec = + sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONT_SPECIFICATION); int result_family = - sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTFAMILY); + 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); + 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); + 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"))); + 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) @@ -3226,35 +4021,47 @@ sp_text_toolbox_selection_changed (Inkscape::Selection *selection, GObject *tbl) 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) { + } else if (query->text->font_specification.value || query->text->font_family.value) { 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); + + // Get the font that corresponds + Glib::ustring familyName; + + font_instance * font = font_factory::Default()->FaceFromStyle(query); + if (font) { + familyName = font_factory::Default()->GetUIFamilyString(font->descr); + font->Unref(); + font = NULL; + } + + gtk_entry_set_text (GTK_ENTRY (entry), familyName.c_str()); Gtk::TreePath path; try { - path = Inkscape::FontLister::get_instance()->get_row_for_font (query->text->font_family.value); + path = Inkscape::FontLister::get_instance()->get_row_for_font (familyName); } catch (...) { + g_warning("Family name %s does not have an entry in the font lister.", familyName.c_str()); 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)); + 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)); + 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)); + g_object_set_data (tbl, "size-block", gpointer(1)); gtk_entry_set_text (GTK_ENTRY(GTK_BIN (cbox)->child), str); - g_object_set_data (tbl, "size-block", gpointer(0)); + g_object_set_data (tbl, "size-block", gpointer(0)); free (str); //Anchor @@ -3295,12 +4102,12 @@ sp_text_toolbox_selection_changed (Inkscape::Selection *selection, GObject *tbl) 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); + gboolean check = (query->font_weight.computed >= SP_CSS_FONT_WEIGHT_700); - if (active != check) + if (active != check) { g_object_set_data (G_OBJECT (button), "block", gpointer(1)); - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), check); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), check); g_object_set_data (G_OBJECT (button), "block", gpointer(0)); } } @@ -3309,12 +4116,12 @@ sp_text_toolbox_selection_changed (Inkscape::Selection *selection, GObject *tbl) 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); + 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); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), check); g_object_set_data (G_OBJECT (button), "block", gpointer(0)); } } @@ -3323,10 +4130,10 @@ sp_text_toolbox_selection_changed (Inkscape::Selection *selection, GObject *tbl) //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); @@ -3338,27 +4145,28 @@ sp_text_toolbox_selection_changed (Inkscape::Selection *selection, GObject *tbl) g_object_set_data (G_OBJECT (button), "block", gpointer(0)); g_object_set_data (G_OBJECT (button1), "block", gpointer(0)); } + + sp_style_unref(query); } void -sp_text_toolbox_selection_modified (Inkscape::Selection *selection, guint flags, GObject *tbl) +sp_text_toolbox_selection_modified (Inkscape::Selection *selection, guint /*flags*/, GObject *tbl) { - sp_text_toolbox_selection_changed (selection, tbl); + sp_text_toolbox_selection_changed (selection, tbl); } void -sp_text_toolbox_subselection_changed (gpointer dragger, GObject *tbl) +sp_text_toolbox_subselection_changed (gpointer /*dragger*/, GObject *tbl) { - sp_text_toolbox_selection_changed (NULL, tbl); + sp_text_toolbox_selection_changed (NULL, tbl); } void sp_text_toolbox_family_changed (GtkTreeSelection *selection, - GObject *tbl) + 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; @@ -3377,23 +4185,64 @@ sp_text_toolbox_family_changed (GtkTreeSelection *selection, 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 (); + sp_style_new (SP_ACTIVE_DOCUMENT); - int result_numbers = - sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + int result_fontspec = + sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONT_SPECIFICATION); - SPCSSAttr *css = sp_repr_css_attr_new (); - sp_repr_css_set_property (css, "font-family", family); + font_instance * fontFromStyle = font_factory::Default()->FaceFromStyle(query); + + SPCSSAttr *css = sp_repr_css_attr_new (); + + + // First try to get the font spec from the stored value + Glib::ustring fontSpec = query->text->font_specification.set ? query->text->font_specification.value : ""; - // If querying returned nothing, read the style from the text tool prefs (default style for new texts) - if (result_numbers == QUERY_STYLE_NOTHING) + if (fontSpec.empty()) { + // Construct a new font specification if it does not yet exist + font_instance * fontFromStyle = font_factory::Default()->FaceFromStyle(query); + fontSpec = font_factory::Default()->ConstructFontSpecification(fontFromStyle); + fontFromStyle->Unref(); + } + + if (!fontSpec.empty()) { + Glib::ustring newFontSpec = font_factory::Default()->ReplaceFontSpecificationFamily(fontSpec, family); + if (!newFontSpec.empty() && fontSpec != newFontSpec) { + font_instance *font = font_factory::Default()->FaceFromFontSpecification(newFontSpec.c_str()); + if (font) { + sp_repr_css_set_property (css, "-inkscape-font-specification", newFontSpec.c_str()); + + // Set all the these just in case they were altered when finding the best + // match for the new family and old style... + + gchar c[256]; + + font->Family(c, 256); + sp_repr_css_set_property (css, "font-family", c); + + font->Attribute( "weight", c, 256); + sp_repr_css_set_property (css, "font-weight", c); + + font->Attribute("style", c, 256); + sp_repr_css_set_property (css, "font-style", c); + + font->Attribute("stretch", c, 256); + sp_repr_css_set_property (css, "font-stretch", c); + + font->Attribute("variant", c, 256); + sp_repr_css_set_property (css, "font-variant", c); + + font->Unref(); + } + } + } + + // If querying returned nothing, set the default style of the tool (for new texts) + if (result_fontspec == 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 @@ -3403,28 +4252,30 @@ sp_text_toolbox_family_changed (GtkTreeSelection *selection, sp_desktop_set_style (desktop, css, true, true); } - sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT, + sp_style_unref(query); + + 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_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) + GObject *tbl) { const char *family = gtk_entry_get_text (entry); - try { + 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"))); + gtk_widget_hide (GTK_WIDGET (g_object_get_data (G_OBJECT(tbl), "warning-image"))); } catch (...) { if (family && strlen (family)) { @@ -3439,45 +4290,45 @@ sp_text_toolbox_anchoring_toggled (GtkRadioButton *button, { 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); + int prop = GPOINTER_TO_INT(data); SPDesktop *desktop = SP_ACTIVE_DESKTOP; - SPCSSAttr *css = sp_repr_css_attr_new (); + SPCSSAttr *css = sp_repr_css_attr_new (); switch (prop) { case 0: { - sp_repr_css_set_property (css, "text-anchor", "start"); - sp_repr_css_set_property (css, "text-align", "start"); + 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"); + sp_repr_css_set_property (css, "text-anchor", "middle"); + sp_repr_css_set_property (css, "text-align", "center"); break; } case 2: { - sp_repr_css_set_property (css, "text-anchor", "end"); - sp_repr_css_set_property (css, "text-align", "end"); + sp_repr_css_set_property (css, "text-anchor", "end"); + sp_repr_css_set_property (css, "text-align", "end"); break; } case 3: { - sp_repr_css_set_property (css, "text-anchor", "start"); - sp_repr_css_set_property (css, "text-align", "justify"); + sp_repr_css_set_property (css, "text-anchor", "start"); + sp_repr_css_set_property (css, "text-align", "justify"); break; } } SPStyle *query = - sp_style_new (); + sp_style_new (SP_ACTIVE_DOCUMENT); int result_numbers = - sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + 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) @@ -3485,8 +4336,10 @@ sp_text_toolbox_anchoring_toggled (GtkRadioButton *button, sp_repr_css_change (inkscape_get_repr (INKSCAPE, "tools.text"), css, "style"); } + sp_style_unref(query); + sp_desktop_set_style (desktop, css, true, true); - sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT, + sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT, _("Text: Change alignment")); sp_repr_css_attr_unref (css); @@ -3500,39 +4353,76 @@ sp_text_toolbox_style_toggled (GtkToggleButton *button, if (g_object_get_data (G_OBJECT (button), "block")) return; SPDesktop *desktop = SP_ACTIVE_DESKTOP; - SPCSSAttr *css = sp_repr_css_attr_new (); - int prop = GPOINTER_TO_INT(data); + SPCSSAttr *css = sp_repr_css_attr_new (); + int prop = GPOINTER_TO_INT(data); bool active = gtk_toggle_button_get_active (button); + SPStyle *query = + sp_style_new (SP_ACTIVE_DOCUMENT); + + int result_fontspec = + sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONT_SPECIFICATION); + + int result_family = + sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTFAMILY); + + int result_style = + sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTSTYLE); + int result_numbers = + sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + + Glib::ustring fontSpec = query->text->font_specification.set ? query->text->font_specification.value : ""; + Glib::ustring newFontSpec = ""; + + if (fontSpec.empty()) { + // Construct a new font specification if it does not yet exist + font_instance * fontFromStyle = font_factory::Default()->FaceFromStyle(query); + fontSpec = font_factory::Default()->ConstructFontSpecification(fontFromStyle); + fontFromStyle->Unref(); + } + switch (prop) { case 0: { - sp_repr_css_set_property (css, "font-weight", active ? "bold" : "normal" ); + if (!fontSpec.empty()) { + newFontSpec = font_factory::Default()->FontSpecificationSetBold(fontSpec, active); + } + if (fontSpec != newFontSpec) { + // Don't even set the bold if the font didn't exist on the system + sp_repr_css_set_property (css, "font-weight", active ? "bold" : "normal" ); + } break; } case 1: { - sp_repr_css_set_property (css, "font-style", active ? "italic" : "normal"); + if (!fontSpec.empty()) { + newFontSpec = font_factory::Default()->FontSpecificationSetItalic(fontSpec, active); + } + if (fontSpec != newFontSpec) { + // Don't even set the italic if the font didn't exist on the system + sp_repr_css_set_property (css, "font-style", active ? "italic" : "normal"); + } break; } } - SPStyle *query = - sp_style_new (); - int result_numbers = - sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + if (!newFontSpec.empty()) { + sp_repr_css_set_property (css, "-inkscape-font-specification", newFontSpec.c_str()); + } // If querying returned nothing, read the style from the text tool prefs (default style for new texts) - if (result_numbers == QUERY_STYLE_NOTHING) + if (result_fontspec == QUERY_STYLE_NOTHING) { sp_repr_css_change (inkscape_get_repr (INKSCAPE, "tools.text"), css, "style"); } + sp_style_unref(query); + sp_desktop_set_style (desktop, css, true, true); - sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT, + sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT, _("Text: Change font style")); sp_repr_css_attr_unref (css); @@ -3547,10 +4437,10 @@ sp_text_toolbox_orientation_toggled (GtkRadioButton *button, 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); + SPCSSAttr *css = sp_repr_css_attr_new (); + int prop = GPOINTER_TO_INT(data); switch (prop) { @@ -3561,53 +4451,33 @@ sp_text_toolbox_orientation_toggled (GtkRadioButton *button, } 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 + { + sp_repr_css_set_property (css, "writing-mode", "tb"); break; + } } - return FALSE; + + SPStyle *query = + sp_style_new (SP_ACTIVE_DOCUMENT); + 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_family_keypress (GtkWidget *w, GdkEventKey *event, GObject *tbl) +sp_text_toolbox_family_keypress (GtkWidget */*w*/, GdkEventKey *event, GObject *tbl) { SPDesktop *desktop = SP_ACTIVE_DESKTOP; if (!desktop) return FALSE; @@ -3623,18 +4493,29 @@ sp_text_toolbox_family_keypress (GtkWidget *w, GdkEventKey *event, GObject *tbl) } gboolean -sp_text_toolbox_family_list_keypress (GtkWidget *w, GdkEventKey *event, GObject *tbl) +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_KP_Enter: + case GDK_Return: case GDK_Escape: // defocus gtk_widget_hide (w); - visible = false; + popdown_visible = false; gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); return TRUE; // I consumed the event break; + case GDK_w: + case GDK_W: + if (event->state & GDK_CONTROL_MASK) { + gtk_widget_hide (w); + popdown_visible = false; + gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); + return TRUE; // I consumed the event + } + break; } return FALSE; } @@ -3642,31 +4523,41 @@ sp_text_toolbox_family_list_keypress (GtkWidget *w, GdkEventKey *event, GObject void sp_text_toolbox_size_changed (GtkComboBox *cbox, - GObject *tbl) + 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 this is not from selecting a size in the list (in which case get_active will give the + // index of the selected item, otherwise -1) and not from user pressing Enter/Return, do not + // process this event. This fixes GTK's stupid insistence on sending an activate change every + // time any character gets typed or deleted, which made this control nearly unusable in 0.45. + if (gtk_combo_box_get_active (cbox) < 0 && !g_object_get_data (tbl, "enter-pressed")) + return; - 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) + gchar *endptr; + gdouble value = -1; + char *text = gtk_combo_box_get_active_text (cbox); + if (text) { + value = g_strtod (text, &endptr); + if (endptr == text) // conversion failed, non-numeric input + value = -1; + free (text); + } + if (value <= 0) { + return; // could not parse value + } - SPCSSAttr *css = sp_repr_css_attr_new (); - sp_repr_css_set_property (css, "font-size", text); - free (text); + SPCSSAttr *css = sp_repr_css_attr_new (); + Inkscape::CSSOStringStream osfs; + osfs << value; + sp_repr_css_set_property (css, "font-size", osfs.str().c_str()); SPStyle *query = - sp_style_new (); + sp_style_new (SP_ACTIVE_DOCUMENT); int result_numbers = - sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + 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) @@ -3674,29 +4565,72 @@ sp_text_toolbox_size_changed (GtkComboBox *cbox, sp_repr_css_change (inkscape_get_repr (INKSCAPE, "tools.text"), css, "style"); } + sp_style_unref(query); + sp_desktop_set_style (desktop, css, true, true); - sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:size", SP_VERB_NONE, + 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); + gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); +} - 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)); +gboolean +sp_text_toolbox_size_focusout (GtkWidget */*w*/, GdkEventFocus *event, GObject *tbl) +{ + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + if (!desktop) return FALSE; + + if (!g_object_get_data (tbl, "esc-pressed")) { + g_object_set_data (tbl, "enter-pressed", gpointer(1)); + GtkComboBox *cbox = GTK_COMBO_BOX(g_object_get_data (G_OBJECT (tbl), "combo-box-size")); + sp_text_toolbox_size_changed (cbox, tbl); + g_object_set_data (tbl, "enter-pressed", gpointer(0)); + } + return FALSE; // I consumed the event +} + + +gboolean +sp_text_toolbox_size_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 + g_object_set_data (tbl, "esc-pressed", gpointer(1)); + gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); + g_object_set_data (tbl, "esc-pressed", gpointer(0)); + return TRUE; // I consumed the event + break; + case GDK_Return: // defocus + case GDK_KP_Enter: + g_object_set_data (tbl, "enter-pressed", gpointer(1)); + GtkComboBox *cbox = GTK_COMBO_BOX(g_object_get_data (G_OBJECT (tbl), "combo-box-size")); + sp_text_toolbox_size_changed (cbox, tbl); + gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); + g_object_set_data (tbl, "enter-pressed", gpointer(0)); + return TRUE; // I consumed the event + break; + } + return FALSE; } void -sp_text_toolbox_text_popdown_clicked (GtkButton *button, +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) + if (!popdown_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_window_move (GTK_WINDOW (popdown), x, y + widget->allocation.height + 2); //2px of grace space gtk_widget_show_all (popdown); + //sp_transientize (popdown); gdk_pointer_grab (widget->window, TRUE, GdkEventMask (GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | @@ -3706,21 +4640,23 @@ sp_text_toolbox_text_popdown_clicked (GtkButton *button, gdk_keyboard_grab (widget->window, TRUE, GDK_CURRENT_TIME); - visible = true; + popdown_visible = true; } else { + SPDesktop *desktop = SP_ACTIVE_DESKTOP; gdk_pointer_ungrab (GDK_CURRENT_TIME); gdk_keyboard_ungrab (GDK_CURRENT_TIME); + gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); gtk_widget_hide (popdown); - visible = false; + popdown_visible = false; } } gboolean sp_text_toolbox_entry_focus_in (GtkWidget *entry, - GdkEventFocus *event, - GObject *tbl) + GdkEventFocus */*event*/, + GObject */*tbl*/) { gtk_entry_select_region (GTK_ENTRY (entry), 0, -1); return FALSE; @@ -3728,23 +4664,37 @@ sp_text_toolbox_entry_focus_in (GtkWidget *entry, gboolean sp_text_toolbox_popdown_focus_out (GtkWidget *popdown, - GdkEventFocus *event, - GObject *tbl) + GdkEventFocus */*event*/, + GObject */*tbl*/) { SPDesktop *desktop = SP_ACTIVE_DESKTOP; - gtk_widget_hide (popdown); - visible = false; - gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); + if (popdown_hasfocus) { + gtk_widget_hide (popdown); + popdown_hasfocus = false; + popdown_visible = false; + gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); + return TRUE; + } + return FALSE; +} + +gboolean +sp_text_toolbox_popdown_focus_in (GtkWidget *popdown, + GdkEventFocus */*event*/, + GObject */*tbl*/) +{ + popdown_hasfocus = true; return TRUE; } + void -cell_data_func (GtkTreeViewColumn *column, +cell_data_func (GtkTreeViewColumn */*column*/, GtkCellRenderer *cell, GtkTreeModel *tree_model, GtkTreeIter *iter, - gpointer data) + gpointer /*data*/) { char *family, *family_escaped, @@ -3756,8 +4706,8 @@ cell_data_func (GtkTreeViewColumn *column, family_escaped = g_markup_escape_text (family, -1); sample_escaped = g_markup_escape_text (sample, -1); - - std::stringstream markup; + + std::stringstream markup; markup << family_escaped << " " << sample_escaped << ""; g_object_set (G_OBJECT (cell), "markup", markup.str().c_str(), NULL); @@ -3766,7 +4716,7 @@ cell_data_func (GtkTreeViewColumn *column, free (sample_escaped); } -static void delete_completion(GObject *obj, GtkWidget *entry) { +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); @@ -3796,14 +4746,14 @@ sp_text_toolbox_new (SPDesktop *desktop) 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); + 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)); @@ -3822,13 +4772,11 @@ sp_text_toolbox_new (SPDesktop *desktop) 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_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); @@ -3841,6 +4789,7 @@ sp_text_toolbox_new (SPDesktop *desktop) 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), "focus-in-event", G_CALLBACK (sp_text_toolbox_popdown_focus_in), 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)); @@ -3877,7 +4826,8 @@ sp_text_toolbox_new (SPDesktop *desktop) 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); + gtk_signal_connect(GTK_OBJECT(gtk_bin_get_child(GTK_BIN(cbox))), "key-press-event", GTK_SIGNAL_FUNC(sp_text_toolbox_size_keypress), tbl); + gtk_signal_connect(GTK_OBJECT(gtk_bin_get_child(GTK_BIN(cbox))), "focus-out-event", GTK_SIGNAL_FUNC(sp_text_toolbox_size_focusout), tbl); //spacer aux_toolbox_space (tbl, 4); @@ -3907,7 +4857,7 @@ sp_text_toolbox_new (SPDesktop *desktop) 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)); + 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 @@ -3941,8 +4891,8 @@ sp_text_toolbox_new (SPDesktop *desktop) ////////////Text style row = gtk_hbox_new (FALSE, 4); - // bold - rbutton = gtk_toggle_button_new (); + // 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); @@ -3953,7 +4903,7 @@ sp_text_toolbox_new (SPDesktop *desktop) g_signal_connect (G_OBJECT (rbutton), "toggled", G_CALLBACK (sp_text_toolbox_style_toggled), gpointer(0)); // italic - rbutton = gtk_toggle_button_new (); + 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); @@ -3961,7 +4911,7 @@ sp_text_toolbox_new (SPDesktop *desktop) 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)); + 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); @@ -3977,7 +4927,7 @@ sp_text_toolbox_new (SPDesktop *desktop) // horizontal rbutton = group; gtk_button_set_relief (GTK_BUTTON (rbutton), GTK_RELIEF_NONE); - gtk_container_add (GTK_CONTAINER (rbutton), sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_WRITING_MODE_LR)); + gtk_container_add (GTK_CONTAINER (rbutton), sp_icon_new (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); @@ -3988,13 +4938,13 @@ sp_text_toolbox_new (SPDesktop *desktop) // vertical rbutton = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group))); gtk_button_set_relief (GTK_BUTTON (rbutton), GTK_RELIEF_NONE); - gtk_container_add (GTK_CONTAINER (rbutton), sp_icon_new (Inkscape::ICON_SIZE_SMALL_TOOLBAR, INKSCAPE_STOCK_WRITING_MODE_TB)); + gtk_container_add (GTK_CONTAINER (rbutton), sp_icon_new (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)); + 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); @@ -4002,12 +4952,12 @@ sp_text_toolbox_new (SPDesktop *desktop) Inkscape::ConnectionPool* pool = Inkscape::ConnectionPool::new_connection_pool ("ISTextToolbox"); sigc::connection *c_selection_changed = - new sigc::connection (sp_desktop_selection (desktop)->connectChanged + 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 + 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); @@ -4019,168 +4969,6 @@ sp_text_toolbox_new (SPDesktop *desktop) 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_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 - { - 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_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); - - // 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 *hb = sp_tb_spinbutton(_(""), _("Spacing between letters"), - "tools.text", "letter_spacing", 0.0, - us, tbl, FALSE, NULL, - -1000.0, 1000.0, 0.1, 0.1, - sp_text_letter_changed, 0.1, 1); - gtk_widget_set_size_request (hb, 45, 6); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, 6); - } - } - - // 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 *hb = sp_tb_spinbutton(_(""), _("Spacing between lines"), - "tools.text", "line_spacing", 0, - us, tbl, FALSE, NULL, - -1000.0, 1000.0, 0.1, 0.1, - sp_text_line_changed, 0.1, 1); - gtk_widget_set_size_request (hb, 45, 0); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, 3); - } - } - - { - // 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); - - // 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 *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 - { - { - 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); - } - } - - // 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 - 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 *hb = sp_tb_spinbutton(_(""), _("Letter rotation"), - "tools.text", "letter_rotation", 0, - us, tbl, FALSE, NULL, - -180.0, 180.0, 0.1, 0.1, - sp_text_letter_rotation_changed, 0.1, 1); - gtk_widget_set_size_request (hb, 45, 0); - gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, 6); - } - // 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); - } - } - - // 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); - gtk_widget_show(button); - gtk_tooltips_set_tip (tt, button, _("Remove manual kerns"), 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, AUX_BETWEEN_BUTTON_GROUPS); - } -#endif - gtk_widget_show_all (tbl); return tbl; @@ -4190,7 +4978,7 @@ sp_text_toolbox_new (SPDesktop *desktop) //######################### -//## Connector Toolbox ## +//## Connector ## //######################### static void sp_connector_path_set_avoid(void) @@ -4206,15 +4994,14 @@ static void sp_connector_path_set_ignore(void) -static void connector_spacing_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void connector_spacing_changed(GtkAdjustment *adj, GObject* tbl) { // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { + if (g_object_get_data( tbl, "freeze" )) { return; } - - SPDesktop *desktop = (SPDesktop *) gtk_object_get_data(GTK_OBJECT(tbl), - "desktop"); + + SPDesktop *desktop = (SPDesktop *) g_object_get_data( tbl, "desktop" ); SPDocument *doc = sp_desktop_document(desktop); if (!sp_document_get_undo_sensitive(doc)) @@ -4222,14 +5009,24 @@ static void connector_spacing_changed(GtkAdjustment *adj, GtkWidget *tbl) return; } - // in turn, prevent callbacks from responding - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE)); - Inkscape::XML::Node *repr = SP_OBJECT_REPR(desktop->namedview); - + + if ( repr->attribute("inkscape:connector-spacing") ) { + gdouble priorValue = gtk_adjustment_get_value(adj); + sp_repr_get_double( repr, "inkscape:connector-spacing", &priorValue ); + if ( priorValue == gtk_adjustment_get_value(adj) ) { + return; + } + } else if ( adj->value == defaultConnSpacing ) { + return; + } + + // in turn, prevent callbacks from responding + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + sp_repr_set_css_double(repr, "inkscape:connector-spacing", adj->value); SP_OBJECT(desktop->namedview)->updateRepr(); - + GSList *items = get_avoided_items(NULL, desktop->currentRoot(), desktop); for ( GSList const *iter = items ; iter != NULL ; iter = iter->next ) { SPItem *item = reinterpret_cast(iter->data); @@ -4240,12 +5037,12 @@ static void connector_spacing_changed(GtkAdjustment *adj, GtkWidget *tbl) if (items) { g_slist_free(items); } - - sp_document_done(doc, SP_VERB_CONTEXT_CONNECTOR, + + sp_document_done(doc, SP_VERB_CONTEXT_CONNECTOR, _("Change connector spacing")); - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); - + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + spinbutton_defocus(GTK_OBJECT(tbl)); } @@ -4264,39 +5061,38 @@ static void sp_connector_graph_layout(void) 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) +static void sp_directed_graph_layout_toggled( GtkToggleAction* act, GtkObject */*tbl*/ ) { - if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) { - prefs_set_string_attribute("tools.connector", "directedlayout", + if ( gtk_toggle_action_get_active( act ) ) { + prefs_set_string_attribute("tools.connector", "directedlayout", "true"); } else { - prefs_set_string_attribute("tools.connector", "directedlayout", + prefs_set_string_attribute("tools.connector", "directedlayout", "false"); } } -static void -sp_nooverlaps_graph_layout_toggled(GtkWidget *widget, GtkObject *tbl) + +static void sp_nooverlaps_graph_layout_toggled( GtkToggleAction* act, GtkObject */*tbl*/ ) { - if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) { - prefs_set_string_attribute("tools.connector", "avoidoverlaplayout", + if ( gtk_toggle_action_get_active( act ) ) { + prefs_set_string_attribute("tools.connector", "avoidoverlaplayout", "true"); } else { - prefs_set_string_attribute("tools.connector", "avoidoverlaplayout", + prefs_set_string_attribute("tools.connector", "avoidoverlaplayout", "false"); } } -static void connector_length_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void connector_length_changed(GtkAdjustment *adj, GObject* 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, - bool is_interactive, gpointer data) + gchar const *name, gchar const */*old_value*/, gchar const */*new_value*/, + bool /*is_interactive*/, gpointer data) { GtkWidget *tbl = GTK_WIDGET(data); @@ -4311,7 +5107,7 @@ static void connector_tb_event_attr_changed(Inkscape::XML::Node *repr, gtk_object_get_data(GTK_OBJECT(tbl), "spacing"); gdouble spacing = defaultConnSpacing; sp_repr_get_double(repr, "inkscape:connector-spacing", &spacing); - + gtk_adjustment_set_value(adj, spacing); } @@ -4325,201 +5121,270 @@ static Inkscape::XML::NodeEventVector connector_tb_repr_events = { }; -static GtkWidget * -sp_connector_toolbox_new(SPDesktop *desktop) +static void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder ) { - GtkTooltips *tt = gtk_tooltips_new(); - 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); - - 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_SMALL_TOOLBAR, - "connector_avoid", GTK_SIGNAL_FUNC(sp_connector_path_set_avoid), - tt, _("Make connectors avoid selected objects")); + { + InkAction* inky = ink_action_new( "ConnectorAvoidAction", + _("Avoid"), + _("Make connectors avoid selected objects"), + "connector_avoid", + Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_path_set_avoid), holder ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } - 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")); + { + InkAction* inky = ink_action_new( "ConnectorIgnoreAction", + _("Ignore"), + _("Make connectors ignore selected objects"), + "connector_ignore", + Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_path_set_ignore), holder ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } - // interval - gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, - AUX_BETWEEN_BUTTON_GROUPS); + EgeAdjustmentAction* eact = 0; // Spacing spinbox - { - GtkWidget *object_spacing = sp_tb_spinbutton(_("Spacing:"), - _("The amount of space left around objects by auto-routing connectors"), - "tools.connector", "spacing", 10, NULL, tbl, TRUE, - "inkscape:connector-spacing", 0, 100, 1.0, 10.0, - connector_spacing_changed, 1, 0); + eact = create_adjustment_action( "ConnectorSpacingAction", + _("Connector Spacing"), _("Spacing:"), + _("The amount of space left around objects by auto-routing connectors"), + "tools.connector", "spacing", defaultConnSpacing, + GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "inkscape:connector-spacing", + 0, 100, 1.0, 10.0, + 0, 0, 0, + connector_spacing_changed, 1, 0 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - 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); + InkAction* inky = ink_action_new( "ConnectorGraphAction", + _("Graph"), + _("Nicely arrange selected connector network"), + "graph_layout", + Inkscape::ICON_SIZE_SMALL_TOOLBAR ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_graph_layout), holder ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); } - gchar const *tbuttonstate; + + // Default connector length spinbox + eact = create_adjustment_action( "ConnectorLengthAction", + _("Connector Length"), _("Length:"), + _("Ideal length for connectors when layout is applied"), + "tools.connector", "length", 100, + GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "inkscape:connector-length", + 10, 1000, 10.0, 100.0, + 0, 0, 0, + connector_length_changed, 1, 0 ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + + // 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 ); + InkToggleAction* act = ink_toggle_action_new( "ConnectorDirectedAction", + _("Downwards"), + _("Make connectors with end-markers (arrows) point downwards"), + "directed_graph", + Inkscape::ICON_SIZE_DECORATION ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + + gchar const* tbuttonstate = prefs_get_string_attribute( "tools.connector", "directedlayout" ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), + (tbuttonstate && !strcmp(tbuttonstate, "true")) ? TRUE:FALSE ); + + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_directed_graph_layout_toggled), holder ); } + // 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); + InkToggleAction* act = ink_toggle_action_new( "ConnectorOverlapAction", + _("Remove overlaps"), + _("Do not allow overlapping shapes"), + "remove_overlaps", + Inkscape::ICON_SIZE_DECORATION ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + + gchar const* tbuttonstate = prefs_get_string_attribute( "tools.connector", "avoidoverlaplayout" ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), + (tbuttonstate && !strcmp(tbuttonstate, "true")) ? TRUE:FALSE ); - 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 ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_nooverlaps_graph_layout_toggled), holder ); } - gtk_widget_show_all(tbl); - sp_set_font_size_smaller (tbl); - // Code to watch for changes to the connector-spacing attribute in // the XML. Inkscape::XML::Node *repr = SP_OBJECT_REPR(desktop->namedview); g_assert(repr != NULL); - - Inkscape::XML::Node *oldrepr = (Inkscape::XML::Node *) - gtk_object_get_data(GTK_OBJECT(tbl), "repr"); - - if (oldrepr) { // remove old listener - sp_repr_remove_listener_by_data(oldrepr, tbl); - Inkscape::GC::release(oldrepr); - oldrepr = NULL; - g_object_set_data(G_OBJECT(tbl), "repr", NULL); - } + + purge_repr_listener( holder, holder ); if (repr) { - g_object_set_data(G_OBJECT(tbl), "repr", repr); + g_object_set_data( holder, "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); + sp_repr_add_listener( repr, &connector_tb_repr_events, holder ); + sp_repr_synthesize_events( repr, &connector_tb_repr_events, holder ); } - - return tbl; +} // end of sp_connector_toolbox_prep() + + +//######################### +//## Paintbucket ## +//######################### -} // end of sp_connector_toolbox_new() +static void paintbucket_channels_changed(EgeSelectOneAction* act, GObject* /*tbl*/) +{ + gint channels = ege_select_one_action_get_active( act ); + flood_channels_set_channels( channels ); +} -static void paintbucket_tolerance_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void paintbucket_threshold_changed(GtkAdjustment *adj, GObject */*tbl*/) { - prefs_set_int_attribute("tools.paintbucket", "tolerance", (gint)adj->value); - spinbutton_defocus(GTK_OBJECT(tbl)); + prefs_set_int_attribute("tools.paintbucket", "threshold", (gint)adj->value); } -static void paintbucket_offset_changed(GtkAdjustment *adj, GtkWidget *tbl) +static void paintbucket_autogap_changed(EgeSelectOneAction* act, GObject */*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_int_attribute("tools.paintbucket", "autogap", ege_select_one_action_get_active( act )); +} + +static void paintbucket_offset_changed(GtkAdjustment *adj, GObject *tbl) +{ + UnitTracker* tracker = static_cast(g_object_get_data( tbl, "tracker" )); + SPUnit const *unit = tracker->getActiveUnit(); + prefs_set_double_attribute("tools.paintbucket", "offset", (gdouble)sp_units_get_pixels(adj->value, *unit)); - spinbutton_defocus(GTK_OBJECT(tbl)); + + prefs_set_string_attribute("tools.paintbucket", "offsetunits", sp_unit_get_abbreviation(unit)); } -static GtkWidget * -sp_paintbucket_toolbox_new(SPDesktop *desktop) +static void paintbucket_defaults(GtkWidget *, GObject *dataKludge) { - GtkWidget *tbl = gtk_hbox_new(FALSE, 0); - + // FIXME: make defaults settable via Inkscape Options + struct KeyValue { + char const *key; + double value; + } const key_values[] = { + {"threshold", 15}, + {"offset", 0.0} + }; + + for (unsigned i = 0; i < G_N_ELEMENTS(key_values); ++i) { + KeyValue const &kv = key_values[i]; + GtkAdjustment* adj = static_cast(g_object_get_data(dataKludge, kv.key)); + if ( adj ) { + gtk_adjustment_set_value(adj, kv.value); + } + } + + EgeSelectOneAction* channels_action = EGE_SELECT_ONE_ACTION( g_object_get_data( dataKludge, "channels_action" ) ); + ege_select_one_action_set_active( channels_action, FLOOD_CHANNELS_RGB ); + EgeSelectOneAction* autogap_action = EGE_SELECT_ONE_ACTION( g_object_get_data( dataKludge, "autogap_action" ) ); + ege_select_one_action_set_active( autogap_action, 0 ); +} + +static void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) +{ + EgeAdjustmentAction* eact = 0; + + { + GtkListStore* model = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_INT ); + + GList* items = 0; + gint count = 0; + for ( items = flood_channels_dropdown_items_list(); items ; items = g_list_next(items) ) + { + GtkTreeIter iter; + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, 0, reinterpret_cast(items->data), 1, count, -1 ); + count++; + } + g_list_free( items ); + items = 0; + EgeSelectOneAction* act1 = ege_select_one_action_new( "ChannelsAction", _("Fill by"), (""), NULL, GTK_TREE_MODEL(model) ); + g_object_set( act1, "short_label", _("Fill by:"), NULL ); + ege_select_one_action_set_appearance( act1, "compact" ); + ege_select_one_action_set_active( act1, prefs_get_int_attribute("tools.paintbucket", "channels", 0) ); + g_signal_connect( G_OBJECT(act1), "changed", G_CALLBACK(paintbucket_channels_changed), holder ); + gtk_action_group_add_action( mainActions, GTK_ACTION(act1) ); + g_object_set_data( holder, "channels_action", act1 ); + } + // Spacing spinbox { - GtkWidget *tolerance = sp_tb_spinbutton(_("Tolerance:"), - _("The maximum allowed difference between the clicked pixel and the neighboring pixels to be counted in the fill"), - "tools.paintbucket", "tolerance", 5, NULL, tbl, TRUE, - "inkscape:paintbucket-tolerance", 0, 100, 1.0, 10.0, - paintbucket_tolerance_changed, 1, 0); + eact = create_adjustment_action( + "ThresholdAction", + _("Fill Threshold"), _("Threshold:"), + _("The maximum allowed difference between the clicked pixel and the neighboring pixels to be counted in the fill"), + "tools.paintbucket", "threshold", 5, GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, + "inkscape:paintbucket-threshold", 0, 100.0, 1.0, 10.0, + 0, 0, 0, + paintbucket_threshold_changed, 1, 0 ); - gtk_box_pack_start(GTK_BOX(tbl), tolerance, FALSE, FALSE, - AUX_SPACING); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); } - - // 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); - + UnitTracker* tracker = new UnitTracker( SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE ); + const gchar *stored_unit = prefs_get_string_attribute("tools.paintbucket", "offsetunits"); + if (stored_unit) + tracker->setActiveUnit(sp_unit_get_by_abbreviation(stored_unit)); + g_object_set_data( holder, "tracker", tracker ); + { + GtkAction* act = tracker->createAction( "PaintbucketUnitsAction", _("Units"), ("") ); + gtk_action_group_add_action( mainActions, act ); + } + // Offset spinbox { - GtkWidget *offset = sp_tb_spinbutton(_("Offset:"), - _("The amount to grow the path after it has been traced"), - "tools.paintbucket", "offset", 5, 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); + eact = create_adjustment_action( + "OffsetAction", + _("Grow/shrink by"), _("Grow/shrink by:"), + _("The amount to grow (positive) or shrink (negative) the created fill path"), + "tools.paintbucket", "offset", 0, GTK_WIDGET(desktop->canvas), NULL/*us*/, holder, TRUE, + "inkscape:paintbucket-offset", -1e6, 1e6, 0.1, 0.5, + 0, 0, 0, + paintbucket_offset_changed, 1, 2); + tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) ); + + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); } - - // interval - gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS); + + /* Auto Gap */ { - - sp_toolbox_add_label(tbl, _("Channels: "), 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); - } - - 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); + GtkListStore* model = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_INT ); - gtk_widget_show_all(tbl); - sp_set_font_size_smaller (tbl); - return tbl; -} + GList* items = 0; + gint count = 0; + for ( items = flood_autogap_dropdown_items_list(); items ; items = g_list_next(items) ) + { + GtkTreeIter iter; + gtk_list_store_append( model, &iter ); + gtk_list_store_set( model, &iter, 0, reinterpret_cast(items->data), 1, count, -1 ); + count++; + } + g_list_free( items ); + items = 0; + EgeSelectOneAction* act2 = ege_select_one_action_new( "AutoGapAction", _("Close gaps"), (""), NULL, GTK_TREE_MODEL(model) ); + g_object_set( act2, "short_label", _("Close gaps:"), NULL ); + ege_select_one_action_set_appearance( act2, "compact" ); + ege_select_one_action_set_active( act2, prefs_get_int_attribute("tools.paintbucket", "autogap", 0) ); + g_signal_connect( G_OBJECT(act2), "changed", G_CALLBACK(paintbucket_autogap_changed), holder ); + gtk_action_group_add_action( mainActions, GTK_ACTION(act2) ); + g_object_set_data( holder, "autogap_action", act2 ); + } + + /* Reset */ + { + GtkAction* act = gtk_action_new( "PaintbucketResetAction", + _("Defaults"), + _("Reset paint bucket parameters to defaults (use Inkscape Preferences > Tools to change defaults)"), + GTK_STOCK_CLEAR ); + g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(paintbucket_defaults), holder ); + gtk_action_group_add_action( mainActions, act ); + gtk_action_set_sensitive( act, TRUE ); + } + +} /* Local Variables: @@ -4532,3 +5397,6 @@ sp_paintbucket_toolbox_new(SPDesktop *desktop) */ // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 : + + +