![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
index b0ab387f097ab9b4afdf74b05fb43db12b4cfe22..9801c9f48876c056fe53b0370b611d9275d45c09 100644 (file)
--- a/src/widgets/toolbox.cpp
+++ b/src/widgets/toolbox.cpp
#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)
*/
* John Cliff <simarilius@yahoo.com>
* David Turner <novalis@gnu.org>
* Josh Andler <scislac@scislac.com>
+* Jon A. Cruz <jon@joncruz.org>
*
* Copyright (C) 2004 David Turner
* Copyright (C) 2003 MenTaLguY
-* Copyright (C) 1999-2005 authors
+* Copyright (C) 1999-2006 authors
* Copyright (C) 2001-2002 Ximian, Inc.
*
* Released under GNU GPL, read the file 'COPYING' for more information
#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 <glibmm/i18n.h>
#include "gradient-toolbar.h"
#include "connector-context.h"
+#include "node-context.h"
+#include "shape-editor.h"
#include "sp-rect.h"
+#include "box3d.h"
+#include "box3d-context.h"
#include "sp-star.h"
#include "sp-spiral.h"
#include "sp-ellipse.h"
#include "toolbox.h"
+#include "flood-context.h"
+
+#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"
+
+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 sp_3dbox_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 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); }
} 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 },
+// { "SP3DBoxContext", "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 },
{ "SPPencilContext", "pencil_tool", SP_VERB_CONTEXT_PENCIL, SP_VERB_CONTEXT_PENCIL_PREFS },
{ "SPPenContext", "pen_tool", SP_VERB_CONTEXT_PEN, SP_VERB_CONTEXT_PEN_PREFS },
{ "SPDynaDrawContext", "dyna_draw_tool", SP_VERB_CONTEXT_CALLIGRAPHIC, SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS },
+ { "SPFloodContext", "paintbucket_tool", SP_VERB_CONTEXT_PAINTBUCKET, SP_VERB_CONTEXT_PAINTBUCKET_PREFS },
{ "SPTextContext", "text_tool", SP_VERB_CONTEXT_TEXT, SP_VERB_CONTEXT_TEXT_PREFS },
{ "SPConnectorContext","connector_tool", SP_VERB_CONTEXT_CONNECTOR, SP_VERB_CONTEXT_CONNECTOR_PREFS },
{ "SPGradientContext", "gradient_tool", SP_VERB_CONTEXT_GRADIENT, SP_VERB_CONTEXT_GRADIENT_PREFS },
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 },
- { 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_INVALID, 0, 0},
+ { "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")},
+ { "SP3DBoxContext", "3dbox_toolbox", 0, sp_3dbox_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 =
+ "<ui>"
+ " <toolbar name='SelectToolbar'>"
+ " <toolitem action='ObjectRotate90CCW' />"
+ " <toolitem action='ObjectRotate90' />"
+ " <toolitem action='ObjectFlipHorizontally' />"
+ " <toolitem action='ObjectFlipVertically' />"
+ " <separator />"
+ " <toolitem action='SelectionToBack' />"
+ " <toolitem action='SelectionLower' />"
+ " <toolitem action='SelectionRaise' />"
+ " <toolitem action='SelectionToFront' />"
+ " <separator />"
+ " <toolitem action='XAction' />"
+ " <toolitem action='YAction' />"
+ " <toolitem action='WidthAction' />"
+ " <toolitem action='LockAction' />"
+ " <toolitem action='HeightAction' />"
+ " <toolitem action='UnitsAction' />"
+ " <separator />"
+ " <toolitem action='transform_stroke' />"
+ " <toolitem action='transform_corners' />"
+ " <toolitem action='transform_gradient' />"
+ " <toolitem action='transform_pattern' />"
+ " </toolbar>"
+
+ " <toolbar name='NodeToolbar'>"
+ " <toolitem action='NodeInsertAction' />"
+ " <toolitem action='NodeDeleteAction' />"
+ " <separator />"
+ " <toolitem action='NodeJoinAction' />"
+ " <toolitem action='NodeJoinSegmentAction' />"
+ " <toolitem action='NodeDeleteSegmentAction' />"
+ " <toolitem action='NodeBreakAction' />"
+ " <separator />"
+ " <toolitem action='NodeCuspAction' />"
+ " <toolitem action='NodeSmoothAction' />"
+ " <toolitem action='NodeSymmetricAction' />"
+ " <separator />"
+ " <toolitem action='NodeLineAction' />"
+ " <toolitem action='NodeCurveAction' />"
+ " <separator />"
+ " <toolitem action='ObjectToPath' />"
+ " <toolitem action='StrokeToPath' />"
+ " <separator />"
+ " <toolitem action='NodesShowHandlesAction' />"
+ " </toolbar>"
+
+ " <toolbar name='TweakToolbar'>"
+ " <toolitem action='TweakWidthAction' />"
+ " <toolitem action='TweakForceAction' />"
+ " <separator />"
+ " <toolitem action='TweakModeAction' />"
+ " <separator />"
+ " <toolitem action='TweakFidelityAction' />"
+ " <toolitem action='TweakPressureAction' />"
+ " </toolbar>"
+
+ " <toolbar name='ZoomToolbar'>"
+ " <toolitem action='ZoomIn' />"
+ " <toolitem action='ZoomOut' />"
+ " <separator />"
+ " <toolitem action='ZoomSelection' />"
+ " <toolitem action='ZoomDrawing' />"
+ " <toolitem action='ZoomPage' />"
+ " <toolitem action='ZoomPageWidth' />"
+ " <separator />"
+ " <toolitem action='ZoomPrev' />"
+ " <toolitem action='ZoomNext' />"
+ " <separator />"
+ " <toolitem action='Zoom1:0' />"
+ " <toolitem action='Zoom1:2' />"
+ " <toolitem action='Zoom2:1' />"
+ " </toolbar>"
+
+ " <toolbar name='StarToolbar'>"
+ " <separator />"
+ " <toolitem action='StarStateAction' />"
+ " <separator />"
+ " <toolitem action='FlatAction' />"
+ " <separator />"
+ " <toolitem action='MagnitudeAction' />"
+ " <toolitem action='SpokeAction' />"
+ " <toolitem action='RoundednessAction' />"
+ " <toolitem action='RandomizationAction' />"
+ " <separator />"
+ " <toolitem action='StarResetAction' />"
+ " </toolbar>"
+
+ " <toolbar name='RectToolbar'>"
+ " <toolitem action='RectStateAction' />"
+ " <toolitem action='RectWidthAction' />"
+ " <toolitem action='RectHeightAction' />"
+ " <toolitem action='RadiusXAction' />"
+ " <toolitem action='RadiusYAction' />"
+ " <toolitem action='RectUnitsAction' />"
+ " <separator />"
+ " <toolitem action='RectResetAction' />"
+ " </toolbar>"
+
+ " <toolbar name='3DBoxToolbar'>"
+ " <toolitem action='3DBoxVPXAction' />"
+ " <toolitem action='3DBoxVPYAction' />"
+ " <toolitem action='3DBoxVPZAction' />"
+ " <separator />"
+ " </toolbar>"
+
+ " <toolbar name='SpiralToolbar'>"
+ " <toolitem action='SpiralStateAction' />"
+ " <toolitem action='SpiralRevolutionAction' />"
+ " <toolitem action='SpiralExpansionAction' />"
+ " <toolitem action='SpiralT0Action' />"
+ " <separator />"
+ " <toolitem action='SpiralResetAction' />"
+ " </toolbar>"
+
+ " <toolbar name='PenToolbar'>"
+ " </toolbar>"
+
+ " <toolbar name='PencilToolbar'>"
+ " </toolbar>"
+
+ " <toolbar name='CalligraphyToolbar'>"
+ " <separator />"
+ " <toolitem action='CalligraphyWidthAction' />"
+ " <toolitem action='ThinningAction' />"
+ " <separator />"
+ " <toolitem action='AngleAction' />"
+ " <toolitem action='FixationAction' />"
+ " <toolitem action='CapRoundingAction' />"
+ " <separator />"
+ " <toolitem action='TremorAction' />"
+ " <toolitem action='WiggleAction' />"
+ " <toolitem action='MassAction' />"
+ " <separator />"
+ " <toolitem action='TraceAction' />"
+ " <toolitem action='PressureAction' />"
+ " <toolitem action='TiltAction' />"
+ " <toolitem action='CalligraphyResetAction' />"
+ " </toolbar>"
+
+ " <toolbar name='ArcToolbar'>"
+ " <toolitem action='ArcStateAction' />"
+ " <separator />"
+ " <toolitem action='ArcStartAction' />"
+ " <toolitem action='ArcEndAction' />"
+ " <separator />"
+ " <toolitem action='ArcOpenAction' />"
+ " <separator />"
+ " <toolitem action='ArcResetAction' />"
+ " <separator />"
+ " </toolbar>"
+
+ " <toolbar name='PaintbucketToolbar'>"
+ " <toolitem action='ChannelsAction' />"
+ " <separator />"
+ " <toolitem action='ThresholdAction' />"
+ " <separator />"
+ " <toolitem action='OffsetAction' />"
+ " <toolitem action='PaintbucketUnitsAction' />"
+ " <separator />"
+ " <toolitem action='AutoGapAction' />"
+ " <separator />"
+ " <toolitem action='PaintbucketResetAction' />"
+ " </toolbar>"
+
+ " <toolbar name='DropperToolbar'>"
+ " <toolitem action='DropperPickAlphaAction' />"
+ " <toolitem action='DropperSetAlphaAction' />"
+ " </toolbar>"
+
+ " <toolbar name='ConnectorToolbar'>"
+ " <toolitem action='ConnectorAvoidAction' />"
+ " <toolitem action='ConnectorIgnoreAction' />"
+ " <toolitem action='ConnectorSpacingAction' />"
+ " <toolitem action='ConnectorGraphAction' />"
+ " <toolitem action='ConnectorLengthAction' />"
+ " <toolitem action='ConnectorDirectedAction' />"
+ " <toolitem action='ConnectorOverlapAction' />"
+ " </toolbar>"
+
+ "</ui>"
+;
+
+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);
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
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<Inkscape::XML::Node *>( 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 *
@@ -214,6 +446,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<SPAction *>( nr_object_ref( dynamic_cast<NRObject *>(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<SPDesktop*, GtkActionGroup*> 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()
{
//# 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 GtkWidget *
-sp_node_toolbox_new(SPDesktop *desktop)
+static void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
{
- Inkscape::UI::View::View *view = desktop;
-
- GtkTooltips *tt = gtk_tooltips_new();
- GtkWidget *tb = gtk_hbox_new(FALSE, 0);
-
- gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
-
- 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"));
-
- gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
-
- 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"));
-
- 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"));
-
- 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"));
-
- gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
-
- 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"));
-
- 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"));
-
- 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"));
-
- gtk_box_pack_start(GTK_BOX(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
+ {
+ InkAction* inky = ink_action_new( "NodeInsertAction",
+ _("Insert"),
+ _("Insert new nodes into selected segments"),
+ "node_insert",
+ Inkscape::ICON_SIZE_SMALL_TOOLBAR );
+ 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) );
+ }
- 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"));
+ {
+ InkAction* inky = ink_action_new( "NodeDeleteAction",
+ _("Delete"),
+ _("Delete selected nodes"),
+ "node_delete",
+ Inkscape::ICON_SIZE_SMALL_TOOLBAR );
+ 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) );
+ }
- 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"));
+ {
+ InkAction* inky = ink_action_new( "NodeJoinAction",
+ _("Join"),
+ _("Join selected endnodes"),
+ "node_join",
+ Inkscape::ICON_SIZE_SMALL_TOOLBAR );
+ 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(tb), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
+ {
+ 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) );
+ }
- sp_toolbox_button_normal_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, Inkscape::Verb::get(SP_VERB_OBJECT_TO_CURVE), view, tt);
+ {
+ 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) );
+ }
- sp_toolbox_button_normal_new_from_verb(tb, Inkscape::ICON_SIZE_SMALL_TOOLBAR, Inkscape::Verb::get(SP_VERB_SELECTION_OUTLINE), view, tt);
+ {
+ 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) );
+ }
- aux_toolbox_space(tb, AUX_BETWEEN_BUTTON_GROUPS);
+ {
+ 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) );
+ }
- GtkWidget *cvbox = gtk_vbox_new (FALSE, 0);
- GtkWidget *cbox = gtk_hbox_new (FALSE, 0);
+ {
+ 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) );
+ }
{
- 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( "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) );
}
- 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( "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) );
+ }
- gtk_widget_show_all(tb);
+ {
+ 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) );
+ }
- return tb;
+ {
+ 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 ) );
+ }
-} // end of sp_node_toolbox_new()
+} // end of sp_node_toolbox_prep()
//########################
//## Zoom Toolbox ##
//########################
-static GtkWidget *
-sp_zoom_toolbox_new(SPDesktop *desktop)
+static void sp_zoom_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
{
- Inkscape::UI::View::View *view=desktop;
-
- GtkTooltips *tt = gtk_tooltips_new();
- GtkWidget *tb = gtk_hbox_new(FALSE, 0);
-
- 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_IN), view, tt);
-
- 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);
-
- 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);
-
- 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_1_1), view, tt);
-
- 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);
-
- 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);
-
- gtk_widget_show_all(tb);
-
- return tb;
-
-} // end of sp_zoom_toolbox_new()
+ // no custom GtkAction setup needed
+} // end of sp_zoom_toolbox_prep()
void
sp_tool_toolbox_set_desktop(GtkWidget *toolbox, SPDesktop *desktop)
@@ -572,7 +957,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);
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++ ) {
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<std::string, GtkWidget*> 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 {
- gtk_size_group_add_widget( grouper, sub_toolbox );
+ 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);
+ 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<GtkIconSize>(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, holder );
+
+ 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) );
}
@@ -655,74 +1112,63 @@ 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);
-
+ gchar const * descr =
+ "<ui>"
+ " <toolbar name='CommandsToolbar'>"
+ " <toolitem action='FileNew' />"
+ " <toolitem action='FileOpen' />"
+ " <toolitem action='FileSave' />"
+ " <toolitem action='FilePrint' />"
+ " <separator />"
+ " <toolitem action='FileImport' />"
+ " <toolitem action='FileExport' />"
+ " <separator />"
+ " <toolitem action='EditUndo' />"
+ " <toolitem action='EditRedo' />"
+ " <separator />"
+ " <toolitem action='EditCopy' />"
+ " <toolitem action='EditCut' />"
+ " <toolitem action='EditPaste' />"
+ " <separator />"
+ " <toolitem action='ZoomSelection' />"
+ " <toolitem action='ZoomDrawing' />"
+ " <toolitem action='ZoomPage' />"
+ " <separator />"
+ " <toolitem action='EditDuplicate' />"
+ " <toolitem action='EditClone' />"
+ " <toolitem action='EditUnlinkClone' />"
+ " <separator />"
+ " <toolitem action='SelectionGroup' />"
+ " <toolitem action='SelectionUnGroup' />"
+ " <separator />"
+ " <toolitem action='DialogFillStroke' />"
+ " <toolitem action='DialogText' />"
+ " <toolitem action='DialogXMLEditor' />"
+ " <toolitem action='DialogAlignDistribute' />"
+ " <separator />"
+ " <toolitem action='DialogPreferences' />"
+ " <toolitem action='DialogDocumentProperties' />"
+ " </toolbar>"
+ "</ui>";
+ 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, descr, -1, &errVal );
+
+ GtkWidget* toolBar = gtk_ui_manager_get_widget( mgr, "/ui/CommandsToolbar" );
+ if ( prefs_get_int_attribute_limited( "toolbox", "icononly", 1, 0, 1 ) ) {
+ gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS );
+ }
gint shrinkTop = prefs_get_int_attribute_limited( "toolbox", "small", 1, 0, 1 );
Inkscape::IconSize toolboxSize = shrinkTop ? Inkscape::ICON_SIZE_SMALL_TOOLBAR : Inkscape::ICON_SIZE_LARGE_TOOLBAR;
+ gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), (GtkIconSize)toolboxSize );
- 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);
-
- 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);
-
- 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_DISPLAY), view, tt);
- sp_toolbox_button_new_from_verb(tb, toolboxSize, SP_BUTTON_TYPE_NORMAL, Inkscape::Verb::get(SP_VERB_DIALOG_NAMEDVIEW), view, tt);
-
- gtk_widget_show_all(tb);
-
- gtk_container_add(GTK_CONTAINER(toolbox), tb);
+ gtk_container_add( GTK_CONTAINER(toolbox), toolBar );
}
static void
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);
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,
+ 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 ( (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<EgeWidgetFixup>(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
}
// 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;
modmade = true;
}
}
- if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
- /* TODO: annotate */ "toolbox.cpp:854");
+ 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);
}
}
- if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
- /* TODO: annotate */ "toolbox.cpp:899");
-
- g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
+ if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
+ _("Star: Change spoke ratio"));
- spinbutton_defocus(GTK_OBJECT(tbl));
+ g_object_set_data( 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,
- /* TODO: annotate */ "toolbox.cpp:953");
- g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
+ if (modmade) {
+ sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
+ flat ? _("Make polygon") : _("Make star"));
+ }
- spinbutton_defocus(GTK_OBJECT(tbl));
+ g_object_set_data( 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;
modmade = true;
}
}
- if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
- /* TODO: annotate */ "toolbox.cpp:990");
+ 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;
modmade = true;
}
}
- if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
- /* TODO: annotate */ "toolbox.cpp:1028");
-
- g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
+ if (modmade) sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_STAR,
+ _("Star: Change randomization"));
- spinbutton_defocus(GTK_OBJECT(tbl));
+ g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) );
}
@@ -1048,24 +1516,24 @@ static void star_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const *n
// in turn, prevent callbacks from responding
g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE));
- GtkAdjustment *adj;
+ GtkAdjustment *adj = 0;
if (!strcmp(name, "inkscape:randomized")) {
- adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "randomized");
+ adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(tbl), "randomized") );
gtk_adjustment_set_value(adj, sp_repr_get_double_attribute(repr, "inkscape:randomized", 0.0));
} else if (!strcmp(name, "inkscape:rounded")) {
- adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "rounded");
+ adj = GTK_ADJUSTMENT( gtk_object_get_data(GTK_OBJECT(tbl), "rounded") );
gtk_adjustment_set_value(adj, sp_repr_get_double_attribute(repr, "inkscape:rounded", 0.0));
} else if (!strcmp(name, "inkscape:flatsided")) {
- GtkWidget *fscb = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "flat_checkbox");
- GtkWidget *prop_widget = (GtkWidget*) g_object_get_data(G_OBJECT(tbl), "prop_widget");
+ 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")) {
adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "proportion");
* \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;
@@ -1115,23 +1584,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), _("<b>New:</b>"));
+ g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), NULL );
} else if (n_selected == 1) {
- gtk_label_set_markup(GTK_LABEL(l), _("<b>Change:</b>"));
-
- 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", _("<b>Change:</b>"), 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);
@@ -1139,18 +1600,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), _("<b>Average:</b>"));
- gtk_label_set_markup(GTK_LABEL(l), _("<b>Change:</b>"));
+ //gtk_label_set_markup(GTK_LABEL(l), _("<b>Change:</b>"));
}
}
-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;
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 );
- adj = (GtkAdjustment*)gtk_object_get_data(GTK_OBJECT(tbl), "magnitude");
+ GtkAction* sb2 = GTK_ACTION( g_object_get_data( dataKludge, "prop_action" ) );
+ gtk_action_set_sensitive( sb2, !flat );
+
+ 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));
}
}
-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, _("<b>New:</b>"));
-
- 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", _("<b>New:</b>"), "", 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"),
- "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);
- }
+ //EgeAdjustmentAction* calligraphy_angle = 0;
+ EgeAdjustmentAction* eact = 0;
+ gchar const *flatsidedstr = prefs_get_string_attribute( "tools.shapes.star", "isflatsided" );
+ bool isFlatSided = flatsidedstr ? (strcmp(flatsidedstr, "false") != 0) : true;
- /* Spoke ratio */
- {
- GtkWidget *hb = sp_tb_spinbutton(_("Spoke ratio:"),
+ /* 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[] = {_("tri (default)"), _("quad"), _("pent")};
+ //gdouble values[] = {3, 4, 5};
+ eact = create_adjustment_action( "MagnitudeAction",
+ _("Corners:"), _("Number of corners of a polygon or star"),
+ "tools.shapes.star", "magnitude", 3,
+ GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
+ 3, 1024, 1, 5,
+ 0, 0, 0, // labels, values, G_N_ELEMENTS(labels),
+ sp_stb_magnitude_value_changed,
+ 1.0, 0 );
+ gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+ gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+
+ /* Spoke ratio */
+ //gchar const* labels2[] = {_("(left edge up)"), _("(horizontal)"), _("(default)"), _("(right edge up)")};
+ //gdouble values2[] = {-90, 0, 30, 90};
+ eact = create_adjustment_action( "SpokeAction",
+ _("Spoke ratio:"),
// TRANSLATORS: Tip radius of a star is the distance from the center to the farthest handle.
// Base radius is the same for the closest handle.
_("Base radius to tip radius ratio"),
"tools.shapes.star", "proportion", 0.5,
- NULL, tbl, FALSE, NULL,
+ GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
0.01, 1.0, 0.01, 0.1,
- sp_stb_proportion_value_changed);
- gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING);
- g_object_set_data(G_OBJECT(tbl), "prop_widget", hb);
- if (!flatsidedstr || (flatsidedstr && !strcmp(flatsidedstr, "false")))
- gtk_widget_set_sensitive(GTK_WIDGET(hb), TRUE);
- else
- gtk_widget_set_sensitive(GTK_WIDGET(hb), FALSE);
- }
+ 0, 0, 0, // labels2, values2, G_N_ELEMENTS(labels2),
+ sp_stb_proportion_value_changed );
+ gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+ g_object_set_data( 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* labels3[] = {_("(left edge up)"), _("(horizontal)"), _("(default)"), _("(right edge up)")};
+ //gdouble values3[] = {-90, 0, 30, 90};
+ eact = create_adjustment_action( "RoundednessAction",
+ _("Rounded:"), _("How much rounded are the corners (0 for sharp)"),
"tools.shapes.star", "rounded", 0.0,
- NULL, tbl, FALSE, NULL,
+ GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
-100.0, 100.0, 0.01, 0.1,
- sp_stb_rounded_value_changed);
- gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING);
- }
-
- /* Randomization */
- {
- GtkWidget *hb = sp_tb_spinbutton(_("Randomized:"), _("Scatter randomly the corners and angles"),
+ 0, 0, 0, // labels3, values3, G_N_ELEMENTS(labels3),
+ sp_stb_rounded_value_changed );
+ gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+ gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+
+ /* Randomization */
+ //gchar const* labels4[] = {_("(left edge up)"), _("(horizontal)"), _("(default)"), _("(right edge up)")};
+ //gdouble values4[] = {-90, 0, 30, 90};
+ eact = create_adjustment_action( "RandomizationAction",
+ _("Randomized:"), _("Scatter randomly the corners and angles"),
"tools.shapes.star", "randomized", 0.0,
- NULL, tbl, FALSE, NULL,
+ GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
-10.0, 10.0, 0.001, 0.01,
- sp_stb_randomized_value_changed, 0.1, 3);
- gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING);
+ 0, 0, 0, // labels4, values4, G_N_ELEMENTS(labels4),
+ sp_stb_randomized_value_changed, 0.1, 3 );
+ gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+ gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
}
- aux_toolbox_space(tbl, AUX_SPACING);
-
- /* Reset */
{
- GtkWidget *hb = gtk_hbox_new(FALSE, 1);
- GtkWidget *b = gtk_button_new_with_label(_("Defaults"));
- gtk_tooltips_set_tip(tt, b, _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"), NULL);
- gtk_widget_show(b);
- gtk_container_add(GTK_CONTAINER(hb), b);
- gtk_signal_connect(GTK_OBJECT(b), "clicked", GTK_SIGNAL_FUNC(sp_stb_defaults), tbl);
- gtk_box_pack_start(GTK_BOX(tbl),hb, FALSE, FALSE, AUX_SPACING);
+ /* Reset */
+ {
+ GtkAction* act = gtk_action_new( "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 );
+ }
}
- Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL);
- 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);
-
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 );
}
//## 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<UnitTracker*>(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);
@@ -1362,39 +1840,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,
- /* TODO: annotate */ "toolbox.cpp:1368");
+ 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);
}
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)
{
- 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<UnitTracker*>( 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) );
}
* \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;
@@ -1501,37 +1976,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), _("<b>New:</b>"));
+ g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), 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), _("<b>Change:</b>"));
- g_object_set_data(G_OBJECT(tbl), "single", GINT_TO_POINTER(TRUE));
+ g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), NULL );
+ g_object_set_data( 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);
+ 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);
- 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);
- }
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);
@@ -1539,108 +2007,181 @@ 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), _("<b>Average:</b>"));
- gtk_label_set_markup(GTK_LABEL(l), _("<b>Change:</b>"));
- sp_rtb_sensitivize (GTK_WIDGET(tbl));
+ g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), 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, _("<b>New:</b>"));
+ {
+ EgeOutputAction* act = ege_output_action_new( "RectStateAction", _("<b>New:</b>"), "", 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"),
+ eact = create_adjustment_action( "RectWidthAction",
+ _("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);
+ 0, 0, 0,
+ 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"),
+ eact = create_adjustment_action( "RectHeightAction",
+ _("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);
+ 0, 0, 0,
+ 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"),
+ eact = create_adjustment_action( "RadiusXAction",
+ _("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,
+ 0, 0, 0,
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"),
+ eact = create_adjustment_action( "RadiusYAction",
+ _("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,
+ 0, 0, 0,
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);
+ 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 );
}
- Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL);
- 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);
-
- 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 ##
+//########################
+
+static void sp_3dbox_toggle_vp_changed( GtkToggleAction *act, gpointer data )
+{
+ SPDocument *document = sp_desktop_document (inkscape_active_desktop ());
+ Box3D::Axis axis = (Box3D::Axis) GPOINTER_TO_INT(data);
+
+ if (document->current_perspective) {
+ document->current_perspective->toggle_boxes (axis);
+ }
+
+}
+
+static void sp_3dbox_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
+{
+ SPDocument *document = sp_desktop_document (desktop);
+ bool toggled = false;
+ /* toggle VP in X direction */
+ {
+ InkToggleAction* act = ink_toggle_action_new( "3DBoxVPXAction",
+ _("Toggle 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 ) );
+ if (document->current_perspective) {
+ toggled = !document->current_perspective->get_vanishing_point(Box3D::X)->is_finite();
+ }
+ gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), toggled );
+ /* we connect the signal after setting the state to avoid switching the state again */
+ g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_3dbox_toggle_vp_changed), GINT_TO_POINTER(Box3D::X));
+ }
+
+ /* toggle VP in Y direction */
+ {
+ InkToggleAction* act = ink_toggle_action_new( "3DBoxVPYAction",
+ _("Toggle 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 ) );
+ if (document->current_perspective) {
+ toggled = !document->current_perspective->get_vanishing_point(Box3D::Y)->is_finite();
+ }
+ gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), toggled );
+ /* we connect the signal after setting the state to avoid switching the state again */
+ g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_3dbox_toggle_vp_changed), GINT_TO_POINTER(Box3D::Y));
+ }
+
+ /* toggle VP in Z direction */
+ {
+ InkToggleAction* act = ink_toggle_action_new( "3DBoxVPZAction",
+ _("Toggle 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 ) );
+ if (document->current_perspective) {
+ toggled = !document->current_perspective->get_vanishing_point(Box3D::Z)->is_finite();
+ }
+ /* we connect the signal after setting the state to avoid switching the state again */
+ gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), toggled );
+ g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_3dbox_toggle_vp_changed), GINT_TO_POINTER(Box3D::Z));
+ }
}
//########################
//########################
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);
@@ -1682,29 +2223,27 @@ 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,
- /* TODO: annotate */ "toolbox.cpp:1685");
+ 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_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;
@@ -1790,23 +2330,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), _("<b>New:</b>"));
+ g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), NULL );
} else if (n_selected == 1) {
- gtk_label_set_markup(GTK_LABEL(l), _("<b>Change:</b>"));
-
- 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", _("<b>Change:</b>"), 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);
@@ -1814,79 +2346,75 @@ 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), _("<b>Average:</b>"));
- gtk_label_set_markup(GTK_LABEL(l), _("<b>Change:</b>"));
+ g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), 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, _("<b>New:</b>"));
+ {
+ EgeOutputAction* act = ege_output_action_new( "SpiralStateAction", _("<b>New:</b>"), "", 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"),
+ eact = create_adjustment_action( "SpiralRevolutionAction",
+ _("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,
+ 0, 0, 0,
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"),
+ eact = create_adjustment_action( "SpiralExpansionAction",
+ _("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,
+ 0, 0, 0,
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)"),
+ eact = create_adjustment_action( "SpiralT0Action",
+ _("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,
+ 0, 0, 0,
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);
+ 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) );
}
- Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL);
- swatch->setWatchedTool ("tools.shapes.spiral", true);
- GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj());
- gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0);
-
- gtk_widget_show_all(tbl);
- sp_set_font_size_smaller (tbl);
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 );
}
//########################
//########################
-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);
+ // Put stuff here
+}
- Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL);
- swatch->setWatchedTool ("tools.freehand.pen", true);
- GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj());
- gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0);
+static void sp_pencil_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
+{
+ // Put stuff here
+}
- gtk_widget_show_all(tbl);
- sp_set_font_size_smaller (tbl);
+//########################
+//## Tweak ##
+//########################
- return tbl;
+static void sp_tweak_width_value_changed( GtkAdjustment *adj, GObject *tbl )
+{
+ prefs_set_double_attribute( "tools.tweak", "width", adj->value * 0.01 );
}
-static GtkWidget *
-sp_pencil_toolbox_new(SPDesktop *desktop)
+static void sp_tweak_force_value_changed( GtkAdjustment *adj, GObject *tbl )
{
- 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);
+ prefs_set_double_attribute( "tools.tweak", "force", adj->value * 0.01 );
+}
- Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL);
- swatch->setWatchedTool ("tools.freehand.pencil", true);
- GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj());
- gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0);
+static void sp_tweak_pressure_state_changed( GtkToggleAction *act, gpointer data )
+{
+ prefs_set_int_attribute( "tools.tweak", "usepressure", gtk_toggle_action_get_active( act ) ? 1 : 0);
+}
- gtk_widget_show_all(tbl);
- sp_set_font_size_smaller (tbl);
+static void sp_tweak_mode_changed( EgeSelectOneAction *act, GObject *tbl )
+{
+ prefs_set_int_attribute("tools.tweak", "mode", ege_select_one_action_get_active( act ));
+}
+
+static void sp_tweak_fidelity_value_changed( GtkAdjustment *adj, GObject *tbl )
+{
+ prefs_set_double_attribute( "tools.tweak", "fidelity", adj->value * 0.01 );
+}
+
+
+static void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
+{
+ {
+ /* 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:"), _("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 );
+ }
+
+
+ {
+ /* 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:"), _("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 );
+ }
+
+ /* 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, _("Switch to Push mode"),
+ 2, "tweak_push_mode",
+ -1 );
+
+ gtk_list_store_append( model, &iter );
+ gtk_list_store_set( model, &iter,
+ 0, _("Melt mode"),
+ 1, _("Switch to Melt mode"),
+ 2, "tweak_suck_mode",
+ -1 );
+
+ gtk_list_store_append( model, &iter );
+ gtk_list_store_set( model, &iter,
+ 0, _("Blow mode"),
+ 1, _("Switch to Blow mode"),
+ 2, "tweak_blow_mode",
+ -1 );
+
+ gtk_list_store_append( model, &iter );
+ gtk_list_store_set( model, &iter,
+ 0, _("Roughen mode"),
+ 1, _("Switch to Roughen mode"),
+ 2, "tweak_roughen_mode",
+ -1 );
+
+ EgeSelectOneAction* act = ege_select_one_action_new( "TweakModeAction", _(""), _(""), NULL, GTK_TREE_MODEL(model) );
+ 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);
+ }
+
+ { /* 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:"), _("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 );
+ }
+
+
+ /* Use Pressure button */
+ {
+ InkToggleAction* act = ink_toggle_action_new( "TweakPressureAction",
+ _("Pressure"),
+ _("Use the pressure of the input device to alter the width of the area"),
+ "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 ) );
+ }
- return tbl;
}
//## Calligraphy ##
//########################
-static void
-sp_ddc_mass_value_changed(GtkAdjustment *adj, GtkWidget *tbl)
+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_drag_value_changed(GtkAdjustment *adj, GtkWidget *tbl)
+static void sp_ddc_wiggle_value_changed( GtkAdjustment *adj, GObject* tbl )
{
- prefs_set_double_attribute("tools.calligraphic", "drag", adj->value);
- spinbutton_defocus(GTK_OBJECT(tbl));
+ prefs_set_double_attribute( "tools.calligraphic", "wiggle", adj->value );
}
-static void
-sp_ddc_angle_value_changed(GtkAdjustment *adj, GtkWidget *tbl)
+static void sp_ddc_angle_value_changed( GtkAdjustment *adj, 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_pressure_state_changed(GtkWidget *button, gpointer data)
+static void sp_ddc_cap_rounding_value_changed( GtkAdjustment *adj, GObject* tbl )
{
- prefs_set_int_attribute ("tools.calligraphic", "usepressure", gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)) ? 1 : 0);
+ prefs_set_double_attribute( "tools.calligraphic", "cap_rounding", adj->value );
}
-static void
-sp_ddc_tilt_state_changed(GtkWidget *button, GtkWidget *calligraphy_angle)
+static void sp_ddc_pressure_state_changed( GtkToggleAction *act, gpointer data )
{
- prefs_set_int_attribute ("tools.calligraphic", "usetilt", 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);
+}
- gtk_widget_set_sensitive(GTK_WIDGET(calligraphy_angle), !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)));
+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_defaults(GtkWidget *, GtkWidget *tbl)
+static void sp_ddc_tilt_state_changed( GtkToggleAction *act, GtkAction *calligraphy_angle )
+{
+ prefs_set_int_attribute( "tools.calligraphic", "usetilt", gtk_toggle_action_get_active( act ) ? 1 : 0 );
+
+ gtk_action_set_sensitive( calligraphy_angle, !gtk_toggle_action_get_active( act ) );
+}
+
+static void sp_ddc_defaults(GtkWidget *, GObject *dataKludge)
{
// FIXME: make defaults settable via Inkscape Options
struct KeyValue {
double value;
} const key_values[] = {
{"mass", 0.02},
- {"drag", 1.0},
+ {"wiggle", 0.0},
{"angle", 30.0},
{"width", 15},
{"thinning", 0.1},
{"tremor", 0.0},
- {"flatness", 0.9}
+ {"flatness", 0.9},
+ {"cap_rounding", 0.0}
};
for (unsigned i = 0; i < G_N_ELEMENTS(key_values); ++i) {
KeyValue const &kv = key_values[i];
- GtkAdjustment &adj = *static_cast<GtkAdjustment *>(gtk_object_get_data(GTK_OBJECT(tbl), kv.key));
- gtk_adjustment_set_value(&adj, kv.value);
+ GtkAdjustment* adj = static_cast<GtkAdjustment *>(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)
-{
- 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 */
+static void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder)
+{
{
- GtkWidget *hb = sp_tb_spinbutton(_("Width:"), _("The width of the calligraphic pen (relative to the visible canvas area)"),
+ EgeAdjustmentAction* calligraphy_angle = 0;
+
+ {
+ /* Width */
+ gchar const* labels[] = {_("(hairline)"), 0, 0, 0, _("(default)"), 0, 0, 0, 0, _("(broad stroke)")};
+ gdouble values[] = {1, 3, 5, 10, 15, 20, 30, 50, 75, 100};
+ EgeAdjustmentAction *eact = create_adjustment_action( "CalligraphyWidthAction",
+ _("Width:"), _("The width of the calligraphic pen (relative to the visible canvas area)"),
"tools.calligraphic", "width", 15,
- NULL, tbl, TRUE, "altx-calligraphy",
+ GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "altx-calligraphy",
1, 100, 1.0, 10.0,
- sp_ddc_width_value_changed, 0.01, 0, 100);
- gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING);
- }
+ labels, values, G_N_ELEMENTS(labels),
+ sp_ddc_width_value_changed, 0.01, 0, 100 );
+ gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+ gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+ }
- /* Thinning */
- {
- GtkWidget *hb = sp_tb_spinbutton(_("Thinning:"), _("How much velocity thins the stroke (> 0 makes fast strokes thinner, < 0 makes them broader, 0 makes width independent of velocity)"),
+ {
+ /* Thinning */
+ gchar const* labels[] = {_("(speed blows up stroke)"), 0, 0, _("(slight widening)"), _("(constant width)"), _("(slight thinning, default)"), 0, 0, _("(speed deflates stroke)")};
+ gdouble values[] = {-1, -0.4, -0.2, -0.1, 0, 0.1, 0.2, 0.4, 1};
+ EgeAdjustmentAction* eact = create_adjustment_action( "ThinningAction",
+ _("Thinning:"), _("How much velocity thins the stroke (> 0 makes fast strokes thinner, < 0 makes them broader, 0 makes width independent of velocity)"),
"tools.calligraphic", "thinning", 0.1,
- NULL, tbl, FALSE, NULL,
+ GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
-1.0, 1.0, 0.01, 0.1,
+ labels, values, G_N_ELEMENTS(labels),
sp_ddc_velthin_value_changed, 0.01, 2);
- gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING);
- }
-
- // interval
- gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
+ gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+ gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+ }
- /* Angle */
- {
- calligraphy_angle = sp_tb_spinbutton(_("Angle:"), _("The angle of the pen's nib (in degrees; 0 = horizontal; has no effect if fixation = 0)"),
- "tools.calligraphic", "angle", 30,
- NULL, tbl, TRUE, "calligraphy-angle",
- -90.0, 90.0, 1.0, 10.0,
- sp_ddc_angle_value_changed, 1, 0);
- gtk_box_pack_start(GTK_BOX(tbl), calligraphy_angle, FALSE, FALSE, AUX_SPACING);
- }
+ {
+ /* Angle */
+ gchar const* labels[] = {_("(left edge up)"), 0, 0, _("(horizontal)"), _("(default)"), 0, _("(right edge up)")};
+ gdouble values[] = {-90, -60, -30, 0, 30, 60, 90};
+ EgeAdjustmentAction* eact = create_adjustment_action( "AngleAction",
+ _("Angle:"), _("The angle of the pen's nib (in degrees; 0 = horizontal; has no effect if fixation = 0)"),
+ "tools.calligraphic", "angle", 30,
+ GTK_WIDGET(desktop->canvas), NULL, holder, TRUE, "calligraphy-angle",
+ -90.0, 90.0, 1.0, 10.0,
+ labels, values, G_N_ELEMENTS(labels),
+ sp_ddc_angle_value_changed, 1, 0 );
+ gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+ gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+ calligraphy_angle = eact;
+ }
- /* Fixation */
- {
- GtkWidget *hb = sp_tb_spinbutton(_("Fixation:"), _("How fixed is the pen angle (0 = always perpendicular to stroke direction, 1 = fixed)"),
+ {
+ /* Fixation */
+ gchar const* labels[] = {_("(perpendicular to stroke, \"brush\")"), 0, 0, 0, _("(almost fixed, default)"), _("(fixed by Angle, \"pen\")")};
+ gdouble values[] = {0, 0.2, 0.4, 0.6, 0.9, 1.0};
+ EgeAdjustmentAction* eact = create_adjustment_action( "FixationAction",
+ _("Fixation:"), _("Angle behavior (0 = nib always perpendicular to stroke direction, 1 = fixed angle)"),
"tools.calligraphic", "flatness", 0.9,
- NULL, tbl, FALSE, NULL,
+ GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
0.0, 1.0, 0.01, 0.1,
- sp_ddc_flatness_value_changed, 0.01, 2);
- gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING);
- }
+ labels, values, G_N_ELEMENTS(labels),
+ sp_ddc_flatness_value_changed, 0.01, 2 );
+ gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+ gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+ }
- // interval
- gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
+ {
+ /* Cap Rounding */
+ gchar const* labels[] = {_("(blunt caps, default)"), _("(slightly bulging)"), 0, 0, _("(approximately round)"), _("(long protruding caps)")};
+ gdouble values[] = {0, 0.3, 0.5, 1.0, 1.4, 5.0};
+ // TRANSLATORS: "cap" means "end" (both start and finish) here
+ EgeAdjustmentAction* eact = create_adjustment_action( "CapRoundingAction",
+ _("Caps:"), _("Increase to make caps at the ends of strokes protrude more (0 = no caps, 1 = round caps)"),
+ "tools.calligraphic", "cap_rounding", 0.0,
+ GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
+ 0.0, 5.0, 0.01, 0.1,
+ labels, values, G_N_ELEMENTS(labels),
+ sp_ddc_cap_rounding_value_changed, 0.01, 2 );
+ gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+ gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+ }
- /* Tremor */
- {
- GtkWidget *hb = sp_tb_spinbutton(_("Tremor:"), _("How uneven or trembling is the pen stroke"),
+ {
+ /* Tremor */
+ gchar const* labels[] = {_("(smooth line)"), _("(slight tremor)"), _("(noticeable tremor)"), 0, 0, _("(maximum tremor)")};
+ gdouble values[] = {0, 0.1, 0.2, 0.4, 0.6, 1.0};
+ EgeAdjustmentAction* eact = create_adjustment_action( "TremorAction",
+ _("Tremor:"), _("Increase to make strokes rugged and trembling"),
"tools.calligraphic", "tremor", 0.0,
- NULL, tbl, FALSE, NULL,
- 0.0, 1.0, 0.01, 0.1,
- sp_ddc_tremor_value_changed, 0.01, 2);
- gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING);
- }
- /* Mass */
- {
- GtkWidget *hb = sp_tb_spinbutton(_("Mass:"), _("How much inertia affects the movement of the pen"),
- "tools.calligraphic", "mass", 0.02,
- NULL, tbl, FALSE, NULL,
+ GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
0.0, 1.0, 0.01, 0.1,
- sp_ddc_mass_value_changed, 0.01, 2);
- gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING);
- }
-
- /* Drag */
- {
- // TRANSLATORS: "drag" means "resistance" here
- GtkWidget *hb = sp_tb_spinbutton(_("Drag:"), _("How much resistance affects the movement of the pen"),
- "tools.calligraphic", "drag", 1,
- NULL, tbl, FALSE, NULL,
- 0.0, 1.0, 0.01, 0.1,
- sp_ddc_drag_value_changed, 0.01, 2);
- gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_SPACING);
- }
-
- // interval
- gtk_box_pack_start(GTK_BOX(tbl), gtk_hbox_new(FALSE, 0), FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
+ labels, values, G_N_ELEMENTS(labels),
+ sp_ddc_tremor_value_changed, 0.01, 2 );
- 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);
- }
+ gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+ gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+ }
- /* Use Tilt button */
- {
- GtkWidget *button = sp_button_new_from_data( Inkscape::ICON_SIZE_DECORATION,
- SP_BUTTON_TYPE_TOGGLE,
- NULL,
- "use_tilt",
- _("Use the tilt of the input device to alter the angle of the pen's nib"),
- tt);
- g_signal_connect_after (G_OBJECT (button), "clicked", G_CALLBACK (sp_ddc_tilt_state_changed), calligraphy_angle);
- gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), prefs_get_int_attribute ("tools.calligraphic", "usetilt", 1));
- gtk_widget_set_sensitive(GTK_WIDGET(calligraphy_angle), !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)));
- gtk_box_pack_start(GTK_BOX(cbox), button, FALSE, FALSE, 0);
- }
+ {
+ /* Wiggle */
+ gchar const* labels[] = {_("(no wiggle)"), _("(slight deviation)"), 0, 0, _("(wild waves and curls)")};
+ gdouble values[] = {0, 0.2, 0.4, 0.6, 1.0};
+ EgeAdjustmentAction* eact = create_adjustment_action( "WiggleAction",
+ _("Wiggle:"), _("Increase to make the pen waver and wiggle"),
+ "tools.calligraphic", "wiggle", 0.0,
+ GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
+ 0.0, 1.0, 0.01, 0.1,
+ labels, values, G_N_ELEMENTS(labels),
+ sp_ddc_wiggle_value_changed, 0.01, 2 );
+ gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+ gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+ }
- gtk_box_pack_start(GTK_BOX(cvbox), cbox, TRUE, FALSE, 0);
- gtk_box_pack_start(GTK_BOX(tbl), cvbox, FALSE, FALSE, 0);
+ {
+ /* Mass */
+ gchar const* labels[] = {_("(no inertia)"), _("(slight smoothing, default)"), _("(noticeable lagging)"), 0, 0, _("(maximum inertia)")};
+ gdouble values[] = {0.0, 0.02, 0.1, 0.2, 0.5, 1.0};
+ EgeAdjustmentAction* eact = create_adjustment_action( "MassAction",
+ _("Mass:"), _("Increase to make the pen drag behind, as if slowed by inertia"),
+ "tools.calligraphic", "mass", 0.02,
+ GTK_WIDGET(desktop->canvas), NULL, holder, FALSE, NULL,
+ 0.0, 1.0, 0.01, 0.1,
+ labels, values, G_N_ELEMENTS(labels),
+ sp_ddc_mass_value_changed, 0.01, 2 );
+ gtk_action_group_add_action( mainActions, GTK_ACTION(eact) );
+ gtk_action_set_sensitive( GTK_ACTION(eact), TRUE );
+ }
- /* 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);
- }
+ /* 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 ) );
+ }
- Inkscape::UI::Widget::StyleSwatch *swatch = new Inkscape::UI::Widget::StyleSwatch(NULL);
- swatch->setWatchedTool ("tools.calligraphic", true);
- GtkWidget *swatch_ = GTK_WIDGET(swatch->gobj());
- gtk_box_pack_end(GTK_BOX(tbl), swatch_, FALSE, FALSE, 0);
+ /* Use Pressure button */
+ {
+ InkToggleAction* act = ink_toggle_action_new( "PressureAction",
+ _("Pressure"),
+ _("Use the pressure of the input device to alter the width of the pen"),
+ "use_pressure",
+ Inkscape::ICON_SIZE_DECORATION );
+ gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
+ g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_ddc_pressure_state_changed), NULL);
+ gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.calligraphic", "usepressure", 1 ) );
+ }
- gtk_widget_show_all(tbl);
- sp_set_font_size_smaller (tbl);
+ /* Use Tilt button */
+ {
+ InkToggleAction* act = ink_toggle_action_new( "TiltAction",
+ _("Tilt"),
+ _("Use the tilt of the input device to alter the angle of the pen's nib"),
+ "use_tilt",
+ Inkscape::ICON_SIZE_DECORATION );
+ gtk_action_group_add_action( mainActions, GTK_ACTION( act ) );
+ g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_ddc_tilt_state_changed), calligraphy_angle );
+ gtk_action_set_sensitive( GTK_ACTION(calligraphy_angle), !prefs_get_int_attribute( "tools.calligraphic", "usetilt", 1 ) );
+ gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs_get_int_attribute( "tools.calligraphic", "usetilt", 1 ) );
+ }
- return tbl;
+ /* Reset */
+ {
+ GtkAction* act = gtk_action_new( "CalligraphyResetAction",
+ _("Defaults"),
+ _("Reset all parameters to defaults"),
+ GTK_STOCK_CLEAR );
+ g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(sp_ddc_defaults), holder );
+ gtk_action_group_add_action( mainActions, act );
+ gtk_action_set_sensitive( act, TRUE );
+ }
+ }
}
//## 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);
@@ -2239,41 +2909,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,
- /* TODO: annotate */ "toolbox.cpp:2247");
+ 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);
}
// 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)
}
if (modmade) {
- sp_document_done(sp_desktop_document(desktop), SP_VERB_CONTEXT_ARC,
- /* TODO: annotate */ "toolbox.cpp:2320");
+ 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)
{
- 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 = {
};
-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;
@@ -2406,26 +3065,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), _("<b>New:</b>"));
+ g_object_set( G_OBJECT(act), "label", _("<b>New:</b>"), 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), _("<b>Change:</b>"));
-
- 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", _("<b>Change:</b>"), 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);
@@ -2433,98 +3083,110 @@ 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), _("<b>Average:</b>"));
- gtk_label_set_markup(GTK_LABEL(l), _("<b>Change:</b>"));
- sp_arctb_sensitivize (GTK_WIDGET(tbl), 1, 0);
+ g_object_set( G_OBJECT(act), "label", _("<b>Change:</b>"), 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);
-
- 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, _("<b>New:</b>"));
+ {
+ EgeOutputAction* act = ege_output_action_new( "ArcStateAction", _("<b>New:</b>"), "", 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:"), _("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:"), _("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);
- 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 );
}
//## 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 );
}
}
-}
-static void toggle_dropper_set_alpha (GtkWidget *button, gpointer data) {
- 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));
}
-*/
/**
* 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, _("<b>New:</b>"));
-
+ 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;
}
void
sp_text_toolbox_selection_changed (Inkscape::Selection *selection, GObject *tbl)
{
-
SPStyle *query =
- sp_style_new ();
+ sp_style_new (SP_ACTIVE_DOCUMENT);
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)
@@ -2888,20 +3348,20 @@ sp_text_toolbox_selection_changed (Inkscape::Selection *selection, GObject *tbl)
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
@@ -2942,12 +3402,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));
}
}
@@ -2956,12 +3416,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));
}
}
@@ -2970,10 +3430,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);
@@ -2985,23 +3445,25 @@ 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_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;
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);
+ sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_FONTNUMBERS);
- SPCSSAttr *css = sp_repr_css_attr_new ();
- sp_repr_css_set_property (css, "font-family", family);
+ SPCSSAttr *css = sp_repr_css_attr_new ();
+ sp_repr_css_set_property (css, "font-family", family);
// If querying returned nothing, read the style from the text tool prefs (default style for new texts)
if (result_numbers == QUERY_STYLE_NOTHING)
sp_desktop_set_style (desktop, css, true, true);
}
- sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT,
- /* TODO: annotate */ "toolbox.cpp:3024");
+ 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))
{
{
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)
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,
- /* TODO: annotate */ "toolbox.cpp:3107");
+ sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT,
+ _("Text: Change alignment"));
sp_repr_css_attr_unref (css);
gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas));
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);
{
case 0:
{
- sp_repr_css_set_property (css, "font-weight", active ? "bold" : "normal" );
+ 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");
+ sp_repr_css_set_property (css, "font-style", active ? "italic" : "normal");
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)
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,
- /* TODO: annotate */ "toolbox.cpp:3153");
+ sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT,
+ _("Text: Change font style"));
sp_repr_css_attr_unref (css);
gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas));
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)
{
case 1:
{
- sp_repr_css_set_property (css, "writing-mode", "tb");
+ sp_repr_css_set_property (css, "writing-mode", "tb");
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)
}
sp_desktop_set_style (desktop, css, true, true);
- sp_document_done (sp_desktop_document (SP_ACTIVE_DESKTOP), SP_VERB_CONTEXT_TEXT,
- /* TODO: annotate */ "toolbox.cpp:3200");
+ 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));
@@ -3289,7 +3757,7 @@ 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;
gtk_tree_model_get (model, &iter, 0, &text, -1);
#endif // GTK_CHECK_VERSION(2,6,0)
- SPCSSAttr *css = sp_repr_css_attr_new ();
- sp_repr_css_set_property (css, "font-size", text);
+ SPCSSAttr *css = sp_repr_css_attr_new ();
+ sp_repr_css_set_property (css, "font-size", text);
free (text);
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)
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,
- /* TODO: annotate */ "toolbox.cpp:3296");
+ sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "ttb:size", SP_VERB_NONE,
+ _("Text: Change font size"));
sp_repr_css_attr_unref (css);
if (!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);
gdk_pointer_grab (widget->window, TRUE,
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 << " <span foreground='darkgray' font_family='" << family_escaped << "'>" << sample_escaped << "</span>";
g_object_set (G_OBJECT (cell), "markup", markup.str().c_str(), NULL);
free (sample_escaped);
}
+static void delete_completion(GObject *obj, GtkWidget *entry) {
+ GObject *completion = (GObject *) gtk_object_get_data(GTK_OBJECT(entry), "completion");
+ if (completion) {
+ gtk_entry_set_completion (GTK_ENTRY(entry), NULL);
+ g_object_unref (completion);
+ }
+}
+
GtkWidget*
sp_text_toolbox_new (SPDesktop *desktop)
{
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));
//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);
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
////////////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);
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);
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);
// 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);
// 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);
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);
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,
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,
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,
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);
-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))
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<SPItem *>(iter->data);
if (items) {
g_slist_free(items);
}
-
- sp_document_done(doc, SP_VERB_CONTEXT_CONNECTOR,
- _("Change connector spacing distance"));
- g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE));
-
+ sp_document_done(doc, SP_VERB_CONTEXT_CONNECTOR,
+ _("Change connector spacing"));
+
+ g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) );
+
spinbutton_defocus(GTK_OBJECT(tbl));
}
prefs_set_int_attribute("options.clonecompensation", "value", saved_compensation);
- sp_document_done(sp_desktop_document(SP_ACTIVE_DESKTOP), SP_VERB_DIALOG_ALIGN_DISTRIBUTE, /* TODO: annotate */ "toolbox.cpp:129");
+ sp_document_done(sp_desktop_document(SP_ACTIVE_DESKTOP), SP_VERB_DIALOG_ALIGN_DISTRIBUTE, _("Arrange connector network"));
}
-static void
-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));
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);
}
};
-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",
+ _("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",
+ _("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 point downwards"), NULL);
+ 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 );
- 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 );
+ 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 );
+ }
+} // end of sp_connector_toolbox_prep()
+
+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_threshold_changed(GtkAdjustment *adj, GObject *tbl)
+{
+ prefs_set_int_attribute("tools.paintbucket", "threshold", (gint)adj->value);
+}
+
+static void paintbucket_autogap_changed(EgeSelectOneAction* act, GObject *tbl)
+{
+ 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 = reinterpret_cast<UnitTracker*>(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));
+}
+
+static void paintbucket_defaults(GtkWidget *, GObject *dataKludge)
+{
+ // 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<GtkAdjustment *>(g_object_get_data(dataKludge, kv.key));
+ if ( adj ) {
+ gtk_adjustment_set_value(adj, kv.value);
+ }
}
- return tbl;
+ 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<gchar*>(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) );
+ 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
+ {
+ eact = create_adjustment_action(
+ "ThresholdAction",
+ _("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_action_group_add_action( mainActions, GTK_ACTION(eact) );
+ }
+
+ // Create the units menu.
+ 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 );
+ {
+ GtkAction* act = tracker->createAction( "PaintbucketUnitsAction", _("Units"), _("") );
+ gtk_action_group_add_action( mainActions, act );
+ }
+
+ // Offset spinbox
+ {
+ eact = create_adjustment_action(
+ "OffsetAction",
+ _("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) );
+ }
+
+ /* Auto Gap */
+ {
+ GtkListStore* model = gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_INT );
-} // end of sp_connector_toolbox_new()
+ 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<gchar*>(items->data), 1, count, -1 );
+ count++;
+ }
+ g_list_free( items );
+ items = 0;
+ EgeSelectOneAction* act2 = ege_select_one_action_new( "AutoGapAction", _("Fill gaps:"), _(""), NULL, GTK_TREE_MODEL(model) );
+ 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: