From e77e650354daef5ced80adddf6d5a334bb6216d3 Mon Sep 17 00:00:00 2001 From: Alexander Valavanis Date: Sat, 19 Jan 2019 13:58:46 +0000 Subject: derive all toolbars from Inkscape::Toolbar --- src/ui/toolbar/arc-toolbar.cpp | 669 +++--- src/ui/toolbar/arc-toolbar.h | 81 +- src/ui/toolbar/box3d-toolbar.cpp | 561 +++-- src/ui/toolbar/box3d-toolbar.h | 75 +- src/ui/toolbar/calligraphy-toolbar.cpp | 815 ++++--- src/ui/toolbar/calligraphy-toolbar.h | 70 +- src/ui/toolbar/connector-toolbar.cpp | 441 ++-- src/ui/toolbar/connector-toolbar.h | 64 +- src/ui/toolbar/eraser-toolbar.cpp | 379 ++-- src/ui/toolbar/eraser-toolbar.h | 62 +- src/ui/toolbar/gradient-toolbar.cpp | 1341 ++++++----- src/ui/toolbar/gradient-toolbar.h | 78 +- src/ui/toolbar/lpe-toolbar.cpp | 484 ++-- src/ui/toolbar/lpe-toolbar.h | 63 +- src/ui/toolbar/measure-toolbar.cpp | 211 +- src/ui/toolbar/measure-toolbar.h | 39 +- src/ui/toolbar/mesh-toolbar.cpp | 463 ++-- src/ui/toolbar/mesh-toolbar.h | 69 +- src/ui/toolbar/node-toolbar.cpp | 349 +-- src/ui/toolbar/node-toolbar.h | 61 +- src/ui/toolbar/paintbucket-toolbar.cpp | 187 +- src/ui/toolbar/paintbucket-toolbar.h | 40 +- src/ui/toolbar/pencil-toolbar.cpp | 605 ++--- src/ui/toolbar/pencil-toolbar.h | 71 +- src/ui/toolbar/rect-toolbar.cpp | 512 ++--- src/ui/toolbar/rect-toolbar.h | 78 +- src/ui/toolbar/select-toolbar.cpp | 607 +++-- src/ui/toolbar/select-toolbar.h | 44 +- src/ui/toolbar/spiral-toolbar.cpp | 344 +-- src/ui/toolbar/spiral-toolbar.h | 58 +- src/ui/toolbar/spray-toolbar.cpp | 689 +++--- src/ui/toolbar/spray-toolbar.h | 87 +- src/ui/toolbar/star-toolbar.cpp | 719 +++--- src/ui/toolbar/star-toolbar.h | 72 +- src/ui/toolbar/text-toolbar.cpp | 3856 ++++++++++++++++---------------- src/ui/toolbar/text-toolbar.h | 105 +- src/ui/toolbar/tweak-toolbar.cpp | 246 +- src/ui/toolbar/tweak-toolbar.h | 43 +- 38 files changed, 8092 insertions(+), 6646 deletions(-) (limited to 'src/ui') diff --git a/src/ui/toolbar/arc-toolbar.cpp b/src/ui/toolbar/arc-toolbar.cpp index 4f31d0ea8..7c75b63bb 100644 --- a/src/ui/toolbar/arc-toolbar.cpp +++ b/src/ui/toolbar/arc-toolbar.cpp @@ -60,60 +60,237 @@ using Inkscape::UI::PrefPusher; using Inkscape::Util::Quantity; using Inkscape::Util::unit_table; -//######################## -//## Circle / Arc ## -//######################## -static void sp_arctb_sensitivize( GObject *tbl, double v1, double v2 ) +static Inkscape::XML::NodeEventVector arc_tb_repr_events = { + nullptr, /* child_added */ + nullptr, /* child_removed */ + Inkscape::UI::Toolbar::ArcToolbar::event_attr_changed, + nullptr, /* content_changed */ + nullptr /* order_changed */ +}; + +namespace Inkscape { +namespace UI { +namespace Toolbar { +ArcToolbar::ArcToolbar(SPDesktop *desktop) : + Toolbar(desktop), + _tracker(new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR)), + _freeze(false), + _repr(nullptr) { - Gtk::Action *ocb = static_cast( g_object_get_data( tbl, "type_action" ) ); - GtkAction *make_whole = GTK_ACTION( g_object_get_data( tbl, "make_whole" ) ); + _tracker->setActiveUnit(unit_table.getUnit("px")); +} - if (v1 == 0 && v2 == 0) { - if (g_object_get_data( tbl, "single" )) { // only for a single selected ellipse (for now) - ocb->set_sensitive(false); - gtk_action_set_sensitive( make_whole, FALSE ); - } - } else { - ocb->set_sensitive(true); - gtk_action_set_sensitive( make_whole, TRUE ); +ArcToolbar::~ArcToolbar() +{ + if(_repr) { + _repr->removeListenerByData(this); + GC::release(_repr); + _repr = nullptr; + } +} + +GtkWidget * +ArcToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) +{ + auto toolbar = new ArcToolbar(desktop); + + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + + GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); + EgeAdjustmentAction* eact = nullptr; + + { + toolbar->_mode_action = ege_output_action_new( "ArcStateAction", _("New:"), "", nullptr ); + ege_output_action_set_use_markup( toolbar->_mode_action, TRUE ); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_mode_action ) ); + } + + /* Radius X */ + { + gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; + gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500}; + toolbar->_rx_action = create_adjustment_action( "ArcRadiusXAction", + _("Horizontal radius"), _("Rx:"), _("Horizontal radius of the circle, ellipse, or arc"), + "/tools/shapes/arc/rx", 0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + TRUE, "altx-arc", + 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + toolbar->_tracker); + toolbar->_rx_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_rx_action)); + toolbar->_rx_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*toolbar, &ArcToolbar::value_changed), + toolbar->_rx_adj, "rx")); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_rx_action), FALSE ); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_rx_action) ); + } + + /* Radius Y */ + { + gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; + gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500}; + toolbar->_ry_action = create_adjustment_action( "ArcRadiusYAction", + _("Vertical radius"), _("Ry:"), _("Vertical radius of the circle, ellipse, or arc"), + "/tools/shapes/arc/ry", 0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + toolbar->_tracker); + toolbar->_ry_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_ry_action)); + toolbar->_ry_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*toolbar, &ArcToolbar::value_changed), + toolbar->_ry_adj, "ry")); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_ry_action), FALSE ); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_ry_action) ); + } + + // add the units menu + { + Gtk::Action* act = toolbar->_tracker->createAction( "ArcUnitsAction", _("Units"), ("") ); + gtk_action_group_add_action( mainActions, act->gobj() ); + } + + /* Start */ + { + eact = create_adjustment_action( "ArcStartAction", + _("Start"), _("Start:"), + _("The angle (in degrees) from the horizontal to the arc's start point"), + "/tools/shapes/arc/start", 0.0, + GTK_WIDGET(desktop->canvas), + nullptr, + TRUE, "altx-arc", + -360.0, 360.0, 1.0, 10.0, + nullptr, nullptr, 0, + nullptr // callback + ); + toolbar->_start_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + } + + /* End */ + { + eact = create_adjustment_action( "ArcEndAction", + _("End"), _("End:"), + _("The angle (in degrees) from the horizontal to the arc's end point"), + "/tools/shapes/arc/end", 0.0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + -360.0, 360.0, 1.0, 10.0, + nullptr, nullptr, 0, + nullptr // callback + ); + toolbar->_end_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + } + toolbar->_start_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*toolbar, &ArcToolbar::startend_value_changed), + toolbar->_start_adj, "start", toolbar->_end_adj)); + toolbar->_end_adj->signal_value_changed().connect( sigc::bind(sigc::mem_fun(*toolbar, &ArcToolbar::startend_value_changed), + toolbar->_end_adj, "end", toolbar->_start_adj)); + + /* Arc: Slice, Arc, Chord */ + { + InkSelectOneActionColumns columns; + + Glib::RefPtr store = Gtk::ListStore::create(columns); + + Gtk::TreeModel::Row row; + + row = *(store->append()); + row[columns.col_label ] = _("Slice"); + row[columns.col_tooltip ] = _("Switch to slice (closed shape with two radii)"), + row[columns.col_icon ] = INKSCAPE_ICON("draw-ellipse-segment"); + row[columns.col_sensitive] = true; + + row = *(store->append()); + row[columns.col_label ] = _("Arc (Open)"); + row[columns.col_tooltip ] = _("Switch to arc (unclosed shape)"); + row[columns.col_icon ] = INKSCAPE_ICON("draw-ellipse-arc"); + row[columns.col_sensitive] = true; + + row = *(store->append()); + row[columns.col_label ] = _("Chord"); + row[columns.col_tooltip ] = _("Switch to chord (closed shape)"), + row[columns.col_icon ] = INKSCAPE_ICON("draw-ellipse-chord"); + row[columns.col_sensitive] = true; + + toolbar->_type_action = + InkSelectOneAction::create( "ArcTypeAction", // Name + "", // Label + "", // Tooltip + "Not Used", // Icon + store ); // Tree store + + toolbar->_type_action->use_radio( true ); + toolbar->_type_action->use_group_label( false ); + gint type = prefs->getInt("/tools/shapes/arc/arc_type", 0); + toolbar->_type_action->set_active( type ); + + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_type_action->gobj() )); + + toolbar->_type_action->signal_changed().connect(sigc::mem_fun(*toolbar, &ArcToolbar::type_changed)); } + + /* Make Whole */ + { + toolbar->_make_whole = ink_action_new( "ArcResetAction", + _("Make whole"), + _("Make the shape a whole ellipse, not arc or segment"), + INKSCAPE_ICON("draw-ellipse-whole"), + secondarySize ); + g_signal_connect_after( G_OBJECT(toolbar->_make_whole), "activate", G_CALLBACK(ArcToolbar::defaults), toolbar ); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_make_whole) ); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_make_whole), TRUE ); + } + + toolbar->_single = true; + // sensitivize make whole and open checkbox + { + toolbar->sensitivize( toolbar->_start_adj->get_value(), toolbar->_end_adj->get_value() ); + } + + desktop->connectEventContextChanged(sigc::mem_fun(*toolbar, &ArcToolbar::check_ec)); + + return GTK_WIDGET(toolbar->gobj()); } -static void sp_arctb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_name) +void +ArcToolbar::value_changed(Glib::RefPtr& adj, + gchar const *value_name) { // Per SVG spec "a [radius] value of zero disables rendering of the element". // However our implementation does not allow a setting of zero in the UI (not even in the XML editor) // and ugly things happen if it's forced here, so better leave the properties untouched. - if (!gtk_adjustment_get_value(adj)) { + if (!adj->get_value()) { return; } - SPDesktop *desktop = static_cast(g_object_get_data( tbl, "desktop" )); - - UnitTracker* tracker = reinterpret_cast(g_object_get_data( tbl, "tracker" )); - Unit const *unit = tracker->getActiveUnit(); + Unit const *unit = _tracker->getActiveUnit(); g_return_if_fail(unit != nullptr); - SPDocument* document = desktop->getDocument(); + SPDocument* document = _desktop->getDocument(); Geom::Scale scale = document->getDocumentScale(); if (DocumentUndo::getUndoSensitive(document)) { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); prefs->setDouble(Glib::ustring("/tools/shapes/arc/") + value_name, - Quantity::convert(gtk_adjustment_get_value(adj), unit, "px")); + Quantity::convert(adj->get_value(), unit, "px")); } // quit if run by the attr_changed listener - if (g_object_get_data( tbl, "freeze" ) || tracker->isUpdating()) { + if (_freeze || _tracker->isUpdating()) { return; } // in turn, prevent listener from responding - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE)); + _freeze = true; bool modmade = false; - Inkscape::Selection *selection = desktop->getSelection(); + Inkscape::Selection *selection = _desktop->getSelection(); auto itemlist= selection->items(); for(auto i=itemlist.begin();i!=itemlist.end();++i){ SPItem *item = *i; @@ -122,9 +299,9 @@ static void sp_arctb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const SPGenericEllipse *ge = SP_GENERICELLIPSE(item); if (!strcmp(value_name, "rx")) { - ge->setVisibleRx(Quantity::convert(gtk_adjustment_get_value(adj), unit, "px")); + ge->setVisibleRx(Quantity::convert(adj->get_value(), unit, "px")); } else { - ge->setVisibleRy(Quantity::convert(gtk_adjustment_get_value(adj), unit, "px")); + ge->setVisibleRy(Quantity::convert(adj->get_value(), unit, "px")); } ge->normalize(); @@ -136,45 +313,35 @@ static void sp_arctb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const } if (modmade) { - DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_ARC, + DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_ARC, _("Ellipse: Change radius")); } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); -} - -static void sp_arctb_rx_value_changed(GtkAdjustment *adj, GObject *tbl) -{ - sp_arctb_value_changed(adj, tbl, "rx"); + _freeze = false; } -static void sp_arctb_ry_value_changed(GtkAdjustment *adj, GObject *tbl) +void +ArcToolbar::startend_value_changed(Glib::RefPtr& adj, + gchar const *value_name, + Glib::RefPtr& other_adj) { - sp_arctb_value_changed(adj, tbl, "ry"); -} - -static void -sp_arctb_startend_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_name, gchar const *other_name) -{ - SPDesktop *desktop = static_cast(g_object_get_data( tbl, "desktop" )); - - if (DocumentUndo::getUndoSensitive(desktop->getDocument())) { + if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble(Glib::ustring("/tools/shapes/arc/") + value_name, gtk_adjustment_get_value(adj)); + prefs->setDouble(Glib::ustring("/tools/shapes/arc/") + value_name, adj->get_value()); } // quit if run by the attr_changed listener - if (g_object_get_data( tbl, "freeze" )) { + if (_freeze) { return; } // in turn, prevent listener from responding - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + _freeze = true; gchar* namespaced_name = g_strconcat("sodipodi:", value_name, NULL); bool modmade = false; - auto itemlist= desktop->getSelection()->items(); + auto itemlist= _desktop->getSelection()->items(); for(auto i=itemlist.begin();i!=itemlist.end();++i){ SPItem *item = *i; if (SP_IS_GENERICELLIPSE(item)) { @@ -182,9 +349,9 @@ sp_arctb_startend_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *v SPGenericEllipse *ge = SP_GENERICELLIPSE(item); if (!strcmp(value_name, "start")) { - ge->start = (gtk_adjustment_get_value(adj) * M_PI)/ 180; + ge->start = (adj->get_value() * M_PI)/ 180; } else { - ge->end = (gtk_adjustment_get_value(adj) * M_PI)/ 180; + ge->end = (adj->get_value() * M_PI)/ 180; } ge->normalize(); @@ -197,45 +364,31 @@ sp_arctb_startend_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *v g_free(namespaced_name); - GtkAdjustment *other = GTK_ADJUSTMENT( g_object_get_data( tbl, other_name ) ); - - sp_arctb_sensitivize( tbl, gtk_adjustment_get_value(adj), gtk_adjustment_get_value(other) ); + sensitivize( adj->get_value(), other_adj->get_value() ); if (modmade) { - DocumentUndo::maybeDone(desktop->getDocument(), value_name, SP_VERB_CONTEXT_ARC, + DocumentUndo::maybeDone(_desktop->getDocument(), value_name, SP_VERB_CONTEXT_ARC, _("Arc: Change start/end")); } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + _freeze = false; } - -static void sp_arctb_start_value_changed(GtkAdjustment *adj, GObject *tbl) +void +ArcToolbar::type_changed( int type ) { - sp_arctb_startend_value_changed(adj, tbl, "start", "end"); -} - -static void sp_arctb_end_value_changed(GtkAdjustment *adj, GObject *tbl) -{ - sp_arctb_startend_value_changed(adj, tbl, "end", "start"); -} - - -static void sp_arctb_type_changed( GObject *tbl, int type ) -{ - SPDesktop *desktop = static_cast(g_object_get_data( tbl, "desktop" )); - if (DocumentUndo::getUndoSensitive(desktop->getDocument())) { + if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); prefs->setInt("/tools/shapes/arc/arc_type", type); } // quit if run by the attr_changed listener - if (g_object_get_data( tbl, "freeze" )) { + if (_freeze) { return; } // in turn, prevent listener from responding - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + _freeze = true; Glib::ustring arc_type = "slice"; bool open = false; @@ -257,7 +410,7 @@ static void sp_arctb_type_changed( GObject *tbl, int type ) } bool modmade = false; - auto itemlist= desktop->getSelection()->items(); + auto itemlist= _desktop->getSelection()->items(); for(auto i=itemlist.begin();i!=itemlist.end();++i){ SPItem *item = *i; if (SP_IS_GENERICELLIPSE(item)) { @@ -270,334 +423,174 @@ static void sp_arctb_type_changed( GObject *tbl, int type ) } if (modmade) { - DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_ARC, + DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_ARC, _("Arc: Changed arc type")); } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + _freeze = false; } -static void sp_arctb_defaults(GtkWidget *, GObject *obj) +void +ArcToolbar::defaults(GtkWidget *, GObject *obj) { + auto toolbar = reinterpret_cast(obj); GtkAdjustment *adj; - adj = GTK_ADJUSTMENT( g_object_get_data(obj, "start") ); - gtk_adjustment_set_value(adj, 0.0); + toolbar->_start_adj->set_value(0.0); + toolbar->_end_adj->set_value(0.0); #if !GTK_CHECK_VERSION(3,18,0) - gtk_adjustment_value_changed(adj); + toolbar->_start_adj->value_changed(); + toolbar->_end_adj->value_changed(); #endif - adj = GTK_ADJUSTMENT( g_object_get_data(obj, "end") ); - gtk_adjustment_set_value(adj, 0.0); - -#if !GTK_CHECK_VERSION(3,18,0) - gtk_adjustment_value_changed(adj); -#endif - - spinbutton_defocus(GTK_WIDGET(obj)); + if(toolbar->_desktop->canvas) gtk_widget_grab_focus(GTK_WIDGET(toolbar->_desktop->canvas)); } -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) +void +ArcToolbar::sensitivize( double v1, double v2 ) { - GObject *tbl = G_OBJECT(data); - - // quit if run by the _changed callbacks - if (g_object_get_data( tbl, "freeze" )) { - return; - } - - // in turn, prevent callbacks from responding - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); - - gpointer item = g_object_get_data( tbl, "item" ); - if (item && SP_IS_GENERICELLIPSE(item)) { - SPGenericEllipse *ge = SP_GENERICELLIPSE(item); - - UnitTracker* tracker = reinterpret_cast( g_object_get_data( tbl, "tracker" ) ); - Unit const *unit = tracker->getActiveUnit(); - g_return_if_fail(unit != nullptr); - - GtkAdjustment *adj; - adj = GTK_ADJUSTMENT( g_object_get_data(tbl, "rx") ); - gdouble rx = ge->getVisibleRx(); - gtk_adjustment_set_value(adj, Quantity::convert(rx, "px", unit)); - -#if !GTK_CHECK_VERSION(3,18,0) - gtk_adjustment_value_changed(adj); -#endif - - adj = GTK_ADJUSTMENT( g_object_get_data(tbl, "ry") ); - gdouble ry = ge->getVisibleRy(); - gtk_adjustment_set_value(adj, Quantity::convert(ry, "px", unit)); - -#if !GTK_CHECK_VERSION(3,18,0) - gtk_adjustment_value_changed(adj); -#endif - } - - gdouble start = 0.; - gdouble end = 0.; - sp_repr_get_double(repr, "sodipodi:start", &start); - sp_repr_get_double(repr, "sodipodi:end", &end); - - GtkAdjustment *adj1,*adj2; - adj1 = GTK_ADJUSTMENT( g_object_get_data( tbl, "start" ) ); - gtk_adjustment_set_value(adj1, mod360((start * 180)/M_PI)); - adj2 = GTK_ADJUSTMENT( g_object_get_data( tbl, "end" ) ); - gtk_adjustment_set_value(adj2, mod360((end * 180)/M_PI)); - - sp_arctb_sensitivize( tbl, gtk_adjustment_get_value(adj1), gtk_adjustment_get_value(adj2) ); - - char const *arctypestr = nullptr; - arctypestr = repr->attribute("sodipodi:arc-type"); - if (!arctypestr) { // For old files. - char const *openstr = nullptr; - openstr = repr->attribute("sodipodi:open"); - arctypestr = (openstr ? "arc" : "slice"); + if (v1 == 0 && v2 == 0) { + if (_single) { // only for a single selected ellipse (for now) + _type_action->set_sensitive(false); + gtk_action_set_sensitive( GTK_ACTION(_make_whole), FALSE ); + } + } else { + _type_action->set_sensitive(true); + gtk_action_set_sensitive( GTK_ACTION(_make_whole), TRUE ); } +} - InkSelectOneAction *typeAction = - static_cast( g_object_get_data( tbl, "type_action" ) ); - - if (!strcmp(arctypestr,"slice")) { - typeAction->set_active( 0 ); - } else if (!strcmp(arctypestr,"arc")) { - typeAction->set_active( 1 ); +void +ArcToolbar::check_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec) +{ + if (SP_IS_ARC_CONTEXT(ec)) { + _changed = _desktop->getSelection()->connectChanged(sigc::mem_fun(*this, &ArcToolbar::selection_changed)); + selection_changed(desktop->getSelection()); } else { - typeAction->set_active( 2 ); + if (_changed) { + _changed.disconnect(); + if(_repr) { + _repr->removeListenerByData(this); + Inkscape::GC::release(_repr); + _repr = nullptr; + } + } } - - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); } -static Inkscape::XML::NodeEventVector arc_tb_repr_events = { - nullptr, /* child_added */ - nullptr, /* child_removed */ - arc_tb_event_attr_changed, - nullptr, /* content_changed */ - nullptr /* order_changed */ -}; - - -static void sp_arc_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl) +void +ArcToolbar::selection_changed(Inkscape::Selection *selection) { int n_selected = 0; Inkscape::XML::Node *repr = nullptr; - SPItem *item = nullptr; - if ( g_object_get_data( tbl, "repr" ) ) { - g_object_set_data( tbl, "item", nullptr ); + if ( _repr ) { + _item = nullptr; + _repr->removeListenerByData(this); + GC::release(_repr); + _repr = nullptr; } - purge_repr_listener( tbl, tbl ); - auto itemlist= selection->items(); - for(auto i=itemlist.begin();i!=itemlist.end();++i){ - if (SP_IS_GENERICELLIPSE(*i)) { + SPItem *item = nullptr; + + for(auto i : selection->items()){ + if (SP_IS_GENERICELLIPSE(i)) { n_selected++; - item = *i; + item = i; repr = item->getRepr(); } } - EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) ); - - g_object_set_data( tbl, "single", GINT_TO_POINTER(FALSE) ); + _single = false; if (n_selected == 0) { - g_object_set( G_OBJECT(act), "label", _("New:"), NULL ); + gtk_action_set_label(GTK_ACTION(_mode_action), _("New:")); } else if (n_selected == 1) { - g_object_set_data( tbl, "single", GINT_TO_POINTER(TRUE) ); - g_object_set( G_OBJECT(act), "label", _("Change:"), NULL ); - - GtkAction* rx = GTK_ACTION( g_object_get_data( tbl, "rx_action" ) ); - gtk_action_set_sensitive(rx, TRUE); - GtkAction* ry = GTK_ACTION( g_object_get_data( tbl, "ry_action" ) ); - gtk_action_set_sensitive(ry, TRUE); + _single = true; + gtk_action_set_label(GTK_ACTION(_mode_action), _("Change:")); + gtk_action_set_sensitive(GTK_ACTION(_rx_action), TRUE); + gtk_action_set_sensitive(GTK_ACTION(_ry_action), TRUE); if (repr) { - g_object_set_data( tbl, "repr", repr ); - g_object_set_data( tbl, "item", item ); - Inkscape::GC::anchor(repr); - sp_repr_add_listener(repr, &arc_tb_repr_events, tbl); - sp_repr_synthesize_events(repr, &arc_tb_repr_events, tbl); + _repr = repr; + _item = item; + Inkscape::GC::anchor(_repr); + _repr->addListener(&arc_tb_repr_events, this); + _repr->synthesizeEvents(&arc_tb_repr_events, this); } } else { // FIXME: implement averaging of all parameters for multiple selected //gtk_label_set_markup(GTK_LABEL(l), _("Average:")); - g_object_set( G_OBJECT(act), "label", _("Change:"), NULL ); - sp_arctb_sensitivize( tbl, 1, 0 ); + gtk_action_set_label(GTK_ACTION(_mode_action), _("Change:")); + sensitivize( 1, 0 ); } } -static void arc_toolbox_check_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder); - -void sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) +void +ArcToolbar::event_attr_changed(Inkscape::XML::Node *repr, gchar const * /*name*/, + gchar const * /*old_value*/, gchar const * /*new_value*/, + bool /*is_interactive*/, gpointer data) { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + auto toolbar = reinterpret_cast(data); - EgeAdjustmentAction* eact = nullptr; - GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); - - UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR); - tracker->setActiveUnit(unit_table.getUnit("px")); - g_object_set_data( holder, "tracker", tracker ); - - { - EgeOutputAction* act = ege_output_action_new( "ArcStateAction", _("New:"), "", nullptr ); - 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 ); + // quit if run by the _changed callbacks + if (toolbar->_freeze) { + return; } - /* Radius X */ - { - gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; - gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500}; - eact = create_adjustment_action( "ArcRadiusXAction", - _("Horizontal radius"), _("Rx:"), _("Horizontal radius of the circle, ellipse, or arc"), - "/tools/shapes/arc/rx", 0, - GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-arc", - 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP, - labels, values, G_N_ELEMENTS(labels), - sp_arctb_rx_value_changed, tracker); - g_object_set_data( holder, "rx_action", eact ); - gtk_action_set_sensitive( GTK_ACTION(eact), FALSE ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - } + // in turn, prevent callbacks from responding + toolbar->_freeze = true; - /* Radius Y */ - { - gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; - gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500}; - eact = create_adjustment_action( "ArcRadiusYAction", - _("Vertical radius"), _("Ry:"), _("Vertical radius of the circle, ellipse, or arc"), - "/tools/shapes/arc/ry", 0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, - 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP, - labels, values, G_N_ELEMENTS(labels), - sp_arctb_ry_value_changed, tracker); - g_object_set_data( holder, "ry_action", eact ); - gtk_action_set_sensitive( GTK_ACTION(eact), FALSE ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - } + if (toolbar->_item && SP_IS_GENERICELLIPSE(toolbar->_item)) { + SPGenericEllipse *ge = SP_GENERICELLIPSE(toolbar->_item); - // add the units menu - { - Gtk::Action* act = tracker->createAction( "ArcUnitsAction", _("Units"), ("") ); - gtk_action_group_add_action( mainActions, act->gobj() ); - } + Unit const *unit = toolbar->_tracker->getActiveUnit(); + g_return_if_fail(unit != nullptr); - /* Start */ - { - eact = create_adjustment_action( "ArcStartAction", - _("Start"), _("Start:"), - _("The angle (in degrees) from the horizontal to the arc's start point"), - "/tools/shapes/arc/start", 0.0, - GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-arc", - -360.0, 360.0, 1.0, 10.0, - nullptr, nullptr, 0, - sp_arctb_start_value_changed); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - } + gdouble rx = ge->getVisibleRx(); + gdouble ry = ge->getVisibleRy(); + toolbar->_rx_adj->set_value(Quantity::convert(rx, "px", unit)); + toolbar->_ry_adj->set_value(Quantity::convert(ry, "px", unit)); - /* End */ - { - eact = create_adjustment_action( "ArcEndAction", - _("End"), _("End:"), - _("The angle (in degrees) from the horizontal to the arc's end point"), - "/tools/shapes/arc/end", 0.0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, - -360.0, 360.0, 1.0, 10.0, - nullptr, nullptr, 0, - sp_arctb_end_value_changed); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); +#if !GTK_CHECK_VERSION(3,18,0) + toolbar->_rx_adj->value_changed(); + toolbar->_ry_adj->value_changed(); +#endif } - /* Arc: Slice, Arc, Chord */ - { - InkSelectOneActionColumns columns; - - Glib::RefPtr store = Gtk::ListStore::create(columns); - - Gtk::TreeModel::Row row; - - row = *(store->append()); - row[columns.col_label ] = _("Slice"); - row[columns.col_tooltip ] = _("Switch to slice (closed shape with two radii)"), - row[columns.col_icon ] = INKSCAPE_ICON("draw-ellipse-segment"); - row[columns.col_sensitive] = true; - - row = *(store->append()); - row[columns.col_label ] = _("Arc (Open)"); - row[columns.col_tooltip ] = _("Switch to arc (unclosed shape)"); - row[columns.col_icon ] = INKSCAPE_ICON("draw-ellipse-arc"); - row[columns.col_sensitive] = true; - - row = *(store->append()); - row[columns.col_label ] = _("Chord"); - row[columns.col_tooltip ] = _("Switch to chord (closed shape)"), - row[columns.col_icon ] = INKSCAPE_ICON("draw-ellipse-chord"); - row[columns.col_sensitive] = true; - - InkSelectOneAction* act = - InkSelectOneAction::create( "ArcTypeAction", // Name - "", // Label - "", // Tooltip - "Not Used", // Icon - store ); // Tree store + gdouble start = 0.; + gdouble end = 0.; + sp_repr_get_double(repr, "sodipodi:start", &start); + sp_repr_get_double(repr, "sodipodi:end", &end); - act->use_radio( true ); - act->use_group_label( false ); - gint type = prefs->getInt("/tools/shapes/arc/arc_type", 0); - act->set_active( type ); + toolbar->_start_adj->set_value(mod360((start * 180)/M_PI)); + toolbar->_end_adj->set_value(mod360((end * 180)/M_PI)); - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( holder, "type_action", act ); + toolbar->sensitivize(toolbar->_start_adj->get_value(), toolbar->_end_adj->get_value()); - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_arctb_type_changed), holder)); + char const *arctypestr = nullptr; + arctypestr = repr->attribute("sodipodi:arc-type"); + if (!arctypestr) { // For old files. + char const *openstr = nullptr; + openstr = repr->attribute("sodipodi:open"); + arctypestr = (openstr ? "arc" : "slice"); } - /* Make Whole */ - { - InkAction* inky = ink_action_new( "ArcResetAction", - _("Make whole"), - _("Make the shape a whole ellipse, not arc or segment"), - INKSCAPE_ICON("draw-ellipse-whole"), - secondarySize ); - g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_arctb_defaults), holder ); - gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); - gtk_action_set_sensitive( GTK_ACTION(inky), TRUE ); - 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( g_object_get_data( holder, "start" ) ); - GtkAdjustment *adj2 = GTK_ADJUSTMENT( g_object_get_data( holder, "end" ) ); - sp_arctb_sensitivize( holder, gtk_adjustment_get_value(adj1), gtk_adjustment_get_value(adj2) ); + if (!strcmp(arctypestr,"slice")) { + toolbar->_type_action->set_active( 0 ); + } else if (!strcmp(arctypestr,"arc")) { + toolbar->_type_action->set_active( 1 ); + } else { + toolbar->_type_action->set_active( 2 ); } - desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(arc_toolbox_check_ec), holder)); - g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder ); + toolbar->_freeze = false; } -static void arc_toolbox_check_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec, GObject* holder) -{ - static sigc::connection changed; - - if (SP_IS_ARC_CONTEXT(ec)) { - changed = desktop->getSelection()->connectChanged(sigc::bind(sigc::ptr_fun(sp_arc_toolbox_selection_changed), holder)); - sp_arc_toolbox_selection_changed(desktop->getSelection(), holder); - } else { - if (changed) { - changed.disconnect(); - purge_repr_listener(nullptr, holder); - } - } } +} +} + /* Local Variables: diff --git a/src/ui/toolbar/arc-toolbar.h b/src/ui/toolbar/arc-toolbar.h index 821db6dd7..b9b735dcb 100644 --- a/src/ui/toolbar/arc-toolbar.h +++ b/src/ui/toolbar/arc-toolbar.h @@ -28,11 +28,88 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" + +#include + +class InkSelectOneAction; class SPDesktop; +class SPItem; +typedef struct _EgeAdjustmentAction EgeAdjustmentAction; +typedef struct _EgeOutputAction EgeOutputAction; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; +typedef struct _InkAction InkAction; + +namespace Inkscape { +class Selection; + +namespace XML { +class Node; +} + +namespace UI { +namespace Tools { +class ToolBase; +} + +namespace Widget { +class UnitTracker; +} + +namespace Toolbar { +class ArcToolbar : public Toolbar { +private: + UI::Widget::UnitTracker *_tracker; + + EgeAdjustmentAction *_rx_action; + EgeAdjustmentAction *_ry_action; + + EgeOutputAction *_mode_action; + + InkSelectOneAction *_type_action; + InkAction *_make_whole; + + Glib::RefPtr _rx_adj; + Glib::RefPtr _ry_adj; + Glib::RefPtr _start_adj; + Glib::RefPtr _end_adj; + + bool _freeze; + bool _single; + + XML::Node *_repr; + SPItem *_item; + + void value_changed(Glib::RefPtr& adj, + gchar const *value_name); + void startend_value_changed(Glib::RefPtr& adj, + gchar const *value_name, + Glib::RefPtr& other_adj); + void type_changed( int type ); + static void defaults(GtkWidget *, GObject *obj); + void sensitivize( double v1, double v2 ); + void check_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec); + void selection_changed(Inkscape::Selection *selection); + + sigc::connection _changed; + +protected: + ArcToolbar(SPDesktop *desktop); + ~ArcToolbar(); + +public: + static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); + static void event_attr_changed(Inkscape::XML::Node *repr, + gchar const *name, + gchar const *old_value, + gchar const *new_value, + bool is_interactive, + gpointer data); +}; -void sp_arc_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +} +} +} #endif /* !SEEN_ARC_TOOLBAR_H */ diff --git a/src/ui/toolbar/box3d-toolbar.cpp b/src/ui/toolbar/box3d-toolbar.cpp index fb59b13b9..50838a393 100644 --- a/src/ui/toolbar/box3d-toolbar.cpp +++ b/src/ui/toolbar/box3d-toolbar.cpp @@ -58,168 +58,176 @@ using Inkscape::UI::PrefPusher; //## 3D Box ## //######################## -// normalize angle so that it lies in the interval [0,360] -static double box3d_normalize_angle (double a) { - double angle = a + ((int) (a/360.0))*360; - if (angle < 0) { - angle += 360.0; - } - return angle; -} -static void box3d_set_button_and_adjustment(Persp3D *persp, - Proj::Axis axis, - GtkAdjustment *adj, - GtkAction *act, - GtkToggleAction *tact) -{ - // TODO: Take all selected perspectives into account but don't touch the state button if not all of them - // have the same state (otherwise a call to box3d_vp_z_state_changed() is triggered and the states - // are reset). - bool is_infinite = !persp3d_VP_is_finite(persp->perspective_impl, axis); - - if (is_infinite) { - gtk_toggle_action_set_active(tact, TRUE); - gtk_action_set_sensitive(act, TRUE); - double angle = persp3d_get_infinite_angle(persp, axis); - if (angle != Geom::infinity()) { // FIXME: We should catch this error earlier (don't show the spinbutton at all) - gtk_adjustment_set_value(adj, box3d_normalize_angle(angle)); - } - } else { - gtk_toggle_action_set_active(tact, FALSE); - gtk_action_set_sensitive(act, FALSE); - } -} +static Inkscape::XML::NodeEventVector box3d_persp_tb_repr_events = +{ + nullptr, /* child_added */ + nullptr, /* child_removed */ + Inkscape::UI::Toolbar::Box3DToolbar::event_attr_changed, + nullptr, /* content_changed */ + nullptr /* order_changed */ +}; -static void box3d_resync_toolbar(Inkscape::XML::Node *persp_repr, GObject *data) +namespace Inkscape { +namespace UI { +namespace Toolbar { +GtkWidget * +Box3DToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) { - if (!persp_repr) { - g_print ("No perspective given to box3d_resync_toolbar().\n"); - return; - } + auto holder = new Box3DToolbar(desktop); - GtkWidget *tbl = GTK_WIDGET(data); - GtkAdjustment *adj = nullptr; - GtkAction *act = nullptr; - GtkToggleAction *tact = nullptr; - Persp3D *persp = persp3d_get_from_repr(persp_repr); - if (!persp) { - // Hmm, is it an error if this happens? - return; - } - { - adj = GTK_ADJUSTMENT(g_object_get_data(G_OBJECT(tbl), "box3d_angle_x")); - act = GTK_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_angle_x_action")); - tact = &INK_TOGGLE_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_vp_x_state_action"))->action; + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + SPDocument *document = desktop->getDocument(); + Persp3DImpl *persp_impl = document->getCurrentPersp3DImpl(); - box3d_set_button_and_adjustment(persp, Proj::X, adj, act, tact); - } + /* Angle X */ { - adj = GTK_ADJUSTMENT(g_object_get_data(G_OBJECT(tbl), "box3d_angle_y")); - act = GTK_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_angle_y_action")); - tact = &INK_TOGGLE_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_vp_y_state_action"))->action; - - box3d_set_button_and_adjustment(persp, Proj::Y, adj, act, tact); + gchar const* labels[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }; + gdouble values[] = {-90, -60, -30, 0, 30, 60, 90}; + holder->_angle_x_action = create_adjustment_action( "3DBoxAngleXAction", + _("Angle in X direction"), _("Angle X:"), + // Translators: PL is short for 'perspective line' + _("Angle of PLs in X direction"), + "/tools/shapes/3dbox/box3d_angle_x", 30, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + TRUE, "altx-box3d", + -360.0, 360.0, 1.0, 10.0, + labels, values, G_N_ELEMENTS(labels), + nullptr // callback + ); + holder->_angle_x_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_angle_x_action)); + holder->_angle_x_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &Box3DToolbar::angle_value_changed), + holder->_angle_x_adj, Proj::X)); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_angle_x_action) ); } - { - adj = GTK_ADJUSTMENT(g_object_get_data(G_OBJECT(tbl), "box3d_angle_z")); - act = GTK_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_angle_z_action")); - tact = &INK_TOGGLE_ACTION(g_object_get_data(G_OBJECT(tbl), "box3d_vp_z_state_action"))->action; - box3d_set_button_and_adjustment(persp, Proj::Z, adj, act, tact); + if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::X)) { + gtk_action_set_sensitive( GTK_ACTION(holder->_angle_x_action), TRUE ); + } else { + gtk_action_set_sensitive( GTK_ACTION(holder->_angle_x_action), FALSE ); } -} -static void box3d_persp_tb_event_attr_changed(Inkscape::XML::Node *repr, - gchar const * /*name*/, - gchar const * /*old_value*/, - gchar const * /*new_value*/, - bool /*is_interactive*/, - gpointer data) -{ - GtkWidget *tbl = GTK_WIDGET(data); - // quit if run by the attr_changed or selection changed listener - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { - return; + /* VP X state */ + { + holder->_vp_x_state_action = ink_toggle_action_new( "3DBoxVPXStateAction", + // Translators: VP is short for 'vanishing point' + _("State of VP in X direction"), + _("Toggle VP in X direction between 'finite' and 'infinite' (=parallel)"), + INKSCAPE_ICON("perspective-parallel"), + GTK_ICON_SIZE_MENU ); + gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_vp_x_state_action ) ); + g_signal_connect_after( G_OBJECT(holder->_vp_x_state_action), "toggled", G_CALLBACK(Box3DToolbar::vp_state_changed), (gpointer)Proj::X ); + gtk_action_set_sensitive( GTK_ACTION(holder->_angle_x_action), !prefs->getBool("/tools/shapes/3dbox/vp_x_state", true) ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_vp_x_state_action), prefs->getBool("/tools/shapes/3dbox/vp_x_state", true) ); } - // set freeze so that it can be caught in box3d_angle_z_value_changed() (to avoid calling - // SPDocumentUndo::maybeDone() when the document is undo insensitive) - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE)); - - // TODO: Only update the appropriate part of the toolbar -// if (!strcmp(name, "inkscape:vp_z")) { - box3d_resync_toolbar(repr, G_OBJECT(tbl)); -// } - - Persp3D *persp = persp3d_get_from_repr(repr); - persp3d_update_box_reprs(persp); + /* Angle Y */ + { + gchar const* labels[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }; + gdouble values[] = {-90, -60, -30, 0, 30, 60, 90}; + holder->_angle_y_action = create_adjustment_action( "3DBoxAngleYAction", + _("Angle in Y direction"), _("Angle Y:"), + // Translators: PL is short for 'perspective line' + _("Angle of PLs in Y direction"), + "/tools/shapes/3dbox/box3d_angle_y", 30, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + -360.0, 360.0, 1.0, 10.0, + labels, values, G_N_ELEMENTS(labels), + nullptr // callback + ); + holder->_angle_y_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_angle_y_action)); + holder->_angle_y_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &Box3DToolbar::angle_value_changed), + holder->_angle_y_adj, Proj::Y)); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_angle_y_action) ); + } - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); -} + if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::Y)) { + gtk_action_set_sensitive( GTK_ACTION(holder->_angle_y_action), TRUE ); + } else { + gtk_action_set_sensitive( GTK_ACTION(holder->_angle_y_action), FALSE ); + } -static Inkscape::XML::NodeEventVector box3d_persp_tb_repr_events = -{ - nullptr, /* child_added */ - nullptr, /* child_removed */ - box3d_persp_tb_event_attr_changed, - nullptr, /* content_changed */ - nullptr /* order_changed */ -}; + /* VP Y state */ + { + holder->_vp_y_state_action = ink_toggle_action_new( "3DBoxVPYStateAction", + // Translators: VP is short for 'vanishing point' + _("State of VP in Y direction"), + _("Toggle VP in Y direction between 'finite' and 'infinite' (=parallel)"), + INKSCAPE_ICON("perspective-parallel"), + GTK_ICON_SIZE_MENU ); + gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_vp_y_state_action ) ); + g_signal_connect_after( G_OBJECT(holder->_vp_y_state_action), "toggled", G_CALLBACK(Box3DToolbar::vp_state_changed), (gpointer)Proj::Y); + gtk_action_set_sensitive( GTK_ACTION(holder->_angle_y_action), !prefs->getBool("/tools/shapes/3dbox/vp_y_state", true) ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_vp_y_state_action), prefs->getBool("/tools/shapes/3dbox/vp_y_state", true) ); + } -/** - * \param selection Should not be NULL. - */ -// FIXME: This should rather be put into persp3d-reference.cpp or something similar so that it reacts upon each -// Change of the perspective, and not of the current selection (but how to refer to the toolbar then?) -static void box3d_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl) -{ - // Here the following should be done: If all selected boxes have finite VPs in a certain direction, - // disable the angle entry fields for this direction (otherwise entering a value in them should only - // update the perspectives with infinite VPs and leave the other ones untouched). + /* Angle Z */ + { + gchar const* labels[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }; + gdouble values[] = {-90, -60, -30, 0, 30, 60, 90}; + holder->_angle_z_action = create_adjustment_action( "3DBoxAngleZAction", + _("Angle in Z direction"), _("Angle Z:"), + // Translators: PL is short for 'perspective line' + _("Angle of PLs in Z direction"), + "/tools/shapes/3dbox/box3d_angle_z", 30, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + -360.0, 360.0, 1.0, 10.0, + labels, values, G_N_ELEMENTS(labels), + nullptr // callback + ); + holder->_angle_z_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_angle_z_action)); + holder->_angle_z_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &Box3DToolbar::angle_value_changed), + holder->_angle_z_adj, Proj::Z)); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_angle_z_action) ); + } - Inkscape::XML::Node *persp_repr = nullptr; - purge_repr_listener(tbl, tbl); + if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::Z)) { + gtk_action_set_sensitive( GTK_ACTION(holder->_angle_z_action), TRUE ); + } else { + gtk_action_set_sensitive( GTK_ACTION(holder->_angle_z_action), FALSE ); + } - SPItem *item = selection->singleItem(); - SPBox3D *box = dynamic_cast(item); - if (box) { - // FIXME: Also deal with multiple selected boxes - Persp3D *persp = box3d_get_perspective(box); - persp_repr = persp->getRepr(); - if (persp_repr) { - g_object_set_data(tbl, "repr", persp_repr); - Inkscape::GC::anchor(persp_repr); - sp_repr_add_listener(persp_repr, &box3d_persp_tb_repr_events, tbl); - sp_repr_synthesize_events(persp_repr, &box3d_persp_tb_repr_events, tbl); + /* VP Z state */ + { + holder->_vp_z_state_action = ink_toggle_action_new( "3DBoxVPZStateAction", + // Translators: VP is short for 'vanishing point' + _("State of VP in Z direction"), + _("Toggle VP in Z direction between 'finite' and 'infinite' (=parallel)"), + INKSCAPE_ICON("perspective-parallel"), + GTK_ICON_SIZE_MENU ); + gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_vp_z_state_action ) ); + g_signal_connect_after( G_OBJECT(holder->_vp_z_state_action), "toggled", G_CALLBACK(Box3DToolbar::vp_state_changed), (gpointer)Proj::Z ); + gtk_action_set_sensitive( GTK_ACTION(holder->_angle_z_action), !prefs->getBool("/tools/shapes/3dbox/vp_z_state", true) ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_vp_z_state_action), prefs->getBool("/tools/shapes/3dbox/vp_z_state", true) ); + } - SP_ACTIVE_DOCUMENT->setCurrentPersp3D(persp3d_get_from_repr(persp_repr)); - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setString("/tools/shapes/3dbox/persp", persp_repr->attribute("id")); + desktop->connectEventContextChanged(sigc::mem_fun(*holder, &Box3DToolbar::check_ec)); - g_object_set_data(tbl, "freeze", GINT_TO_POINTER(TRUE)); - box3d_resync_toolbar(persp_repr, tbl); - g_object_set_data(tbl, "freeze", GINT_TO_POINTER(FALSE)); - } - } + return GTK_WIDGET(holder->gobj()); } -static void box3d_angle_value_changed(GtkAdjustment *adj, GObject *dataKludge, Proj::Axis axis) +void +Box3DToolbar::angle_value_changed(Glib::RefPtr &adj, + Proj::Axis axis) { - SPDesktop *desktop = static_cast(g_object_get_data( dataKludge, "desktop" )); - SPDocument *document = desktop->getDocument(); + SPDocument *document = _desktop->getDocument(); // quit if run by the attr_changed or selection changed listener - if (g_object_get_data( dataKludge, "freeze" )) { + if (_freeze) { return; } // in turn, prevent listener from responding - g_object_set_data(dataKludge, "freeze", GINT_TO_POINTER(TRUE)); + _freeze = true; - std::list sel_persps = desktop->getSelection()->perspList(); + std::list sel_persps = _desktop->getSelection()->perspList(); if (sel_persps.empty()) { // this can happen when the document is created; we silently ignore it return; @@ -227,33 +235,18 @@ static void box3d_angle_value_changed(GtkAdjustment *adj, GObject *dataKludge, P Persp3D *persp = sel_persps.front(); persp->perspective_impl->tmat.set_infinite_direction (axis, - gtk_adjustment_get_value(adj)); + adj->get_value()); persp->updateRepr(); // TODO: use the correct axis here, too DocumentUndo::maybeDone(document, "perspangle", SP_VERB_CONTEXT_3DBOX, _("3D Box: Change perspective (angle of infinite axis)")); - g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) ); + _freeze = false; } - -static void box3d_angle_x_value_changed(GtkAdjustment *adj, GObject *dataKludge) -{ - box3d_angle_value_changed(adj, dataKludge, Proj::X); -} - -static void box3d_angle_y_value_changed(GtkAdjustment *adj, GObject *dataKludge) -{ - box3d_angle_value_changed(adj, dataKludge, Proj::Y); -} - -static void box3d_angle_z_value_changed(GtkAdjustment *adj, GObject *dataKludge) -{ - box3d_angle_value_changed(adj, dataKludge, Proj::Z); -} - - -static void box3d_vp_state_changed( GtkToggleAction *act, GtkAction * /*box3d_angle*/, Proj::Axis axis ) +void +Box3DToolbar::vp_state_changed(GtkToggleAction *act, + Proj::Axis axis ) { // TODO: Take all selected perspectives into account std::list sel_persps = SP_ACTIVE_DESKTOP->getSelection()->perspList(); @@ -267,167 +260,171 @@ static void box3d_vp_state_changed( GtkToggleAction *act, GtkAction * /*box3d_an persp3d_set_VP_state (persp, axis, set_infinite ? Proj::VP_INFINITE : Proj::VP_FINITE); } -static void box3d_vp_x_state_changed( GtkToggleAction *act, GtkAction *box3d_angle ) +void +Box3DToolbar::check_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec) { - box3d_vp_state_changed(act, box3d_angle, Proj::X); -} - -static void box3d_vp_y_state_changed( GtkToggleAction *act, GtkAction *box3d_angle ) -{ - box3d_vp_state_changed(act, box3d_angle, Proj::Y); + if (SP_IS_BOX3D_CONTEXT(ec)) { + _changed = desktop->getSelection()->connectChanged(sigc::mem_fun(*this, &Box3DToolbar::selection_changed)); + selection_changed(desktop->getSelection()); + } else { + if (_changed) + _changed.disconnect(); + } } -static void box3d_vp_z_state_changed( GtkToggleAction *act, GtkAction *box3d_angle ) +Box3DToolbar::~Box3DToolbar() { - box3d_vp_state_changed(act, box3d_angle, Proj::Z); + if (_repr) { // remove old listener + _repr->removeListenerByData(this); + Inkscape::GC::release(_repr); + _repr = nullptr; + } } -static void box3d_toolbox_check_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder); - -void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) +/** + * \param selection Should not be NULL. + */ +// FIXME: This should rather be put into persp3d-reference.cpp or something similar so that it reacts upon each +// Change of the perspective, and not of the current selection (but how to refer to the toolbar then?) +void +Box3DToolbar::selection_changed(Inkscape::Selection *selection) { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - EgeAdjustmentAction* eact = nullptr; - SPDocument *document = desktop->getDocument(); - Persp3DImpl *persp_impl = document->getCurrentPersp3DImpl(); + // Here the following should be done: If all selected boxes have finite VPs in a certain direction, + // disable the angle entry fields for this direction (otherwise entering a value in them should only + // update the perspectives with infinite VPs and leave the other ones untouched). - EgeAdjustmentAction* box3d_angle_x = nullptr; - EgeAdjustmentAction* box3d_angle_y = nullptr; - EgeAdjustmentAction* box3d_angle_z = nullptr; + Inkscape::XML::Node *persp_repr = nullptr; - /* Angle X */ - { - gchar const* labels[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }; - gdouble values[] = {-90, -60, -30, 0, 30, 60, 90}; - eact = create_adjustment_action( "3DBoxAngleXAction", - _("Angle in X direction"), _("Angle X:"), - // Translators: PL is short for 'perspective line' - _("Angle of PLs in X direction"), - "/tools/shapes/3dbox/box3d_angle_x", 30, - GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-box3d", - -360.0, 360.0, 1.0, 10.0, - labels, values, G_N_ELEMENTS(labels), - box3d_angle_x_value_changed ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - g_object_set_data( holder, "box3d_angle_x_action", eact ); - box3d_angle_x = eact; + if (_repr) { // remove old listener + _repr->removeListenerByData(this); + Inkscape::GC::release(_repr); + _repr = nullptr; } - if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::X)) { - gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); - } else { - gtk_action_set_sensitive( GTK_ACTION(eact), FALSE ); - } + SPItem *item = selection->singleItem(); + SPBox3D *box = dynamic_cast(item); + if (box) { + // FIXME: Also deal with multiple selected boxes + Persp3D *persp = box3d_get_perspective(box); + persp_repr = persp->getRepr(); + if (persp_repr) { + _repr = persp_repr; + Inkscape::GC::anchor(_repr); + _repr->addListener(&box3d_persp_tb_repr_events, this); + _repr->synthesizeEvents(&box3d_persp_tb_repr_events, this); + SP_ACTIVE_DOCUMENT->setCurrentPersp3D(persp3d_get_from_repr(_repr)); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setString("/tools/shapes/3dbox/persp", _repr->attribute("id")); - /* VP X state */ - { - InkToggleAction* act = ink_toggle_action_new( "3DBoxVPXStateAction", - // Translators: VP is short for 'vanishing point' - _("State of VP in X direction"), - _("Toggle VP in X direction between 'finite' and 'infinite' (=parallel)"), - INKSCAPE_ICON("perspective-parallel"), - GTK_ICON_SIZE_MENU ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - g_object_set_data( holder, "box3d_vp_x_state_action", act ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(box3d_vp_x_state_changed), box3d_angle_x ); - gtk_action_set_sensitive( GTK_ACTION(box3d_angle_x), !prefs->getBool("/tools/shapes/3dbox/vp_x_state", true) ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/shapes/3dbox/vp_x_state", true) ); + _freeze = true; + resync_toolbar(_repr); + _freeze = false; + } } +} - /* Angle Y */ - { - gchar const* labels[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }; - gdouble values[] = {-90, -60, -30, 0, 30, 60, 90}; - eact = create_adjustment_action( "3DBoxAngleYAction", - _("Angle in Y direction"), _("Angle Y:"), - // Translators: PL is short for 'perspective line' - _("Angle of PLs in Y direction"), - "/tools/shapes/3dbox/box3d_angle_y", 30, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, - -360.0, 360.0, 1.0, 10.0, - labels, values, G_N_ELEMENTS(labels), - box3d_angle_y_value_changed ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - g_object_set_data( holder, "box3d_angle_y_action", eact ); - box3d_angle_y = eact; +void +Box3DToolbar::resync_toolbar(Inkscape::XML::Node *persp_repr) +{ + if (!persp_repr) { + g_print ("No perspective given to box3d_resync_toolbar().\n"); + return; } - if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::Y)) { - gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); - } else { - gtk_action_set_sensitive( GTK_ACTION(eact), FALSE ); + Persp3D *persp = persp3d_get_from_repr(persp_repr); + if (!persp) { + // Hmm, is it an error if this happens? + return; } + set_button_and_adjustment(persp, Proj::X, + _angle_x_adj, + GTK_ACTION(_angle_x_action), + GTK_TOGGLE_ACTION(_vp_x_state_action)); + set_button_and_adjustment(persp, Proj::Y, + _angle_y_adj, + GTK_ACTION(_angle_y_action), + GTK_TOGGLE_ACTION(_vp_y_state_action)); + set_button_and_adjustment(persp, Proj::Z, + _angle_z_adj, + GTK_ACTION(_angle_z_action), + GTK_TOGGLE_ACTION(_vp_z_state_action)); +} - /* VP Y state */ - { - InkToggleAction* act = ink_toggle_action_new( "3DBoxVPYStateAction", - // Translators: VP is short for 'vanishing point' - _("State of VP in Y direction"), - _("Toggle VP in Y direction between 'finite' and 'infinite' (=parallel)"), - INKSCAPE_ICON("perspective-parallel"), - GTK_ICON_SIZE_MENU ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - g_object_set_data( holder, "box3d_vp_y_state_action", act ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(box3d_vp_y_state_changed), box3d_angle_y ); - gtk_action_set_sensitive( GTK_ACTION(box3d_angle_y), !prefs->getBool("/tools/shapes/3dbox/vp_y_state", true) ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/shapes/3dbox/vp_y_state", true) ); - } +void +Box3DToolbar::set_button_and_adjustment(Persp3D *persp, + Proj::Axis axis, + Glib::RefPtr& adj, + GtkAction *act, + GtkToggleAction *tact) +{ + // TODO: Take all selected perspectives into account but don't touch the state button if not all of them + // have the same state (otherwise a call to box3d_vp_z_state_changed() is triggered and the states + // are reset). + bool is_infinite = !persp3d_VP_is_finite(persp->perspective_impl, axis); - /* Angle Z */ - { - gchar const* labels[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }; - gdouble values[] = {-90, -60, -30, 0, 30, 60, 90}; - eact = create_adjustment_action( "3DBoxAngleZAction", - _("Angle in Z direction"), _("Angle Z:"), - // Translators: PL is short for 'perspective line' - _("Angle of PLs in Z direction"), - "/tools/shapes/3dbox/box3d_angle_z", 30, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, - -360.0, 360.0, 1.0, 10.0, - labels, values, G_N_ELEMENTS(labels), - box3d_angle_z_value_changed ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - g_object_set_data( holder, "box3d_angle_z_action", eact ); - box3d_angle_z = eact; - } + if (is_infinite) { + gtk_toggle_action_set_active(tact, TRUE); + gtk_action_set_sensitive(act, TRUE); - if (!persp_impl || !persp3d_VP_is_finite(persp_impl, Proj::Z)) { - gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + double angle = persp3d_get_infinite_angle(persp, axis); + if (angle != Geom::infinity()) { // FIXME: We should catch this error earlier (don't show the spinbutton at all) + adj->set_value(normalize_angle(angle)); + } } else { - gtk_action_set_sensitive( GTK_ACTION(eact), FALSE ); + gtk_toggle_action_set_active(tact, FALSE); + gtk_action_set_sensitive(act, FALSE); } +} - /* VP Z state */ - { - InkToggleAction* act = ink_toggle_action_new( "3DBoxVPZStateAction", - // Translators: VP is short for 'vanishing point' - _("State of VP in Z direction"), - _("Toggle VP in Z direction between 'finite' and 'infinite' (=parallel)"), - INKSCAPE_ICON("perspective-parallel"), - GTK_ICON_SIZE_MENU ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - g_object_set_data( holder, "box3d_vp_z_state_action", act ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(box3d_vp_z_state_changed), box3d_angle_z ); - gtk_action_set_sensitive( GTK_ACTION(box3d_angle_z), !prefs->getBool("/tools/shapes/3dbox/vp_z_state", true) ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/shapes/3dbox/vp_z_state", true) ); +void +Box3DToolbar::event_attr_changed(Inkscape::XML::Node *repr, + gchar const * /*name*/, + gchar const * /*old_value*/, + gchar const * /*new_value*/, + bool /*is_interactive*/, + gpointer data) +{ + auto toolbar = reinterpret_cast(data); + + // quit if run by the attr_changed or selection changed listener + if (toolbar->_freeze) { + return; } - desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(box3d_toolbox_check_ec), holder)); - g_signal_connect(holder, "destroy", G_CALLBACK(purge_repr_listener), holder); + // set freeze so that it can be caught in box3d_angle_z_value_changed() (to avoid calling + // SPDocumentUndo::maybeDone() when the document is undo insensitive) + toolbar->_freeze = true; + + // TODO: Only update the appropriate part of the toolbar +// if (!strcmp(name, "inkscape:vp_z")) { + toolbar->resync_toolbar(repr); +// } + + Persp3D *persp = persp3d_get_from_repr(repr); + persp3d_update_box_reprs(persp); + + toolbar->_freeze = false; } -static void box3d_toolbox_check_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec, GObject* holder) -{ - static sigc::connection changed; - if (SP_IS_BOX3D_CONTEXT(ec)) { - changed = desktop->getSelection()->connectChanged(sigc::bind(sigc::ptr_fun(box3d_toolbox_selection_changed), holder)); - box3d_toolbox_selection_changed(desktop->getSelection(), holder); - } else { - if (changed) - changed.disconnect(); +/** + * \brief normalize angle so that it lies in the interval [0,360] + * + * TODO: Isn't there something in 2Geom or cmath that does this? + */ +double +Box3DToolbar::normalize_angle(double a) { + double angle = a + ((int) (a/360.0))*360; + if (angle < 0) { + angle += 360.0; } + return angle; +} + +} } +} + /* Local Variables: diff --git a/src/ui/toolbar/box3d-toolbar.h b/src/ui/toolbar/box3d-toolbar.h index 962a43c25..6ff04cc81 100644 --- a/src/ui/toolbar/box3d-toolbar.h +++ b/src/ui/toolbar/box3d-toolbar.h @@ -28,12 +28,83 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" +#include + +#include "axis-manip.h" + +class Persp3D; class SPDesktop; +typedef struct _EgeAdjustmentAction EgeAdjustmentAction; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; +typedef struct _InkToggleAction InkToggleAction; + +namespace Inkscape { +class Selection; + +namespace XML { +class Node; +} + +namespace UI { +namespace Tools { +class ToolBase; +} + +namespace Toolbar { +class Box3DToolbar : public Toolbar { +private: + EgeAdjustmentAction *_angle_x_action; + EgeAdjustmentAction *_angle_y_action; + EgeAdjustmentAction *_angle_z_action; + + Glib::RefPtr _angle_x_adj; + Glib::RefPtr _angle_y_adj; + Glib::RefPtr _angle_z_adj; + + InkToggleAction *_vp_x_state_action; + InkToggleAction *_vp_y_state_action; + InkToggleAction *_vp_z_state_action; + + XML::Node *_repr; + bool _freeze; + + void angle_value_changed(Glib::RefPtr &adj, + Proj::Axis axis); + static void vp_state_changed(GtkToggleAction *act, + Proj::Axis axis); + void check_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec); + void selection_changed(Inkscape::Selection *selection); + void resync_toolbar(Inkscape::XML::Node *persp_repr); + void set_button_and_adjustment(Persp3D *persp, + Proj::Axis axis, + Glib::RefPtr& adj, + GtkAction *act, + GtkToggleAction *tact); + double normalize_angle(double a); + + sigc::connection _changed; + +protected: + Box3DToolbar(SPDesktop *desktop) + : Toolbar(desktop), + _repr(nullptr) + {} + ~Box3DToolbar(); -void box3d_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +public: + static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); + static void event_attr_changed(Inkscape::XML::Node *repr, + gchar const *name, + gchar const *old_value, + gchar const *new_value, + bool is_interactive, + gpointer data); +}; +} +} +} #endif /* !SEEN_BOX3D_TOOLBAR_H */ diff --git a/src/ui/toolbar/calligraphy-toolbar.cpp b/src/ui/toolbar/calligraphy-toolbar.cpp index 2a9d7b0d9..a2908401e 100644 --- a/src/ui/toolbar/calligraphy-toolbar.cpp +++ b/src/ui/toolbar/calligraphy-toolbar.cpp @@ -58,129 +58,8 @@ std::vector get_presets_list() { return presets; } -void update_presets_list(GObject *tbl) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - if (g_object_get_data(tbl, "presets_blocked")) { - return; - } - - InkSelectOneAction *act = static_cast(g_object_get_data(tbl, "profile_selector")); - - std::vector presets = get_presets_list(); - - int index = 1; // 0 is for no preset. - for (std::vector::iterator i = presets.begin(); i != presets.end(); ++i, ++index) { - bool match = true; - - std::vector preset = prefs->getAllEntries(*i); - for (auto & j : preset) { - Glib::ustring entry_name = j.getEntryName(); - if (entry_name == "id" || entry_name == "name") { - continue; - } - - void *widget = g_object_get_data(tbl, entry_name.data()); - if (widget) { - if (GTK_IS_ADJUSTMENT(widget)) { - double v = j.getDouble(); - GtkAdjustment* adj = static_cast(widget); - //std::cout << "compared adj " << attr_name << gtk_adjustment_get_value(adj) << " to " << v << "\n"; - if (fabs(gtk_adjustment_get_value(adj) - v) > 1e-6) { - match = false; - break; - } - } else if (GTK_IS_TOGGLE_ACTION(widget)) { - bool v = j.getBool(); - GtkToggleAction* toggle = static_cast(widget); - //std::cout << "compared toggle " << attr_name << gtk_toggle_action_get_active(toggle) << " to " << v << "\n"; - if ( static_cast(gtk_toggle_action_get_active(toggle)) != v ) { - match = false; - break; - } - } - } - } - - if (match) { - // newly added item is at the same index as the - // save command, so we need to change twice for it to take effect - act->set_active(0); - act->set_active(index); - return; - } - } - - // no match found - act->set_active(0); -} - -static void sp_ddc_mass_value_changed( GtkAdjustment *adj, GObject* tbl ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/calligraphic/mass", gtk_adjustment_get_value(adj) ); - update_presets_list(tbl); -} - -static void sp_ddc_wiggle_value_changed( GtkAdjustment *adj, GObject* tbl ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/calligraphic/wiggle", gtk_adjustment_get_value(adj) ); - update_presets_list(tbl); -} - -static void sp_ddc_angle_value_changed( GtkAdjustment *adj, GObject* tbl ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/calligraphic/angle", gtk_adjustment_get_value(adj) ); - update_presets_list(tbl); -} - -static void sp_ddc_width_value_changed( GtkAdjustment *adj, GObject *tbl ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/calligraphic/width", gtk_adjustment_get_value(adj) ); - update_presets_list(tbl); -} - -static void sp_ddc_velthin_value_changed( GtkAdjustment *adj, GObject* tbl ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble("/tools/calligraphic/thinning", gtk_adjustment_get_value(adj) ); - update_presets_list(tbl); -} - -static void sp_ddc_flatness_value_changed( GtkAdjustment *adj, GObject* tbl ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/calligraphic/flatness", gtk_adjustment_get_value(adj) ); - update_presets_list(tbl); -} - -static void sp_ddc_tremor_value_changed( GtkAdjustment *adj, GObject* tbl ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/calligraphic/tremor", gtk_adjustment_get_value(adj) ); - update_presets_list(tbl); -} - -static void sp_ddc_cap_rounding_value_changed( GtkAdjustment *adj, GObject* tbl ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/calligraphic/cap_rounding", gtk_adjustment_get_value(adj) ); - update_presets_list(tbl); -} - -static void sp_ddc_tilt_state_changed( GtkToggleAction *act, GObject* tbl ) -{ - // TODO merge into PrefPusher - GtkAction * calligraphy_angle = static_cast (g_object_get_data(tbl,"angle_action")); - if (calligraphy_angle ) { - gtk_action_set_sensitive( calligraphy_angle, !gtk_toggle_action_get_active( act ) ); - } -} - +#if 0 static gchar const *const widget_names[] = { "width", "mass", @@ -194,200 +73,29 @@ static gchar const *const widget_names[] = { "tracebackground", "usetilt" }; +#endif -static void sp_dcc_build_presets_list(GObject *tbl) -{ - g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(TRUE)); - - InkSelectOneAction* act = static_cast(g_object_get_data(tbl, "profile_selector")); - - Glib::RefPtr store = act->get_store(); - store->clear(); - - InkSelectOneActionColumns columns; - - Gtk::TreeModel::Row row; - - row = *(store->append()); - row[columns.col_label ] = _("No preset"); - row[columns.col_sensitive] = true; - - // iterate over all presets to populate the list - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - std::vector presets = get_presets_list(); - int ii=1; - - for (auto & preset : presets) { - GtkTreeIter iter; - Glib::ustring preset_name = prefs->getString(preset + "/name"); - - if (!preset_name.empty()) { - row = *(store->append()); - row[columns.col_label ] = _(preset_name.data()); - row[columns.col_sensitive] = true; - } - } - - g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE)); - - update_presets_list (tbl); -} - -static void sp_dcc_save_profile(GtkWidget * /*widget*/, GObject *tbl) -{ - using Inkscape::UI::Dialog::CalligraphicProfileRename; - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - SPDesktop *desktop = static_cast(g_object_get_data(tbl, "desktop" )); - if (! desktop) { - return; - } - - if (g_object_get_data(tbl, "presets_blocked")) { - return; - } - - InkSelectOneAction *act = static_cast(g_object_get_data(tbl, "profile_selector")); - - Glib::ustring current_profile_name = act->get_active_text(); - - if (current_profile_name == _("No preset")) { - current_profile_name = ""; - } - - CalligraphicProfileRename::show(desktop, current_profile_name); - if ( !CalligraphicProfileRename::applied()) { - // dialog cancelled - update_presets_list (tbl); - return; - } - Glib::ustring new_profile_name = CalligraphicProfileRename::getProfileName(); - - if (new_profile_name.empty()) { - // empty name entered - update_presets_list (tbl); - return; - } - - g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(TRUE)); - - // If there's a preset with the given name, find it and set save_path appropriately - std::vector presets = get_presets_list(); - int total_presets = presets.size(); - int new_index = -1; - Glib::ustring save_path; // profile pref path without a trailing slash - - int temp_index = 0; - for (std::vector::iterator i = presets.begin(); i != presets.end(); ++i, ++temp_index) { - Glib::ustring name = prefs->getString(*i + "/name"); - if (!name.empty() && (new_profile_name == name || current_profile_name == name)) { - new_index = temp_index; - save_path = *i; - break; - } - } - - - if ( CalligraphicProfileRename::deleted() && new_index != -1) { - prefs->remove(save_path); - g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE)); - sp_dcc_build_presets_list (tbl); - return; - } - - if (new_index == -1) { - // no preset with this name, create - new_index = total_presets + 1; - gchar *profile_id = g_strdup_printf("/dcc%d", new_index); - save_path = Glib::ustring("/tools/calligraphic/preset") + profile_id; - g_free(profile_id); - } - - for (auto widget_name : widget_names) { - void *widget = g_object_get_data(tbl, widget_name); - if (widget) { - if (GTK_IS_ADJUSTMENT(widget)) { - GtkAdjustment* adj = static_cast(widget); - prefs->setDouble(save_path + "/" + widget_name, gtk_adjustment_get_value(adj)); - //std::cout << "wrote adj " << widget_name << ": " << v << "\n"; - } else if (GTK_IS_TOGGLE_ACTION(widget)) { - GtkToggleAction* toggle = static_cast(widget); - prefs->setBool(save_path + "/" + widget_name, gtk_toggle_action_get_active(toggle)); - //std::cout << "wrote tog " << widget_name << ": " << v << "\n"; - } else { - g_warning("Unknown widget type for preset: %s\n", widget_name); - } - } else { - g_warning("Bad key when writing preset: %s\n", widget_name); - } - } - prefs->setString(save_path + "/name", new_profile_name); - - g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE)); - sp_dcc_build_presets_list (tbl); -} +namespace Inkscape { +namespace UI { +namespace Toolbar { -static void sp_ddc_change_profile(GObject* tbl, int mode) +CalligraphyToolbar::~CalligraphyToolbar() { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - - if (g_object_get_data(tbl, "presets_blocked")) { - return; - } - - // mode is one-based so we subtract 1 - std::vector presets = get_presets_list(); - - Glib::ustring preset_path = ""; - if (mode - 1 < presets.size()) { - preset_path = presets.at(mode - 1); - } - - if (!preset_path.empty()) { - g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(TRUE)); //temporarily block the selector so no one will updadte it while we're reading it - - std::vector preset = prefs->getAllEntries(preset_path); - - // Shouldn't this be std::map? - for (auto & i : preset) { - Glib::ustring entry_name = i.getEntryName(); - if (entry_name == "id" || entry_name == "name") { - continue; - } - void *widget = g_object_get_data(tbl, entry_name.data()); - if (widget) { - if (GTK_IS_ADJUSTMENT(widget)) { - GtkAdjustment* adj = static_cast(widget); - gtk_adjustment_set_value(adj, i.getDouble()); - //std::cout << "set adj " << attr_name << " to " << v << "\n"; - } else if (GTK_IS_TOGGLE_ACTION(widget)) { - GtkToggleAction* toggle = static_cast(widget); - gtk_toggle_action_set_active(toggle, i.getBool()); - //std::cout << "set toggle " << attr_name << " to " << v << "\n"; - } else { - g_warning("Unknown widget type for preset: %s\n", entry_name.data()); - } - } else { - g_warning("Bad key found in a preset record: %s\n", entry_name.data()); - } - } - g_object_set_data(tbl, "presets_blocked", GINT_TO_POINTER(FALSE)); - } + if(_tracebackground_pusher) delete _tracebackground_pusher; + if(_usepressure_pusher) delete _usepressure_pusher; + if(_usetilt_pusher) delete _usetilt_pusher; } -static void sp_ddc_edit_profile(GtkAction * /*act*/, GObject* tbl) +GtkWidget * +CalligraphyToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) { - sp_dcc_save_profile(nullptr, tbl); -} + auto toolbar = new CalligraphyToolbar(desktop); -void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) -{ Inkscape::Preferences *prefs = Inkscape::Preferences::get(); { - g_object_set_data(holder, "presets_blocked", GINT_TO_POINTER(TRUE)); - - EgeAdjustmentAction* calligraphy_angle = nullptr; + toolbar->_presets_blocked = true; { /* Width */ @@ -397,10 +105,16 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions _("Pen Width"), _("Width:"), _("The width of the calligraphic pen (relative to the visible canvas area)"), "/tools/calligraphic/width", 15, - GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-calligraphy", + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + TRUE, "altx-calligraphy", 1, 100, 1.0, 10.0, labels, values, G_N_ELEMENTS(labels), - sp_ddc_width_value_changed, nullptr /*unit tracker*/, 1, 0 ); + nullptr, // callback + nullptr /*unit tracker*/, 1, 0 ); + toolbar->_width_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + toolbar->_width_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &CalligraphyToolbar::width_value_changed)); + toolbar->_widget_map["width"] = G_OBJECT(toolbar->_width_adj->gobj()); ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); @@ -414,10 +128,16 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions _("Stroke Thinning"), _("Thinning:"), _("How much velocity thins the stroke (> 0 makes fast strokes thinner, < 0 makes them broader, 0 makes width independent of velocity)"), "/tools/calligraphic/thinning", 10, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, -100, 100, 1, 10.0, labels, values, G_N_ELEMENTS(labels), - sp_ddc_velthin_value_changed, nullptr /*unit tracker*/, 1, 0); + nullptr, // callback + nullptr /*unit tracker*/, 1, 0); + toolbar->_thinning_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + toolbar->_thinning_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &CalligraphyToolbar::velthin_value_changed)); + toolbar->_widget_map["thinning"] = G_OBJECT(toolbar->_thinning_adj->gobj()); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); } @@ -426,18 +146,22 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions /* Angle */ gchar const* labels[] = {_("(left edge up)"), nullptr, nullptr, _("(horizontal)"), _("(default)"), nullptr, _("(right edge up)")}; gdouble values[] = {-90, -60, -30, 0, 30, 60, 90}; - EgeAdjustmentAction* eact = create_adjustment_action( "AngleAction", - _("Pen Angle"), _("Angle:"), - _("The angle of the pen's nib (in degrees; 0 = horizontal; has no effect if fixation = 0)"), - "/tools/calligraphic/angle", 30, - GTK_WIDGET(desktop->canvas), holder, TRUE, "calligraphy-angle", - -90.0, 90.0, 1.0, 10.0, - labels, values, G_N_ELEMENTS(labels), - sp_ddc_angle_value_changed, nullptr /*unit tracker*/, 1, 0 ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - g_object_set_data( holder, "angle_action", eact ); - gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); - calligraphy_angle = eact; + toolbar->_angle_action = create_adjustment_action( "AngleAction", + _("Pen Angle"), _("Angle:"), + _("The angle of the pen's nib (in degrees; 0 = horizontal; has no effect if fixation = 0)"), + "/tools/calligraphic/angle", 30, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + TRUE, "calligraphy-angle", + -90.0, 90.0, 1.0, 10.0, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + nullptr /*unit tracker*/, 1, 0 ); + toolbar->_angle_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_angle_action)); + toolbar->_angle_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &CalligraphyToolbar::angle_value_changed)); + toolbar->_widget_map["angle"] = G_OBJECT(toolbar->_angle_adj->gobj()); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_angle_action) ); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_angle_action), TRUE ); } { @@ -448,10 +172,16 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions _("Fixation"), _("Fixation:"), _("Angle behavior (0 = nib always perpendicular to stroke direction, 100 = fixed angle)"), "/tools/calligraphic/flatness", 90, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, 0.0, 100, 1.0, 10.0, labels, values, G_N_ELEMENTS(labels), - sp_ddc_flatness_value_changed, nullptr /*unit tracker*/, 1, 0); + nullptr, // callback + nullptr /*unit tracker*/, 1, 0); + toolbar->_fixation_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + toolbar->_fixation_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &CalligraphyToolbar::flatness_value_changed)); + toolbar->_widget_map["flatness"] = G_OBJECT(toolbar->_fixation_adj->gobj()); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); } @@ -465,10 +195,16 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions _("Cap rounding"), _("Caps:"), _("Increase to make caps at the ends of strokes protrude more (0 = no caps, 1 = round caps)"), "/tools/calligraphic/cap_rounding", 0.0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, 0.0, 5.0, 0.01, 0.1, labels, values, G_N_ELEMENTS(labels), - sp_ddc_cap_rounding_value_changed, nullptr /*unit tracker*/, 0.01, 2 ); + nullptr, // callback + nullptr /*unit tracker*/, 0.01, 2 ); + toolbar->_cap_rounding_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + toolbar->_cap_rounding_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &CalligraphyToolbar::cap_rounding_value_changed)); + toolbar->_widget_map["cap_rounding"] = G_OBJECT(toolbar->_cap_rounding_adj->gobj()); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); } @@ -481,11 +217,17 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions _("Stroke Tremor"), _("Tremor:"), _("Increase to make strokes rugged and trembling"), "/tools/calligraphic/tremor", 0.0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, 0.0, 100, 1, 10.0, labels, values, G_N_ELEMENTS(labels), - sp_ddc_tremor_value_changed, nullptr /*unit tracker*/, 1, 0); + nullptr, // callback + nullptr /*unit tracker*/, 1, 0); + toolbar->_tremor_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + toolbar->_tremor_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &CalligraphyToolbar::tremor_value_changed)); + toolbar->_widget_map["tremor"] = G_OBJECT(toolbar->_tremor_adj->gobj()); ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); @@ -499,10 +241,16 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions _("Pen Wiggle"), _("Wiggle:"), _("Increase to make the pen waver and wiggle"), "/tools/calligraphic/wiggle", 0.0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, 0.0, 100, 1, 10.0, labels, values, G_N_ELEMENTS(labels), - sp_ddc_wiggle_value_changed, nullptr /*unit tracker*/, 1, 0); + nullptr, // callback + nullptr /*unit tracker*/, 1, 0); + toolbar->_wiggle_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + toolbar->_wiggle_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &CalligraphyToolbar::wiggle_value_changed)); + toolbar->_widget_map["wiggle"] = G_OBJECT(toolbar->_wiggle_adj->gobj()); ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); @@ -516,10 +264,16 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions _("Pen Mass"), _("Mass:"), _("Increase to make the pen drag behind, as if slowed by inertia"), "/tools/calligraphic/mass", 2.0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, 0.0, 100, 1, 10.0, labels, values, G_N_ELEMENTS(labels), - sp_ddc_mass_value_changed, nullptr /*unit tracker*/, 1, 0); + nullptr, // callback + nullptr /*unit tracker*/, 1, 0); + toolbar->_mass_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + toolbar->_mass_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &CalligraphyToolbar::mass_value_changed)); + toolbar->_widget_map["mass"] = G_OBJECT(toolbar->_mass_adj->gobj()); ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); @@ -528,44 +282,41 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions /* 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)"), - INKSCAPE_ICON("draw-trace-background"), - GTK_ICON_SIZE_MENU ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/calligraphic/tracebackground", update_presets_list, holder); - g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher); - g_object_set_data( holder, "tracebackground", act ); + toolbar->_tracebackground = 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)"), + INKSCAPE_ICON("draw-trace-background"), + GTK_ICON_SIZE_MENU ); + toolbar->_widget_map["tracebackground"] = G_OBJECT(toolbar->_tracebackground); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_tracebackground ) ); + toolbar->_tracebackground_pusher = new PrefPusher(GTK_TOGGLE_ACTION(toolbar->_tracebackground), "/tools/calligraphic/tracebackground", update_presets_list, gpointer(toolbar)); } /* 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"), - INKSCAPE_ICON("draw-use-pressure"), - GTK_ICON_SIZE_MENU ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/calligraphic/usepressure", update_presets_list, holder); - g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher); - g_object_set_data( holder, "usepressure", act ); + toolbar->_usepressure = ink_toggle_action_new( "PressureAction", + _("Pressure"), + _("Use the pressure of the input device to alter the width of the pen"), + INKSCAPE_ICON("draw-use-pressure"), + GTK_ICON_SIZE_MENU ); + toolbar->_widget_map["usepressure"] = G_OBJECT(toolbar->_usepressure); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_usepressure ) ); + toolbar->_usepressure_pusher = new PrefPusher(GTK_TOGGLE_ACTION(toolbar->_usepressure), "/tools/calligraphic/usepressure", update_presets_list, gpointer(toolbar)); } /* 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"), - INKSCAPE_ICON("draw-use-tilt"), - GTK_ICON_SIZE_MENU ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/calligraphic/usetilt", update_presets_list, holder); - g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_ddc_tilt_state_changed), holder ); - gtk_action_set_sensitive( GTK_ACTION(calligraphy_angle), !prefs->getBool("/tools/calligraphic/usetilt", true) ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/calligraphic/usetilt", true) ); - g_object_set_data( holder, "usetilt", act ); + toolbar->_usetilt = ink_toggle_action_new( "TiltAction", + _("Tilt"), + _("Use the tilt of the input device to alter the angle of the pen's nib"), + INKSCAPE_ICON("draw-use-tilt"), + GTK_ICON_SIZE_MENU ); + toolbar->_widget_map["usetilt"] = G_OBJECT(toolbar->_usetilt); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_usetilt ) ); + toolbar->_usetilt_pusher = new PrefPusher(GTK_TOGGLE_ACTION(toolbar->_usetilt), "/tools/calligraphic/usetilt", update_presets_list, gpointer(toolbar)); + g_signal_connect_after( G_OBJECT(toolbar->_usetilt), "toggled", G_CALLBACK(tilt_state_changed), toolbar ); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_angle_action), !prefs->getBool("/tools/calligraphic/usetilt", true) ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(toolbar->_usetilt), prefs->getBool("/tools/calligraphic/usetilt", true) ); } /*calligraphic profile */ @@ -574,22 +325,20 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions Glib::RefPtr store = Gtk::ListStore::create(columns); - InkSelectOneAction* act = + toolbar->_profile_selector = InkSelectOneAction::create( "SetProfileAction", // Name "", // Label _("Choose a preset"), // Tooltip "NotUsed", // Icon store ); // Tree store - act->use_radio( false ); - act->use_label( true ); + toolbar->_profile_selector->use_radio( false ); + toolbar->_profile_selector->use_label( true ); - g_object_set_data (holder, "profile_selector", act); + toolbar->build_presets_list(); - sp_dcc_build_presets_list (holder); + gtk_action_group_add_action(mainActions, GTK_ACTION( toolbar->_profile_selector->gobj() )); - gtk_action_group_add_action(mainActions, GTK_ACTION( act->gobj() )); - - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_ddc_change_profile), holder)); + toolbar->_profile_selector->signal_changed().connect(sigc::mem_fun(*toolbar, &CalligraphyToolbar::change_profile)); } /*calligraphic profile editor */ @@ -599,11 +348,335 @@ void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions _("Add or edit calligraphic profile"), INKSCAPE_ICON("document-properties"), GTK_ICON_SIZE_MENU ); - g_object_set( inky, "short_label", _("Edit"), NULL ); - g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_ddc_edit_profile), (GObject*)holder ); + gtk_action_set_short_label(GTK_ACTION(inky), _("Edit")); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(edit_profile), toolbar ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); } } + + return GTK_WIDGET(toolbar->gobj()); +} + +void +CalligraphyToolbar::width_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/calligraphic/width", _width_adj->get_value() ); + update_presets_list(this); +} + +void +CalligraphyToolbar::velthin_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble("/tools/calligraphic/thinning", _thinning_adj->get_value() ); + update_presets_list(this); +} + +void +CalligraphyToolbar::angle_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/calligraphic/angle", _angle_adj->get_value() ); + update_presets_list(this); +} + +void +CalligraphyToolbar::flatness_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/calligraphic/flatness", _fixation_adj->get_value() ); + update_presets_list(this); +} + +void +CalligraphyToolbar::cap_rounding_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/calligraphic/cap_rounding", _cap_rounding_adj->get_value() ); + update_presets_list(this); +} + +void +CalligraphyToolbar::tremor_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/calligraphic/tremor", _tremor_adj->get_value() ); + update_presets_list(this); +} + +void +CalligraphyToolbar::wiggle_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/calligraphic/wiggle", _wiggle_adj->get_value() ); + update_presets_list(this); +} + +void +CalligraphyToolbar::mass_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/calligraphic/mass", _mass_adj->get_value() ); + update_presets_list(this); +} + +void +CalligraphyToolbar::update_presets_list(gpointer data) +{ + auto toolbar = reinterpret_cast(data); + + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + if (toolbar->_presets_blocked) { + return; + } + + std::vector presets = get_presets_list(); + + int index = 1; // 0 is for no preset. + for (std::vector::iterator i = presets.begin(); i != presets.end(); ++i, ++index) { + bool match = true; + + std::vector preset = prefs->getAllEntries(*i); + for (auto & j : preset) { + Glib::ustring entry_name = j.getEntryName(); + if (entry_name == "id" || entry_name == "name") { + continue; + } + + void *widget = toolbar->_widget_map[entry_name.data()]; + if (widget) { + if (GTK_IS_ADJUSTMENT(widget)) { + double v = j.getDouble(); + GtkAdjustment* adj = static_cast(widget); + //std::cout << "compared adj " << attr_name << gtk_adjustment_get_value(adj) << " to " << v << "\n"; + if (fabs(gtk_adjustment_get_value(adj) - v) > 1e-6) { + match = false; + break; + } + } else if (GTK_IS_TOGGLE_ACTION(widget)) { + bool v = j.getBool(); + GtkToggleAction* toggle = static_cast(widget); + //std::cout << "compared toggle " << attr_name << gtk_toggle_action_get_active(toggle) << " to " << v << "\n"; + if ( static_cast(gtk_toggle_action_get_active(toggle)) != v ) { + match = false; + break; + } + } + } + } + + if (match) { + // newly added item is at the same index as the + // save command, so we need to change twice for it to take effect + toolbar->_profile_selector->set_active(0); + toolbar->_profile_selector->set_active(index); + return; + } + } + + // no match found + toolbar->_profile_selector->set_active(0); +} + +void +CalligraphyToolbar::tilt_state_changed( GtkToggleAction *act, gpointer data ) +{ + auto toolbar = reinterpret_cast(data); + + // TODO merge into PrefPusher + if (toolbar->_angle_action) { + gtk_action_set_sensitive( GTK_ACTION(toolbar->_angle_action), !gtk_toggle_action_get_active( act ) ); + } +} + +void +CalligraphyToolbar::build_presets_list() +{ + _presets_blocked = true; + + auto store = _profile_selector->get_store(); + store->clear(); + + InkSelectOneActionColumns columns; + + Gtk::TreeModel::Row row; + + row = *(store->append()); + row[columns.col_label ] = _("No preset"); + row[columns.col_sensitive] = true; + + // iterate over all presets to populate the list + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + std::vector presets = get_presets_list(); + int ii=1; + + for (auto & preset : presets) { + GtkTreeIter iter; + Glib::ustring preset_name = prefs->getString(preset + "/name"); + + if (!preset_name.empty()) { + row = *(store->append()); + row[columns.col_label ] = _(preset_name.data()); + row[columns.col_sensitive] = true; + } + } + + _presets_blocked = false; + + update_presets_list(this); +} + +void +CalligraphyToolbar::change_profile(int mode) +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + + if (_presets_blocked) { + return; + } + + // mode is one-based so we subtract 1 + std::vector presets = get_presets_list(); + + Glib::ustring preset_path = ""; + if (mode - 1 < presets.size()) { + preset_path = presets.at(mode - 1); + } + + if (!preset_path.empty()) { + _presets_blocked = true; //temporarily block the selector so no one will updadte it while we're reading it + + std::vector preset = prefs->getAllEntries(preset_path); + + // Shouldn't this be std::map? + for (auto & i : preset) { + Glib::ustring entry_name = i.getEntryName(); + if (entry_name == "id" || entry_name == "name") { + continue; + } + void *widget = _widget_map[entry_name.data()]; + if (widget) { + if (GTK_IS_ADJUSTMENT(widget)) { + GtkAdjustment* adj = static_cast(widget); + gtk_adjustment_set_value(adj, i.getDouble()); + //std::cout << "set adj " << attr_name << " to " << v << "\n"; + } else if (GTK_IS_TOGGLE_ACTION(widget)) { + GtkToggleAction* toggle = static_cast(widget); + gtk_toggle_action_set_active(toggle, i.getBool()); + //std::cout << "set toggle " << attr_name << " to " << v << "\n"; + } else { + g_warning("Unknown widget type for preset: %s\n", entry_name.data()); + } + } else { + g_warning("Bad key found in a preset record: %s\n", entry_name.data()); + } + } + _presets_blocked = false; + } +} + +void +CalligraphyToolbar::edit_profile(GtkAction * /*act*/, gpointer data) +{ + auto toolbar = reinterpret_cast(data); + toolbar->save_profile(nullptr); +} + +void +CalligraphyToolbar::save_profile(GtkWidget * /*widget*/) +{ + using Inkscape::UI::Dialog::CalligraphicProfileRename; + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + if (! _desktop) { + return; + } + + if (_presets_blocked) { + return; + } + + Glib::ustring current_profile_name = _profile_selector->get_active_text(); + + if (current_profile_name == _("No preset")) { + current_profile_name = ""; + } + + CalligraphicProfileRename::show(_desktop, current_profile_name); + if ( !CalligraphicProfileRename::applied()) { + // dialog cancelled + update_presets_list(this); + return; + } + Glib::ustring new_profile_name = CalligraphicProfileRename::getProfileName(); + + if (new_profile_name.empty()) { + // empty name entered + update_presets_list (this); + return; + } + + _presets_blocked = true; + + // If there's a preset with the given name, find it and set save_path appropriately + auto presets = get_presets_list(); + int total_presets = presets.size(); + int new_index = -1; + Glib::ustring save_path; // profile pref path without a trailing slash + + int temp_index = 0; + for (std::vector::iterator i = presets.begin(); i != presets.end(); ++i, ++temp_index) { + Glib::ustring name = prefs->getString(*i + "/name"); + if (!name.empty() && (new_profile_name == name || current_profile_name == name)) { + new_index = temp_index; + save_path = *i; + break; + } + } + + if ( CalligraphicProfileRename::deleted() && new_index != -1) { + prefs->remove(save_path); + _presets_blocked = false; + build_presets_list(); + return; + } + + if (new_index == -1) { + // no preset with this name, create + new_index = total_presets + 1; + gchar *profile_id = g_strdup_printf("/dcc%d", new_index); + save_path = Glib::ustring("/tools/calligraphic/preset") + profile_id; + g_free(profile_id); + } + + for (auto map_item : _widget_map) { + auto widget_name = map_item.first; + auto widget = map_item.second; + + if (widget) { + if (GTK_IS_ADJUSTMENT(widget)) { + GtkAdjustment* adj = GTK_ADJUSTMENT(widget); + prefs->setDouble(save_path + "/" + widget_name, gtk_adjustment_get_value(adj)); + //std::cout << "wrote adj " << widget_name << ": " << v << "\n"; + } else if (GTK_IS_TOGGLE_ACTION(widget)) { + GtkToggleAction* toggle = GTK_TOGGLE_ACTION(widget); + prefs->setBool(save_path + "/" + widget_name, gtk_toggle_action_get_active(toggle)); + //std::cout << "wrote tog " << widget_name << ": " << v << "\n"; + } else { + g_warning("Unknown widget type for preset: %s\n", widget_name.c_str()); + } + } else { + g_warning("Bad key when writing preset: %s\n", widget_name.c_str()); + } + } + prefs->setString(save_path + "/name", new_profile_name); + + _presets_blocked = true; + build_presets_list(); +} + +} +} } diff --git a/src/ui/toolbar/calligraphy-toolbar.h b/src/ui/toolbar/calligraphy-toolbar.h index ea9804d2e..2305a72a2 100644 --- a/src/ui/toolbar/calligraphy-toolbar.h +++ b/src/ui/toolbar/calligraphy-toolbar.h @@ -28,12 +28,76 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" +#include + +class InkSelectOneAction; class SPDesktop; +typedef struct _EgeAdjustmentAction EgeAdjustmentAction; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; +typedef struct _InkToggleAction InkToggleAction; + +namespace Inkscape { +namespace UI { +class PrefPusher; + +namespace Toolbar { + +class CalligraphyToolbar : public Toolbar { +private: + bool _presets_blocked; + + EgeAdjustmentAction *_angle_action; + InkSelectOneAction *_profile_selector; + + std::map _widget_map; + + Glib::RefPtr _width_adj; + Glib::RefPtr _mass_adj; + Glib::RefPtr _wiggle_adj; + Glib::RefPtr _angle_adj; + Glib::RefPtr _thinning_adj; + Glib::RefPtr _tremor_adj; + Glib::RefPtr _fixation_adj; + Glib::RefPtr _cap_rounding_adj; + InkToggleAction *_usepressure; + InkToggleAction *_tracebackground; + InkToggleAction *_usetilt; + + PrefPusher *_tracebackground_pusher; + PrefPusher *_usepressure_pusher; + PrefPusher *_usetilt_pusher; + + void width_value_changed(); + void velthin_value_changed(); + void angle_value_changed(); + void flatness_value_changed(); + void cap_rounding_value_changed(); + void tremor_value_changed(); + void wiggle_value_changed(); + void mass_value_changed(); + void build_presets_list(); + void change_profile(int mode); + void save_profile(GtkWidget *widget); + + static void edit_profile(GtkAction *act, gpointer data); + static void update_presets_list(gpointer data); + static void tilt_state_changed( GtkToggleAction *act, gpointer data ); + +protected: + CalligraphyToolbar(SPDesktop *desktop) + : Toolbar(desktop) + {} + + ~CalligraphyToolbar(); + +public: + static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); +}; -void sp_calligraphy_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); -void update_presets_list(GObject *tbl); +} +} +} #endif /* !SEEN_CALLIGRAPHY_TOOLBAR_H */ diff --git a/src/ui/toolbar/connector-toolbar.cpp b/src/ui/toolbar/connector-toolbar.cpp index 77308c9ec..1cf80cec8 100644 --- a/src/ui/toolbar/connector-toolbar.cpp +++ b/src/ui/toolbar/connector-toolbar.cpp @@ -57,38 +57,200 @@ using Inkscape::DocumentUndo; using Inkscape::UI::ToolboxFactory; using Inkscape::UI::PrefPusher; -//######################### -//## Connector ## -//######################### +static Inkscape::XML::NodeEventVector connector_tb_repr_events = { + nullptr, /* child_added */ + nullptr, /* child_removed */ + Inkscape::UI::Toolbar::ConnectorToolbar::event_attr_changed, + nullptr, /* content_changed */ + nullptr /* order_changed */ +}; + +namespace Inkscape { +namespace UI { +namespace Toolbar { +GtkWidget * +ConnectorToolbar::prep( SPDesktop *desktop, GtkActionGroup* mainActions) +{ + auto toolbar = new ConnectorToolbar(desktop); + + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); + + { + InkAction* inky = ink_action_new( "ConnectorAvoidAction", + _("Avoid"), + _("Make connectors avoid selected objects"), + INKSCAPE_ICON("connector-avoid"), + secondarySize ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(path_set_avoid), (gpointer)toolbar); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } + + { + InkAction* inky = ink_action_new( "ConnectorIgnoreAction", + _("Ignore"), + _("Make connectors ignore selected objects"), + INKSCAPE_ICON("connector-ignore"), + secondarySize ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(path_set_ignore), (gpointer)toolbar); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } + + // Orthogonal connectors toggle button + { + toolbar->_orthogonal = ink_toggle_action_new( "ConnectorOrthogonalAction", + _("Orthogonal"), + _("Make connector orthogonal or polyline"), + INKSCAPE_ICON("connector-orthogonal"), + GTK_ICON_SIZE_MENU ); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_orthogonal ) ); + + bool tbuttonstate = prefs->getBool("/tools/connector/orthogonal"); + gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(toolbar->_orthogonal), ( tbuttonstate ? TRUE : FALSE )); + g_signal_connect_after( G_OBJECT(toolbar->_orthogonal), "toggled", G_CALLBACK(orthogonal_toggled), (gpointer)toolbar ); + } + + EgeAdjustmentAction* eact = nullptr; + // Curvature spinbox + eact = create_adjustment_action( "ConnectorCurvatureAction", + _("Connector Curvature"), _("Curvature:"), + _("The amount of connectors curvature"), + "/tools/connector/curvature", defaultConnCurvature, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + TRUE, "inkscape:connector-curvature", + 0, 100, 1.0, 10.0, + nullptr, nullptr, 0, + nullptr, // callback + nullptr /*unit tracker*/, 1, 0 ); + toolbar->_curvature_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + toolbar->_curvature_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &ConnectorToolbar::curvature_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + + // Spacing spinbox + eact = create_adjustment_action( "ConnectorSpacingAction", + _("Connector Spacing"), _("Spacing:"), + _("The amount of space left around objects by auto-routing connectors"), + "/tools/connector/spacing", defaultConnSpacing, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + TRUE, "inkscape:connector-spacing", + 0, 100, 1.0, 10.0, + nullptr, nullptr, 0, + nullptr, // callback + nullptr /*unit tracker*/, 1, 0 ); + toolbar->_spacing_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + toolbar->_spacing_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &ConnectorToolbar::spacing_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + + // Graph (connector network) layout + { + InkAction* inky = ink_action_new( "ConnectorGraphAction", + _("Graph"), + _("Nicely arrange selected connector network"), + INKSCAPE_ICON("distribute-graph"), + secondarySize ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(graph_layout), (gpointer)toolbar); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } + + // Default connector length spinbox + eact = create_adjustment_action( "ConnectorLengthAction", + _("Connector Length"), _("Length:"), + _("Ideal length for connectors when layout is applied"), + "/tools/connector/length", 100, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + TRUE, "inkscape:connector-length", + 10, 1000, 10.0, 100.0, + nullptr, nullptr, 0, + nullptr, // callback + nullptr /*unit tracker*/, 1, 0 ); + toolbar->_length_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + toolbar->_length_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &ConnectorToolbar::length_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + + // Directed edges toggle button + { + InkToggleAction* act = ink_toggle_action_new( "ConnectorDirectedAction", + _("Downwards"), + _("Make connectors with end-markers (arrows) point downwards"), + INKSCAPE_ICON("distribute-graph-directed"), + GTK_ICON_SIZE_MENU ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + + bool tbuttonstate = prefs->getBool("/tools/connector/directedlayout"); + gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), ( tbuttonstate ? TRUE : FALSE )); + + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(directed_graph_layout_toggled), (gpointer)toolbar); + desktop->getSelection()->connectChanged(sigc::mem_fun(*toolbar, &ConnectorToolbar::selection_changed)); + } + + // Avoid overlaps toggle button + { + InkToggleAction* act = ink_toggle_action_new( "ConnectorOverlapAction", + _("Remove overlaps"), + _("Do not allow overlapping shapes"), + INKSCAPE_ICON("distribute-remove-overlaps"), + GTK_ICON_SIZE_MENU ); + gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + + bool tbuttonstate = prefs->getBool("/tools/connector/avoidoverlaplayout"); + gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), (tbuttonstate ? TRUE : FALSE )); + + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(nooverlaps_graph_layout_toggled), (gpointer)toolbar); + } + + // Code to watch for changes to the connector-spacing attribute in + // the XML. + Inkscape::XML::Node *repr = desktop->namedview->getRepr(); + g_assert(repr != nullptr); + + if(toolbar->_repr) { + toolbar->_repr->removeListenerByData(toolbar); + Inkscape::GC::release(toolbar->_repr); + toolbar->_repr = nullptr; + } + + if (repr) { + toolbar->_repr = repr; + Inkscape::GC::anchor(toolbar->_repr); + toolbar->_repr->addListener(&connector_tb_repr_events, toolbar); + toolbar->_repr->synthesizeEvents(&connector_tb_repr_events, toolbar); + } + + return GTK_WIDGET(toolbar->gobj()); +} // end of ConnectorToolbar::prep() -static void sp_connector_path_set_avoid() +void +ConnectorToolbar::path_set_avoid() { Inkscape::UI::Tools::cc_selection_set_avoid(true); } - -static void sp_connector_path_set_ignore() +void +ConnectorToolbar::path_set_ignore() { Inkscape::UI::Tools::cc_selection_set_avoid(false); } -static void sp_connector_orthogonal_toggled( GtkToggleAction* act, GObject *tbl ) +void +ConnectorToolbar::orthogonal_toggled( GtkToggleAction* act, gpointer data) { - SPDesktop *desktop = static_cast(g_object_get_data( tbl, "desktop" )); - SPDocument *doc = desktop->getDocument(); + auto toolbar = reinterpret_cast(data); + SPDocument *doc = toolbar->_desktop->getDocument(); if (!DocumentUndo::getUndoSensitive(doc)) { return; } - // quit if run by the _changed callbacks - if (g_object_get_data( tbl, "freeze" )) { + if (toolbar->_freeze) { return; } // in turn, prevent callbacks from responding - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + toolbar->_freeze = true; bool is_orthog = gtk_toggle_action_get_active( act ); gchar orthog_str[] = "orthogonal"; @@ -96,7 +258,7 @@ static void sp_connector_orthogonal_toggled( GtkToggleAction* act, GObject *tbl gchar *value = is_orthog ? orthog_str : polyline_str ; bool modmade = false; - auto itemlist= desktop->getSelection()->items(); + auto itemlist= toolbar->_desktop->getSelection()->items(); for(auto i=itemlist.begin();i!=itemlist.end();++i){ SPItem *item = *i; @@ -117,13 +279,13 @@ static void sp_connector_orthogonal_toggled( GtkToggleAction* act, GObject *tbl is_orthog ? _("Set connector type: orthogonal"): _("Set connector type: polyline")); } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + toolbar->_freeze = false; } -static void connector_curvature_changed(GtkAdjustment *adj, GObject* tbl) +void +ConnectorToolbar::curvature_changed() { - SPDesktop *desktop = static_cast(g_object_get_data( tbl, "desktop" )); - SPDocument *doc = desktop->getDocument(); + SPDocument *doc = _desktop->getDocument(); if (!DocumentUndo::getUndoSensitive(doc)) { return; @@ -131,19 +293,19 @@ static void connector_curvature_changed(GtkAdjustment *adj, GObject* tbl) // quit if run by the _changed callbacks - if (g_object_get_data( tbl, "freeze" )) { + if (_freeze) { return; } // in turn, prevent callbacks from responding - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + _freeze = true; - gdouble newValue = gtk_adjustment_get_value(adj); + auto newValue = _curvature_adj->get_value(); gchar value[G_ASCII_DTOSTR_BUF_SIZE]; g_ascii_dtostr(value, G_ASCII_DTOSTR_BUF_SIZE, newValue); bool modmade = false; - auto itemlist= desktop->getSelection()->items(); + auto itemlist= _desktop->getSelection()->items(); for(auto i=itemlist.begin();i!=itemlist.end();++i){ SPItem *item = *i; @@ -164,23 +326,22 @@ static void connector_curvature_changed(GtkAdjustment *adj, GObject* tbl) _("Change connector curvature")); } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + _freeze = false; } - -static void connector_spacing_changed(GtkAdjustment *adj, GObject* tbl) +void +ConnectorToolbar::spacing_changed() { - SPDesktop *desktop = static_cast(g_object_get_data( tbl, "desktop" )); - SPDocument *doc = desktop->getDocument(); + SPDocument *doc = _desktop->getDocument(); if (!DocumentUndo::getUndoSensitive(doc)) { return; } - Inkscape::XML::Node *repr = desktop->namedview->getRepr(); + Inkscape::XML::Node *repr = _desktop->namedview->getRepr(); if ( !repr->attribute("inkscape:connector-spacing") && - ( gtk_adjustment_get_value(adj) == defaultConnSpacing )) { + ( _spacing_adj->get_value() == defaultConnSpacing )) { // Don't need to update the repr if the attribute doesn't // exist and it is being set to the default value -- as will // happen at startup. @@ -188,19 +349,19 @@ static void connector_spacing_changed(GtkAdjustment *adj, GObject* tbl) } // quit if run by the attr_changed listener - if (g_object_get_data( tbl, "freeze" )) { + if (_freeze) { return; } // in turn, prevent listener from responding - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE)); + _freeze = true; - sp_repr_set_css_double(repr, "inkscape:connector-spacing", gtk_adjustment_get_value(adj)); - desktop->namedview->updateRepr(); + sp_repr_set_css_double(repr, "inkscape:connector-spacing", _spacing_adj->get_value()); + _desktop->namedview->updateRepr(); bool modmade = false; std::vector items; - items = get_avoided_items(items, desktop->currentRoot(), desktop); + items = get_avoided_items(items, _desktop->currentRoot(), _desktop); for (std::vector::const_iterator iter = items.begin(); iter != items.end(); ++iter ) { SPItem *item = *iter; Geom::Affine m = Geom::identity(); @@ -212,10 +373,11 @@ static void connector_spacing_changed(GtkAdjustment *adj, GObject* tbl) DocumentUndo::done(doc, SP_VERB_CONTEXT_CONNECTOR, _("Change connector spacing")); } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + _freeze = false; } -static void sp_connector_graph_layout() +void +ConnectorToolbar::graph_layout() { if (!SP_ACTIVE_DESKTOP) { return; @@ -235,205 +397,72 @@ static void sp_connector_graph_layout() DocumentUndo::done(SP_ACTIVE_DESKTOP->getDocument(), SP_VERB_DIALOG_ALIGN_DISTRIBUTE, _("Arrange connector network")); } -static void sp_directed_graph_layout_toggled( GtkToggleAction* act, GObject * /*tbl*/ ) +void +ConnectorToolbar::length_changed() { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setBool("/tools/connector/directedlayout", - gtk_toggle_action_get_active( act )); + prefs->setDouble("/tools/connector/length", _length_adj->get_value()); } -static void sp_nooverlaps_graph_layout_toggled( GtkToggleAction* act, GObject * /*tbl*/ ) +void +ConnectorToolbar::directed_graph_layout_toggled(GtkToggleAction *act, + gpointer data) { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setBool("/tools/connector/avoidoverlaplayout", + prefs->setBool("/tools/connector/directedlayout", gtk_toggle_action_get_active( act )); } - -static void connector_length_changed(GtkAdjustment *adj, GObject* /*tbl*/) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble("/tools/connector/length", gtk_adjustment_get_value(adj)); -} - -static void connector_tb_event_attr_changed(Inkscape::XML::Node *repr, - gchar const *name, gchar const * /*old_value*/, gchar const * /*new_value*/, - bool /*is_interactive*/, gpointer data) -{ - GtkWidget *tbl = GTK_WIDGET(data); - - if ( !g_object_get_data(G_OBJECT(tbl), "freeze") - && (strcmp(name, "inkscape:connector-spacing") == 0) ) { - GtkAdjustment *adj = static_cast(g_object_get_data(G_OBJECT(tbl), "spacing")); - gdouble spacing = defaultConnSpacing; - sp_repr_get_double(repr, "inkscape:connector-spacing", &spacing); - - gtk_adjustment_set_value(adj, spacing); - -#if !GTK_CHECK_VERSION(3,18,0) - gtk_adjustment_value_changed(adj); -#endif - - spinbutton_defocus(tbl); - } -} - -static Inkscape::XML::NodeEventVector connector_tb_repr_events = { - nullptr, /* child_added */ - nullptr, /* child_removed */ - connector_tb_event_attr_changed, - nullptr, /* content_changed */ - nullptr /* order_changed */ -}; - -static void sp_connector_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl) +void +ConnectorToolbar::selection_changed(Inkscape::Selection *selection) { - GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "curvature" ) ); - GtkToggleAction *act = GTK_TOGGLE_ACTION( g_object_get_data( tbl, "orthogonal" ) ); SPItem *item = selection->singleItem(); if (SP_IS_PATH(item)) { gdouble curvature = SP_PATH(item)->connEndPair.getCurvature(); bool is_orthog = SP_PATH(item)->connEndPair.isOrthogonal(); - gtk_toggle_action_set_active(act, is_orthog); - gtk_adjustment_set_value(adj, curvature); + gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(_orthogonal), is_orthog); + _curvature_adj->set_value(curvature); } } -void sp_connector_toolbox_prep( SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder ) +void +ConnectorToolbar::nooverlaps_graph_layout_toggled( GtkToggleAction* act, gpointer /* data */) { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); - - { - InkAction* inky = ink_action_new( "ConnectorAvoidAction", - _("Avoid"), - _("Make connectors avoid selected objects"), - INKSCAPE_ICON("connector-avoid"), - secondarySize ); - g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_path_set_avoid), holder ); - gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); - } - - { - InkAction* inky = ink_action_new( "ConnectorIgnoreAction", - _("Ignore"), - _("Make connectors ignore selected objects"), - INKSCAPE_ICON("connector-ignore"), - secondarySize ); - g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_path_set_ignore), holder ); - gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); - } - - // Orthogonal connectors toggle button - { - InkToggleAction* act = ink_toggle_action_new( "ConnectorOrthogonalAction", - _("Orthogonal"), - _("Make connector orthogonal or polyline"), - INKSCAPE_ICON("connector-orthogonal"), - GTK_ICON_SIZE_MENU ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - - bool tbuttonstate = prefs->getBool("/tools/connector/orthogonal"); - gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), ( tbuttonstate ? TRUE : FALSE )); - g_object_set_data( holder, "orthogonal", act ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_connector_orthogonal_toggled), holder ); - } - - EgeAdjustmentAction* eact = nullptr; - // Curvature spinbox - eact = create_adjustment_action( "ConnectorCurvatureAction", - _("Connector Curvature"), _("Curvature:"), - _("The amount of connectors curvature"), - "/tools/connector/curvature", defaultConnCurvature, - GTK_WIDGET(desktop->canvas), holder, TRUE, "inkscape:connector-curvature", - 0, 100, 1.0, 10.0, - nullptr, nullptr, 0, - connector_curvature_changed, nullptr /*unit tracker*/, 1, 0 ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - - // Spacing spinbox - eact = create_adjustment_action( "ConnectorSpacingAction", - _("Connector Spacing"), _("Spacing:"), - _("The amount of space left around objects by auto-routing connectors"), - "/tools/connector/spacing", defaultConnSpacing, - GTK_WIDGET(desktop->canvas), holder, TRUE, "inkscape:connector-spacing", - 0, 100, 1.0, 10.0, - nullptr, nullptr, 0, - connector_spacing_changed, nullptr /*unit tracker*/, 1, 0 ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - - // Graph (connector network) layout - { - InkAction* inky = ink_action_new( "ConnectorGraphAction", - _("Graph"), - _("Nicely arrange selected connector network"), - INKSCAPE_ICON("distribute-graph"), - secondarySize ); - g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_connector_graph_layout), holder ); - gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); - } - - // Default connector length spinbox - eact = create_adjustment_action( "ConnectorLengthAction", - _("Connector Length"), _("Length:"), - _("Ideal length for connectors when layout is applied"), - "/tools/connector/length", 100, - GTK_WIDGET(desktop->canvas), holder, TRUE, "inkscape:connector-length", - 10, 1000, 10.0, 100.0, - nullptr, nullptr, 0, - connector_length_changed, nullptr /*unit tracker*/, 1, 0 ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - - - // Directed edges toggle button - { - InkToggleAction* act = ink_toggle_action_new( "ConnectorDirectedAction", - _("Downwards"), - _("Make connectors with end-markers (arrows) point downwards"), - INKSCAPE_ICON("distribute-graph-directed"), - GTK_ICON_SIZE_MENU ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - - bool tbuttonstate = prefs->getBool("/tools/connector/directedlayout"); - gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), ( tbuttonstate ? TRUE : FALSE )); - - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_directed_graph_layout_toggled), holder ); - desktop->getSelection()->connectChanged(sigc::bind(sigc::ptr_fun(sp_connector_toolbox_selection_changed), holder)); - } - - // Avoid overlaps toggle button - { - InkToggleAction* act = ink_toggle_action_new( "ConnectorOverlapAction", - _("Remove overlaps"), - _("Do not allow overlapping shapes"), - INKSCAPE_ICON("distribute-remove-overlaps"), - GTK_ICON_SIZE_MENU ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - - bool tbuttonstate = prefs->getBool("/tools/connector/avoidoverlaplayout"); - gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(act), (tbuttonstate ? TRUE : FALSE )); + prefs->setBool("/tools/connector/avoidoverlaplayout", + gtk_toggle_action_get_active( act )); +} - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_nooverlaps_graph_layout_toggled), holder ); - } +void +ConnectorToolbar::event_attr_changed(Inkscape::XML::Node *repr, + gchar const *name, + gchar const * /*old_value*/, + gchar const * /*new_value*/, + bool /*is_interactive*/, + gpointer data) +{ + auto toolbar = reinterpret_cast(data); + if ( !toolbar->_freeze + && (strcmp(name, "inkscape:connector-spacing") == 0) ) { + gdouble spacing = defaultConnSpacing; + sp_repr_get_double(repr, "inkscape:connector-spacing", &spacing); - // Code to watch for changes to the connector-spacing attribute in - // the XML. - Inkscape::XML::Node *repr = desktop->namedview->getRepr(); - g_assert(repr != nullptr); + toolbar->_spacing_adj->set_value(spacing); - purge_repr_listener( holder, holder ); +#if !GTK_CHECK_VERSION(3,18,0) + toolbar->_spacing_adj->value_changed(); +#endif - if (repr) { - g_object_set_data( holder, "repr", repr ); - Inkscape::GC::anchor(repr); - sp_repr_add_listener( repr, &connector_tb_repr_events, holder ); - sp_repr_synthesize_events( repr, &connector_tb_repr_events, holder ); + if(toolbar->_desktop->canvas) gtk_widget_grab_focus(GTK_WIDGET(toolbar->_desktop->canvas)); } -} // end of sp_connector_toolbox_prep() +} +} +} +} /* Local Variables: diff --git a/src/ui/toolbar/connector-toolbar.h b/src/ui/toolbar/connector-toolbar.h index bc75f6bfe..f350739d0 100644 --- a/src/ui/toolbar/connector-toolbar.h +++ b/src/ui/toolbar/connector-toolbar.h @@ -28,11 +28,71 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" + +#include + class SPDesktop; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; +typedef struct _InkToggleAction InkToggleAction; + +namespace Inkscape { +class Selection; + +namespace XML { +class Node; +} + +namespace UI { +namespace Toolbar { +class ConnectorToolbar : public Toolbar { +private: + InkToggleAction *_orthogonal; + + Glib::RefPtr _curvature_adj; + Glib::RefPtr _spacing_adj; + Glib::RefPtr _length_adj; + + bool _freeze; + + Inkscape::XML::Node *_repr; + + static void path_set_avoid(); + static void path_set_ignore(); + static void orthogonal_toggled(GtkToggleAction *act, + gpointer data); + static void graph_layout(); + static void directed_graph_layout_toggled (GtkToggleAction *act, + gpointer data); + static void nooverlaps_graph_layout_toggled(GtkToggleAction *act, + gpointer data); + + void curvature_changed(); + void spacing_changed(); + void length_changed(); + void selection_changed(Inkscape::Selection *selection); + +protected: + ConnectorToolbar(SPDesktop *desktop) + : Toolbar(desktop), + _freeze(false), + _repr(nullptr) + {} + +public: + static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); + + static void event_attr_changed(Inkscape::XML::Node *repr, + gchar const *name, + gchar const * /*old_value*/, + gchar const * /*new_value*/, + bool /*is_interactive*/, + gpointer data); +}; -void sp_connector_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +} +} +} #endif /* !SEEN_CONNECTOR_TOOLBAR_H */ diff --git a/src/ui/toolbar/eraser-toolbar.cpp b/src/ui/toolbar/eraser-toolbar.cpp index ee28c127b..8950b6a58 100644 --- a/src/ui/toolbar/eraser-toolbar.cpp +++ b/src/ui/toolbar/eraser-toolbar.cpp @@ -48,89 +48,19 @@ using Inkscape::UI::PrefPusher; //## Eraser ## //######################## -// A dummy function for PrefPusher. -// The code was calling the update_presets_list function in the calligraphy tool -// which was immediately returning. TODO: Investigate this further. -void eraser_update_presets_list(GObject *tbl) -{ - return; -} - -static void sp_erc_width_value_changed( GtkAdjustment *adj, GObject *tbl ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/eraser/width", gtk_adjustment_get_value(adj) ); -} - -static void sp_erc_mass_value_changed( GtkAdjustment *adj, GObject* tbl ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/eraser/mass", gtk_adjustment_get_value(adj) ); -} - -static void sp_erc_velthin_value_changed( GtkAdjustment *adj, GObject* tbl ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble("/tools/eraser/thinning", gtk_adjustment_get_value(adj) ); -} - -static void sp_erc_cap_rounding_value_changed( GtkAdjustment *adj, GObject* tbl ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/eraser/cap_rounding", gtk_adjustment_get_value(adj) ); -} - -static void sp_erc_tremor_value_changed( GtkAdjustment *adj, GObject* tbl ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/eraser/tremor", gtk_adjustment_get_value(adj) ); -} - -static void sp_set_tbl_eraser_mode_visibility(GObject *const tbl, const guint eraser_mode) -{ - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "split") ), (eraser_mode == ERASER_MODE_CUT)); - - const gboolean visibility = (eraser_mode != ERASER_MODE_DELETE); - const std::array arr = {"cap_rounding", "mass", "thinning", "tremor", "usepressure", "width"}; - for (const gchar * str : arr) { - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, str) ), visibility ); - } -} - -static void sp_erasertb_mode_changed( GObject *tbl, int mode ) -{ - SPDesktop *desktop = static_cast(g_object_get_data( tbl, "desktop" )); - if (DocumentUndo::getUndoSensitive(desktop->getDocument())) { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setInt( "/tools/eraser/mode", mode ); - } - sp_set_tbl_eraser_mode_visibility(tbl, mode); - - // only take action if run by the attr_changed listener - if (!g_object_get_data( tbl, "freeze" )) { - // in turn, prevent listener from responding - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); - - /* - if ( eraser_mode != ERASER_MODE_DELETE ) { - } else { - } - */ - // TODO finish implementation - - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); - } -} -static void sp_toggle_break_apart( GtkToggleAction* act, gpointer data ) +namespace Inkscape { +namespace UI { +namespace Toolbar { +EraserToolbar::~EraserToolbar() { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - gboolean active = gtk_toggle_action_get_active(act); - prefs->setBool("/tools/eraser/break_apart", active); + if(_pressure_pusher) delete _pressure_pusher; } -void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) +GtkWidget * +EraserToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) { + auto toolbar = new EraserToolbar(desktop); GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); Inkscape::Preferences *prefs = Inkscape::Preferences::get(); gint eraser_mode = ERASER_MODE_DELETE; @@ -160,21 +90,20 @@ void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb row[columns.col_icon ] = INKSCAPE_ICON("path-intersection"); row[columns.col_sensitive] = true; - InkSelectOneAction* act = + toolbar->_eraser_mode_action = InkSelectOneAction::create( "EraserModeAction", // Name _("Mode"), // Label "", // Tooltip "Not Used", // Icon store ); // Tree store - act->use_radio( true ); - act->use_group_label( true ); + toolbar->_eraser_mode_action->use_radio( true ); + toolbar->_eraser_mode_action->use_group_label( true ); eraser_mode = prefs->getInt("/tools/eraser/mode", ERASER_MODE_CLIP); // Used at end - act->set_active( eraser_mode ); + toolbar->_eraser_mode_action->set_active( eraser_mode ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( holder, "EraserModeAction", act ); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_eraser_mode_action->gobj() )); - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_erasertb_mode_changed), holder)); + toolbar->_eraser_mode_action->signal_changed().connect(sigc::mem_fun(*toolbar, &EraserToolbar::mode_changed)); } @@ -182,32 +111,34 @@ void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb { gchar const* labels[] = {_("(no width)"),_("(hairline)"), nullptr, nullptr, nullptr, _("(default)"), nullptr, nullptr, nullptr, nullptr, _("(broad stroke)")}; gdouble values[] = {0, 1, 3, 5, 10, 15, 20, 30, 50, 75, 100}; - EgeAdjustmentAction *eact = create_adjustment_action( "EraserWidthAction", - _("Pen Width"), _("Width:"), - _("The width of the eraser pen (relative to the visible canvas area)"), - "/tools/eraser/width", 15, - GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-eraser", - 0, 100, 1.0, 10.0, - labels, values, G_N_ELEMENTS(labels), - sp_erc_width_value_changed, nullptr /*unit tracker*/, 1, 0); - ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - g_object_set_data( holder, "width", eact ); - gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + toolbar->_width = create_adjustment_action( "EraserWidthAction", + _("Pen Width"), _("Width:"), + _("The width of the eraser pen (relative to the visible canvas area)"), + "/tools/eraser/width", 15, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + TRUE, "altx-eraser", + 0, 100, 1.0, 10.0, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + nullptr /*unit tracker*/, 1, 0); + toolbar->_width_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_width)); + toolbar->_width_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &EraserToolbar::width_value_changed)); + ege_adjustment_action_set_appearance( toolbar->_width, TOOLBAR_SLIDER_HINT ); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_width) ); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_width), TRUE ); } /* Use Pressure button */ { - InkToggleAction* act = ink_toggle_action_new( "EraserPressureAction", - _("Eraser Pressure"), - _("Use the pressure of the input device to alter the width of the pen"), - INKSCAPE_ICON("draw-use-pressure"), - GTK_ICON_SIZE_MENU ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/eraser/usepressure", eraser_update_presets_list, holder); - g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher); - g_object_set_data( holder, "usepressure", act ); + toolbar->_usepressure = ink_toggle_action_new( "EraserPressureAction", + _("Eraser Pressure"), + _("Use the pressure of the input device to alter the width of the pen"), + INKSCAPE_ICON("draw-use-pressure"), + GTK_ICON_SIZE_MENU ); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_usepressure ) ); + toolbar->_pressure_pusher = new PrefPusher(GTK_TOGGLE_ACTION(toolbar->_usepressure), "/tools/eraser/usepressure", update_presets_list, (gpointer)toolbar); } @@ -215,17 +146,21 @@ void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb { gchar const* labels[] = {_("(speed blows up stroke)"), nullptr, nullptr, _("(slight widening)"), _("(constant width)"), _("(slight thinning, default)"), nullptr, nullptr, _("(speed deflates stroke)")}; gdouble values[] = {-100, -40, -20, -10, 0, 10, 20, 40, 100}; - EgeAdjustmentAction* eact = create_adjustment_action( "EraserThinningAction", - _("Eraser Stroke Thinning"), _("Thinning:"), - _("How much velocity thins the stroke (> 0 makes fast strokes thinner, < 0 makes them broader, 0 makes width independent of velocity)"), - "/tools/eraser/thinning", 10, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, - -100, 100, 1, 10.0, - labels, values, G_N_ELEMENTS(labels), - sp_erc_velthin_value_changed, nullptr /*unit tracker*/, 1, 0); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - g_object_set_data( holder, "thinning", eact ); - gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + toolbar->_thinning = create_adjustment_action( "EraserThinningAction", + _("Eraser Stroke Thinning"), _("Thinning:"), + _("How much velocity thins the stroke (> 0 makes fast strokes thinner, < 0 makes them broader, 0 makes width independent of velocity)"), + "/tools/eraser/thinning", 10, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + -100, 100, 1, 10.0, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + nullptr /*unit tracker*/, 1, 0); + toolbar->_thinning_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_thinning)); + toolbar->_thinning_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &EraserToolbar::velthin_value_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_thinning) ); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_thinning), TRUE ); } @@ -234,17 +169,21 @@ void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb gchar const* labels[] = {_("(blunt caps, default)"), _("(slightly bulging)"), nullptr, nullptr, _("(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( "EraserCapRoundingAction", - _("Eraser Cap rounding"), _("Caps:"), - _("Increase to make caps at the ends of strokes protrude more (0 = no caps, 1 = round caps)"), - "/tools/eraser/cap_rounding", 0.0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, - 0.0, 5.0, 0.01, 0.1, - labels, values, G_N_ELEMENTS(labels), - sp_erc_cap_rounding_value_changed, nullptr /*unit tracker*/, 0.01, 2 ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - g_object_set_data( holder, "cap_rounding", eact ); - gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + toolbar->_cap_rounding = create_adjustment_action( "EraserCapRoundingAction", + _("Eraser Cap rounding"), _("Caps:"), + _("Increase to make caps at the ends of strokes protrude more (0 = no caps, 1 = round caps)"), + "/tools/eraser/cap_rounding", 0.0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + 0.0, 5.0, 0.01, 0.1, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + nullptr /*unit tracker*/, 0.01, 2 ); + toolbar->_cap_rounding_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_cap_rounding)); + toolbar->_cap_rounding_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &EraserToolbar::cap_rounding_value_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_cap_rounding) ); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_cap_rounding), TRUE ); } @@ -252,55 +191,163 @@ void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb { gchar const* labels[] = {_("(smooth line)"), _("(slight tremor)"), _("(noticeable tremor)"), nullptr, nullptr, _("(maximum tremor)")}; gdouble values[] = {0, 10, 20, 40, 60, 100}; - EgeAdjustmentAction* eact = create_adjustment_action( "EraserTremorAction", - _("EraserStroke Tremor"), _("Tremor:"), - _("Increase to make strokes rugged and trembling"), - "/tools/eraser/tremor", 0.0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, - 0.0, 100, 1, 10.0, - labels, values, G_N_ELEMENTS(labels), - sp_erc_tremor_value_changed, nullptr /*unit tracker*/, 1, 0); - - ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); - g_object_set_data( holder, "tremor", eact ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + toolbar->_tremor = create_adjustment_action( "EraserTremorAction", + _("EraserStroke Tremor"), _("Tremor:"), + _("Increase to make strokes rugged and trembling"), + "/tools/eraser/tremor", 0.0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + 0.0, 100, 1, 10.0, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + nullptr /*unit tracker*/, 1, 0); + toolbar->_tremor_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_tremor)); + toolbar->_tremor_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &EraserToolbar::tremor_value_changed)); + + ege_adjustment_action_set_appearance( toolbar->_tremor, TOOLBAR_SLIDER_HINT ); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_tremor) ); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_tremor), TRUE ); } - /* Mass */ { - gchar const* labels[] = {_("(no inertia)"), _("(slight smoothing, default)"), _("(noticeable lagging)"), nullptr, nullptr, _("(maximum inertia)")}; + gchar const* labels[] = {_("(no inertia)"), _("(slight smoothing, default)"), _("(noticeable lagging)"), nullptr, nullptr, _("(maximum inertia)")}; gdouble values[] = {0.0, 2, 10, 20, 50, 100}; - EgeAdjustmentAction* eact = create_adjustment_action( "EraserMassAction", - _("Eraser Mass"), _("Mass:"), - _("Increase to make the eraser drag behind, as if slowed by inertia"), - "/tools/eraser/mass", 10.0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, - 0.0, 100, 1, 10.0, - labels, values, G_N_ELEMENTS(labels), - sp_erc_mass_value_changed, nullptr /*unit tracker*/, 1, 0); - ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); - g_object_set_data( holder, "mass", eact ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + toolbar->_mass = create_adjustment_action( "EraserMassAction", + _("Eraser Mass"), _("Mass:"), + _("Increase to make the eraser drag behind, as if slowed by inertia"), + "/tools/eraser/mass", 10.0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + 0.0, 100, 1, 10.0, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + nullptr /*unit tracker*/, 1, 0); + toolbar->_mass_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_mass)); + toolbar->_mass_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &EraserToolbar::mass_value_changed)); + ege_adjustment_action_set_appearance( toolbar->_mass, TOOLBAR_SLIDER_HINT ); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_mass) ); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_mass), TRUE ); } - /* Overlap */ { - InkToggleAction* act = ink_toggle_action_new( "EraserBreakAppart", - _("Break apart cut items"), - _("Break apart cut items"), - INKSCAPE_ICON("distribute-randomize"), - secondarySize ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/eraser/break_apart", false) ); - g_object_set_data( holder, "split", act ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_break_apart), holder) ; - gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); + toolbar->_split = ink_toggle_action_new( "EraserBreakAppart", + _("Break apart cut items"), + _("Break apart cut items"), + INKSCAPE_ICON("distribute-randomize"), + secondarySize ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(toolbar->_split), prefs->getBool("/tools/eraser/break_apart", false) ); + g_signal_connect_after( G_OBJECT(toolbar->_split), "toggled", G_CALLBACK(toggle_break_apart), (gpointer)toolbar); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_split) ); } - sp_set_tbl_eraser_mode_visibility(holder, eraser_mode); + toolbar->set_eraser_mode_visibility(eraser_mode); + + return GTK_WIDGET(toolbar->gobj()); +} + +void +EraserToolbar::mode_changed(int mode) +{ + if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) { + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setInt( "/tools/eraser/mode", mode ); + } + + set_eraser_mode_visibility(mode); + + // only take action if run by the attr_changed listener + if (!_freeze) { + // in turn, prevent listener from responding + _freeze = true; + + /* + if ( eraser_mode != ERASER_MODE_DELETE ) { + } else { + } + */ + // TODO finish implementation + + _freeze = false; + } +} + +void +EraserToolbar::set_eraser_mode_visibility(const guint eraser_mode) +{ + gtk_action_set_visible( GTK_ACTION(_split), (eraser_mode == ERASER_MODE_CUT)); + + const gboolean visibility = (eraser_mode != ERASER_MODE_DELETE); + + const std::array arr = {GTK_ACTION(_cap_rounding), + GTK_ACTION(_mass), + GTK_ACTION(_thinning), + GTK_ACTION(_tremor), + GTK_ACTION(_usepressure), + GTK_ACTION(_width)}; + for (auto act : arr) { + gtk_action_set_visible( act, visibility ); + } +} + +void +EraserToolbar::width_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/eraser/width", _width_adj->get_value() ); +} + +void +EraserToolbar::mass_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/eraser/mass", _mass_adj->get_value() ); +} + +void +EraserToolbar::velthin_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble("/tools/eraser/thinning", _thinning_adj->get_value() ); +} + +void +EraserToolbar::cap_rounding_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/eraser/cap_rounding", _cap_rounding_adj->get_value() ); +} + +void +EraserToolbar::tremor_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/eraser/tremor", _tremor_adj->get_value() ); +} + +// A dummy function for PrefPusher. +// The code was calling the update_presets_list function in the calligraphy tool +// which was immediately returning. TODO: Investigate this further. +void +EraserToolbar::update_presets_list(gpointer data) +{ + return; +} + +void +EraserToolbar::toggle_break_apart(GtkToggleAction *act, + gpointer data) +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + gboolean active = gtk_toggle_action_get_active(act); + prefs->setBool("/tools/eraser/break_apart", active); +} + +} +} } /* diff --git a/src/ui/toolbar/eraser-toolbar.h b/src/ui/toolbar/eraser-toolbar.h index 2f837e5d7..0f8485aeb 100644 --- a/src/ui/toolbar/eraser-toolbar.h +++ b/src/ui/toolbar/eraser-toolbar.h @@ -28,11 +28,69 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" + +#include + +class InkSelectOneAction; class SPDesktop; +typedef struct _EgeAdjustmentAction EgeAdjustmentAction; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; +typedef struct _InkToggleAction InkToggleAction; + +namespace Inkscape { +namespace UI { +class PrefPusher; + +namespace Toolbar { +class EraserToolbar : public Toolbar { +private: + InkSelectOneAction *_eraser_mode_action; + EgeAdjustmentAction *_width; + EgeAdjustmentAction *_mass; + EgeAdjustmentAction *_thinning; + EgeAdjustmentAction *_cap_rounding; + EgeAdjustmentAction *_tremor; + + InkToggleAction *_usepressure; + InkToggleAction *_split; + + Glib::RefPtr _width_adj; + Glib::RefPtr _mass_adj; + Glib::RefPtr _thinning_adj; + Glib::RefPtr _cap_rounding_adj; + Glib::RefPtr _tremor_adj; + + PrefPusher *_pressure_pusher; + + bool _freeze; + + void mode_changed(int mode); + void set_eraser_mode_visibility(const guint eraser_mode); + void width_value_changed(); + void mass_value_changed(); + void velthin_value_changed(); + void cap_rounding_value_changed(); + void tremor_value_changed(); + static void update_presets_list(gpointer data); + static void toggle_break_apart(GtkToggleAction *act, + gpointer data); + +protected: + EraserToolbar(SPDesktop *desktop) + : Toolbar(desktop), + _freeze(false) + {} + + ~EraserToolbar(); + +public: + static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); +}; -void sp_eraser_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +} +} +} #endif /* !SEEN_ERASOR_TOOLBAR_H */ diff --git a/src/ui/toolbar/gradient-toolbar.cpp b/src/ui/toolbar/gradient-toolbar.cpp index cf14be7c3..4d1b16c6e 100644 --- a/src/ui/toolbar/gradient-toolbar.cpp +++ b/src/ui/toolbar/gradient-toolbar.cpp @@ -336,511 +336,18 @@ void gr_read_selection( Inkscape::Selection *selection, } } -/* Get stop selected by menu */ -static SPStop *get_selected_stop( GObject *data) -{ - InkSelectOneAction *act = - static_cast(g_object_get_data(data, "gradient_stop_action")); - - int active = act->get_active(); - - Glib::RefPtr store = act->get_store(); - Gtk::TreeModel::Row row = store->children()[active]; - InkSelectOneActionColumns columns; - void* pointer = row[columns.col_data]; - SPStop *stop = static_cast(pointer); - - return stop; -} - -/* Add stop to gradient */ -static void gr_add_stop(GtkWidget * /*button*/, GObject *data) -{ - SPDesktop *desktop = static_cast(g_object_get_data(data, "desktop")); - if (!desktop) { - return; - } - - Inkscape::Selection *selection = desktop->getSelection(); - if (!selection) { - return; - } - - ToolBase *ev = desktop->getEventContext(); - Inkscape::UI::Tools::GradientTool *rc = SP_GRADIENT_CONTEXT(ev); - - if (rc) { - sp_gradient_context_add_stops_between_selected_stops(rc); - } - -} - -/* Remove stop from vector */ -static void gr_remove_stop(GtkWidget * /*button*/, GObject *data) -{ - - SPDesktop *desktop = static_cast(g_object_get_data(data, "desktop")); - if (!desktop) { - return; - } - - Inkscape::Selection *selection = desktop->getSelection(); // take from desktop, not from args - if (!selection) { - return; - } - - ToolBase *ev = desktop->getEventContext(); - GrDrag *drag = nullptr; - if (ev) { - drag = ev->get_drag(); - } - - if (drag) { - drag->deleteSelected(); - } - -} - -/* Lock or unlock links */ -static void gr_linked_changed(GtkToggleAction *act, gpointer /*data*/) -{ - gboolean active = gtk_toggle_action_get_active( act ); - if ( active ) { - g_object_set( G_OBJECT(act), "iconId", INKSCAPE_ICON("object-locked"), NULL ); - } else { - g_object_set( G_OBJECT(act), "iconId", INKSCAPE_ICON("object-unlocked"), NULL ); - } - - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setBool("/options/forkgradientvectors/value", !active); -} - -/* Reverse vector */ -static void gr_reverse(GtkWidget * /*button*/, gpointer data) -{ - SPDesktop *desktop = static_cast(data); - sp_gradient_reverse_selected_gradients(desktop); -} - -/* - * Change desktop dragger selection to this stop - */ -/* Set the offset widget value (based on which stop is selected). */ -static void gr_stop_set_offset (GObject *data) -{ - if (!blocked) { - std::cerr << "gr_stop_set_offset: should be blocked!" << std::endl; - } - - SPStop *stop = get_selected_stop(data); - if (!stop) { - // std::cerr << "gr_stop_set_offset: no stop!" << std::endl; - return; - } - - EgeAdjustmentAction* act = (EgeAdjustmentAction *)g_object_get_data( data, "offset_action"); - if (!act) { - return; - } - GtkAdjustment *adj = ege_adjustment_action_get_adjustment(act); - - bool isEndStop = false; - - SPStop *prev = nullptr; - prev = stop->getPrevStop(); - if (prev != nullptr ) { - gtk_adjustment_set_lower(adj, prev->offset); - } else { - isEndStop = true; - gtk_adjustment_set_lower(adj, 0); - } - - SPStop *next = nullptr; - next = stop->getNextStop(); - if (next != nullptr ) { - gtk_adjustment_set_upper(adj, next->offset); - } else { - isEndStop = true; - gtk_adjustment_set_upper(adj, 1.0); - } - - gtk_adjustment_set_value(adj, stop->offset); - gtk_action_set_sensitive( GTK_ACTION(act), !isEndStop ); - gtk_adjustment_changed(adj); -} - -static void select_dragger_by_stop( GObject *data, SPGradient *gradient, ToolBase *ev) -{ - if (!blocked) { - std::cerr << "select_dragger_by_stop: should be blocked!" << std::endl; - } - - if (!ev || !gradient) { - return; - } - - GrDrag *drag = ev->get_drag(); - if (!drag) { - return; - } - - SPStop *stop = get_selected_stop(data); - - drag->selectByStop(stop, false, true); - - gr_stop_set_offset(data); -} - -/* Find position of new_stop in menu. */ -static int select_stop_in_list (SPGradient *gradient, SPStop *new_stop, GObject *data) -{ - int i = 0; - for (auto& ochild: gradient->children) { - if (SP_IS_STOP(&ochild)) { - if (&ochild == new_stop) { - return i; - } - i++; - } - } - return -1; -} - -/* Construct stop list */ -static int update_stop_list( SPGradient *gradient, SPStop *new_stop, GObject *data, bool gr_multi) -{ - if (!blocked) { - std::cerr << "update_stop_list should be blocked!" << std::endl; - } - - int selected = -1; - - auto act = static_cast(g_object_get_data(data, "gradient_stop_action")); - Glib::RefPtr store = act->get_store(); - - if (!store) { - return selected; - } - - store->clear(); - - InkSelectOneActionColumns columns; - Gtk::TreeModel::Row row; - - if (!SP_IS_GRADIENT(gradient)) { - // No valid gradient - - row = *(store->append()); - row[columns.col_label ] = _("No gradient"); - row[columns.col_tooltip ] = ""; - row[columns.col_icon ] = "NotUsed"; - row[columns.col_data ] = nullptr; - row[columns.col_sensitive] = true; - - } else if (!gradient->hasStops()) { - // Has gradient but it has no stops - - row = *(store->append()); - row[columns.col_label ] = _("No stops in gradient"); - row[columns.col_tooltip ] = ""; - row[columns.col_icon ] = "NotUsed"; - row[columns.col_data ] = nullptr; - row[columns.col_sensitive] = true; - - } else { - // Gradient has stops - - // Get list of stops - for (auto& ochild: gradient->children) { - if (SP_IS_STOP(&ochild)) { - - SPStop *stop = SP_STOP(&ochild); - Glib::RefPtr pixbuf = sp_gradstop_to_pixbuf_ref (stop, 32, 16); - - Inkscape::XML::Node *repr = reinterpret_cast(&ochild)->getRepr(); - Glib::ustring label = gr_ellipsize_text(repr->attribute("id"), 25); - - row = *(store->append()); - row[columns.col_label ] = label; - row[columns.col_tooltip ] = ""; - row[columns.col_icon ] = "NotUsed"; - row[columns.col_pixbuf ] = pixbuf; - row[columns.col_data ] = stop; - row[columns.col_sensitive] = true; - } - } - } - - if (new_stop != nullptr) { - selected = select_stop_in_list (gradient, new_stop, data); - } - - return selected; -} - -/* Set stop in menu to match stops selected by draggers. */ -static void select_stop_by_draggers(SPGradient *gradient, ToolBase *ev, GObject *data) -{ - if (!blocked) { - std::cerr << "select_stop_by_draggers should be blocked!" << std::endl; - } - - if (!ev || !gradient) - return; - - SPGradient *vector = gradient->getVector(); - if (!vector) - return; - - InkSelectOneAction *act = - static_cast(g_object_get_data(data, "gradient_stop_action")); - - GrDrag *drag = ev->get_drag(); - - if (!drag || drag->selected.empty()) { - act->set_active(0); - gr_stop_set_offset(data); - return; - } - - gint n = 0; - SPStop *stop = nullptr; - int selected = -1; - - // For all selected draggers - for(auto dragger : drag->selected) { - - // For all draggables of dragger - for(auto draggable : dragger->draggables) { - - if (draggable->point_type != POINT_RG_FOCUS) { - n++; - if (n > 1) break; - } - - stop = vector->getFirstStop(); - - switch (draggable->point_type) { - case POINT_LG_MID: - case POINT_RG_MID1: - case POINT_RG_MID2: - stop = sp_get_stop_i(vector, draggable->point_i); - break; - case POINT_LG_END: - case POINT_RG_R1: - case POINT_RG_R2: - stop = sp_last_stop(vector); - break; - default: - break; - } - } - if (n > 1) break; - } - - if (n > 1) { - // Multiple stops selected - - EgeAdjustmentAction* offset = (EgeAdjustmentAction *)g_object_get_data( G_OBJECT(data), "offset_action"); - if (offset) { - gtk_action_set_sensitive( GTK_ACTION(offset), FALSE); - } - - // Stop list always updated first... reinsert "Multiple stops" as first entry. - InkSelectOneActionColumns columns; - Glib::RefPtr store = act->get_store(); - - Gtk::TreeModel::Row row = *(store->prepend()); - row[columns.col_label ] = _("Multiple stops"); - row[columns.col_tooltip ] = ""; - row[columns.col_icon ] = "NotUsed"; - row[columns.col_sensitive] = true; - selected = 0; - - } else { - selected = select_stop_in_list( gradient, stop, data); - } - - if (selected < 0) { - act->set_active (0); - act->set_sensitive (false); - } else { - act->set_active (selected); - act->set_sensitive (true); - gr_stop_set_offset(data); - } -} - -/* Return gradient selected in menu. */ -static SPGradient *gr_get_selected_gradient(GObject *data) -{ - InkSelectOneAction *act = - static_cast(g_object_get_data(data, "gradient_select_action")); - - int active = act->get_active(); - - Glib::RefPtr store = act->get_store(); - Gtk::TreeModel::Row row = store->children()[active]; - InkSelectOneActionColumns columns; - - void* pointer = row[columns.col_data]; - SPGradient *gr = static_cast(pointer); - - return gr; -} - -/* - * Callback functions for user actions - */ - -static void gr_new_type_changed( GObject * /*data*/, int mode ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setInt("/tools/gradient/newgradient", - mode == 0 ? SP_GRADIENT_TYPE_LINEAR : SP_GRADIENT_TYPE_RADIAL); -} - -static void gr_new_fillstroke_changed( GObject * /*data*/, int mode ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - Inkscape::PaintTarget fsmode = (mode == 0) ? Inkscape::FOR_FILL : Inkscape::FOR_STROKE; - prefs->setInt("/tools/gradient/newfillorstroke", (fsmode == Inkscape::FOR_FILL) ? 1 : 0); -} - -/* - * User selected a gradient from the combobox - */ -static void gr_gradient_changed( GObject *data, int active ) -{ - if (blocked) { - return; - } - - if (active < 0) { - return; - } - - blocked = true; - - SPGradient *gr = gr_get_selected_gradient (data); - - if (gr) { - gr = sp_gradient_ensure_vector_normalized(gr); - - SPDesktop *desktop = static_cast(g_object_get_data(data, "desktop")); - Inkscape::Selection *selection = desktop->getSelection(); - ToolBase *ev = desktop->getEventContext(); - - gr_apply_gradient(selection, ev ? ev->get_drag() : nullptr, gr); - - DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_GRADIENT, - _("Assign gradient to object")); - } - - blocked = false; -} - -/* - * User selected a spread method from the combobox - */ -static void gr_spread_changed( GObject *data, int active ) -{ - if (blocked) { - return; - } - - blocked = true; - - SPDesktop *desktop = static_cast(g_object_get_data(data, "desktop")); - Inkscape::Selection *selection = desktop->getSelection(); - SPGradient *gradient = nullptr; - gr_get_dt_selected_gradient(selection, gradient); - - if (gradient) { - SPGradientSpread spread = (SPGradientSpread) active; - gradient->setSpread(spread); - gradient->updateRepr(); - - DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_GRADIENT, - _("Set gradient repeat")); - } - - blocked = false; -} - -/* - * User selected a stop from the combobox - */ -static void gr_stop_changed( GObject *data, int active ) -{ - if (blocked) { - return; - } - - blocked = true; - - SPDesktop *desktop = static_cast(g_object_get_data(G_OBJECT(data), "desktop")); - ToolBase *ev = desktop->getEventContext(); - SPGradient *gr = gr_get_selected_gradient(data); - - select_dragger_by_stop(data, gr, ev); - - blocked = false; -} - -/* - * User selected a stop from the combobox - */ -static void gr_stop_combo_changed(GtkComboBox * /*widget*/, GObject *data) -{ - if (blocked) { - return; - } - - blocked = true; - - SPDesktop *desktop = static_cast(g_object_get_data(G_OBJECT(data), "desktop")); - ToolBase *ev = desktop->getEventContext(); - SPGradient *gr = gr_get_selected_gradient(data); - - select_dragger_by_stop(data, gr, ev); - - blocked = false; -} - -/* - * User changed the offset - */ -static void gr_stop_offset_adjustment_changed(GtkAdjustment *adj, GObject *data) -{ - if (blocked) { - return; - } - - blocked = true; - - SPStop *stop = get_selected_stop(data); - if (stop) { - stop->offset = gtk_adjustment_get_value(adj); - sp_repr_set_css_double(stop->getRepr(), "offset", stop->offset); - - DocumentUndo::maybeDone(stop->document, "gradient:stop:offset", SP_VERB_CONTEXT_GRADIENT, - _("Change gradient stop offset")); - - } - - blocked = false; -} - - -static void gradient_toolbox_check_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* data); +namespace Inkscape { +namespace UI { +namespace Toolbar { /** * Gradient auxiliary toolbar construction and setup. * */ -void sp_gradient_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObject* data) +GtkWidget * +GradientToolbar::prep(SPDesktop * desktop, GtkActionGroup* mainActions) { + auto toolbar = new GradientToolbar(desktop); GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); Inkscape::Preferences *prefs = Inkscape::Preferences::get(); @@ -865,22 +372,21 @@ void sp_gradient_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, row[columns.col_icon ] = INKSCAPE_ICON("paint-gradient-radial"); row[columns.col_sensitive] = true; - InkSelectOneAction* act = + toolbar->_new_type_mode = InkSelectOneAction::create( "GradientNewTypeAction", // Name _("New"), // Label "", // Tooltip "Not Used", // Icon store ); // Tree store - act->use_radio( true ); - act->use_group_label( true ); + toolbar->_new_type_mode->use_radio( true ); + toolbar->_new_type_mode->use_group_label( true ); gint mode = prefs->getInt("/tools/gradient/newgradient", SP_GRADIENT_TYPE_LINEAR); - act->set_active( mode == SP_GRADIENT_TYPE_LINEAR ? 0 : 1 ); // linear == 1, radial == 2 + toolbar->_new_type_mode->set_active( mode == SP_GRADIENT_TYPE_LINEAR ? 0 : 1 ); // linear == 1, radial == 2 - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( data, "gradient_new_type_mode", act ); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_new_type_mode->gobj() )); - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&gr_new_type_changed), data)); + toolbar->_new_type_mode->signal_changed().connect(sigc::mem_fun(*toolbar, &GradientToolbar::new_type_changed)); } /* New gradient on fill or stroke*/ @@ -903,22 +409,21 @@ void sp_gradient_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, row[columns.col_icon ] = INKSCAPE_ICON("object-stroke"); row[columns.col_sensitive] = true; - InkSelectOneAction* act = + toolbar->_new_fillstroke_action = InkSelectOneAction::create( "GradientNewFillStrokeAction", // Name "", // Label "", // Tooltip "Not Used", // Icon store ); // Tree store - act->use_radio( true ); - act->use_group_label( false ); + toolbar->_new_fillstroke_action->use_radio( true ); + toolbar->_new_fillstroke_action->use_group_label( false ); Inkscape::PaintTarget fsmode = (prefs->getInt("/tools/gradient/newfillorstroke", 1) != 0) ? Inkscape::FOR_FILL : Inkscape::FOR_STROKE; - act->set_active( fsmode == Inkscape::FOR_FILL ? 0 : 1 ); + toolbar->_new_fillstroke_action->set_active( fsmode == Inkscape::FOR_FILL ? 0 : 1 ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( data, "gradient_new_fillstroke_action", act ); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_new_fillstroke_action->gobj() )); - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&gr_new_fillstroke_changed), data)); + toolbar->_new_fillstroke_action->signal_changed().connect(sigc::mem_fun(*toolbar, &GradientToolbar::new_fillstroke_changed)); } /* Gradient Select list*/ @@ -935,24 +440,23 @@ void sp_gradient_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, row[columns.col_icon ] = "NotUsed"; row[columns.col_sensitive] = true; - InkSelectOneAction* act = + toolbar->_select_action = InkSelectOneAction::create( "GradientSelectGradientAction", // Name _("Select"), // Label "", // Tooltip "Not Used", // Icon store ); // Tree store - act->use_radio( false ); - act->use_icon( false ); - act->use_pixbuf( true ); - act->use_group_label( true ); - act->set_active( 0 ); - act->set_sensitive( false ); + toolbar->_select_action->use_radio( false ); + toolbar->_select_action->use_icon( false ); + toolbar->_select_action->use_pixbuf( true ); + toolbar->_select_action->use_group_label( true ); + toolbar->_select_action->set_active( 0 ); + toolbar->_select_action->set_sensitive( false ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( data, "gradient_select_action", act ); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_select_action->gobj() )); - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&gr_gradient_changed), data)); + toolbar->_select_action->signal_changed().connect(sigc::mem_fun(*toolbar, &GradientToolbar::gradient_changed)); } // Gradient Spread type (how a gradient is drawn outside it's nominal area) @@ -981,7 +485,7 @@ void sp_gradient_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, row[columns.col_icon ] = "NotUsed"; row[columns.col_sensitive] = true; - InkSelectOneAction* act = + toolbar->_spread_action = InkSelectOneAction::create( "GradientSelectSpreadAction", // Name _("Repeat"), // Label // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/pservers.html#LinearGradientSpreadMethodAttribute @@ -992,15 +496,14 @@ void sp_gradient_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, "Not Used", // Icon store ); // Tree store - act->use_radio( false ); - act->use_icon( false ); - act->use_group_label( true ); - act->set_sensitive( false ); + toolbar->_spread_action->use_radio( false ); + toolbar->_spread_action->use_icon( false ); + toolbar->_spread_action->use_group_label( true ); + toolbar->_spread_action->set_sensitive( false ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( data, "gradient_spread_action", act ); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_spread_action->gobj() )); - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&gr_spread_changed), data)); + toolbar->_spread_action->signal_changed().connect(sigc::mem_fun(*toolbar, &GradientToolbar::spread_changed)); } /* Gradidnt Stop list */ @@ -1017,130 +520,468 @@ void sp_gradient_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, row[columns.col_icon ] = "NotUsed"; row[columns.col_sensitive] = true; - InkSelectOneAction* act = + toolbar->_stop_action = InkSelectOneAction::create( "GradientStopAction", // Name _("Stops" ), // Label "", // Tooltip "Not Used", // Icon store ); // Tree store - act->use_radio( false ); - act->use_icon( false ); - act->use_pixbuf( true ); - act->use_group_label( true ); - act->set_active( 0 ); - act->set_sensitive( false ); + toolbar->_stop_action->use_radio( false ); + toolbar->_stop_action->use_icon( false ); + toolbar->_stop_action->use_pixbuf( true ); + toolbar->_stop_action->use_group_label( true ); + toolbar->_stop_action->set_active( 0 ); + toolbar->_stop_action->set_sensitive( false ); + + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_stop_action->gobj() )); + + toolbar->_stop_action->signal_changed().connect(sigc::mem_fun(*toolbar, &GradientToolbar::stop_changed)); + } + + /* Offset */ + { + toolbar->_offset_action = create_adjustment_action( "GradientEditOffsetAction", + _("Offset"), C_("Gradient", "Offset:"), _("Offset of selected stop"), + "/tools/gradient/stopoffset", 0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + 0.0, 1.0, 0.01, 0.1, + nullptr, nullptr, 0, + nullptr, // callback + nullptr /*unit tracker*/, + 0.01, 2, 1.0); + + toolbar->_offset_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_offset_action)); + toolbar->_offset_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &GradientToolbar::stop_offset_adjustment_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_offset_action) ); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_offset_action), FALSE ); + } + + /* Add stop */ + { + toolbar->_stops_add_action = ink_action_new( "GradientEditAddAction", + _("Insert new stop"), + _("Insert new stop"), + INKSCAPE_ICON("node-add"), + secondarySize ); + gtk_action_set_short_label(GTK_ACTION(toolbar->_stops_add_action), _("Delete")); + g_signal_connect_after( G_OBJECT(toolbar->_stops_add_action), "activate", G_CALLBACK(add_stop), (gpointer)toolbar); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_stops_add_action) ); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_stops_add_action), FALSE ); + } + + /* Delete stop */ + { + toolbar->_stops_delete_action = ink_action_new( "GradientEditDeleteAction", + _("Delete stop"), + _("Delete stop"), + INKSCAPE_ICON("node-delete"), + secondarySize ); + gtk_action_set_short_label(GTK_ACTION(toolbar->_stops_delete_action), _("Delete")); + g_signal_connect_after( G_OBJECT(toolbar->_stops_delete_action), "activate", G_CALLBACK(remove_stop), (gpointer)toolbar ); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_stops_delete_action) ); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_stops_delete_action), FALSE ); + } + + /* Reverse */ + { + toolbar->_stops_reverse_action = ink_action_new( "GradientEditReverseAction", + _("Reverse"), + _("Reverse the direction of the gradient"), + INKSCAPE_ICON("object-flip-horizontal"), + secondarySize ); + // TODO: Is this label correct? + gtk_action_set_short_label(GTK_ACTION(toolbar->_stops_reverse_action), _("Delete")); + g_signal_connect_after( G_OBJECT(toolbar->_stops_reverse_action), "activate", G_CALLBACK(reverse), desktop ); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_stops_reverse_action) ); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_stops_reverse_action), FALSE ); + } + + // Gradients Linked toggle + { + InkToggleAction* itact = ink_toggle_action_new( "GradientEditLinkAction", + _("Link gradients"), + _("Link gradients to change all related gradients"), + INKSCAPE_ICON("object-unlocked"), + GTK_ICON_SIZE_MENU ); + // TODO: Shouldn't this be translatable? + gtk_action_set_short_label( GTK_ACTION(itact), "Lock"); + g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(linked_changed), desktop) ; + gtk_action_group_add_action( mainActions, GTK_ACTION(itact) ); + + bool linkedmode = prefs->getBool("/options/forkgradientvectors/value", true); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(itact), !linkedmode ); + } + + desktop->connectEventContextChanged(sigc::mem_fun(*toolbar, &GradientToolbar::check_ec)); + + return GTK_WIDGET(toolbar->gobj()); +} + +void +GradientToolbar::new_type_changed(int mode) +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setInt("/tools/gradient/newgradient", + mode == 0 ? SP_GRADIENT_TYPE_LINEAR : SP_GRADIENT_TYPE_RADIAL); +} + +void +GradientToolbar::new_fillstroke_changed(int mode) +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + Inkscape::PaintTarget fsmode = (mode == 0) ? Inkscape::FOR_FILL : Inkscape::FOR_STROKE; + prefs->setInt("/tools/gradient/newfillorstroke", (fsmode == Inkscape::FOR_FILL) ? 1 : 0); +} + +/* + * User selected a gradient from the combobox + */ +void +GradientToolbar::gradient_changed(int active) +{ + if (blocked) { + return; + } + + if (active < 0) { + return; + } + + blocked = true; + + SPGradient *gr = get_selected_gradient(); + + if (gr) { + gr = sp_gradient_ensure_vector_normalized(gr); + + Inkscape::Selection *selection = _desktop->getSelection(); + ToolBase *ev = _desktop->getEventContext(); + + gr_apply_gradient(selection, ev ? ev->get_drag() : nullptr, gr); + + DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_GRADIENT, + _("Assign gradient to object")); + } + + blocked = false; +} + +/** + * \brief Return gradient selected in menu + */ +SPGradient * +GradientToolbar::get_selected_gradient() +{ + int active = _select_action->get_active(); + + Glib::RefPtr store = _select_action->get_store(); + Gtk::TreeModel::Row row = store->children()[active]; + InkSelectOneActionColumns columns; + + void* pointer = row[columns.col_data]; + SPGradient *gr = static_cast(pointer); + + return gr; +} + +/** + * \brief User selected a spread method from the combobox + */ +void +GradientToolbar::spread_changed(int active) +{ + if (blocked) { + return; + } + + blocked = true; + + Inkscape::Selection *selection = _desktop->getSelection(); + SPGradient *gradient = nullptr; + gr_get_dt_selected_gradient(selection, gradient); + + if (gradient) { + SPGradientSpread spread = (SPGradientSpread) active; + gradient->setSpread(spread); + gradient->updateRepr(); + + DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_GRADIENT, + _("Set gradient repeat")); + } + + blocked = false; +} + +/** + * \brief User selected a stop from the combobox + */ +void +GradientToolbar::stop_changed(int active) +{ + if (blocked) { + return; + } + + blocked = true; + + ToolBase *ev = _desktop->getEventContext(); + SPGradient *gr = get_selected_gradient(); + + select_dragger_by_stop(gr, ev); + + blocked = false; +} + +void +GradientToolbar::select_dragger_by_stop(SPGradient *gradient, + ToolBase *ev) +{ + if (!blocked) { + std::cerr << "select_dragger_by_stop: should be blocked!" << std::endl; + } + + if (!ev || !gradient) { + return; + } + + GrDrag *drag = ev->get_drag(); + if (!drag) { + return; + } + + SPStop *stop = get_selected_stop(); + + drag->selectByStop(stop, false, true); + + stop_set_offset(); +} + +/** + * \brief Get stop selected by menu + */ +SPStop * +GradientToolbar::get_selected_stop() +{ + int active = _stop_action->get_active(); + + Glib::RefPtr store = _stop_action->get_store(); + Gtk::TreeModel::Row row = store->children()[active]; + InkSelectOneActionColumns columns; + void* pointer = row[columns.col_data]; + SPStop *stop = static_cast(pointer); + + return stop; +} + +/** + * Change desktop dragger selection to this stop + * + * Set the offset widget value (based on which stop is selected) + */ +void +GradientToolbar::stop_set_offset() +{ + if (!blocked) { + std::cerr << "gr_stop_set_offset: should be blocked!" << std::endl; + } + + SPStop *stop = get_selected_stop(); + if (!stop) { + // std::cerr << "gr_stop_set_offset: no stop!" << std::endl; + return; + } + + if (!_offset_action) { + return; + } + bool isEndStop = false; + + SPStop *prev = nullptr; + prev = stop->getPrevStop(); + if (prev != nullptr ) { + _offset_adj->set_lower(prev->offset); + } else { + isEndStop = true; + _offset_adj->set_lower(0); + } + + SPStop *next = nullptr; + next = stop->getNextStop(); + if (next != nullptr ) { + _offset_adj->set_upper(next->offset); + } else { + isEndStop = true; + _offset_adj->set_upper(1.0); + } + + _offset_adj->set_value(stop->offset); + gtk_action_set_sensitive( GTK_ACTION(_offset_action), !isEndStop ); + _offset_adj->changed(); +} + +/** + * \brief User changed the offset + */ +void +GradientToolbar::stop_offset_adjustment_changed() +{ + if (blocked) { + return; + } + + blocked = true; + + SPStop *stop = get_selected_stop(); + if (stop) { + stop->offset = _offset_adj->get_value(); + sp_repr_set_css_double(stop->getRepr(), "offset", stop->offset); + + DocumentUndo::maybeDone(stop->document, "gradient:stop:offset", SP_VERB_CONTEXT_GRADIENT, + _("Change gradient stop offset")); + + } + + blocked = false; +} - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( data, "gradient_stop_action", act ); +/** + * \brief Add stop to gradient + */ +void +GradientToolbar::add_stop(GtkWidget * /*button*/, gpointer data) +{ + auto toolbar = reinterpret_cast(data); + if (!toolbar->_desktop) { + return; + } - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&gr_stop_changed), data)); + Inkscape::Selection *selection = toolbar->_desktop->getSelection(); + if (!selection) { + return; } - /* Offset */ - { - EgeAdjustmentAction* eact = nullptr; - eact = create_adjustment_action( "GradientEditOffsetAction", - _("Offset"), C_("Gradient", "Offset:"), _("Offset of selected stop"), - "/tools/gradient/stopoffset", 0, - GTK_WIDGET(desktop->canvas), data, FALSE, nullptr, - 0.0, 1.0, 0.01, 0.1, - nullptr, nullptr, 0, - gr_stop_offset_adjustment_changed, - nullptr /*unit tracker*/, - 0.01, 2, 1.0); - - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - g_object_set_data( data, "offset_action", eact ); - gtk_action_set_sensitive( GTK_ACTION(eact), FALSE ); + ToolBase *ev = toolbar->_desktop->getEventContext(); + Inkscape::UI::Tools::GradientTool *rc = SP_GRADIENT_CONTEXT(ev); + if (rc) { + sp_gradient_context_add_stops_between_selected_stops(rc); } +} - /* Add stop */ - { - InkAction* inky = ink_action_new( "GradientEditAddAction", - _("Insert new stop"), - _("Insert new stop"), - INKSCAPE_ICON("node-add"), - secondarySize ); - g_object_set( inky, "short_label", _("Delete"), NULL ); - g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(gr_add_stop), data ); - gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); - gtk_action_set_sensitive( GTK_ACTION(inky), FALSE ); - g_object_set_data( data, "gradient_stops_add_action", inky ); +/** + * \brief Remove stop from vector + */ +void +GradientToolbar::remove_stop(GtkWidget * /*button*/, gpointer data) +{ + auto toolbar = reinterpret_cast(data); + + if (!toolbar->_desktop) { + return; } - /* Delete stop */ - { - InkAction* inky = ink_action_new( "GradientEditDeleteAction", - _("Delete stop"), - _("Delete stop"), - INKSCAPE_ICON("node-delete"), - secondarySize ); - g_object_set( inky, "short_label", _("Delete"), NULL ); - g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(gr_remove_stop), data ); - gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); - gtk_action_set_sensitive( GTK_ACTION(inky), FALSE ); - g_object_set_data( data, "gradient_stops_delete_action", inky ); + Inkscape::Selection *selection = toolbar->_desktop->getSelection(); // take from desktop, not from args + if (!selection) { + return; } - /* Reverse */ - { - InkAction* inky = ink_action_new( "GradientEditReverseAction", - _("Reverse"), - _("Reverse the direction of the gradient"), - INKSCAPE_ICON("object-flip-horizontal"), - secondarySize ); - g_object_set( inky, "short_label", _("Delete"), NULL ); - g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(gr_reverse), desktop ); - gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); - gtk_action_set_sensitive( GTK_ACTION(inky), FALSE ); - g_object_set_data( data, "gradient_stops_reverse_action", inky ); + ToolBase *ev = toolbar->_desktop->getEventContext(); + GrDrag *drag = nullptr; + if (ev) { + drag = ev->get_drag(); + } + if (drag) { + drag->deleteSelected(); } +} - // Gradients Linked toggle - { - InkToggleAction* itact = ink_toggle_action_new( "GradientEditLinkAction", - _("Link gradients"), - _("Link gradients to change all related gradients"), - INKSCAPE_ICON("object-unlocked"), - GTK_ICON_SIZE_MENU ); - g_object_set( itact, "short_label", "Lock", NULL ); - g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(gr_linked_changed), desktop) ; - gtk_action_group_add_action( mainActions, GTK_ACTION(itact) ); +/** + * \brief Reverse vector + */ +void +GradientToolbar::reverse(GtkWidget * /*button*/, gpointer data) +{ + SPDesktop *desktop = static_cast(data); + sp_gradient_reverse_selected_gradients(desktop); +} - bool linkedmode = prefs->getBool("/options/forkgradientvectors/value", true); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(itact), !linkedmode ); +/** + * \brief Lock or unlock links + */ +void +GradientToolbar::linked_changed(GtkToggleAction *act, gpointer /*data*/) +{ + gboolean active = gtk_toggle_action_get_active( act ); + if ( active ) { + g_object_set( G_OBJECT(act), "iconId", INKSCAPE_ICON("object-locked"), NULL ); + } else { + g_object_set( G_OBJECT(act), "iconId", INKSCAPE_ICON("object-unlocked"), NULL ); } - g_object_set_data(data, "desktop", desktop); - - desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(&gradient_toolbox_check_ec), data)); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setBool("/options/forkgradientvectors/value", !active); } +// lp:1327267 +/** + * Checks the current tool and connects gradient aux toolbox signals if it happens to be the gradient tool. + * Called every time the current tool changes by signal emission. + */ +void +GradientToolbar::check_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec) +{ + if (SP_IS_GRADIENT_CONTEXT(ec)) { + Inkscape::Selection *selection = desktop->getSelection(); + SPDocument *document = desktop->getDocument(); + + // connect to selection modified and changed signals + _connection_changed = selection->connectChanged(sigc::mem_fun(*this, &GradientToolbar::selection_changed)); + _connection_modified = selection->connectModified(sigc::mem_fun(*this, &GradientToolbar::selection_modified)); + _connection_subselection_changed = desktop->connectToolSubselectionChanged(sigc::mem_fun(*this, &GradientToolbar::drag_selection_changed)); -// =================== Selection Changed Callbacks ======================= // + // Is this necessary? Couldn't hurt. + selection_changed(selection); -/* + // connect to release and modified signals of the defs (i.e. when someone changes gradient) + _connection_defs_release = document->getDefs()->connectRelease(sigc::mem_fun(*this, &GradientToolbar::defs_release)); + _connection_defs_modified = document->getDefs()->connectModified(sigc::mem_fun(*this, &GradientToolbar::defs_modified)); + } else { + if (_connection_changed) + _connection_changed.disconnect(); + if (_connection_modified) + _connection_modified.disconnect(); + if (_connection_subselection_changed) + _connection_subselection_changed.disconnect(); + if (_connection_defs_release) + _connection_defs_release.disconnect(); + if (_connection_defs_modified) + _connection_defs_modified.disconnect(); + } +} + +/** * Core function, setup all the widgets whenever something changes on the desktop */ -static void gr_tb_selection_changed(Inkscape::Selection * /*selection*/, GObject* data) +void +GradientToolbar::selection_changed(Inkscape::Selection * /*selection*/) { if (blocked) return; blocked = true; - SPDesktop *desktop = static_cast(g_object_get_data(data, "desktop")); - if (!desktop) { + if (!_desktop) { return; } - Inkscape::Selection *selection = desktop->getSelection(); // take from desktop, not from args + Inkscape::Selection *selection = _desktop->getSelection(); // take from desktop, not from args if (selection) { - ToolBase *ev = desktop->getEventContext(); + ToolBase *ev = _desktop->getEventContext(); GrDrag *drag = nullptr; if (ev) { drag = ev->get_drag(); @@ -1154,106 +995,246 @@ static void gr_tb_selection_changed(Inkscape::Selection * /*selection*/, GObject gr_read_selection(selection, drag, gr_selected, gr_multi, spr_selected, spr_multi); // Gradient selection menu - auto sel = static_cast(g_object_get_data(data, "gradient_select_action")); - Glib::RefPtr store = sel->get_store(); - int gradient = gr_vector_list (store, desktop, selection->isEmpty(), gr_selected, gr_multi); + auto store = _select_action->get_store(); + int gradient = gr_vector_list (store, _desktop, selection->isEmpty(), gr_selected, gr_multi); if (gradient < 0) { // No selection or no gradients - sel->set_active( 0 ); - sel->set_sensitive (false); + _select_action->set_active( 0 ); + _select_action->set_sensitive (false); } else { // Single gradient or multiple gradients - sel->set_active( gradient ); - sel->set_sensitive (true); + _select_action->set_active( gradient ); + _select_action->set_sensitive (true); } // Spread menu - auto spread = static_cast(g_object_get_data(data, "gradient_spread_action")); - spread->set_sensitive( gr_selected && !gr_multi ); - spread->set_active( gr_selected ? (int)spr_selected : 0 ); + _spread_action->set_sensitive( gr_selected && !gr_multi ); + _spread_action->set_active( gr_selected ? (int)spr_selected : 0 ); - InkAction *add = (InkAction *) g_object_get_data(data, "gradient_stops_add_action"); - gtk_action_set_sensitive(GTK_ACTION(add), (gr_selected && !gr_multi && drag && !drag->selected.empty())); + gtk_action_set_sensitive(GTK_ACTION(_stops_add_action), (gr_selected && !gr_multi && drag && !drag->selected.empty())); + gtk_action_set_sensitive(GTK_ACTION(_stops_delete_action), (gr_selected && !gr_multi && drag && !drag->selected.empty())); + gtk_action_set_sensitive(GTK_ACTION(_stops_reverse_action), (gr_selected!= nullptr)); - InkAction *del = (InkAction *) g_object_get_data(data, "gradient_stops_delete_action"); - gtk_action_set_sensitive(GTK_ACTION(del), (gr_selected && !gr_multi && drag && !drag->selected.empty())); + _stop_action->set_sensitive( gr_selected && !gr_multi); - InkAction *reverse = (InkAction *) g_object_get_data(data, "gradient_stops_reverse_action"); - gtk_action_set_sensitive(GTK_ACTION(reverse), (gr_selected!= nullptr)); - - InkSelectOneAction *stops_action = (InkSelectOneAction *) g_object_get_data(data, "gradient_stop_action"); - stops_action->set_sensitive( gr_selected && !gr_multi); - - int stop = update_stop_list (gr_selected, nullptr, data, gr_multi); - select_stop_by_draggers(gr_selected, ev, data); + int stop = update_stop_list (gr_selected, nullptr, gr_multi); + select_stop_by_draggers(gr_selected, ev); } blocked = false; } -static void gr_tb_selection_modified(Inkscape::Selection *selection, guint /*flags*/, GObject* data) +/** + * \brief Construct stop list + */ +int +GradientToolbar::update_stop_list( SPGradient *gradient, SPStop *new_stop, bool gr_multi) { - gr_tb_selection_changed(selection, data); -} + if (!blocked) { + std::cerr << "update_stop_list should be blocked!" << std::endl; + } -static void gr_drag_selection_changed(gpointer /*dragger*/, GObject* data) -{ - gr_tb_selection_changed(nullptr, data); -} + int selected = -1; -static void gr_defs_release(SPObject * /*defs*/, GObject* data) -{ - gr_tb_selection_changed(nullptr, data); + auto store = _stop_action->get_store(); + + if (!store) { + return selected; + } + + store->clear(); + + InkSelectOneActionColumns columns; + Gtk::TreeModel::Row row; + + if (!SP_IS_GRADIENT(gradient)) { + // No valid gradient + + row = *(store->append()); + row[columns.col_label ] = _("No gradient"); + row[columns.col_tooltip ] = ""; + row[columns.col_icon ] = "NotUsed"; + row[columns.col_data ] = nullptr; + row[columns.col_sensitive] = true; + + } else if (!gradient->hasStops()) { + // Has gradient but it has no stops + + row = *(store->append()); + row[columns.col_label ] = _("No stops in gradient"); + row[columns.col_tooltip ] = ""; + row[columns.col_icon ] = "NotUsed"; + row[columns.col_data ] = nullptr; + row[columns.col_sensitive] = true; + + } else { + // Gradient has stops + + // Get list of stops + for (auto& ochild: gradient->children) { + if (SP_IS_STOP(&ochild)) { + + SPStop *stop = SP_STOP(&ochild); + Glib::RefPtr pixbuf = sp_gradstop_to_pixbuf_ref (stop, 32, 16); + + Inkscape::XML::Node *repr = reinterpret_cast(&ochild)->getRepr(); + Glib::ustring label = gr_ellipsize_text(repr->attribute("id"), 25); + + row = *(store->append()); + row[columns.col_label ] = label; + row[columns.col_tooltip ] = ""; + row[columns.col_icon ] = "NotUsed"; + row[columns.col_pixbuf ] = pixbuf; + row[columns.col_data ] = stop; + row[columns.col_sensitive] = true; + } + } + } + + if (new_stop != nullptr) { + selected = select_stop_in_list (gradient, new_stop); + } + + return selected; } -static void gr_defs_modified(SPObject * /*defs*/, guint /*flags*/, GObject* data) +/** + * \brief Find position of new_stop in menu. + */ +int +GradientToolbar::select_stop_in_list(SPGradient *gradient, SPStop *new_stop) { - gr_tb_selection_changed(nullptr, data); + int i = 0; + for (auto& ochild: gradient->children) { + if (SP_IS_STOP(&ochild)) { + if (&ochild == new_stop) { + return i; + } + i++; + } + } + return -1; } -// lp:1327267 /** - * Checks the current tool and connects gradient aux toolbox signals if it happens to be the gradient tool. - * Called every time the current tool changes by signal emission. + * \brief Set stop in menu to match stops selected by draggers */ -static void gradient_toolbox_check_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec, GObject* data) +void +GradientToolbar::select_stop_by_draggers(SPGradient *gradient, ToolBase *ev) { - static sigc::connection connChanged; - static sigc::connection connModified; - static sigc::connection connSubselectionChanged; - static sigc::connection connDefsRelease; - static sigc::connection connDefsModified; + if (!blocked) { + std::cerr << "select_stop_by_draggers should be blocked!" << std::endl; + } - if (SP_IS_GRADIENT_CONTEXT(ec)) { - Inkscape::Selection *selection = desktop->getSelection(); - SPDocument *document = desktop->getDocument(); + if (!ev || !gradient) + return; - // connect to selection modified and changed signals - connChanged = selection->connectChanged(sigc::bind(sigc::ptr_fun(&gr_tb_selection_changed), data)); - connModified = selection->connectModified(sigc::bind(sigc::ptr_fun(&gr_tb_selection_modified), data)); - connSubselectionChanged = desktop->connectToolSubselectionChanged(sigc::bind(sigc::ptr_fun(&gr_drag_selection_changed), data)); + SPGradient *vector = gradient->getVector(); + if (!vector) + return; - // Is this necessary? Couldn't hurt. - gr_tb_selection_changed(selection, data); + GrDrag *drag = ev->get_drag(); - // connect to release and modified signals of the defs (i.e. when someone changes gradient) - connDefsRelease = document->getDefs()->connectRelease( sigc::bind<1>(sigc::ptr_fun(&gr_defs_release), data)); - connDefsModified = document->getDefs()->connectModified(sigc::bind<2>(sigc::ptr_fun(&gr_defs_modified), data)); + if (!drag || drag->selected.empty()) { + _stop_action->set_active(0); + stop_set_offset(); + return; + } + + gint n = 0; + SPStop *stop = nullptr; + int selected = -1; + + // For all selected draggers + for(auto dragger : drag->selected) { + + // For all draggables of dragger + for(auto draggable : dragger->draggables) { + + if (draggable->point_type != POINT_RG_FOCUS) { + n++; + if (n > 1) break; + } + + stop = vector->getFirstStop(); + + switch (draggable->point_type) { + case POINT_LG_MID: + case POINT_RG_MID1: + case POINT_RG_MID2: + stop = sp_get_stop_i(vector, draggable->point_i); + break; + case POINT_LG_END: + case POINT_RG_R1: + case POINT_RG_R2: + stop = sp_last_stop(vector); + break; + default: + break; + } + } + if (n > 1) break; + } + + if (n > 1) { + // Multiple stops selected + if (_offset_action) { + gtk_action_set_sensitive( GTK_ACTION(_offset_action), FALSE); + } + + // Stop list always updated first... reinsert "Multiple stops" as first entry. + InkSelectOneActionColumns columns; + Glib::RefPtr store = _stop_action->get_store(); + + Gtk::TreeModel::Row row = *(store->prepend()); + row[columns.col_label ] = _("Multiple stops"); + row[columns.col_tooltip ] = ""; + row[columns.col_icon ] = "NotUsed"; + row[columns.col_sensitive] = true; + selected = 0; + + } else { + selected = select_stop_in_list(gradient, stop); + } + + if (selected < 0) { + _stop_action->set_active (0); + _stop_action->set_sensitive (false); } else { - if (connChanged) - connChanged.disconnect(); - if (connModified) - connModified.disconnect(); - if (connSubselectionChanged) - connSubselectionChanged.disconnect(); - if (connDefsRelease) - connDefsRelease.disconnect(); - if (connDefsModified) - connDefsModified.disconnect(); + _stop_action->set_active (selected); + _stop_action->set_sensitive (true); + stop_set_offset(); } } +void +GradientToolbar::selection_modified(Inkscape::Selection *selection, guint /*flags*/) +{ + selection_changed(selection); +} + +void +GradientToolbar::drag_selection_changed(gpointer /*dragger*/) +{ + selection_changed(nullptr); +} + +void +GradientToolbar::defs_release(SPObject * /*defs*/) +{ + selection_changed(nullptr); +} + +void +GradientToolbar::defs_modified(SPObject * /*defs*/, guint /*flags*/) +{ + selection_changed(nullptr); +} + +} +} +} /* Local Variables: mode:c++ diff --git a/src/ui/toolbar/gradient-toolbar.h b/src/ui/toolbar/gradient-toolbar.h index 242086758..4e9f33bb7 100644 --- a/src/ui/toolbar/gradient-toolbar.h +++ b/src/ui/toolbar/gradient-toolbar.h @@ -13,11 +13,85 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" + +#include + +class InkSelectOneAction; class SPDesktop; +class SPGradient; +typedef struct _EgeAdjustmentAction EgeAdjustmentAction; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; +typedef struct _InkAction InkAction; + +namespace Inkscape { +class Selection; + +namespace UI { +namespace Tools { +class ToolBase; +} + +namespace Toolbar { +class GradientToolbar : public Toolbar { +private: + InkSelectOneAction *_new_type_mode; + InkSelectOneAction *_new_fillstroke_action; + InkSelectOneAction *_select_action; + InkSelectOneAction *_spread_action; + InkSelectOneAction *_stop_action; + + InkAction *_stops_add_action; + InkAction *_stops_delete_action; + InkAction *_stops_reverse_action; + + EgeAdjustmentAction *_offset_action; + + Glib::RefPtr _offset_adj; + + void new_type_changed(int mode); + void new_fillstroke_changed(int mode); + void gradient_changed(int active); + SPGradient * get_selected_gradient(); + void spread_changed(int active); + void stop_changed(int active); + void select_dragger_by_stop(SPGradient *gradient, + UI::Tools::ToolBase *ev); + SPStop * get_selected_stop(); + void stop_set_offset(); + void stop_offset_adjustment_changed(); + static void add_stop(GtkWidget *button, gpointer data); + static void remove_stop(GtkWidget *button, gpointer data); + static void reverse(GtkWidget *button, gpointer data); + static void linked_changed(GtkToggleAction *act, gpointer data); + void check_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec); + void selection_changed(Inkscape::Selection *selection); + int update_stop_list( SPGradient *gradient, SPStop *new_stop, bool gr_multi); + int select_stop_in_list(SPGradient *gradient, SPStop *new_stop); + void select_stop_by_draggers(SPGradient *gradient, UI::Tools::ToolBase *ev); + void selection_modified(Inkscape::Selection *selection, guint flags); + void drag_selection_changed(gpointer dragger); + void defs_release(SPObject * defs); + void defs_modified(SPObject *defs, guint flags); + + sigc::connection _connection_changed; + sigc::connection _connection_modified; + sigc::connection _connection_subselection_changed; + sigc::connection _connection_defs_release; + sigc::connection _connection_defs_modified; + +protected: + GradientToolbar(SPDesktop *desktop) + : Toolbar(desktop) + {} + +public: + static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); +}; -void sp_gradient_toolbox_prep(SPDesktop * /*desktop*/, GtkActionGroup* mainActions, GObject* holder); +} +} +} #endif /* !SEEN_GRADIENT_TOOLBAR_H */ diff --git a/src/ui/toolbar/lpe-toolbar.cpp b/src/ui/toolbar/lpe-toolbar.cpp index 8ed30d9ac..361144881 100644 --- a/src/ui/toolbar/lpe-toolbar.cpp +++ b/src/ui/toolbar/lpe-toolbar.cpp @@ -45,219 +45,30 @@ using Inkscape::DocumentUndo; using Inkscape::UI::Tools::ToolBase; using Inkscape::UI::Tools::LpeTool; - -//######################## -//## LPETool ## -//######################## - -// the subtools from which the toolbar is built automatically are listed in lpe-tool-context.h - -// this is called when the mode is changed via the toolbar (i.e., one of the subtool buttons is pressed) -static void sp_lpetool_mode_changed(GObject *tbl, int mode) -{ - using namespace Inkscape::LivePathEffect; - - SPDesktop *desktop = static_cast(g_object_get_data(tbl, "desktop")); - ToolBase *ec = desktop->event_context; - if (!SP_IS_LPETOOL_CONTEXT(ec)) { - return; - } - - // only take action if run by the attr_changed listener - if (!g_object_get_data(tbl, "freeze")) { - // in turn, prevent listener from responding - g_object_set_data(tbl, "freeze", GINT_TO_POINTER(TRUE)); - - EffectType type = lpesubtools[mode].type; - - LpeTool *lc = SP_LPETOOL_CONTEXT(desktop->event_context); - bool success = lpetool_try_construction(lc, type); - if (success) { - // since the construction was already performed, we set the state back to inactive - InkSelectOneAction* act = - static_cast( g_object_get_data( tbl, "lpetool_mode_action" ) ); - act->set_active(0); - mode = 0; - } else { - // switch to the chosen subtool - SP_LPETOOL_CONTEXT(desktop->event_context)->mode = type; - } - - if (DocumentUndo::getUndoSensitive(desktop->getDocument())) { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setInt( "/tools/lpetool/mode", mode ); - } - - g_object_set_data(tbl, "freeze", GINT_TO_POINTER(FALSE)); - } -} - -static void sp_lpetool_toolbox_sel_modified(Inkscape::Selection *selection, guint /*flags*/, GObject * /*tbl*/) -{ - ToolBase *ec = selection->desktop()->event_context; - if (SP_IS_LPETOOL_CONTEXT(ec)) { - lpetool_update_measuring_items(SP_LPETOOL_CONTEXT(ec)); - } -} - -static void sp_lpetool_toolbox_sel_changed(Inkscape::Selection *selection, GObject *tbl) -{ - using namespace Inkscape::LivePathEffect; - ToolBase *ec = selection->desktop()->event_context; - if (!SP_IS_LPETOOL_CONTEXT(ec)) { - return; - } - LpeTool *lc = SP_LPETOOL_CONTEXT(ec); - - lpetool_delete_measuring_items(lc); - lpetool_create_measuring_items(lc, selection); - - // activate line segment combo box if a single item with LPELineSegment is selected - InkSelectOneAction* act = - static_cast( g_object_get_data( tbl, "lpetool_line_segment_action" ) ); - - SPItem *item = selection->singleItem(); - if (item && SP_IS_LPE_ITEM(item) && lpetool_item_has_construction(lc, item)) { - - SPLPEItem *lpeitem = SP_LPE_ITEM(item); - Effect* lpe = lpeitem->getCurrentLPE(); - if (lpe && lpe->effectType() == LINE_SEGMENT) { - LPELineSegment *lpels = static_cast(lpe); - g_object_set_data(tbl, "currentlpe", lpe); - g_object_set_data(tbl, "currentlpeitem", lpeitem); - act->set_sensitive(true); - act->set_active( lpels->end_type.get_value() ); - } else { - g_object_set_data(tbl, "currentlpe", nullptr); - g_object_set_data(tbl, "currentlpeitem", nullptr); - act->set_sensitive(false); - } - - } else { - g_object_set_data(tbl, "currentlpe", nullptr); - g_object_set_data(tbl, "currentlpeitem", nullptr); - act->set_sensitive(false); - } -} - -static void lpetool_toggle_show_bbox(GtkToggleAction *act, gpointer data) { - SPDesktop *desktop = static_cast(data); - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - - bool show = gtk_toggle_action_get_active( act ); - prefs->setBool("/tools/lpetool/show_bbox", show); - - if (tools_isactive(desktop, TOOLS_LPETOOL)) { - LpeTool *lc = SP_LPETOOL_CONTEXT(desktop->event_context); - lpetool_context_reset_limiting_bbox(lc); - } -} - -static void lpetool_toggle_show_measuring_info(GtkToggleAction *act, GObject *tbl) -{ - SPDesktop *desktop = static_cast(g_object_get_data(tbl, "desktop")); - if (!tools_isactive(desktop, TOOLS_LPETOOL)) { - return; - } - - bool show = gtk_toggle_action_get_active( act ); - - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setBool("/tools/lpetool/show_measuring_info", show); - - LpeTool *lc = SP_LPETOOL_CONTEXT(desktop->event_context); - lpetool_show_measuring_info(lc, show); - - InkSelectOneAction* unitact = - static_cast(g_object_get_data(tbl, "lpetool_units_action")); - unitact->set_sensitive( show ); -} - -static void lpetool_unit_changed(GObject* tbl, int /* NotUsed */) -{ - UnitTracker* tracker = reinterpret_cast(g_object_get_data(tbl, "tracker")); - Unit const *unit = tracker->getActiveUnit(); - g_return_if_fail(unit != nullptr); - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setString("/tools/lpetool/unit", unit->abbr); - - SPDesktop *desktop = static_cast(g_object_get_data( tbl, "desktop" )); - if (SP_IS_LPETOOL_CONTEXT(desktop->event_context)) { - LpeTool *lc = SP_LPETOOL_CONTEXT(desktop->event_context); - lpetool_delete_measuring_items(lc); - lpetool_create_measuring_items(lc); - } -} - -static void lpetool_toggle_set_bbox(GtkToggleAction *act, gpointer data) -{ - SPDesktop *desktop = static_cast(data); - Inkscape::Selection *selection = desktop->selection; - - Geom::OptRect bbox = selection->visualBounds(); - - if (bbox) { - Geom::Point A(bbox->min()); - Geom::Point B(bbox->max()); - - A *= desktop->doc2dt(); - B *= desktop->doc2dt(); - - // TODO: should we provide a way to store points in prefs? - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble("/tools/lpetool/bbox_upperleftx", A[Geom::X]); - prefs->setDouble("/tools/lpetool/bbox_upperlefty", A[Geom::Y]); - prefs->setDouble("/tools/lpetool/bbox_lowerrightx", B[Geom::X]); - prefs->setDouble("/tools/lpetool/bbox_lowerrighty", B[Geom::Y]); - - lpetool_context_reset_limiting_bbox(SP_LPETOOL_CONTEXT(desktop->event_context)); - } - - gtk_toggle_action_set_active(act, false); -} - -static void sp_lpetool_change_line_segment_type(GObject* tbl, int mode) +namespace Inkscape { +namespace UI { +namespace Toolbar { +LPEToolbar::LPEToolbar(SPDesktop *desktop) + : Toolbar(desktop), + _tracker(new UnitTracker(Util::UNIT_TYPE_LINEAR)), + _freeze(false), + _currentlpe(nullptr), + _currentlpeitem(nullptr) { - using namespace Inkscape::LivePathEffect; - - // quit if run by the attr_changed listener - if (g_object_get_data(tbl, "freeze")) { - return; - } - - // in turn, prevent listener from responding - g_object_set_data(tbl, "freeze", GINT_TO_POINTER(TRUE)); - - LPELineSegment *lpe = static_cast(g_object_get_data(tbl, "currentlpe")); - SPLPEItem *lpeitem = static_cast(g_object_get_data(tbl, "currentlpeitem")); - if (lpeitem) { - SPLPEItem *lpeitem = static_cast(g_object_get_data(tbl, "currentlpeitem")); - lpe->end_type.param_set_value(static_cast(mode)); - sp_lpe_item_update_patheffect(lpeitem, true, true); - } - - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + _tracker->setActiveUnit(_desktop->getNamedView()->display_units); } -static void lpetool_open_lpe_dialog(GtkToggleAction *act, gpointer data) +LPEToolbar::~LPEToolbar() { - SPDesktop *desktop = static_cast(data); - - if (tools_isactive(desktop, TOOLS_LPETOOL)) { - sp_action_perform(Inkscape::Verb::get(SP_VERB_DIALOG_LIVE_PATH_EFFECT)->get_action(Inkscape::ActionContext(desktop)), nullptr); - } - gtk_toggle_action_set_active(act, false); + delete _tracker; } -static void lpetool_toolbox_watch_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder); - -void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) +GtkWidget * +LPEToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) { - UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR); - tracker->setActiveUnit(desktop->getNamedView()->display_units); - g_object_set_data(holder, "tracker", tracker); - Unit const *unit = tracker->getActiveUnit(); - g_return_if_fail(unit != nullptr); + auto toolbar = new LPEToolbar(desktop); + Unit const *unit = toolbar->_tracker->getActiveUnit(); + g_return_val_if_fail(unit != nullptr, nullptr); Inkscape::Preferences *prefs = Inkscape::Preferences::get(); prefs->setString("/tools/lpetool/unit", unit->abbr); @@ -289,23 +100,22 @@ void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GO row[columns.col_sensitive] = true; } - InkSelectOneAction* act = + toolbar->_mode_action = InkSelectOneAction::create( "LPEToolModeAction", // Name (""), // Label (""), // Tooltip "Not Used", // Icon store ); // Tree store - act->use_radio( true ); - act->use_icon( true ); - act->use_label( false ); + toolbar->_mode_action->use_radio( true ); + toolbar->_mode_action->use_icon( true ); + toolbar->_mode_action->use_label( false ); int mode = prefs->getInt("/tools/lpetool/mode", 0); - act->set_active( mode ); + toolbar->_mode_action->set_active( mode ); - gtk_action_group_add_action( mainActions, act->gobj() ); - g_object_set_data( holder, "lpetool_mode_action", act ); + gtk_action_group_add_action( mainActions, toolbar->_mode_action->gobj() ); - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_lpetool_mode_changed), holder)); + toolbar->_mode_action->signal_changed().connect(sigc::mem_fun(*toolbar, &LPEToolbar::mode_changed)); } /* Show limiting bounding box */ @@ -316,7 +126,7 @@ void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GO "show-bounding-box", GTK_ICON_SIZE_MENU ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(lpetool_toggle_show_bbox), desktop ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_show_bbox), desktop ); gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool( "/tools/lpetool/show_bbox", true ) ); } @@ -328,11 +138,10 @@ void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GO "draw-geometry-set-bounding-box", GTK_ICON_SIZE_MENU ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(lpetool_toggle_set_bbox), desktop ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_set_bbox), desktop ); gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), FALSE ); } - /* Combo box to choose line segment type */ { InkSelectOneActionColumns columns; @@ -365,22 +174,21 @@ void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GO row[columns.col_icon ] = "NotUsed"; row[columns.col_sensitive] = true; - InkSelectOneAction* act = + toolbar->_line_segment_action = InkSelectOneAction::create( "LPELineSegmentAction", // Name (""), // Label _("Choose a line segment type"), // Tooltip "Not Used", // Icon store ); // Tree store - act->use_radio( false ); - act->use_icon( false ); - act->use_label( true ); - act->set_sensitive( false ); + toolbar->_line_segment_action->use_radio( false ); + toolbar->_line_segment_action->use_icon( false ); + toolbar->_line_segment_action->use_label( true ); + toolbar->_line_segment_action->set_sensitive( false ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data (holder, "lpetool_line_segment_action", act ); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_line_segment_action->gobj() )); - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(sp_lpetool_change_line_segment_type), holder)); + toolbar->_line_segment_action->signal_changed().connect(sigc::mem_fun(*toolbar, &LPEToolbar::change_line_segment_type)); } /* Display measuring info for selected items */ @@ -391,17 +199,16 @@ void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GO "draw-geometry-show-measuring-info", GTK_ICON_SIZE_MENU ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(lpetool_toggle_show_measuring_info), holder ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(toggle_show_measuring_info), toolbar ); gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool( "/tools/lpetool/show_measuring_info", true ) ); } // Add the units menu { - InkSelectOneAction* act = tracker->createAction( "LPEToolUnitsAction", _("Units"), ("") ); - gtk_action_group_add_action( mainActions, act->gobj() ); - act->signal_changed_after().connect(sigc::bind<0>(sigc::ptr_fun(&lpetool_unit_changed), holder)); - g_object_set_data(holder, "lpetool_units_action", act); - act->set_sensitive( prefs->getBool("/tools/lpetool/show_measuring_info", true)); + toolbar->_units_action = toolbar->_tracker->createAction( "LPEToolUnitsAction", _("Units"), ("") ); + gtk_action_group_add_action( mainActions, toolbar->_units_action->gobj() ); + toolbar->_units_action->signal_changed_after().connect(sigc::mem_fun(*toolbar, &LPEToolbar::unit_changed)); + toolbar->_units_action->set_sensitive( prefs->getBool("/tools/lpetool/show_measuring_info", true)); } /* Open LPE dialog (to adapt parameters numerically) */ @@ -412,23 +219,171 @@ void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GO "dialog-geometry", GTK_ICON_SIZE_MENU ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(lpetool_open_lpe_dialog), desktop ); + g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(open_lpe_dialog), desktop ); gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), FALSE ); } - desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(lpetool_toolbox_watch_ec), holder)); + desktop->connectEventContextChanged(sigc::mem_fun(*toolbar, &LPEToolbar::watch_ec)); + + return GTK_WIDGET(toolbar->gobj()); } -static void lpetool_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec, GObject* holder) +// this is called when the mode is changed via the toolbar (i.e., one of the subtool buttons is pressed) +void +LPEToolbar::mode_changed(int mode) { - static sigc::connection c_selection_modified; - static sigc::connection c_selection_changed; + using namespace Inkscape::LivePathEffect; + + ToolBase *ec = _desktop->event_context; + if (!SP_IS_LPETOOL_CONTEXT(ec)) { + return; + } + + // only take action if run by the attr_changed listener + if (!_freeze) { + // in turn, prevent listener from responding + _freeze = true; + + EffectType type = lpesubtools[mode].type; + + LpeTool *lc = SP_LPETOOL_CONTEXT(_desktop->event_context); + bool success = lpetool_try_construction(lc, type); + if (success) { + // since the construction was already performed, we set the state back to inactive + _mode_action->set_active(0); + mode = 0; + } else { + // switch to the chosen subtool + SP_LPETOOL_CONTEXT(_desktop->event_context)->mode = type; + } + + if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) { + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setInt( "/tools/lpetool/mode", mode ); + } + + _freeze = false; + } +} + +void +LPEToolbar::toggle_show_bbox(GtkToggleAction *act, gpointer data) { + SPDesktop *desktop = static_cast(data); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + + bool show = gtk_toggle_action_get_active( act ); + prefs->setBool("/tools/lpetool/show_bbox", show); + + if (tools_isactive(desktop, TOOLS_LPETOOL)) { + LpeTool *lc = SP_LPETOOL_CONTEXT(desktop->event_context); + lpetool_context_reset_limiting_bbox(lc); + } +} + +void +LPEToolbar::toggle_set_bbox(GtkToggleAction *act, gpointer data) +{ + SPDesktop *desktop = static_cast(data); + Inkscape::Selection *selection = desktop->selection; + + Geom::OptRect bbox = selection->visualBounds(); + + if (bbox) { + Geom::Point A(bbox->min()); + Geom::Point B(bbox->max()); + + A *= desktop->doc2dt(); + B *= desktop->doc2dt(); + + // TODO: should we provide a way to store points in prefs? + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble("/tools/lpetool/bbox_upperleftx", A[Geom::X]); + prefs->setDouble("/tools/lpetool/bbox_upperlefty", A[Geom::Y]); + prefs->setDouble("/tools/lpetool/bbox_lowerrightx", B[Geom::X]); + prefs->setDouble("/tools/lpetool/bbox_lowerrighty", B[Geom::Y]); + + lpetool_context_reset_limiting_bbox(SP_LPETOOL_CONTEXT(desktop->event_context)); + } + + gtk_toggle_action_set_active(act, false); +} + +void +LPEToolbar::change_line_segment_type(int mode) +{ + using namespace Inkscape::LivePathEffect; + + // quit if run by the attr_changed listener + if (_freeze) { + return; + } + + // in turn, prevent listener from responding + _freeze = true; + auto line_seg = dynamic_cast(_currentlpe); + + if (_currentlpeitem && line_seg) { + line_seg->end_type.param_set_value(static_cast(mode)); + sp_lpe_item_update_patheffect(_currentlpeitem, true, true); + } + _freeze = false; +} + +void +LPEToolbar::toggle_show_measuring_info(GtkToggleAction *act, gpointer data) +{ + auto toolbar = reinterpret_cast(data); + + if (!tools_isactive(toolbar->_desktop, TOOLS_LPETOOL)) { + return; + } + + bool show = gtk_toggle_action_get_active( act ); + + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setBool("/tools/lpetool/show_measuring_info", show); + + LpeTool *lc = SP_LPETOOL_CONTEXT(toolbar->_desktop->event_context); + lpetool_show_measuring_info(lc, show); + + toolbar->_units_action->set_sensitive( show ); +} + +void +LPEToolbar::unit_changed(int /* NotUsed */) +{ + Unit const *unit = _tracker->getActiveUnit(); + g_return_if_fail(unit != nullptr); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setString("/tools/lpetool/unit", unit->abbr); + + if (SP_IS_LPETOOL_CONTEXT(_desktop->event_context)) { + LpeTool *lc = SP_LPETOOL_CONTEXT(_desktop->event_context); + lpetool_delete_measuring_items(lc); + lpetool_create_measuring_items(lc); + } +} + +void +LPEToolbar::open_lpe_dialog(GtkToggleAction *act, gpointer data) +{ + SPDesktop *desktop = static_cast(data); + + if (tools_isactive(desktop, TOOLS_LPETOOL)) { + sp_action_perform(Inkscape::Verb::get(SP_VERB_DIALOG_LIVE_PATH_EFFECT)->get_action(Inkscape::ActionContext(desktop)), nullptr); + } + gtk_toggle_action_set_active(act, false); +} + +void +LPEToolbar::watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec) +{ if (SP_IS_LPETOOL_CONTEXT(ec)) { // Watch selection - c_selection_modified = desktop->getSelection()->connectModified(sigc::bind(sigc::ptr_fun(sp_lpetool_toolbox_sel_modified), holder)); - c_selection_changed = desktop->getSelection()->connectChanged(sigc::bind(sigc::ptr_fun(sp_lpetool_toolbox_sel_changed), holder)); - sp_lpetool_toolbox_sel_changed(desktop->getSelection(), holder); + c_selection_modified = desktop->getSelection()->connectModified(sigc::mem_fun(*this, &LPEToolbar::sel_modified)); + c_selection_changed = desktop->getSelection()->connectChanged(sigc::mem_fun(*this, &LPEToolbar::sel_changed)); + sel_changed(desktop->getSelection()); } else { if (c_selection_modified) c_selection_modified.disconnect(); @@ -437,6 +392,57 @@ static void lpetool_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::To } } +void +LPEToolbar::sel_modified(Inkscape::Selection *selection, guint /*flags*/) +{ + ToolBase *ec = selection->desktop()->event_context; + if (SP_IS_LPETOOL_CONTEXT(ec)) { + lpetool_update_measuring_items(SP_LPETOOL_CONTEXT(ec)); + } +} + +void +LPEToolbar::sel_changed(Inkscape::Selection *selection) +{ + using namespace Inkscape::LivePathEffect; + ToolBase *ec = selection->desktop()->event_context; + if (!SP_IS_LPETOOL_CONTEXT(ec)) { + return; + } + LpeTool *lc = SP_LPETOOL_CONTEXT(ec); + + lpetool_delete_measuring_items(lc); + lpetool_create_measuring_items(lc, selection); + + // activate line segment combo box if a single item with LPELineSegment is selected + SPItem *item = selection->singleItem(); + if (item && SP_IS_LPE_ITEM(item) && lpetool_item_has_construction(lc, item)) { + + SPLPEItem *lpeitem = SP_LPE_ITEM(item); + Effect* lpe = lpeitem->getCurrentLPE(); + if (lpe && lpe->effectType() == LINE_SEGMENT) { + LPELineSegment *lpels = static_cast(lpe); + _currentlpe = lpe; + _currentlpeitem = lpeitem; + _line_segment_action->set_sensitive(true); + _line_segment_action->set_active( lpels->end_type.get_value() ); + } else { + _currentlpe = nullptr; + _currentlpeitem = nullptr; + _line_segment_action->set_sensitive(false); + } + + } else { + _currentlpe = nullptr; + _currentlpeitem = nullptr; + _line_segment_action->set_sensitive(false); + } +} + +} +} +} + /* Local Variables: mode:c++ diff --git a/src/ui/toolbar/lpe-toolbar.h b/src/ui/toolbar/lpe-toolbar.h index 4ceada774..5e5187a07 100644 --- a/src/ui/toolbar/lpe-toolbar.h +++ b/src/ui/toolbar/lpe-toolbar.h @@ -28,11 +28,70 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" + +class InkSelectOneAction; class SPDesktop; +class SPLPEItem; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; -void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +namespace Inkscape { +namespace LivePathEffect { +class Effect; +} + +namespace UI { +namespace Tools { +class ToolBase; +} + +namespace Widget { +class UnitTracker; +} + +namespace Toolbar { +class LPEToolbar : public Toolbar { +private: + UI::Widget::UnitTracker *_tracker; + InkSelectOneAction *_mode_action; + InkSelectOneAction *_line_segment_action; + InkSelectOneAction *_units_action; + + bool _freeze; + + LivePathEffect::Effect *_currentlpe; + SPLPEItem *_currentlpeitem; + + sigc::connection c_selection_modified; + sigc::connection c_selection_changed; + + void mode_changed(int mode); + void unit_changed(int not_used); + void sel_modified(Inkscape::Selection *selection, guint flags); + void sel_changed(Inkscape::Selection *selection); + void change_line_segment_type(int mode); + void watch_ec(SPDesktop* desktop, UI::Tools::ToolBase* ec); + + static void toggle_show_bbox(GtkToggleAction *act, + gpointer data); + static void toggle_set_bbox(GtkToggleAction *act, + gpointer data); + static void toggle_show_measuring_info(GtkToggleAction *act, + gpointer data); + static void open_lpe_dialog(GtkToggleAction *act, + gpointer data); + +protected: + LPEToolbar(SPDesktop *desktop); + ~LPEToolbar(); + +public: + static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); +}; + +} +} +} #endif /* !SEEN_LPE_TOOLBAR_H */ diff --git a/src/ui/toolbar/measure-toolbar.cpp b/src/ui/toolbar/measure-toolbar.cpp index fa0d8827e..f16b1fdb6 100644 --- a/src/ui/toolbar/measure-toolbar.cpp +++ b/src/ui/toolbar/measure-toolbar.cpp @@ -25,10 +25,10 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ -#include - #include "measure-toolbar.h" +#include + #include "desktop.h" #include "document-undo.h" #include "widgets/ink-action.h" @@ -70,81 +70,8 @@ static MeasureTool *get_measure_tool() return tool; } -static void -sp_measure_fontsize_value_changed(GtkAdjustment *adj, GObject *tbl) -{ - SPDesktop *desktop = static_cast(g_object_get_data( tbl, "desktop" )); - - if (DocumentUndo::getUndoSensitive(desktop->getDocument())) { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble(Glib::ustring("/tools/measure/fontsize"), - gtk_adjustment_get_value(adj)); - MeasureTool *mt = get_measure_tool(); - if (mt) { - mt->showCanvasItems(); - } - } -} - -static void -sp_measure_offset_value_changed(GtkAdjustment *adj, GObject *tbl) -{ - SPDesktop *desktop = static_cast(g_object_get_data( tbl, "desktop" )); - - if (DocumentUndo::getUndoSensitive(desktop->getDocument())) { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble(Glib::ustring("/tools/measure/offset"), - gtk_adjustment_get_value(adj)); - MeasureTool *mt = get_measure_tool(); - if (mt) { - mt->showCanvasItems(); - } - } -} - -static void sp_measure_scale_value_changed(GtkAdjustment *adj, GObject *tbl) -{ - SPDesktop *desktop = static_cast(g_object_get_data( tbl, "desktop" )); - - if (DocumentUndo::getUndoSensitive(desktop->getDocument())) { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble(Glib::ustring("/tools/measure/scale"), - gtk_adjustment_get_value(adj)); - MeasureTool *mt = get_measure_tool(); - if (mt) { - mt->showCanvasItems(); - } - } -} - -static void -sp_measure_precision_value_changed(GtkAdjustment *adj, GObject *tbl) -{ - SPDesktop *desktop = static_cast(g_object_get_data( tbl, "desktop" )); - if (DocumentUndo::getUndoSensitive(desktop->getDocument())) { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setInt(Glib::ustring("/tools/measure/precision"), - gtk_adjustment_get_value(adj)); - MeasureTool *mt = get_measure_tool(); - if (mt) { - mt->showCanvasItems(); - } - } -} -static void -sp_measure_unit_changed(GObject* tbl, int /* notUsed */) -{ - UnitTracker* tracker = reinterpret_cast(g_object_get_data(tbl, "tracker")); - Glib::ustring const unit = tracker->getActiveUnit()->abbr; - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setString("/tools/measure/unit", unit); - MeasureTool *mt = get_measure_tool(); - if (mt) { - mt->showCanvasItems(); - } -} static void sp_toggle_ignore_1st_and_last( GtkToggleAction* act, gpointer data ) @@ -275,13 +202,21 @@ sp_to_item(){ } } -void sp_measure_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObject* holder) +namespace Inkscape { +namespace UI { +namespace Toolbar { +MeasureToolbar::MeasureToolbar(SPDesktop *desktop) + : Toolbar(desktop), + _tracker(new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR)) +{} + +GtkWidget * +MeasureToolbar::prep(SPDesktop * desktop, GtkActionGroup* mainActions) { - UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR); + auto holder = new MeasureToolbar(desktop); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - tracker->setActiveUnitByAbbr(prefs->getString("/tools/measure/unit").c_str()); - - g_object_set_data( holder, "tracker", tracker ); + holder->_tracker->setActiveUnitByAbbr(prefs->getString("/tools/measure/unit").c_str()); EgeAdjustmentAction *eact = nullptr; GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); @@ -292,10 +227,15 @@ void sp_measure_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, G _("Font Size"), _("Font Size:"), _("The font size to be used in the measurement labels"), "/tools/measure/fontsize", 10.0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, 1.0, 36.0, 1.0, 4.0, nullptr, nullptr, 0, - sp_measure_fontsize_value_changed, nullptr, 0 , 2); + nullptr, // callback + nullptr, 0 , 2); + holder->_font_size_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + holder->_font_size_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &MeasureToolbar::fontsize_value_changed)); gtk_action_group_add_action( mainActions, GTK_ACTION(eact)); } @@ -309,8 +249,8 @@ void sp_measure_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, G /* units menu */ { - InkSelectOneAction* act = tracker->createAction( "MeasureUnitsAction", _("Units:"), _("The units to be used for the measurements") ); - act->signal_changed_after().connect(sigc::bind<0>(sigc::ptr_fun(&sp_measure_unit_changed), holder)); + InkSelectOneAction* act = holder->_tracker->createAction( "MeasureUnitsAction", _("Units:"), _("The units to be used for the measurements") ); + act->signal_changed_after().connect(sigc::mem_fun(*holder, &MeasureToolbar::unit_changed)); gtk_action_group_add_action( mainActions, act->gobj() ); } @@ -320,10 +260,15 @@ void sp_measure_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, G _("Precision"), _("Precision:"), _("Decimal precision of measure"), "/tools/measure/precision", 2, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, 0, 10, 1, 0, nullptr, nullptr, 0, - sp_measure_precision_value_changed, nullptr, 0 ,0); + nullptr, // callback + nullptr, 0 ,0); + holder->_precision_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + holder->_precision_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &MeasureToolbar::precision_value_changed)); gtk_action_group_add_action( mainActions, GTK_ACTION(eact)); } @@ -333,10 +278,15 @@ void sp_measure_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, G _("Scale %"), _("Scale %:"), _("Scale the results"), "/tools/measure/scale", 100.0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, 0.0, 90000.0, 1.0, 4.0, nullptr, nullptr, 0, - sp_measure_scale_value_changed, nullptr, 0 , 3); + nullptr, // callback + nullptr, 0 , 3); + holder->_scale_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + holder->_scale_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &MeasureToolbar::scale_value_changed)); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); } @@ -346,10 +296,15 @@ void sp_measure_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, G _("Offset"), _("Offset:"), _("Mark dimension offset"), "/tools/measure/offset", 5.0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, 0.0, 90000.0, 1.0, 4.0, nullptr, nullptr, 0, - sp_measure_offset_value_changed, nullptr, 0 , 2); + nullptr, // callback + nullptr, 0 , 2); + holder->_offset_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + holder->_offset_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &MeasureToolbar::offset_value_changed)); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); } @@ -459,7 +414,81 @@ void sp_measure_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, G g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(sp_to_item), 0 ); gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); } -} // end of sp_measure_toolbox_prep() + + return GTK_WIDGET(holder->gobj()); +} // MeasureToolbar::prep() + +void +MeasureToolbar::fontsize_value_changed() +{ + if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) { + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble(Glib::ustring("/tools/measure/fontsize"), + _font_size_adj->get_value()); + MeasureTool *mt = get_measure_tool(); + if (mt) { + mt->showCanvasItems(); + } + } +} + +void +MeasureToolbar::unit_changed(int /* notUsed */) +{ + Glib::ustring const unit = _tracker->getActiveUnit()->abbr; + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setString("/tools/measure/unit", unit); + MeasureTool *mt = get_measure_tool(); + if (mt) { + mt->showCanvasItems(); + } +} + +void +MeasureToolbar::precision_value_changed() +{ + if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) { + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setInt(Glib::ustring("/tools/measure/precision"), + _precision_adj->get_value()); + MeasureTool *mt = get_measure_tool(); + if (mt) { + mt->showCanvasItems(); + } + } +} + +void +MeasureToolbar::scale_value_changed() +{ + if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) { + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble(Glib::ustring("/tools/measure/scale"), + _scale_adj->get_value()); + MeasureTool *mt = get_measure_tool(); + if (mt) { + mt->showCanvasItems(); + } + } +} + +void +MeasureToolbar::offset_value_changed() +{ + if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) { + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble(Glib::ustring("/tools/measure/offset"), + _offset_adj->get_value()); + MeasureTool *mt = get_measure_tool(); + if (mt) { + mt->showCanvasItems(); + } + } +} + +} +} +} /* diff --git a/src/ui/toolbar/measure-toolbar.h b/src/ui/toolbar/measure-toolbar.h index 9a03bb8c3..fd11ab425 100644 --- a/src/ui/toolbar/measure-toolbar.h +++ b/src/ui/toolbar/measure-toolbar.h @@ -4,7 +4,7 @@ /** * @file - * Measue aux toolbar + * Measure aux toolbar */ /* Authors: * MenTaLguY @@ -28,11 +28,44 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" + +#include + class SPDesktop; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; -void sp_measure_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +namespace Inkscape { +namespace UI { +namespace Widget { +class UnitTracker; +} + +namespace Toolbar { +class MeasureToolbar : public Toolbar { +private: + UI::Widget::UnitTracker *_tracker; + Glib::RefPtr _font_size_adj; + Glib::RefPtr _precision_adj; + Glib::RefPtr _scale_adj; + Glib::RefPtr _offset_adj; + + void fontsize_value_changed(); + void unit_changed(int notUsed); + void precision_value_changed(); + void scale_value_changed(); + void offset_value_changed(); + +protected: + MeasureToolbar(SPDesktop *desktop); + +public: + static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); +}; + +} +} +} #endif /* !SEEN_MEASURE_TOOLBAR_H */ diff --git a/src/ui/toolbar/mesh-toolbar.cpp b/src/ui/toolbar/mesh-toolbar.cpp index b3f37f3e5..2345a16ba 100644 --- a/src/ui/toolbar/mesh-toolbar.cpp +++ b/src/ui/toolbar/mesh-toolbar.cpp @@ -133,143 +133,11 @@ void ms_read_selection( Inkscape::Selection *selection, } } -/* - * Core function, setup all the widgets whenever something changes on the desktop - */ -static void ms_tb_selection_changed(Inkscape::Selection * /*selection*/, gpointer data) -{ - - // std::cout << "ms_tb_selection_changed" << std::endl; - - if (blocked) - return; - - SPDesktop *desktop = static_cast(g_object_get_data(G_OBJECT(data), "desktop")); - if (!desktop) { - return; - } - - Inkscape::Selection *selection = desktop->getSelection(); // take from desktop, not from args - if (selection) { - // ToolBase *ev = sp_desktop_event_context(desktop); - // GrDrag *drag = NULL; - // if (ev) { - // drag = ev->get_drag(); - // // Hide/show handles? - // } - - SPMeshGradient *ms_selected = nullptr; - SPMeshType ms_type = SP_MESH_TYPE_COONS; - bool ms_selected_multi = false; - bool ms_type_multi = false; - ms_read_selection( selection, ms_selected, ms_selected_multi, ms_type, ms_type_multi ); - // std::cout << " type: " << ms_type << std::endl; - - InkSelectOneAction* type = static_cast (g_object_get_data(G_OBJECT(data), "mesh_select_type_action")); - if (type) { - type->set_sensitive(!ms_type_multi); - blocked = TRUE; - type->set_active(ms_type); - blocked = FALSE; - } - } -} - - -static void ms_tb_selection_modified(Inkscape::Selection *selection, guint /*flags*/, gpointer data) -{ - ms_tb_selection_changed(selection, data); -} - -static void ms_drag_selection_changed(gpointer /*dragger*/, gpointer data) -{ - ms_tb_selection_changed(nullptr, data); - -} - -static void ms_defs_release(SPObject * /*defs*/, GObject *widget) -{ - ms_tb_selection_changed(nullptr, widget); -} - -static void ms_defs_modified(SPObject * /*defs*/, guint /*flags*/, GObject *widget) -{ - ms_tb_selection_changed(nullptr, widget); -} /* * Callback functions for user actions */ -static void ms_new_geometry_changed( GObject * /*tbl*/, int mode ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setInt("/tools/mesh/mesh_geometry", mode); -} - -static void ms_new_fillstroke_changed( GObject * /*tbl*/, int mode ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setInt("/tools/mesh/newfillorstroke", mode); -} - -static void ms_row_changed(GtkAdjustment *adj, GObject * /*tbl*/ ) -{ - if (blocked) { - return; - } - - blocked = TRUE; - - int rows = gtk_adjustment_get_value(adj); - - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - - prefs->setInt("/tools/mesh/mesh_rows", rows); - - blocked = FALSE; -} - -static void ms_col_changed(GtkAdjustment *adj, GObject * /*tbl*/ ) -{ - if (blocked) { - return; - } - - blocked = TRUE; - - int cols = gtk_adjustment_get_value(adj); - - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - - prefs->setInt("/tools/mesh/mesh_cols", cols); - - blocked = FALSE; -} - -/** - * Sets mesh type: Coons, Bicubic - */ -static void ms_type_changed( GObject *tbl, int mode ) -{ - if (blocked) { - return; - } - - SPDesktop *desktop = static_cast(g_object_get_data(tbl, "desktop")); - Inkscape::Selection *selection = desktop->getSelection(); - std::vector meshes = ms_get_dt_selected_gradients(selection); - - SPMeshType type = (SPMeshType) mode; - for (auto & meshe : meshes) { - meshe->type = type; - meshe->type_set = true; - meshe->updateRepr(); - } - if (!meshes.empty() ) { - DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_MESH,_("Set mesh type")); - } -} /** Temporary hack: Returns the mesh tool in the active desktop. * Will go away during tool refactoring. */ @@ -317,50 +185,30 @@ static void ms_fit_mesh() } } -static void ms_toggle_handles() -{ - MeshTool *mt = get_mesh_tool(); - if (mt) { - GrDrag *drag = mt->_grdrag; - drag->refreshDraggers(); - } -} -static void ms_toggle_fill_stroke(InkToggleAction * /*act*/, gpointer data) -{ - MeshTool *mt = get_mesh_tool(); - if (mt) { - GrDrag *drag = mt->_grdrag; - drag->updateDraggers(); - drag->updateLines(); - drag->updateLevels(); - ms_tb_selection_changed(nullptr, data); // Need to update Type widget - } -} +static void mesh_toolbox_watch_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder); -static void ms_warning_popup() -{ - char *msg = _("Mesh gradients are part of SVG 2:\n" - "* Syntax may change.\n" - "* Web browser implementation is not guaranteed.\n" - "\n" - "For web: convert to bitmap (Edit->Make bitmap copy).\n" - "For print: export to PDF."); - Gtk::MessageDialog dialog(msg, false, Gtk::MESSAGE_WARNING, - Gtk::BUTTONS_OK, true); - dialog.run(); +namespace Inkscape { +namespace UI { +namespace Toolbar { +MeshToolbar::~MeshToolbar() +{ + if(_edit_fill_pusher) delete _edit_fill_pusher; + if(_edit_stroke_pusher) delete _edit_stroke_pusher; + if(_show_handles_pusher) delete _show_handles_pusher; } -static void mesh_toolbox_watch_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder); - /** * Mesh auxiliary toolbar construction and setup. * Don't forget to add to XML in widgets/toolbox.cpp! * */ -void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObject* holder) +GtkWidget * +MeshToolbar::prep(SPDesktop * desktop, GtkActionGroup* mainActions) { + auto toolbar = new MeshToolbar(desktop); + GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); EgeAdjustmentAction* eact = nullptr; @@ -387,22 +235,21 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj row[columns.col_icon ] = INKSCAPE_ICON("paint-gradient-conical"); row[columns.col_sensitive] = true; - InkSelectOneAction* act = + toolbar->_new_type_mode = InkSelectOneAction::create( "MeshNewTypeAction", // Name _("New:"), // Label "", // Tooltip "Not Used", // Icon store ); // Tree store - act->use_radio( true ); - act->use_group_label( true ); + toolbar->_new_type_mode->use_radio( true ); + toolbar->_new_type_mode->use_group_label( true ); gint mode = prefs->getInt("/tools/mesh/mesh_geometry", SP_MESH_GEOMETRY_NORMAL); - act->set_active( mode ); + toolbar->_new_type_mode->set_active( mode ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( holder, "mesh_new_type_mode", act ); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_new_type_mode->gobj() )); - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&ms_new_geometry_changed), holder)); + toolbar->_new_type_mode->signal_changed().connect(sigc::mem_fun(*toolbar, &MeshToolbar::new_geometry_changed)); } /* New gradient on fill or stroke*/ @@ -425,22 +272,21 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj row[columns.col_icon ] = INKSCAPE_ICON("object-stroke"); row[columns.col_sensitive] = true; - InkSelectOneAction* act = + toolbar->_new_fillstroke_mode = InkSelectOneAction::create( "MeshNewFillStrokeAction", // Name "", // Label "", // Tooltip "Not Used", // Icon store ); // Tree store - act->use_radio( true ); - act->use_group_label( false ); + toolbar->_new_fillstroke_mode->use_radio( true ); + toolbar->_new_fillstroke_mode->use_group_label( false ); gint mode = prefs->getInt("/tools/mesh/newfillorstroke"); - act->set_active( mode ); + toolbar->_new_fillstroke_mode->set_active( mode ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( holder, "mesh_new_type_mode", act ); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_new_fillstroke_mode->gobj() )); - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&ms_new_fillstroke_changed), holder)); + toolbar->_new_fillstroke_mode->signal_changed().connect(sigc::mem_fun(*toolbar, &MeshToolbar::new_fillstroke_changed)); } /* Number of mesh rows */ @@ -450,11 +296,16 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj eact = create_adjustment_action( "MeshRowAction", _("Rows"), _("Rows:"), _("Number of rows in new mesh"), "/tools/mesh/mesh_rows", 1, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, 1, 20, 1, 1, labels, values, 0, - ms_row_changed, nullptr /*unit tracker*/, + nullptr, // callback + nullptr /*unit tracker*/, 1.0, 0 ); + toolbar->_row_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + toolbar->_row_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &MeshToolbar::row_changed)); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); } @@ -466,11 +317,16 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj eact = create_adjustment_action( "MeshColumnAction", _("Columns"), _("Columns:"), _("Number of columns in new mesh"), "/tools/mesh/mesh_cols", 1, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, 1, 20, 1, 1, labels, values, 0, - ms_col_changed, nullptr /*unit tracker*/, + nullptr, // callback + nullptr /*unit tracker*/, 1.0, 0 ); + toolbar->_col_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + toolbar->_col_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &MeshToolbar::col_changed)); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); } @@ -483,9 +339,8 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj INKSCAPE_ICON("object-fill"), secondarySize ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/mesh/edit_fill"); - g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher); - g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(ms_toggle_fill_stroke), holder); + toolbar->_edit_fill_pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/mesh/edit_fill"); + g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(toggle_fill_stroke), (gpointer)toolbar); } /* Edit stroke mesh */ @@ -496,9 +351,8 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj INKSCAPE_ICON("object-stroke"), secondarySize ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/mesh/edit_stroke"); - g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher); - g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(ms_toggle_fill_stroke), holder); + toolbar->_edit_stroke_pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/mesh/edit_stroke"); + g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(toggle_fill_stroke), (gpointer)toolbar); } /* Show/hide side and tensor handles */ @@ -509,14 +363,11 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj INKSCAPE_ICON("show-node-handles"), secondarySize ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/mesh/show_handles"); - g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher); - g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(ms_toggle_handles), 0); + toolbar->_show_handles_pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/mesh/show_handles"); + g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(toggle_handles), nullptr); } - g_object_set_data(holder, "desktop", desktop); - - desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(mesh_toolbox_watch_ec), holder)); + desktop->connectEventContextChanged(sigc::mem_fun(*toolbar, &MeshToolbar::watch_ec)); /* Warning */ { @@ -526,7 +377,7 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj INKSCAPE_ICON("dialog-warning"), secondarySize ); gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); - g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(ms_warning_popup), holder ); + g_signal_connect_after( G_OBJECT(act), "activate", G_CALLBACK(warning_popup), (gpointer)toolbar ); gtk_action_set_sensitive( GTK_ACTION(act), TRUE ); } @@ -551,24 +402,23 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj row[columns.col_sensitive] = true; // TRANSLATORS: Type of Smoothing. See https://en.wikipedia.org/wiki/Coons_patch - InkSelectOneAction* act = + toolbar->_select_type_action = InkSelectOneAction::create( "MeshSmoothAction", // Name _("Smoothing"), // Label _("Coons: no smothing. Bicubic: smothing across patch boundaries."), // Tooltip "Not Used", // Icon store ); // Tree store - act->use_radio( false ); - act->use_label( true ); - act->use_icon( false ); - act->use_group_label( true ); - act->set_sensitive( false ); - act->set_active( 0 ); + toolbar->_select_type_action->use_radio( false ); + toolbar->_select_type_action->use_label( true ); + toolbar->_select_type_action->use_icon( false ); + toolbar->_select_type_action->use_group_label( true ); + toolbar->_select_type_action->set_sensitive( false ); + toolbar->_select_type_action->set_active( 0 ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( holder, "mesh_select_type_action", act ); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_select_type_action->gobj() )); - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&ms_type_changed), holder)); + toolbar->_select_type_action->signal_changed().connect(sigc::mem_fun(*toolbar, &MeshToolbar::type_changed)); } { @@ -616,28 +466,98 @@ void sp_mesh_toolbox_prep(SPDesktop * desktop, GtkActionGroup* mainActions, GObj gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); } + return GTK_WIDGET(toolbar->gobj()); } -static void mesh_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec, GObject* holder) +void +MeshToolbar::new_geometry_changed(int mode) { - static sigc::connection c_selection_changed; - static sigc::connection c_selection_modified; - static sigc::connection c_subselection_changed; - static sigc::connection c_defs_release; - static sigc::connection c_defs_modified; + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setInt("/tools/mesh/mesh_geometry", mode); +} + +void +MeshToolbar::new_fillstroke_changed(int mode) +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setInt("/tools/mesh/newfillorstroke", mode); +} + +void +MeshToolbar::row_changed() +{ + if (blocked) { + return; + } + + blocked = TRUE; + int rows = _row_adj->get_value(); + + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + + prefs->setInt("/tools/mesh/mesh_rows", rows); + + blocked = FALSE; +} + +void +MeshToolbar::col_changed() +{ + if (blocked) { + return; + } + + blocked = TRUE; + + int cols = _col_adj->get_value(); + + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + + prefs->setInt("/tools/mesh/mesh_cols", cols); + + blocked = FALSE; +} + +void +MeshToolbar::toggle_fill_stroke(InkToggleAction * /*act*/, gpointer data) +{ + auto toolbar = reinterpret_cast(data); + MeshTool *mt = get_mesh_tool(); + if (mt) { + GrDrag *drag = mt->_grdrag; + drag->updateDraggers(); + drag->updateLines(); + drag->updateLevels(); + toolbar->selection_changed(nullptr); // Need to update Type widget + } +} + +void +MeshToolbar::toggle_handles() +{ + MeshTool *mt = get_mesh_tool(); + if (mt) { + GrDrag *drag = mt->_grdrag; + drag->refreshDraggers(); + } +} + +void +MeshToolbar::watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec) +{ if (SP_IS_MESH_CONTEXT(ec)) { // connect to selection modified and changed signals Inkscape::Selection *selection = desktop->getSelection(); SPDocument *document = desktop->getDocument(); - c_selection_changed = selection->connectChanged(sigc::bind(sigc::ptr_fun(&ms_tb_selection_changed), holder)); - c_selection_modified = selection->connectModified(sigc::bind(sigc::ptr_fun(&ms_tb_selection_modified), holder)); - c_subselection_changed = desktop->connectToolSubselectionChanged(sigc::bind(sigc::ptr_fun(&ms_drag_selection_changed), holder)); + c_selection_changed = selection->connectChanged(sigc::mem_fun(*this, &MeshToolbar::selection_changed)); + c_selection_modified = selection->connectModified(sigc::mem_fun(*this, &MeshToolbar::selection_modified)); + c_subselection_changed = desktop->connectToolSubselectionChanged(sigc::mem_fun(*this, &MeshToolbar::drag_selection_changed)); - c_defs_release = document->getDefs()->connectRelease(sigc::bind<1>(sigc::ptr_fun(&ms_defs_release), holder)); - c_defs_modified = document->getDefs()->connectModified(sigc::bind<2>(sigc::ptr_fun(&ms_defs_modified), holder)); - ms_tb_selection_changed(selection, holder); + c_defs_release = document->getDefs()->connectRelease(sigc::mem_fun(*this, &MeshToolbar::defs_release)); + c_defs_modified = document->getDefs()->connectModified(sigc::mem_fun(*this, &MeshToolbar::defs_modified)); + selection_changed(selection); } else { if (c_selection_changed) c_selection_changed.disconnect(); @@ -652,6 +572,113 @@ static void mesh_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolB } } +void +MeshToolbar::selection_modified(Inkscape::Selection *selection, guint /*flags*/) +{ + selection_changed(selection); +} + +void +MeshToolbar::drag_selection_changed(gpointer /*dragger*/) +{ + selection_changed(nullptr); +} + +void +MeshToolbar::defs_release(SPObject * /*defs*/) +{ + selection_changed(nullptr); +} + +void +MeshToolbar::defs_modified(SPObject * /*defs*/, guint /*flags*/) +{ + selection_changed(nullptr); +} + +/* + * Core function, setup all the widgets whenever something changes on the desktop + */ +void +MeshToolbar::selection_changed(Inkscape::Selection * /* selection */) +{ + // std::cout << "ms_tb_selection_changed" << std::endl; + + if (blocked) + return; + + if (!_desktop) { + return; + } + + Inkscape::Selection *selection = _desktop->getSelection(); // take from desktop, not from args + if (selection) { + // ToolBase *ev = sp_desktop_event_context(desktop); + // GrDrag *drag = NULL; + // if (ev) { + // drag = ev->get_drag(); + // // Hide/show handles? + // } + + SPMeshGradient *ms_selected = nullptr; + SPMeshType ms_type = SP_MESH_TYPE_COONS; + bool ms_selected_multi = false; + bool ms_type_multi = false; + ms_read_selection( selection, ms_selected, ms_selected_multi, ms_type, ms_type_multi ); + // std::cout << " type: " << ms_type << std::endl; + + if (_select_type_action) { + _select_type_action->set_sensitive(!ms_type_multi); + blocked = TRUE; + _select_type_action->set_active(ms_type); + blocked = FALSE; + } + } +} + +void +MeshToolbar::warning_popup() +{ + char *msg = _("Mesh gradients are part of SVG 2:\n" + "* Syntax may change.\n" + "* Web browser implementation is not guaranteed.\n" + "\n" + "For web: convert to bitmap (Edit->Make bitmap copy).\n" + "For print: export to PDF."); + Gtk::MessageDialog dialog(msg, false, Gtk::MESSAGE_WARNING, + Gtk::BUTTONS_OK, true); + dialog.run(); + +} + +/** + * Sets mesh type: Coons, Bicubic + */ +void +MeshToolbar::type_changed(int mode) +{ + if (blocked) { + return; + } + + Inkscape::Selection *selection = _desktop->getSelection(); + std::vector meshes = ms_get_dt_selected_gradients(selection); + + SPMeshType type = (SPMeshType) mode; + for (auto & meshe : meshes) { + meshe->type = type; + meshe->type_set = true; + meshe->updateRepr(); + } + if (!meshes.empty() ) { + DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_MESH,_("Set mesh type")); + } +} + +} +} +} + /* Local Variables: mode:c++ diff --git a/src/ui/toolbar/mesh-toolbar.h b/src/ui/toolbar/mesh-toolbar.h index 34ccc844e..8d431dccb 100644 --- a/src/ui/toolbar/mesh-toolbar.h +++ b/src/ui/toolbar/mesh-toolbar.h @@ -15,11 +15,76 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" + +#include + +class InkSelectOneAction; class SPDesktop; +class SPObject; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; +typedef struct _InkToggleAction InkToggleAction; + +namespace Inkscape { +class Selection; + +namespace UI { +class PrefPusher; + +namespace Tools { +class ToolBase; +} + +namespace Toolbar { +class MeshToolbar : public Toolbar { +private: + InkSelectOneAction *_new_type_mode; + InkSelectOneAction *_new_fillstroke_mode; + InkSelectOneAction *_select_type_action; + + Glib::RefPtr _row_adj; + Glib::RefPtr _col_adj; + + UI::PrefPusher *_edit_fill_pusher; + UI::PrefPusher *_edit_stroke_pusher; + UI::PrefPusher *_show_handles_pusher; + + sigc::connection c_selection_changed; + sigc::connection c_selection_modified; + sigc::connection c_subselection_changed; + sigc::connection c_defs_release; + sigc::connection c_defs_modified; + + void new_geometry_changed(int mode); + void new_fillstroke_changed(int mode); + void row_changed(); + void col_changed(); + static void toggle_fill_stroke(InkToggleAction *act, gpointer data); + void selection_changed(Inkscape::Selection *selection); + static void toggle_handles(); + void watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec); + void selection_modified(Inkscape::Selection *selection, guint flags); + void drag_selection_changed(gpointer dragger); + void defs_release(SPObject *defs); + void defs_modified(SPObject *defs, guint flags); + static void warning_popup(); + void type_changed(int mode); + +protected: + MeshToolbar(SPDesktop *desktop) + : Toolbar(desktop), + _edit_fill_pusher(nullptr) + {} + + ~MeshToolbar(); + +public: + static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); +}; -void sp_mesh_toolbox_prep( SPDesktop * /*desktop*/, GtkActionGroup* mainActions, GObject* holder); +} +} +} #endif /* !SEEN_MESH_TOOLBAR_H */ diff --git a/src/ui/toolbar/node-toolbar.cpp b/src/ui/toolbar/node-toolbar.cpp index 86d2f4d52..32fbaaefd 100644 --- a/src/ui/toolbar/node-toolbar.cpp +++ b/src/ui/toolbar/node-toolbar.cpp @@ -25,8 +25,11 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "node-toolbar.h" + #include +#include #include "desktop.h" #include "document-undo.h" @@ -34,7 +37,6 @@ #include "widgets/ink-tool-menu-action.h" #include "widgets/toolbox.h" #include "inkscape.h" -#include "node-toolbar.h" #include "selection-chemistry.h" #include "verbs.h" @@ -207,132 +209,36 @@ static void sp_node_path_edit_nextLPEparam(GtkAction * /*act*/, gpointer data) { sp_selection_next_patheffect_param( reinterpret_cast(data) ); } -/* is called when the node selection is modified */ -static void sp_node_toolbox_coord_changed(gpointer /*shape_editor*/, GObject *tbl) -{ - GtkAction* xact = GTK_ACTION( g_object_get_data( tbl, "nodes_x_action" ) ); - GtkAction* yact = GTK_ACTION( g_object_get_data( tbl, "nodes_y_action" ) ); - GtkAdjustment *xadj = ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION(xact)); - GtkAdjustment *yadj = ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION(yact)); - - // quit if run by the attr_changed listener - if (g_object_get_data( tbl, "freeze" )) { - return; - } - // in turn, prevent listener from responding - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE)); - - UnitTracker* tracker = reinterpret_cast( g_object_get_data( tbl, "tracker" ) ); - if (!tracker) { - return; - } - Unit const *unit = tracker->getActiveUnit(); - g_return_if_fail(unit != nullptr); - - NodeTool *nt = get_node_tool(); - if (!nt || !(nt->_selected_nodes) ||nt->_selected_nodes->empty()) { - // no path selected - gtk_action_set_sensitive(xact, FALSE); - gtk_action_set_sensitive(yact, FALSE); - } else { - gtk_action_set_sensitive(xact, TRUE); - gtk_action_set_sensitive(yact, TRUE); - Geom::Coord oldx = Quantity::convert(gtk_adjustment_get_value(xadj), unit, "px"); - Geom::Coord oldy = Quantity::convert(gtk_adjustment_get_value(yadj), unit, "px"); - Geom::Point mid = nt->_selected_nodes->pointwiseBounds()->midpoint(); - - if (oldx != mid[Geom::X]) { - gtk_adjustment_set_value(xadj, Quantity::convert(mid[Geom::X], "px", unit)); - } - if (oldy != mid[Geom::Y]) { - gtk_adjustment_set_value(yadj, Quantity::convert(mid[Geom::Y], "px", unit)); - } - } - - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); -} - -static void sp_node_path_value_changed(GtkAdjustment *adj, GObject *tbl, Geom::Dim2 d) -{ - SPDesktop *desktop = static_cast(g_object_get_data( tbl, "desktop" )); - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - - UnitTracker* tracker = reinterpret_cast(g_object_get_data( tbl, "tracker" )); - if (!tracker) { - return; - } - Unit const *unit = tracker->getActiveUnit(); - - if (DocumentUndo::getUndoSensitive(desktop->getDocument())) { - prefs->setDouble(Glib::ustring("/tools/nodes/") + (d == Geom::X ? "x" : "y"), - Quantity::convert(gtk_adjustment_get_value(adj), unit, "px")); - } - // quit if run by the attr_changed listener - if (g_object_get_data( tbl, "freeze" ) || tracker->isUpdating()) { - return; - } - - // in turn, prevent listener from responding - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE)); - - NodeTool *nt = get_node_tool(); - if (nt && !nt->_selected_nodes->empty()) { - double val = Quantity::convert(gtk_adjustment_get_value(adj), unit, "px"); - double oldval = nt->_selected_nodes->pointwiseBounds()->midpoint()[d]; - Geom::Point delta(0,0); - delta[d] = val - oldval; - nt->_multipath->move(delta); - } - - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); -} - -static void sp_node_path_x_value_changed(GtkAdjustment *adj, GObject *tbl) -{ - sp_node_path_value_changed(adj, tbl, Geom::X); -} +//################################ +//## Node Editing Toolbox ## +//################################ -static void sp_node_path_y_value_changed(GtkAdjustment *adj, GObject *tbl) -{ - sp_node_path_value_changed(adj, tbl, Geom::Y); -} +namespace Inkscape { +namespace UI { +namespace Toolbar { -static void sp_node_toolbox_sel_changed(Inkscape::Selection *selection, GObject *tbl) -{ - { - GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "nodes_lpeedit" ) ); - SPItem *item = selection->singleItem(); - if (item && SP_IS_LPE_ITEM(item)) { - if (SP_LPE_ITEM(item)->hasPathEffect()) { - gtk_action_set_sensitive(w, TRUE); - } else { - gtk_action_set_sensitive(w, FALSE); - } - } else { - gtk_action_set_sensitive(w, FALSE); - } - } -} +NodeToolbar::NodeToolbar(SPDesktop *desktop) + : Toolbar(desktop), + _tracker(new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR)) +{} -static void sp_node_toolbox_sel_modified(Inkscape::Selection *selection, guint /*flags*/, GObject *tbl) +NodeToolbar::~NodeToolbar() { - sp_node_toolbox_sel_changed (selection, tbl); + delete _pusher_show_transform_handles; + delete _pusher_show_handles; + delete _pusher_show_outline; + delete _pusher_edit_clipping_paths; + delete _pusher_edit_masks; } -static void node_toolbox_watch_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder); - -//################################ -//## Node Editing Toolbox ## -//################################ - -void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) +GtkWidget * +NodeToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) { - UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR); + auto holder = new NodeToolbar(desktop); Unit doc_units = *desktop->getNamedView()->display_units; - tracker->setActiveUnit(&doc_units); - g_object_set_data( holder, "tracker", tracker ); + holder->_tracker->setActiveUnit(&doc_units); GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); @@ -342,7 +248,7 @@ void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObje _("Insert new nodes into selected segments"), INKSCAPE_ICON("node-add"), secondarySize ); - g_object_set( INK_ACTION(inky), "short_label", _("Insert"), NULL ); + gtk_action_set_short_label(GTK_ACTION(inky), _("Insert")); 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) ); GtkToolItem *menu_tool_button = gtk_menu_tool_button_new (nullptr, nullptr); @@ -357,7 +263,7 @@ void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObje _("Insert new nodes at min X into selected segments"), INKSCAPE_ICON("node_insert_min_x"), secondarySize ); - g_object_set( inky, "short_label", _("Insert min X"), NULL ); + gtk_action_set_short_label( GTK_ACTION(inky), _("Insert min X")); g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_add_min_x), 0 ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); } @@ -512,8 +418,7 @@ void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObje "node-transform", secondarySize ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/nodes/show_transform_handles"); - g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher); + holder->_pusher_show_transform_handles = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/nodes/show_transform_handles"); } { @@ -523,8 +428,7 @@ void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObje INKSCAPE_ICON("show-node-handles"), secondarySize ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/nodes/show_handles"); - g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher); + holder->_pusher_show_handles = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/nodes/show_handles"); } { @@ -534,20 +438,18 @@ void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObje INKSCAPE_ICON("show-path-outline"), secondarySize ); gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/nodes/show_outline"); - g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher); + holder->_pusher_show_outline = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/nodes/show_outline"); } { Inkscape::Verb* verb = Inkscape::Verb::get(SP_VERB_EDIT_NEXT_PATHEFFECT_PARAMETER); - InkAction* inky = ink_action_new( verb->get_id(), - verb->get_name(), - verb->get_tip(), - INKSCAPE_ICON("path-effect-parameter-next"), - secondarySize ); - g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_node_path_edit_nextLPEparam), desktop ); - gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); - g_object_set_data( holder, "nodes_lpeedit", inky); + holder->_nodes_lpeedit = ink_action_new( verb->get_id(), + verb->get_name(), + verb->get_tip(), + INKSCAPE_ICON("path-effect-parameter-next"), + secondarySize ); + g_signal_connect_after( G_OBJECT(holder->_nodes_lpeedit), "activate", G_CALLBACK(sp_node_path_edit_nextLPEparam), desktop ); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_nodes_lpeedit) ); } { @@ -557,8 +459,7 @@ void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObje INKSCAPE_ICON("path-clip-edit"), secondarySize ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); - PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(inky), "/tools/nodes/edit_clipping_paths"); - g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher); + holder->_pusher_edit_clipping_paths = new PrefPusher(GTK_TOGGLE_ACTION(inky), "/tools/nodes/edit_clipping_paths"); } { @@ -568,68 +469,124 @@ void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObje INKSCAPE_ICON("path-mask-edit"), secondarySize ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); - PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(inky), "/tools/nodes/edit_masks"); - g_signal_connect( holder, "destroy", G_CALLBACK(delete_prefspusher), pusher); + holder->_pusher_edit_masks = new PrefPusher(GTK_TOGGLE_ACTION(inky), "/tools/nodes/edit_masks"); } /* X coord of selected node(s) */ { - EgeAdjustmentAction* eact = nullptr; gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500}; - eact = create_adjustment_action( "NodeXAction", - _("X coordinate:"), _("X:"), _("X coordinate of selected node(s)"), - "/tools/nodes/Xcoord", 0, - GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-nodes", - -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP, - labels, values, G_N_ELEMENTS(labels), - sp_node_path_x_value_changed, tracker ); - g_object_set_data( holder, "nodes_x_action", eact ); - gtk_action_set_sensitive( GTK_ACTION(eact), FALSE ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + holder->_nodes_x_action = create_adjustment_action( "NodeXAction", + _("X coordinate:"), _("X:"), _("X coordinate of selected node(s)"), + "/tools/nodes/Xcoord", 0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + TRUE, "altx-nodes", + -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + holder->_tracker ); + holder->_nodes_x_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_nodes_x_action)); + holder->_nodes_x_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &NodeToolbar::value_changed), Geom::X)); + gtk_action_set_sensitive( GTK_ACTION(holder->_nodes_x_action), FALSE ); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_nodes_x_action) ); } /* Y coord of selected node(s) */ { - EgeAdjustmentAction* eact = nullptr; gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500}; - eact = create_adjustment_action( "NodeYAction", - _("Y coordinate:"), _("Y:"), _("Y coordinate of selected node(s)"), - "/tools/nodes/Ycoord", 0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, - -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP, - labels, values, G_N_ELEMENTS(labels), - sp_node_path_y_value_changed, tracker ); - g_object_set_data( holder, "nodes_y_action", eact ); - gtk_action_set_sensitive( GTK_ACTION(eact), FALSE ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + holder->_nodes_y_action = create_adjustment_action( "NodeYAction", + _("Y coordinate:"), _("Y:"), _("Y coordinate of selected node(s)"), + "/tools/nodes/Ycoord", 0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + holder->_tracker ); + holder->_nodes_y_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_nodes_y_action)); + holder->_nodes_y_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &NodeToolbar::value_changed), Geom::Y)); + gtk_action_set_sensitive( GTK_ACTION(holder->_nodes_y_action), FALSE ); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_nodes_y_action) ); } // add the units menu { - InkSelectOneAction* act = tracker->createAction( "NodeUnitsAction", _("Units"), ("") ); + InkSelectOneAction* act = holder->_tracker->createAction( "NodeUnitsAction", _("Units"), ("") ); gtk_action_group_add_action( mainActions, act->gobj() ); } - sp_node_toolbox_sel_changed(desktop->getSelection(), holder); - desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(node_toolbox_watch_ec), holder)); + holder->sel_changed(desktop->getSelection()); + desktop->connectEventContextChanged(sigc::mem_fun(*holder, &NodeToolbar::watch_ec)); -} // end of sp_node_toolbox_prep() + return GTK_WIDGET(holder->gobj()); +} // NodeToolbar::prep() -static void node_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec, GObject* holder) +void +NodeToolbar::value_changed(Geom::Dim2 d) { - static sigc::connection c_selection_changed; - static sigc::connection c_selection_modified; - static sigc::connection c_subselection_changed; + auto adj = (d == Geom::X) ? _nodes_x_adj : _nodes_y_adj; + + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + + if (!_tracker) { + return; + } + Unit const *unit = _tracker->getActiveUnit(); + + if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) { + prefs->setDouble(Glib::ustring("/tools/nodes/") + (d == Geom::X ? "x" : "y"), + Quantity::convert(adj->get_value(), unit, "px")); + } + + // quit if run by the attr_changed listener + if (_freeze || _tracker->isUpdating()) { + return; + } + + // in turn, prevent listener from responding + _freeze = true; + + NodeTool *nt = get_node_tool(); + if (nt && !nt->_selected_nodes->empty()) { + double val = Quantity::convert(adj->get_value(), unit, "px"); + double oldval = nt->_selected_nodes->pointwiseBounds()->midpoint()[d]; + Geom::Point delta(0,0); + delta[d] = val - oldval; + nt->_multipath->move(delta); + } + + _freeze = false; +} + +void +NodeToolbar::sel_changed(Inkscape::Selection *selection) +{ + SPItem *item = selection->singleItem(); + if (item && SP_IS_LPE_ITEM(item)) { + if (SP_LPE_ITEM(item)->hasPathEffect()) { + gtk_action_set_sensitive(GTK_ACTION(_nodes_lpeedit), TRUE); + } else { + gtk_action_set_sensitive(GTK_ACTION(_nodes_lpeedit), FALSE); + } + } else { + gtk_action_set_sensitive(GTK_ACTION(_nodes_lpeedit), FALSE); + } +} + +void +NodeToolbar::watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec) +{ if (INK_IS_NODE_TOOL(ec)) { // watch selection - c_selection_changed = desktop->getSelection()->connectChanged(sigc::bind(sigc::ptr_fun(sp_node_toolbox_sel_changed), holder)); - c_selection_modified = desktop->getSelection()->connectModified(sigc::bind(sigc::ptr_fun(sp_node_toolbox_sel_modified), holder)); - c_subselection_changed = desktop->connectToolSubselectionChanged(sigc::bind(sigc::ptr_fun(sp_node_toolbox_coord_changed), holder)); + c_selection_changed = desktop->getSelection()->connectChanged(sigc::mem_fun(*this, &NodeToolbar::sel_changed)); + c_selection_modified = desktop->getSelection()->connectModified(sigc::mem_fun(*this, &NodeToolbar::sel_modified)); + c_subselection_changed = desktop->connectToolSubselectionChanged(sigc::mem_fun(*this, &NodeToolbar::coord_changed)); - sp_node_toolbox_sel_changed(desktop->getSelection(), holder); + sel_changed(desktop->getSelection()); } else { if (c_selection_changed) c_selection_changed.disconnect(); @@ -640,6 +597,56 @@ static void node_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolB } } +void +NodeToolbar::sel_modified(Inkscape::Selection *selection, guint /*flags*/) +{ + sel_changed(selection); +} + +/* is called when the node selection is modified */ +void +NodeToolbar::coord_changed(gpointer /*shape_editor*/) +{ + // quit if run by the attr_changed listener + if (_freeze) { + return; + } + + // in turn, prevent listener from responding + _freeze = true; + + if (!_tracker) { + return; + } + Unit const *unit = _tracker->getActiveUnit(); + g_return_if_fail(unit != nullptr); + + NodeTool *nt = get_node_tool(); + if (!nt || !(nt->_selected_nodes) ||nt->_selected_nodes->empty()) { + // no path selected + gtk_action_set_sensitive(GTK_ACTION(_nodes_x_action), FALSE); + gtk_action_set_sensitive(GTK_ACTION(_nodes_y_action), FALSE); + } else { + gtk_action_set_sensitive(GTK_ACTION(_nodes_x_action), TRUE); + gtk_action_set_sensitive(GTK_ACTION(_nodes_y_action), TRUE); + Geom::Coord oldx = Quantity::convert(_nodes_x_adj->get_value(), unit, "px"); + Geom::Coord oldy = Quantity::convert(_nodes_y_adj->get_value(), unit, "px"); + Geom::Point mid = nt->_selected_nodes->pointwiseBounds()->midpoint(); + + if (oldx != mid[Geom::X]) { + _nodes_x_adj->set_value(Quantity::convert(mid[Geom::X], "px", unit)); + } + if (oldy != mid[Geom::Y]) { + _nodes_y_adj->set_value(Quantity::convert(mid[Geom::Y], "px", unit)); + } + } + + _freeze = false; +} + +} +} +} /* Local Variables: diff --git a/src/ui/toolbar/node-toolbar.h b/src/ui/toolbar/node-toolbar.h index 9cbd6ba6c..c612b52d8 100644 --- a/src/ui/toolbar/node-toolbar.h +++ b/src/ui/toolbar/node-toolbar.h @@ -28,11 +28,68 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" +#include "2geom/coord.h" + class SPDesktop; +typedef struct _EgeAdjustmentAction EgeAdjustmentAction; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; +typedef struct _InkAction InkAction; + +namespace Inkscape { +class Selection; + +namespace UI { +class PrefPusher; + +namespace Tools { +class ToolBase; +} + +namespace Widget { +class UnitTracker; +} + +namespace Toolbar { +class NodeToolbar : public Toolbar { +private: + UI::Widget::UnitTracker *_tracker; + + PrefPusher *_pusher_show_transform_handles; + PrefPusher *_pusher_show_handles; + PrefPusher *_pusher_show_outline; + PrefPusher *_pusher_edit_clipping_paths; + PrefPusher *_pusher_edit_masks; + + InkAction *_nodes_lpeedit; + + EgeAdjustmentAction *_nodes_x_action; + EgeAdjustmentAction *_nodes_y_action; + + Glib::RefPtr _nodes_x_adj; + Glib::RefPtr _nodes_y_adj; + + bool _freeze; + + sigc::connection c_selection_changed; + sigc::connection c_selection_modified; + sigc::connection c_subselection_changed; + + void value_changed(Geom::Dim2 d); + void sel_changed(Inkscape::Selection *selection); + void sel_modified(Inkscape::Selection *selection, guint /*flags*/); + void coord_changed(gpointer shape_editor); + void watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec); -void sp_node_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +protected: + NodeToolbar(SPDesktop *desktop); + ~NodeToolbar(); +public: + static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); +}; +} +} +} #endif /* !SEEN_SELECT_TOOLBAR_H */ diff --git a/src/ui/toolbar/paintbucket-toolbar.cpp b/src/ui/toolbar/paintbucket-toolbar.cpp index 81a240262..fd463289d 100644 --- a/src/ui/toolbar/paintbucket-toolbar.cpp +++ b/src/ui/toolbar/paintbucket-toolbar.cpp @@ -49,70 +49,18 @@ using Inkscape::UI::PrefPusher; using Inkscape::Util::unit_table; -//######################### -//## Paintbucket ## -//######################### - -static void paintbucket_channels_changed(GObject* /*tbl*/, int channels) -{ - Inkscape::UI::Tools::FloodTool::set_channels(channels); -} - -static void paintbucket_threshold_changed(GtkAdjustment *adj, GObject * /*tbl*/) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setInt("/tools/paintbucket/threshold", (gint)gtk_adjustment_get_value(adj)); -} - -static void paintbucket_autogap_changed(GObject * /*tbl*/, int autogap) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setInt("/tools/paintbucket/autogap", autogap); -} - -static void paintbucket_offset_changed(GtkAdjustment *adj, GObject *tbl) -{ - UnitTracker* tracker = static_cast(g_object_get_data( tbl, "tracker" )); - Unit const *unit = tracker->getActiveUnit(); - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - - // Don't adjust the offset value because we're saving the - // unit and it'll be correctly handled on load. - prefs->setDouble("/tools/paintbucket/offset", (gdouble)gtk_adjustment_get_value(adj)); - - g_return_if_fail(unit != nullptr); - prefs->setString("/tools/paintbucket/offsetunits", unit->abbr); -} - -static void paintbucket_defaults(GtkWidget *, GObject *tbl) -{ - // FIXME: make defaults settable via Inkscape Options - struct KeyValue { - char const *key; - double value; - } const key_values[] = { - {"threshold", 15}, - {"offset", 0.0} - }; - - for (auto kv : key_values) { - GtkAdjustment* adj = static_cast(g_object_get_data(tbl, kv.key)); - if ( adj ) { - gtk_adjustment_set_value(adj, kv.value); - } - } - - InkSelectOneAction* channels_action = - static_cast( g_object_get_data( tbl, "channels_action" ) ); - channels_action->set_active( Inkscape::UI::Tools::FLOOD_CHANNELS_RGB ); - - InkSelectOneAction* autogap_action = - static_cast( g_object_get_data( tbl, "autogap_action" ) ); - autogap_action->set_active( 0 ); -} - -void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) +namespace Inkscape { +namespace UI { +namespace Toolbar { +PaintbucketToolbar::PaintbucketToolbar(SPDesktop *desktop) + : Toolbar(desktop), + _tracker(new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR)) +{} + +GtkWidget * +PaintbucketToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) { + auto toolbar = new PaintbucketToolbar(desktop); EgeAdjustmentAction* eact = nullptr; Inkscape::Preferences *prefs = Inkscape::Preferences::get(); @@ -132,24 +80,23 @@ void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions row[columns.col_sensitive] = true; } - InkSelectOneAction* act = + toolbar->_channels_action = InkSelectOneAction::create( "ChannelsAction", // Name _("Fill by"), // Label (""), // Tooltip "Not Used", // Icon store ); // Tree store - act->use_radio( false ); - act->use_icon( false ); - act->use_label( true ); - act->use_group_label( true ); + toolbar->_channels_action->use_radio( false ); + toolbar->_channels_action->use_icon( false ); + toolbar->_channels_action->use_label( true ); + toolbar->_channels_action->use_group_label( true ); int channels = prefs->getInt("/tools/paintbucket/channels", 0); - act->set_active( channels ); + toolbar->_channels_action->set_active( channels ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( holder, "channels_action", act ); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_channels_action->gobj() )); - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&paintbucket_channels_changed), holder)); + toolbar->_channels_action->signal_changed().connect(sigc::mem_fun(*toolbar, &PaintbucketToolbar::channels_changed)); } // Spacing spinbox @@ -158,26 +105,29 @@ void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions "ThresholdAction", _("Fill Threshold"), _("Threshold:"), _("The maximum allowed difference between the clicked pixel and the neighboring pixels to be counted in the fill"), - "/tools/paintbucket/threshold", 5, GTK_WIDGET(desktop->canvas), holder, TRUE, + "/tools/paintbucket/threshold", 5, GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + TRUE, "inkscape:paintbucket-threshold", 0, 100.0, 1.0, 10.0, nullptr, nullptr, 0, - paintbucket_threshold_changed, nullptr /*unit tracker*/, 1, 0 ); + nullptr, // callback + nullptr /*unit tracker*/, 1, 0 ); + toolbar->_threshold_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + toolbar->_threshold_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &PaintbucketToolbar::threshold_changed)); ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); } // Create the units menu. - UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR); Glib::ustring stored_unit = prefs->getString("/tools/paintbucket/offsetunits"); if (!stored_unit.empty()) { Unit const *u = unit_table.getUnit(stored_unit); - tracker->setActiveUnit(u); + toolbar->_tracker->setActiveUnit(u); } - g_object_set_data( holder, "tracker", tracker ); { - InkSelectOneAction* act = tracker->createAction( "PaintbucketUnitsAction", _("Units"), ("") ); + InkSelectOneAction* act = toolbar->_tracker->createAction( "PaintbucketUnitsAction", _("Units"), ("") ); gtk_action_group_add_action( mainActions, act->gobj() ); } @@ -187,10 +137,16 @@ void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions "OffsetAction", _("Grow/shrink by"), _("Grow/shrink by:"), _("The amount to grow (positive) or shrink (negative) the created fill path"), - "/tools/paintbucket/offset", 0, GTK_WIDGET(desktop->canvas), holder, TRUE, + "/tools/paintbucket/offset", 0, GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + TRUE, "inkscape:paintbucket-offset", -1e4, 1e4, 0.1, 0.5, nullptr, nullptr, 0, - paintbucket_offset_changed, tracker, 1, 2); + nullptr, // callback + toolbar->_tracker, + 1, 2); + toolbar->_offset_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + toolbar->_offset_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &PaintbucketToolbar::offset_changed)); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); } @@ -210,24 +166,23 @@ void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions row[columns.col_sensitive] = true; } - InkSelectOneAction* act = + toolbar->_autogap_action = InkSelectOneAction::create( "AutoGapAction", // Name _("Close gaps"), // Label (""), // Tooltip "Not Used", // Icon store ); // Tree store - act->use_radio( false ); - act->use_icon( false ); - act->use_label( true ); - act->use_group_label( true ); + toolbar->_autogap_action->use_radio( false ); + toolbar->_autogap_action->use_icon( false ); + toolbar->_autogap_action->use_label( true ); + toolbar->_autogap_action->use_group_label( true ); int autogap = prefs->getInt("/tools/paintbucket/autogap"); - act->set_active( autogap ); + toolbar->_autogap_action->set_active( autogap ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( holder, "autogap_action", act ); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_autogap_action->gobj() )); - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&paintbucket_autogap_changed), holder)); + toolbar->_autogap_action->signal_changed().connect(sigc::mem_fun(*toolbar, &PaintbucketToolbar::autogap_changed)); } /* Reset */ @@ -237,11 +192,63 @@ void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions _("Reset paint bucket parameters to defaults (use Inkscape Preferences > Tools to change defaults)"), INKSCAPE_ICON("edit-clear"), GTK_ICON_SIZE_SMALL_TOOLBAR); - g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(paintbucket_defaults), holder ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(defaults), (gpointer)toolbar ); gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); gtk_action_set_sensitive( GTK_ACTION(inky), TRUE ); } + return GTK_WIDGET(toolbar->gobj()); +} + +void +PaintbucketToolbar::channels_changed(int channels) +{ + Inkscape::UI::Tools::FloodTool::set_channels(channels); +} + +void +PaintbucketToolbar::threshold_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setInt("/tools/paintbucket/threshold", (gint)_threshold_adj->get_value()); +} + +void +PaintbucketToolbar::offset_changed() +{ + Unit const *unit = _tracker->getActiveUnit(); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + + // Don't adjust the offset value because we're saving the + // unit and it'll be correctly handled on load. + prefs->setDouble("/tools/paintbucket/offset", (gdouble)_offset_adj->get_value()); + + g_return_if_fail(unit != nullptr); + prefs->setString("/tools/paintbucket/offsetunits", unit->abbr); +} + +void +PaintbucketToolbar::autogap_changed(int autogap) +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setInt("/tools/paintbucket/autogap", autogap); +} + +void +PaintbucketToolbar::defaults(GtkWidget * /* widget */, gpointer data) +{ + auto toolbar = reinterpret_cast(data); + + // FIXME: make defaults settable via Inkscape Options + toolbar->_threshold_adj->set_value(15); + toolbar->_offset_adj->set_value(0.0); + + toolbar->_channels_action->set_active( Inkscape::UI::Tools::FLOOD_CHANNELS_RGB ); + toolbar->_autogap_action->set_active( 0 ); +} + +} +} } /* diff --git a/src/ui/toolbar/paintbucket-toolbar.h b/src/ui/toolbar/paintbucket-toolbar.h index 8b530a50d..e8a92fbcf 100644 --- a/src/ui/toolbar/paintbucket-toolbar.h +++ b/src/ui/toolbar/paintbucket-toolbar.h @@ -28,11 +28,47 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" + +#include + +class InkSelectOneAction; class SPDesktop; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; -void sp_paintbucket_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +namespace Inkscape { +namespace UI { +namespace Widget { +class UnitTracker; +} + +namespace Toolbar { +class PaintbucketToolbar : public Toolbar { +private: + InkSelectOneAction *_channels_action; + InkSelectOneAction *_autogap_action; + + Glib::RefPtr _threshold_adj; + Glib::RefPtr _offset_adj; + + UI::Widget::UnitTracker *_tracker; + + void channels_changed(int channels); + void threshold_changed(); + void offset_changed(); + void autogap_changed(int autogap); + static void defaults(GtkWidget *widget, gpointer data); + +protected: + PaintbucketToolbar(SPDesktop *desktop); + +public: + static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); +}; + +} +} +} #endif /* !SEEN_PAINTBUCKET_TOOLBAR_H */ diff --git a/src/ui/toolbar/pencil-toolbar.cpp b/src/ui/toolbar/pencil-toolbar.cpp index 52cc32637..74c40c44f 100644 --- a/src/ui/toolbar/pencil-toolbar.cpp +++ b/src/ui/toolbar/pencil-toolbar.cpp @@ -62,58 +62,228 @@ using Inkscape::UI::UXManager; using Inkscape::UI::ToolboxFactory; using Inkscape::UI::PrefPusher; -//######################## -//## Pen/Pencil ## -//######################## -static void sp_flatten_spiro_bspline(GtkWidget * /*widget*/, GObject *obj); -/* This is used in generic functions below to share large portions of code between pen and pencil tool */ -static Glib::ustring const freehand_tool_name(GObject *dataKludge) + +/* +class PencilToleranceObserver : public Inkscape::Preferences::Observer { +public: + PencilToleranceObserver(Glib::ustring const &path, GObject *x) : Observer(path), _obj(x) + { + g_object_set_data(_obj, "prefobserver", this); + } + virtual ~PencilToleranceObserver() { + if (g_object_get_data(_obj, "prefobserver") == this) { + g_object_set_data(_obj, "prefobserver", NULL); + } + } + virtual void notify(Inkscape::Preferences::Entry const &val) { + GObject* tbl = _obj; + if (g_object_get_data( tbl, "freeze" )) { + return; + } + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + + GtkAdjustment * adj = GTK_ADJUSTMENT(g_object_get_data(tbl, "tolerance")); + + double v = val.getDouble(adj->value); + gtk_adjustment_set_value(adj, v); + g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + } +private: + GObject *_obj; +}; +*/ + +namespace Inkscape { +namespace UI { +namespace Toolbar { + +GtkWidget * +PencilToolbar::prep_pencil(SPDesktop *desktop, GtkActionGroup* mainActions) { - SPDesktop *desktop = static_cast(g_object_get_data(dataKludge, "desktop")); - return ( tools_isactive(desktop, TOOLS_FREEHAND_PEN) - ? "/tools/freehand/pen" - : "/tools/freehand/pencil" ); + auto toolbar = new PencilToolbar(desktop); + toolbar->add_freehand_mode_toggle(mainActions, true); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + + /* min pressure */ + { + toolbar->_minpressure = create_adjustment_action( "MinPressureAction", + _("Min pressure"), _("Min:"), _("Min percent of pressure"), + "/tools/freehand/pencil/minpressure", 0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + 0, 100, 1, 0, + nullptr, nullptr, 0, + nullptr, // callback + nullptr, 0 ,0); + + toolbar->_minpressure_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_minpressure)); + toolbar->_minpressure_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &PencilToolbar::minpressure_value_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_minpressure) ); + if (prefs->getInt("/tools/freehand/pencil/freehand-mode", 0) == 3) { + gtk_action_set_visible( GTK_ACTION(toolbar->_minpressure), true ); + } else { + gtk_action_set_visible( GTK_ACTION(toolbar->_minpressure), false ); + } + } + /* max pressure */ + { + toolbar->_maxpressure = create_adjustment_action( "MaxPressureAction", + _("Max pressure"), _("Max:"), _("Max percent of pressure"), + "/tools/freehand/pencil/maxpressure", 100, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + 0, 100, 1, 0, + nullptr, nullptr, 0, + nullptr, // callback + nullptr, 0 ,0); + toolbar->_maxpressure_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_maxpressure)); + toolbar->_maxpressure_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &PencilToolbar::maxpressure_value_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_maxpressure) ); + if (prefs->getInt("/tools/freehand/pencil/freehand-mode", 0) == 3) { + gtk_action_set_visible( GTK_ACTION(toolbar->_maxpressure), true ); + } else { + gtk_action_set_visible( GTK_ACTION(toolbar->_maxpressure), false ); + } + } + /* Use pressure */ + { + InkToggleAction* itact = ink_toggle_action_new( "PencilPressureAction", + _("Use pressure input"), + _("Use pressure input"), + INKSCAPE_ICON("draw-use-pressure"), + GTK_ICON_SIZE_SMALL_TOOLBAR ); + bool pressure = prefs->getBool(toolbar->freehand_tool_name() + "/pressure", false); + gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(itact), pressure ); + g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(PencilToolbar::use_pencil_pressure), toolbar); + gtk_action_group_add_action( mainActions, GTK_ACTION(itact) ); + if (pressure) { + gtk_action_set_visible( GTK_ACTION( toolbar->_minpressure ), true ); + gtk_action_set_visible( GTK_ACTION( toolbar->_maxpressure ), true ); + } else { + gtk_action_set_visible( GTK_ACTION( toolbar->_minpressure ), false ); + gtk_action_set_visible( GTK_ACTION( toolbar->_maxpressure ), false ); + } + } + /* Tolerance */ + { + gchar const* labels[] = {_("(many nodes, rough)"), _("(default)"), nullptr, nullptr, nullptr, nullptr, _("(few nodes, smooth)")}; + gdouble values[] = {1, 10, 20, 30, 50, 75, 100}; + EgeAdjustmentAction *eact = create_adjustment_action( "PencilToleranceAction", + _("Smoothing:"), _("Smoothing: "), + _("How much smoothing (simplifying) is applied to the line"), + "/tools/freehand/pencil/tolerance", + 3.0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + TRUE, "altx-pencil", + 1, 100.0, 0.5, 1.0, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + nullptr /*unit tracker*/, + 1, 2); + + toolbar->_tolerance_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + toolbar->_tolerance_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &PencilToolbar::tolerance_value_changed)); + ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + } + + /* advanced shape options */ + toolbar->freehand_add_advanced_shape_options(mainActions, true); + + /* Reset */ + { + InkAction* inky = ink_action_new( "PencilResetAction", + _("Defaults"), + _("Reset pencil parameters to defaults (use Inkscape Preferences > Tools to change defaults)"), + INKSCAPE_ICON("edit-clear"), + GTK_ICON_SIZE_SMALL_TOOLBAR ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(PencilToolbar::defaults), toolbar ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } + /* LPE simplify based tolerance */ + { + toolbar->_simplify = ink_toggle_action_new( "PencilLpeSimplify", + _("LPE based interactive simplify"), + _("LPE based interactive simplify"), + INKSCAPE_ICON("interactive_simplify"), + GTK_ICON_SIZE_SMALL_TOOLBAR ); + gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(toolbar->_simplify), prefs->getInt("/tools/freehand/pencil/simplify", 0) ); + g_signal_connect_after( G_OBJECT(toolbar->_simplify), "toggled", G_CALLBACK(PencilToolbar::freehand_simplify_lpe), toolbar) ; + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_simplify) ); + guint freehandMode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0); + if (freehandMode == 2) { + gtk_action_set_visible( GTK_ACTION( toolbar->_simplify ), false ); + } else { + gtk_action_set_visible( GTK_ACTION( toolbar->_simplify ), true ); + } + } + /* LPE simplify flatten */ + { + toolbar->_flatten_simplify = ink_action_new( "PencilLpeSimplifyFlatten", + _("LPE simplify flatten"), + _("LPE simplify flatten"), + INKSCAPE_ICON("flatten"), + GTK_ICON_SIZE_SMALL_TOOLBAR ); + g_signal_connect_after( G_OBJECT(toolbar->_flatten_simplify), "activate", G_CALLBACK(PencilToolbar::simplify_flatten), toolbar ); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_flatten_simplify) ); + guint freehandMode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0); + if (freehandMode == 2 || !prefs->getInt("/tools/freehand/pencil/simplify", 0)) { + gtk_action_set_visible( GTK_ACTION(toolbar->_flatten_simplify), false ); + } else { + gtk_action_set_visible( GTK_ACTION(toolbar->_flatten_simplify), true ); + } + } + + return GTK_WIDGET(toolbar->gobj()); +} + +PencilToolbar::~PencilToolbar() +{ + if(_repr) { + _repr->removeListenerByData(this); + GC::release(_repr); + _repr = nullptr; + } } -static void freehand_mode_changed(GObject* tbl, int mode) +void +PencilToolbar::freehand_mode_changed(int mode) { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setInt(freehand_tool_name(tbl) + "/freehand-mode", mode); + prefs->setInt(freehand_tool_name() + "/freehand-mode", mode); if (mode == 1 || mode == 2) { - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "flatten_spiro_bspline") ), true ); + gtk_action_set_visible( GTK_ACTION( _flatten_spiro_bspline ), true ); } else { - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "flatten_spiro_bspline") ), false ); + gtk_action_set_visible( GTK_ACTION( _flatten_spiro_bspline ), false ); } - if (mode == 2) { - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "flatten_simplify") ), false ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "simplify") ), false ); - } else { - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "flatten_simplify") ), true ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "simplify") ), true ); + + bool visible = (mode != 2); + + if (_flatten_simplify) { + gtk_action_set_visible(GTK_ACTION(_flatten_simplify), visible); } -} -static void use_pencil_pressure(InkToggleAction* itact, GObject *dataKludge) { - bool pressure = gtk_toggle_action_get_active( GTK_TOGGLE_ACTION(itact) ); - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setBool(freehand_tool_name(dataKludge) + "/pressure", pressure); - if (pressure) { - gtk_action_set_visible( GTK_ACTION( g_object_get_data(dataKludge, "minpressure") ), true ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(dataKludge, "maxpressure") ), true ); - InkSelectOneAction* act = - static_cast( g_object_get_data( dataKludge, "shape_action" ) ); - act->set_visible (false); - } else { - gtk_action_set_visible( GTK_ACTION( g_object_get_data(dataKludge, "minpressure") ), false ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(dataKludge, "maxpressure") ), false ); - InkSelectOneAction* act = - static_cast( g_object_get_data( dataKludge, "shape_action" ) ); - act->set_visible (true); + if (_simplify) { + gtk_action_set_visible(GTK_ACTION(_simplify), visible); } } -static void sp_add_freehand_mode_toggle(GtkActionGroup* mainActions, GObject* holder, bool tool_is_pencil) +/* This is used in generic functions below to share large portions of code between pen and pencil tool */ +Glib::ustring const +PencilToolbar::freehand_tool_name() +{ + return ( tools_isactive(_desktop, TOOLS_FREEHAND_PEN) + ? "/tools/freehand/pen" + : "/tools/freehand/pencil" ); +} + +void +PencilToolbar::add_freehand_mode_toggle(GtkActionGroup* mainActions, + bool tool_is_pencil) { /* Freehand mode toggle buttons */ @@ -176,43 +346,69 @@ static void sp_add_freehand_mode_toggle(GtkActionGroup* mainActions, GObject* ho gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); // g_object_set_data( dataKludge, "flat_action", act ); - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&freehand_mode_changed), holder)); + act->signal_changed().connect(sigc::mem_fun(*this, &PencilToolbar::freehand_mode_changed)); /* LPE bspline spiro flatten */ - InkAction* inky = ink_action_new( tool_is_pencil ? "FlattenSpiroBsplinePencil" : - "FlattenSpiroBsplinePen", - _("LPE spiro or bspline flatten"), - _("LPE spiro or bspline flatten"), - INKSCAPE_ICON("flatten"), - GTK_ICON_SIZE_SMALL_TOOLBAR ); - g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_flatten_spiro_bspline), holder ); - gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); - g_object_set_data( holder, "flatten_spiro_bspline", inky ); + _flatten_spiro_bspline = ink_action_new( tool_is_pencil ? "FlattenSpiroBsplinePencil" : + "FlattenSpiroBsplinePen", + _("LPE spiro or bspline flatten"), + _("LPE spiro or bspline flatten"), + INKSCAPE_ICON("flatten"), + GTK_ICON_SIZE_SMALL_TOOLBAR ); + g_signal_connect_after( G_OBJECT(_flatten_spiro_bspline), "activate", G_CALLBACK(PencilToolbar::flatten_spiro_bspline), this); + gtk_action_group_add_action( mainActions, GTK_ACTION(_flatten_spiro_bspline) ); + if (freehandMode == 1 || freehandMode == 2) { - gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "flatten_spiro_bspline") ), true ); + gtk_action_set_visible( GTK_ACTION( _flatten_spiro_bspline ), true ); } else { - gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "flatten_spiro_bspline") ), false ); + gtk_action_set_visible( GTK_ACTION( _flatten_spiro_bspline ), false ); } } -static void freehand_change_shape(GObject *dataKludge, int shape) { +void +PencilToolbar::minpressure_value_changed() +{ + // quit if run by the attr_changed listener + if (_freeze) { + return; + } + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setInt(freehand_tool_name(dataKludge) + "/shape", shape); + prefs->setDouble( "/tools/freehand/pencil/minpressure", _minpressure_adj->get_value()); } -static void freehand_simplify_lpe(InkToggleAction* itact, GObject *dataKludge) { - bool simplify = gtk_toggle_action_get_active( GTK_TOGGLE_ACTION(itact) ); +void +PencilToolbar::maxpressure_value_changed() +{ + // quit if run by the attr_changed listener + if (_freeze) { + return; + } + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setBool(freehand_tool_name(dataKludge) + "/simplify", simplify); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(dataKludge, "flatten_simplify") ), simplify ); - if (simplify) { - gtk_action_set_visible( GTK_ACTION( g_object_get_data(dataKludge, "flatten_simplify") ), true ); + prefs->setDouble( "/tools/freehand/pencil/maxpressure", _maxpressure_adj->get_value()); +} + +void +PencilToolbar::use_pencil_pressure(InkToggleAction* itact, gpointer data) { + auto toolbar = reinterpret_cast(data); + + bool pressure = gtk_toggle_action_get_active( GTK_TOGGLE_ACTION(itact) ); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setBool(toolbar->freehand_tool_name() + "/pressure", pressure); + if (pressure) { + gtk_action_set_visible( GTK_ACTION( toolbar->_minpressure ), true ); + gtk_action_set_visible( GTK_ACTION( toolbar->_maxpressure ), true ); + toolbar->_shape_action->set_visible (false); } else { - gtk_action_set_visible( GTK_ACTION( g_object_get_data(dataKludge, "flatten_simplify") ), false ); + gtk_action_set_visible( GTK_ACTION( toolbar->_minpressure ), false ); + gtk_action_set_visible( GTK_ACTION( toolbar->_maxpressure ), false ); + toolbar->_shape_action->set_visible (true); } } -static void freehand_add_advanced_shape_options(GtkActionGroup* mainActions, GObject* holder, bool tool_is_pencil) +void +PencilToolbar::freehand_add_advanced_shape_options(GtkActionGroup* mainActions, bool tool_is_pencil) { /*advanced shape options */ @@ -243,7 +439,7 @@ static void freehand_add_advanced_shape_options(GtkActionGroup* mainActions, GOb row[columns.col_sensitive] = true; } - InkSelectOneAction* act = + _shape_action = InkSelectOneAction::create( tool_is_pencil ? "SetPencilShapeAction" : "SetPenShapeAction", // Name @@ -252,55 +448,68 @@ static void freehand_add_advanced_shape_options(GtkActionGroup* mainActions, GOb "Not Used", // Icon store ); // Tree store - act->use_radio( false ); - act->use_icon( false ); - act->use_label( true ); - act->use_group_label( true ); + _shape_action->use_radio( false ); + _shape_action->use_icon( false ); + _shape_action->use_label( true ); + _shape_action->use_group_label( true ); int shape = prefs->getInt( (tool_is_pencil ? "/tools/freehand/pencil/shape" : "/tools/freehand/pen/shape" ), 0); - act->set_active( shape ); + _shape_action->set_active( shape ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( holder, "shape_action", act ); + gtk_action_group_add_action( mainActions, GTK_ACTION( _shape_action->gobj() )); bool hide = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0) == 3 || (tool_is_pencil && prefs->getBool("/tools/freehand/pencil/pressure", false)); - act->set_visible( !hide ); + _shape_action->set_visible( !hide ); - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&freehand_change_shape), holder)); + _shape_action->signal_changed().connect(sigc::mem_fun(*this, &PencilToolbar::freehand_change_shape)); } -void sp_pen_toolbox_prep(SPDesktop * /*desktop*/, GtkActionGroup* mainActions, GObject* holder) -{ - sp_add_freehand_mode_toggle(mainActions, holder, false); - freehand_add_advanced_shape_options(mainActions, holder, false); +void +PencilToolbar::freehand_change_shape(int shape) { + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setInt(freehand_tool_name() + "/shape", shape); } - -static void sp_pencil_tb_defaults(GtkWidget * /*widget*/, GObject *obj) +void +PencilToolbar::defaults(GtkWidget * /*widget*/, GObject *obj) { - GtkWidget *tbl = GTK_WIDGET(obj); - - GtkAdjustment *adj; + auto toolbar = reinterpret_cast(obj); // fixme: make settable gdouble tolerance = 4; - adj = GTK_ADJUSTMENT(g_object_get_data(obj, "tolerance")); - gtk_adjustment_set_value(adj, tolerance); + toolbar->_tolerance_adj->set_value(tolerance); #if !GTK_CHECK_VERSION(3,18,0) - gtk_adjustment_value_changed(adj); + toolbar->_tolerance_adj->value_changed(); #endif - spinbutton_defocus(tbl); + if(toolbar->_desktop->canvas) gtk_widget_grab_focus(GTK_WIDGET(toolbar->_desktop->canvas)); } -static void sp_flatten_spiro_bspline(GtkWidget * /*widget*/, GObject *obj) +void +PencilToolbar::freehand_simplify_lpe(InkToggleAction* itact, GObject *data) { - SPDesktop *desktop = static_cast(g_object_get_data(obj, "desktop")); - auto selected = desktop->getSelection()->items(); + auto toolbar = reinterpret_cast(data); + + bool simplify = gtk_toggle_action_get_active( GTK_TOGGLE_ACTION(itact) ); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setBool(toolbar->freehand_tool_name() + "/simplify", simplify); + gtk_action_set_visible( GTK_ACTION( toolbar->_flatten_simplify ), simplify ); + if (simplify) { + gtk_action_set_visible( GTK_ACTION( toolbar->_flatten_simplify ), true ); + } else { + gtk_action_set_visible( GTK_ACTION( toolbar->_flatten_simplify ), false ); + } +} + +void +PencilToolbar::simplify_flatten(GtkWidget * /*widget*/, GObject *data) +{ + auto toolbar = reinterpret_cast(data); + auto selected = toolbar->_desktop->getSelection()->items(); SPLPEItem* lpeitem = nullptr; for (auto it(selected.begin()); it != selected.end(); ++it){ lpeitem = dynamic_cast(*it); @@ -311,9 +520,7 @@ static void sp_flatten_spiro_bspline(GtkWidget * /*widget*/, GObject *obj) LivePathEffectObject *lpeobj = (*i)->lpeobject; if (lpeobj) { Inkscape::LivePathEffect::Effect *lpe = lpeobj->get_lpe(); - if (dynamic_cast(lpe) || - dynamic_cast(lpe)) - { + if (dynamic_cast(lpe)) { SPShape * shape = dynamic_cast(lpeitem); if(shape){ SPCurve * c = shape->getCurveForEdit(); @@ -334,16 +541,17 @@ static void sp_flatten_spiro_bspline(GtkWidget * /*widget*/, GObject *obj) } } if (lpeitem) { - desktop->getSelection()->remove(lpeitem->getRepr()); - desktop->getSelection()->add(lpeitem->getRepr()); + toolbar->_desktop->getSelection()->remove(lpeitem->getRepr()); + toolbar->_desktop->getSelection()->add(lpeitem->getRepr()); sp_lpe_item_update_patheffect(lpeitem, false, false); } } -static void sp_simplify_flatten(GtkWidget * /*widget*/, GObject *obj) +void +PencilToolbar::flatten_spiro_bspline(GtkWidget * /*widget*/, gpointer data) { - SPDesktop *desktop = static_cast(g_object_get_data(obj, "desktop")); - auto selected = desktop->getSelection()->items(); + auto toolbar = reinterpret_cast(data); + auto selected = toolbar->_desktop->getSelection()->items(); SPLPEItem* lpeitem = nullptr; for (auto it(selected.begin()); it != selected.end(); ++it){ lpeitem = dynamic_cast(*it); @@ -354,7 +562,9 @@ static void sp_simplify_flatten(GtkWidget * /*widget*/, GObject *obj) LivePathEffectObject *lpeobj = (*i)->lpeobject; if (lpeobj) { Inkscape::LivePathEffect::Effect *lpe = lpeobj->get_lpe(); - if (dynamic_cast(lpe)) { + if (dynamic_cast(lpe) || + dynamic_cast(lpe)) + { SPShape * shape = dynamic_cast(lpeitem); if(shape){ SPCurve * c = shape->getCurveForEdit(); @@ -375,46 +585,36 @@ static void sp_simplify_flatten(GtkWidget * /*widget*/, GObject *obj) } } if (lpeitem) { - desktop->getSelection()->remove(lpeitem->getRepr()); - desktop->getSelection()->add(lpeitem->getRepr()); + toolbar->_desktop->getSelection()->remove(lpeitem->getRepr()); + toolbar->_desktop->getSelection()->add(lpeitem->getRepr()); sp_lpe_item_update_patheffect(lpeitem, false, false); } } -static void sp_minpressure_value_changed(GtkAdjustment *adj, GObject *tbl) +GtkWidget * +PencilToolbar::prep_pen(SPDesktop *desktop, GtkActionGroup* mainActions) { - // quit if run by the attr_changed listener - if (g_object_get_data( tbl, "freeze" )) { - return; - } - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/freehand/pencil/minpressure", gtk_adjustment_get_value(adj)); + auto toolbar = new PencilToolbar(desktop); + toolbar->add_freehand_mode_toggle(mainActions, false); + toolbar->freehand_add_advanced_shape_options(mainActions, false); + return GTK_WIDGET(toolbar->gobj()); } -static void sp_maxpressure_value_changed(GtkAdjustment *adj, GObject *tbl) +void +PencilToolbar::tolerance_value_changed() { // quit if run by the attr_changed listener - if (g_object_get_data( tbl, "freeze" )) { + if (_freeze) { return; } - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/freehand/pencil/maxpressure", gtk_adjustment_get_value(adj)); -} -static void sp_pencil_tb_tolerance_value_changed(GtkAdjustment *adj, GObject *tbl) -{ - // quit if run by the attr_changed listener - if (g_object_get_data( tbl, "freeze" )) { - return; - } // in turn, prevent listener from responding Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + _freeze = true; prefs->setDouble("/tools/freehand/pencil/tolerance", - gtk_adjustment_get_value(adj)); - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); - SPDesktop *desktop = static_cast(g_object_get_data(tbl, "desktop")); - auto selected = desktop->getSelection()->items(); + _tolerance_adj->get_value()); + _freeze = false; + auto selected = _desktop->getSelection()->items(); for (auto it(selected.begin()); it != selected.end(); ++it){ SPLPEItem* lpeitem = dynamic_cast(*it); if (lpeitem && lpeitem->hasPathEffect()){ @@ -460,170 +660,9 @@ static void sp_pencil_tb_tolerance_value_changed(GtkAdjustment *adj, GObject *tb } } -/* -class PencilToleranceObserver : public Inkscape::Preferences::Observer { -public: - PencilToleranceObserver(Glib::ustring const &path, GObject *x) : Observer(path), _obj(x) - { - g_object_set_data(_obj, "prefobserver", this); - } - virtual ~PencilToleranceObserver() { - if (g_object_get_data(_obj, "prefobserver") == this) { - g_object_set_data(_obj, "prefobserver", NULL); - } - } - virtual void notify(Inkscape::Preferences::Entry const &val) { - GObject* tbl = _obj; - if (g_object_get_data( tbl, "freeze" )) { - return; - } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); - - GtkAdjustment * adj = GTK_ADJUSTMENT(g_object_get_data(tbl, "tolerance")); - - double v = val.getDouble(adj->value); - gtk_adjustment_set_value(adj, v); - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); - } -private: - GObject *_obj; -}; -*/ - -void sp_pencil_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) -{ - sp_add_freehand_mode_toggle(mainActions, holder, true); - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - EgeAdjustmentAction* eact = nullptr; - - - /* min pressure */ - { - eact = create_adjustment_action( "MinPressureAction", - _("Min pressure"), _("Min:"), _("Min percent of pressure"), - "/tools/freehand/pencil/minpressure", 0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, - 0, 100, 1, 0, - nullptr, nullptr, 0, - sp_minpressure_value_changed, nullptr, 0 ,0); - - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - g_object_set_data( holder, "minpressure", eact ); - if (prefs->getInt("/tools/freehand/pencil/freehand-mode", 0) == 3) { - gtk_action_set_visible( GTK_ACTION(eact), true ); - } else { - gtk_action_set_visible( GTK_ACTION(eact), false ); - } - } - /* max pressure */ - { - eact = create_adjustment_action( "MaxPressureAction", - _("Max pressure"), _("Max:"), _("Max percent of pressure"), - "/tools/freehand/pencil/maxpressure", 100, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, - 0, 100, 1, 0, - nullptr, nullptr, 0, - sp_maxpressure_value_changed, nullptr, 0 ,0); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - g_object_set_data( holder, "maxpressure", eact ); - if (prefs->getInt("/tools/freehand/pencil/freehand-mode", 0) == 3) { - gtk_action_set_visible( GTK_ACTION(eact), true ); - } else { - gtk_action_set_visible( GTK_ACTION(eact), false ); - } - } - /* Use pressure */ - { - InkToggleAction* itact = ink_toggle_action_new( "PencilPressureAction", - _("Use pressure input"), - _("Use pressure input"), - INKSCAPE_ICON("draw-use-pressure"), - GTK_ICON_SIZE_SMALL_TOOLBAR ); - bool pressure = prefs->getBool(freehand_tool_name(holder) + "/pressure", false); - gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(itact), pressure ); - g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(use_pencil_pressure), holder) ; - gtk_action_group_add_action( mainActions, GTK_ACTION(itact) ); - if (pressure) { - gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "minpressure") ), true ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "maxpressure") ), true ); - } else { - gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "minpressure") ), false ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "maxpressure") ), false ); - } - } - /* Tolerance */ - { - gchar const* labels[] = {_("(many nodes, rough)"), _("(default)"), nullptr, nullptr, nullptr, nullptr, _("(few nodes, smooth)")}; - gdouble values[] = {1, 10, 20, 30, 50, 75, 100}; - eact = create_adjustment_action( "PencilToleranceAction", - _("Smoothing:"), _("Smoothing: "), - _("How much smoothing (simplifying) is applied to the line"), - "/tools/freehand/pencil/tolerance", - 3.0, - GTK_WIDGET(desktop->canvas), - holder, TRUE, "altx-pencil", - 1, 100.0, 0.5, 1.0, - labels, values, G_N_ELEMENTS(labels), - sp_pencil_tb_tolerance_value_changed, - nullptr /*unit tracker*/, - 1, 2); - ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - } - - /* advanced shape options */ - freehand_add_advanced_shape_options(mainActions, holder, true); - - /* Reset */ - { - InkAction* inky = ink_action_new( "PencilResetAction", - _("Defaults"), - _("Reset pencil parameters to defaults (use Inkscape Preferences > Tools to change defaults)"), - INKSCAPE_ICON("edit-clear"), - GTK_ICON_SIZE_SMALL_TOOLBAR ); - g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_pencil_tb_defaults), holder ); - gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); - } - /* LPE simplify based tolerance */ - { - InkToggleAction* itact = ink_toggle_action_new( "PencilLpeSimplify", - _("LPE based interactive simplify"), - _("LPE based interactive simplify"), - INKSCAPE_ICON("interactive_simplify"), - GTK_ICON_SIZE_SMALL_TOOLBAR ); - gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(itact), prefs->getInt("/tools/freehand/pencil/simplify", 0) ); - g_object_set_data( holder, "simplify", itact ); - g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(freehand_simplify_lpe), holder) ; - gtk_action_group_add_action( mainActions, GTK_ACTION(itact) ); - guint freehandMode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0); - if (freehandMode == 2) { - gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "simplify") ), false ); - } else { - gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "simplify") ), true ); - } - } - /* LPE simplify flatten */ - { - InkAction* inky = ink_action_new( "PencilLpeSimplifyFlatten", - _("LPE simplify flatten"), - _("LPE simplify flatten"), - INKSCAPE_ICON("flatten"), - GTK_ICON_SIZE_SMALL_TOOLBAR ); - g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_simplify_flatten), holder ); - gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); - g_object_set_data( holder, "flatten_simplify", inky ); - guint freehandMode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0); - if (freehandMode == 2 || !prefs->getInt("/tools/freehand/pencil/simplify", 0)) { - gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "flatten_simplify") ), false ); - } else { - gtk_action_set_visible( GTK_ACTION( g_object_get_data(holder, "flatten_simplify") ), true ); - } - } - - g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder ); - } - +} +} /* Local Variables: mode:c++ diff --git a/src/ui/toolbar/pencil-toolbar.h b/src/ui/toolbar/pencil-toolbar.h index 33a56aed2..1016ae8d9 100644 --- a/src/ui/toolbar/pencil-toolbar.h +++ b/src/ui/toolbar/pencil-toolbar.h @@ -28,12 +28,77 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" + +#include + +class InkSelectOneAction; class SPDesktop; +typedef struct _EgeAdjustmentAction EgeAdjustmentAction; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; +typedef struct _InkAction InkAction; +typedef struct _InkToggleAction InkToggleAction; + +namespace Inkscape { +namespace XML { +class Node; +} + +namespace UI { +namespace Toolbar { +class PencilToolbar : public Toolbar { +private: + EgeAdjustmentAction *_minpressure; + EgeAdjustmentAction *_maxpressure; + + XML::Node *_repr; + InkAction *_flatten_spiro_bspline; + InkAction *_flatten_simplify; + + InkSelectOneAction *_shape_action; + + InkToggleAction *_simplify; + + bool _freeze; + + Glib::RefPtr _minpressure_adj; + Glib::RefPtr _maxpressure_adj; + Glib::RefPtr _tolerance_adj; + + void add_freehand_mode_toggle(GtkActionGroup* mainActions, + bool tool_is_pencil); + void freehand_mode_changed(int mode); + Glib::ustring const freehand_tool_name(); + void minpressure_value_changed(); + void maxpressure_value_changed(); + static void use_pencil_pressure(InkToggleAction *itact, + gpointer data); + void tolerance_value_changed(); + void freehand_add_advanced_shape_options(GtkActionGroup* mainActions, bool tool_is_pencil); + void freehand_change_shape(int shape); + static void defaults(GtkWidget *widget, GObject *obj); + static void freehand_simplify_lpe(InkToggleAction* itact, GObject *data); + static void simplify_flatten(GtkWidget *widget, GObject *data); + static void flatten_spiro_bspline(GtkWidget *widget, gpointer data); + +protected: + PencilToolbar(SPDesktop *desktop) + : Toolbar(desktop), + _repr(nullptr), + _freeze(false), + _flatten_simplify(nullptr), + _simplify(nullptr) + {} + + ~PencilToolbar(); -void sp_pencil_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); -void sp_pen_toolbox_prep(SPDesktop * /*desktop*/, GtkActionGroup* mainActions, GObject* holder); +public: + static GtkWidget * prep_pencil(SPDesktop *desktop, GtkActionGroup* mainActions); + static GtkWidget * prep_pen(SPDesktop *desktop, GtkActionGroup* mainActions); +}; +} +} +} #endif /* !SEEN_PENCIL_TOOLBAR_H */ diff --git a/src/ui/toolbar/rect-toolbar.cpp b/src/ui/toolbar/rect-toolbar.cpp index cc615a35d..d4fa9d74f 100644 --- a/src/ui/toolbar/rect-toolbar.cpp +++ b/src/ui/toolbar/rect-toolbar.cpp @@ -61,55 +61,198 @@ using Inkscape::Util::Unit; using Inkscape::Util::Quantity; using Inkscape::Util::unit_table; +static Inkscape::XML::NodeEventVector rect_tb_repr_events = { + nullptr, /* child_added */ + nullptr, /* child_removed */ + Inkscape::UI::Toolbar::RectToolbar::event_attr_changed, + nullptr, /* content_changed */ + nullptr /* order_changed */ +}; -//######################## -//## Rect ## -//######################## +namespace Inkscape { +namespace UI { +namespace Toolbar { -static void sp_rtb_sensitivize( GObject *tbl ) +RectToolbar::RectToolbar(SPDesktop *desktop) + : Toolbar(desktop), + _tracker(new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR)), + _freeze(false), + _single(true) { - 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") ); + // rx/ry units menu: create + //tracker->addUnit( SP_UNIT_PERCENT, 0 ); + // fixme: add % meaning per cent of the width/height + _tracker->setActiveUnit(unit_table.getUnit("px")); +} - if (gtk_adjustment_get_value(adj1) == 0 && gtk_adjustment_get_value(adj2) == 0 && g_object_get_data(tbl, "single")) { // only for a single selected rect (for now) - gtk_action_set_sensitive( not_rounded, FALSE ); - } else { - gtk_action_set_sensitive( not_rounded, TRUE ); +RectToolbar::~RectToolbar() +{ + if (_repr) { // remove old listener + _repr->removeListenerByData(this); + Inkscape::GC::release(_repr); + _repr = nullptr; } } - -static void sp_rtb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *value_name, - void (SPRect::*setter)(gdouble)) +GtkWidget * +RectToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) { - SPDesktop *desktop = static_cast(g_object_get_data( tbl, "desktop" )); + auto holder = new RectToolbar(desktop); + + EgeAdjustmentAction* eact = nullptr; + GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); + + { + holder->_mode_action = ege_output_action_new( "RectStateAction", _("New:"), "", nullptr ); + ege_output_action_set_use_markup( holder->_mode_action, TRUE ); + gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_mode_action ) ); + } + + /* W */ + { + gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; + gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500}; + holder->_width_action = create_adjustment_action( "RectWidthAction", + _("Width"), _("W:"), _("Width of rectangle"), + "/tools/shapes/rect/width", 0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + TRUE, "altx-rect", + 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + holder->_tracker); + + holder->_width_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_width_action)); + holder->_width_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &RectToolbar::value_changed), + holder->_width_adj, + "width", + &SPRect::setVisibleWidth)); + gtk_action_set_sensitive( GTK_ACTION(holder->_width_action), FALSE ); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_width_action) ); + } + + /* H */ + { + gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; + gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500}; + holder->_height_action = create_adjustment_action( "RectHeightAction", + _("Height"), _("H:"), _("Height of rectangle"), + "/tools/shapes/rect/height", 0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + holder->_tracker); + holder->_height_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_height_action)); + holder->_height_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &RectToolbar::value_changed), + holder->_height_adj, + "height", + &SPRect::setVisibleHeight)); + gtk_action_set_sensitive( GTK_ACTION(holder->_height_action), FALSE ); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_height_action) ); + } + + /* rx */ + { + gchar const* labels[] = {_("not rounded"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; + gdouble values[] = {0.5, 1, 2, 3, 5, 10, 20, 50, 100}; + eact = create_adjustment_action( "RadiusXAction", + _("Horizontal radius"), _("Rx:"), _("Horizontal radius of rounded corners"), + "/tools/shapes/rect/rx", 0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + holder->_tracker); + holder->_rx_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + holder->_rx_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &RectToolbar::value_changed), + holder->_rx_adj, + "rx", + &SPRect::setVisibleRx)); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + } + + /* ry */ + { + gchar const* labels[] = {_("not rounded"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; + gdouble values[] = {0.5, 1, 2, 3, 5, 10, 20, 50, 100}; + eact = create_adjustment_action( "RadiusYAction", + _("Vertical radius"), _("Ry:"), _("Vertical radius of rounded corners"), + "/tools/shapes/rect/ry", 0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + holder->_tracker); + holder->_ry_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + holder->_ry_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &RectToolbar::value_changed), + holder->_ry_adj, + "ry", + &SPRect::setVisibleRy)); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + } + + // add the units menu + { + InkSelectOneAction* act = holder->_tracker->createAction( "RectUnitsAction", _("Units"), ("") ); + gtk_action_group_add_action( mainActions, act->gobj() ); + } - UnitTracker* tracker = reinterpret_cast(g_object_get_data( tbl, "tracker" )); - Unit const *unit = tracker->getActiveUnit(); + /* Reset */ + { + holder->_not_rounded = ink_action_new( "RectResetAction", + _("Not rounded"), + _("Make corners sharp"), + INKSCAPE_ICON("rectangle-make-corners-sharp"), + secondarySize ); + g_signal_connect_after( G_OBJECT(holder->_not_rounded), "activate", G_CALLBACK(&RectToolbar::defaults), holder ); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_not_rounded) ); + gtk_action_set_sensitive( GTK_ACTION(holder->_not_rounded), TRUE ); + } + + holder->sensitivize(); + + desktop->connectEventContextChanged(sigc::mem_fun(*holder, &RectToolbar::watch_ec)); + + return GTK_WIDGET(holder->gobj()); +} + +void +RectToolbar::value_changed(Glib::RefPtr& adj, + gchar const *value_name, + void (SPRect::*setter)(gdouble)) +{ + Unit const *unit = _tracker->getActiveUnit(); g_return_if_fail(unit != nullptr); - if (DocumentUndo::getUndoSensitive(desktop->getDocument())) { + if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); prefs->setDouble(Glib::ustring("/tools/shapes/rect/") + value_name, - Quantity::convert(gtk_adjustment_get_value(adj), unit, "px")); + Quantity::convert(adj->get_value(), unit, "px")); } // quit if run by the attr_changed listener - if (g_object_get_data( tbl, "freeze" ) || tracker->isUpdating()) { + if (_freeze || _tracker->isUpdating()) { return; } // in turn, prevent listener from responding - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE)); + _freeze = true; bool modmade = false; - Inkscape::Selection *selection = desktop->getSelection(); + Inkscape::Selection *selection = _desktop->getSelection(); auto itemlist= selection->items(); for(auto i=itemlist.begin();i!=itemlist.end();++i){ if (SP_IS_RECT(*i)) { - if (gtk_adjustment_get_value(adj) != 0) { - (SP_RECT(*i)->*setter)(Quantity::convert(gtk_adjustment_get_value(adj), unit, "px")); + if (adj->get_value() != 0) { + (SP_RECT(*i)->*setter)(Quantity::convert(adj->get_value(), unit, "px")); } else { (*i)->getRepr()->setAttribute(value_name, nullptr); } @@ -117,136 +260,86 @@ static void sp_rtb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const * } } - sp_rtb_sensitivize( tbl ); + sensitivize(); if (modmade) { - DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_RECT, + DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_RECT, _("Change rectangle")); } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + _freeze = false; } -static void sp_rtb_rx_value_changed(GtkAdjustment *adj, GObject *tbl) +void +RectToolbar::sensitivize() { - sp_rtb_value_changed(adj, tbl, "rx", &SPRect::setVisibleRx); -} - -static void sp_rtb_ry_value_changed(GtkAdjustment *adj, GObject *tbl) -{ - sp_rtb_value_changed(adj, tbl, "ry", &SPRect::setVisibleRy); -} - -static void sp_rtb_width_value_changed(GtkAdjustment *adj, GObject *tbl) -{ - sp_rtb_value_changed(adj, tbl, "width", &SPRect::setVisibleWidth); + if (_rx_adj->get_value() == 0 && _ry_adj->get_value() == 0 && _single) { // only for a single selected rect (for now) + gtk_action_set_sensitive( GTK_ACTION(_not_rounded), FALSE ); + } else { + gtk_action_set_sensitive( GTK_ACTION(_not_rounded), TRUE ); + } } -static void sp_rtb_height_value_changed(GtkAdjustment *adj, GObject *tbl) +void +RectToolbar::defaults( GtkWidget * /*widget*/, GObject *obj) { - sp_rtb_value_changed(adj, tbl, "height", &SPRect::setVisibleHeight); -} - + auto toolbar = reinterpret_cast(obj); - -static void sp_rtb_defaults( GtkWidget * /*widget*/, GObject *obj) -{ - GtkAdjustment *adj = nullptr; - - adj = GTK_ADJUSTMENT( g_object_get_data(obj, "rx") ); - gtk_adjustment_set_value(adj, 0.0); + toolbar->_rx_adj->set_value(0.0); + toolbar->_ry_adj->set_value(0.0); #if !GTK_CHECK_VERSION(3,18,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); + toolbar->_rx_adj->value_changed(); + toolbar->_ry_adj->value_changed(); #endif - adj = GTK_ADJUSTMENT( g_object_get_data(obj, "ry") ); - gtk_adjustment_set_value(adj, 0.0); - -#if !GTK_CHECK_VERSION(3,18,0) - gtk_adjustment_value_changed(adj); -#endif - - sp_rtb_sensitivize( obj ); + toolbar->sensitivize(); } -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) +void +RectToolbar::watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec) { - GObject *tbl = G_OBJECT(data); - - // quit if run by the _changed callbacks - if (g_object_get_data( tbl, "freeze" )) { - return; - } - - // in turn, prevent callbacks from responding - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); - - UnitTracker* tracker = reinterpret_cast( g_object_get_data( tbl, "tracker" ) ); - Unit const *unit = tracker->getActiveUnit(); - g_return_if_fail(unit != nullptr); - - gpointer item = g_object_get_data( tbl, "item" ); - if (item && SP_IS_RECT(item)) { - { - GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "rx" ) ); - - gdouble rx = SP_RECT(item)->getVisibleRx(); - gtk_adjustment_set_value(adj, Quantity::convert(rx, "px", unit)); - } - - { - GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "ry" ) ); - - gdouble ry = SP_RECT(item)->getVisibleRy(); - gtk_adjustment_set_value(adj, Quantity::convert(ry, "px", unit)); - } + static sigc::connection changed; - { - GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "width" ) ); + // use of dynamic_cast<> seems wrong here -- we just need to check the current tool - gdouble width = SP_RECT(item)->getVisibleWidth(); - gtk_adjustment_set_value(adj, Quantity::convert(width, "px", unit)); - } + if (dynamic_cast(ec)) { + Inkscape::Selection *sel = desktop->getSelection(); - { - GtkAdjustment *adj = GTK_ADJUSTMENT( g_object_get_data( tbl, "height" ) ); + changed = sel->connectChanged(sigc::mem_fun(*this, &RectToolbar::selection_changed)); - gdouble height = SP_RECT(item)->getVisibleHeight(); - gtk_adjustment_set_value(adj, Quantity::convert(height, "px", unit)); + // Synthesize an emission to trigger the update + selection_changed(sel); + } else { + if (changed) { + changed.disconnect(); + + if (_repr) { // remove old listener + _repr->removeListenerByData(this); + Inkscape::GC::release(_repr); + _repr = nullptr; + } } } - - sp_rtb_sensitivize( tbl ); - - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); } - -static Inkscape::XML::NodeEventVector rect_tb_repr_events = { - nullptr, /* child_added */ - nullptr, /* child_removed */ - rect_tb_event_attr_changed, - nullptr, /* content_changed */ - nullptr /* order_changed */ -}; - /** * \param selection should not be NULL. */ -static void sp_rect_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl) +void +RectToolbar::selection_changed(Inkscape::Selection *selection) { int n_selected = 0; Inkscape::XML::Node *repr = nullptr; SPItem *item = nullptr; - if ( g_object_get_data( tbl, "repr" ) ) { - g_object_set_data( tbl, "item", nullptr ); + if (_repr) { // remove old listener + _item = nullptr; + _repr->removeListenerByData(this); + Inkscape::GC::release(_repr); + _repr = nullptr; } - purge_repr_listener( tbl, tbl ); auto itemlist= selection->items(); for(auto i=itemlist.begin();i!=itemlist.end();++i){ @@ -257,169 +350,80 @@ static void sp_rect_toolbox_selection_changed(Inkscape::Selection *selection, GO } } - EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) ); - - g_object_set_data( tbl, "single", GINT_TO_POINTER(FALSE) ); + _single = false; if (n_selected == 0) { - g_object_set( G_OBJECT(act), "label", _("New:"), NULL ); - - 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); - + gtk_action_set_label(GTK_ACTION(_mode_action), _("New:")); + gtk_action_set_sensitive(GTK_ACTION(_width_action), FALSE); + gtk_action_set_sensitive(GTK_ACTION(_height_action), FALSE); } else if (n_selected == 1) { - g_object_set( G_OBJECT(act), "label", _("Change:"), NULL ); - g_object_set_data( tbl, "single", GINT_TO_POINTER(TRUE) ); - - GtkAction* w = GTK_ACTION( g_object_get_data( tbl, "width_action" ) ); - gtk_action_set_sensitive(w, TRUE); - GtkAction* h = GTK_ACTION( g_object_get_data( tbl, "height_action" ) ); - gtk_action_set_sensitive(h, TRUE); + gtk_action_set_label(GTK_ACTION(_mode_action), _("Change:")); + _single = true; + gtk_action_set_sensitive(GTK_ACTION(_width_action), TRUE); + gtk_action_set_sensitive(GTK_ACTION(_height_action), TRUE); if (repr) { - 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); + _repr = repr; + _item = item; + Inkscape::GC::anchor(_repr); + _repr->addListener(&rect_tb_repr_events, this); + _repr->synthesizeEvents(&rect_tb_repr_events, this); } } else { // FIXME: implement averaging of all parameters for multiple selected //gtk_label_set_markup(GTK_LABEL(l), _("Average:")); - g_object_set( G_OBJECT(act), "label", _("Change:"), NULL ); - sp_rtb_sensitivize( tbl ); + gtk_action_set_label(GTK_ACTION(_mode_action), _("Change:")); + sensitivize(); } } -static void rect_toolbox_watch_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder); - -void sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) +void RectToolbar::event_attr_changed(Inkscape::XML::Node * /*repr*/, gchar const * /*name*/, + gchar const * /*old_value*/, gchar const * /*new_value*/, + bool /*is_interactive*/, gpointer data) { - EgeAdjustmentAction* eact = nullptr; - GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); + auto toolbar = reinterpret_cast(data); - { - EgeOutputAction* act = ege_output_action_new( "RectStateAction", _("New:"), "", nullptr ); - 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 ); + // quit if run by the _changed callbacks + if (toolbar->_freeze) { + return; } - // rx/ry units menu: create - UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR); - //tracker->addUnit( SP_UNIT_PERCENT, 0 ); - // fixme: add % meaning per cent of the width/height - tracker->setActiveUnit(unit_table.getUnit("px")); - g_object_set_data( holder, "tracker", tracker ); - - /* W */ - { - gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; - gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500}; - eact = create_adjustment_action( "RectWidthAction", - _("Width"), _("W:"), _("Width of rectangle"), - "/tools/shapes/rect/width", 0, - GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-rect", - 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP, - labels, values, G_N_ELEMENTS(labels), - sp_rtb_width_value_changed, tracker); - 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) ); - } + // in turn, prevent callbacks from responding + toolbar->_freeze = true; - /* H */ - { - gchar const* labels[] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; - gdouble values[] = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500}; - eact = create_adjustment_action( "RectHeightAction", - _("Height"), _("H:"), _("Height of rectangle"), - "/tools/shapes/rect/height", 0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, - 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP, - labels, values, G_N_ELEMENTS(labels), - sp_rtb_height_value_changed, tracker); - 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) ); - } + Unit const *unit = toolbar->_tracker->getActiveUnit(); + g_return_if_fail(unit != nullptr); - /* rx */ - { - gchar const* labels[] = {_("not rounded"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; - gdouble values[] = {0.5, 1, 2, 3, 5, 10, 20, 50, 100}; - eact = create_adjustment_action( "RadiusXAction", - _("Horizontal radius"), _("Rx:"), _("Horizontal radius of rounded corners"), - "/tools/shapes/rect/rx", 0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, - 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP, - labels, values, G_N_ELEMENTS(labels), - sp_rtb_rx_value_changed, tracker); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - } + if (toolbar->_item && SP_IS_RECT(toolbar->_item)) { + { + gdouble rx = SP_RECT(toolbar->_item)->getVisibleRx(); + toolbar->_rx_adj->set_value(Quantity::convert(rx, "px", unit)); + } - /* ry */ - { - gchar const* labels[] = {_("not rounded"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; - gdouble values[] = {0.5, 1, 2, 3, 5, 10, 20, 50, 100}; - eact = create_adjustment_action( "RadiusYAction", - _("Vertical radius"), _("Ry:"), _("Vertical radius of rounded corners"), - "/tools/shapes/rect/ry", 0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, - 0, 1e6, SPIN_STEP, SPIN_PAGE_STEP, - labels, values, G_N_ELEMENTS(labels), - sp_rtb_ry_value_changed, tracker); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - } + { + gdouble ry = SP_RECT(toolbar->_item)->getVisibleRy(); + toolbar->_ry_adj->set_value(Quantity::convert(ry, "px", unit)); + } - // add the units menu - { - InkSelectOneAction* act = tracker->createAction( "RectUnitsAction", _("Units"), ("") ); - gtk_action_group_add_action( mainActions, act->gobj() ); - } + { + gdouble width = SP_RECT(toolbar->_item)->getVisibleWidth(); + toolbar->_width_adj->set_value(Quantity::convert(width, "px", unit)); + } - /* Reset */ - { - InkAction* inky = ink_action_new( "RectResetAction", - _("Not rounded"), - _("Make corners sharp"), - INKSCAPE_ICON("rectangle-make-corners-sharp"), - secondarySize ); - g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_rtb_defaults), holder ); - gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); - gtk_action_set_sensitive( GTK_ACTION(inky), TRUE ); - g_object_set_data( holder, "not_rounded", inky ); + { + gdouble height = SP_RECT(toolbar->_item)->getVisibleHeight(); + toolbar->_height_adj->set_value(Quantity::convert(height, "px", unit)); + } } - g_object_set_data( holder, "single", GINT_TO_POINTER(TRUE) ); - sp_rtb_sensitivize( holder ); - - desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(rect_toolbox_watch_ec), holder)); - g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder ); + toolbar->sensitivize(); + toolbar->_freeze = false; } -static void rect_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec, GObject* holder) -{ - static sigc::connection changed; - - // use of dynamic_cast<> seems wrong here -- we just need to check the current tool - - if (dynamic_cast(ec)) { - Inkscape::Selection *sel = desktop->getSelection(); - - changed = sel->connectChanged(sigc::bind(sigc::ptr_fun(sp_rect_toolbox_selection_changed), holder)); - - // Synthesize an emission to trigger the update - sp_rect_toolbox_selection_changed(sel, holder); - } else { - if (changed) { - changed.disconnect(); - purge_repr_listener(nullptr, holder); - } - } } +} +} + /* Local Variables: diff --git a/src/ui/toolbar/rect-toolbar.h b/src/ui/toolbar/rect-toolbar.h index 9976d8a43..297ac5281 100644 --- a/src/ui/toolbar/rect-toolbar.h +++ b/src/ui/toolbar/rect-toolbar.h @@ -28,11 +28,85 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" + +#include + class SPDesktop; +class SPItem; +class SPRect; +typedef struct _EgeAdjustmentAction EgeAdjustmentAction; +typedef struct _EgeOutputAction EgeOutputAction; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; +typedef struct _InkAction InkAction; + +namespace Inkscape { +class Selection; + +namespace XML { +class Node; +} + +namespace UI { +namespace Tools { +class ToolBase; +} + +namespace Widget { +class UnitTracker; +} + +namespace Toolbar { +class RectToolbar : public Toolbar { +private: + EgeOutputAction *_mode_action; + + UI::Widget::UnitTracker *_tracker; + + XML::Node *_repr; + SPItem *_item; + + EgeAdjustmentAction *_width_action; + EgeAdjustmentAction *_height_action; + InkAction *_not_rounded; + + Glib::RefPtr _width_adj; + Glib::RefPtr _height_adj; + Glib::RefPtr _rx_adj; + Glib::RefPtr _ry_adj; + + bool _freeze; + bool _single; + + void value_changed(Glib::RefPtr& adj, + gchar const *value_name, + void (SPRect::*setter)(gdouble)); + + void sensitivize(); + static void defaults(GtkWidget *widget, + GObject *obj); + void watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec); + void selection_changed(Inkscape::Selection *selection); + +protected: + RectToolbar(SPDesktop *desktop); + ~RectToolbar(); + +public: + static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); + + static void event_attr_changed(Inkscape::XML::Node *repr, + gchar const *name, + gchar const *old_value, + gchar const *new_value, + bool is_interactive, + gpointer data); + +}; -void sp_rect_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +} +} +} #endif /* !SEEN_RECT_TOOLBAR_H */ diff --git a/src/ui/toolbar/select-toolbar.cpp b/src/ui/toolbar/select-toolbar.cpp index 0e1ad9c1b..604b185b7 100644 --- a/src/ui/toolbar/select-toolbar.cpp +++ b/src/ui/toolbar/select-toolbar.cpp @@ -44,7 +44,6 @@ #include "ui/widget/unit-tracker.h" #include "widgets/ege-adjustment-action.h" -#include "widgets/sp-widget.h" #include "widgets/widget-sizes.h" using Inkscape::UI::Widget::UnitTracker; @@ -53,219 +52,7 @@ using Inkscape::Util::Quantity; using Inkscape::DocumentUndo; using Inkscape::Util::unit_table; -static void -sp_selection_layout_widget_update(SPWidget *spw, Inkscape::Selection *sel) -{ - if (g_object_get_data(G_OBJECT(spw), "update")) { - return; - } - - g_object_set_data(G_OBJECT(spw), "update", GINT_TO_POINTER(TRUE)); - - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - using Geom::X; - using Geom::Y; - if ( sel && !sel->isEmpty() ) { - int prefs_bbox = prefs->getInt("/tools/bounding_box", 0); - SPItem::BBoxType bbox_type = (prefs_bbox ==0)? - SPItem::VISUAL_BBOX : SPItem::GEOMETRIC_BBOX; - Geom::OptRect const bbox(sel->bounds(bbox_type)); - if ( bbox ) { - UnitTracker *tracker = reinterpret_cast(g_object_get_data(G_OBJECT(spw), "tracker")); - Unit const *unit = tracker->getActiveUnit(); - g_return_if_fail(unit != nullptr); - struct { char const *key; double val; } const keyval[] = { - { "X", bbox->min()[X] }, - { "Y", bbox->min()[Y] }, - { "width", bbox->dimensions()[X] }, - { "height", bbox->dimensions()[Y] } - }; - - if (unit->type == Inkscape::Util::UNIT_TYPE_DIMENSIONLESS) { - double const val = unit->factor * 100; - for (auto i : keyval) { - GtkAdjustment *a = GTK_ADJUSTMENT(g_object_get_data(G_OBJECT(spw), i.key)); - gtk_adjustment_set_value(a, val); - tracker->setFullVal( a, i.val ); - } - } else { - for (auto i : keyval) { - GtkAdjustment *a = GTK_ADJUSTMENT(g_object_get_data(G_OBJECT(spw), i.key)); - gtk_adjustment_set_value(a, Quantity::convert(i.val, "px", unit)); - } - } - } - } - - g_object_set_data(G_OBJECT(spw), "update", GINT_TO_POINTER(FALSE)); -} - - -static void -sp_selection_layout_widget_modify_selection(SPWidget *spw, Inkscape::Selection *selection, guint flags, gpointer data) -{ - SPDesktop *desktop = static_cast(data); - if ((desktop->getSelection() == selection) // only respond to changes in our desktop - && (flags & (SP_OBJECT_MODIFIED_FLAG | - SP_OBJECT_PARENT_MODIFIED_FLAG | - SP_OBJECT_CHILD_MODIFIED_FLAG ))) - { - sp_selection_layout_widget_update(spw, selection); - } -} - -static void -sp_selection_layout_widget_change_selection(SPWidget *spw, Inkscape::Selection *selection, gpointer data) -{ - SPDesktop *desktop = static_cast(data); - if (desktop->getSelection() == selection) { // only respond to changes in our desktop - gboolean setActive = (selection && !selection->isEmpty()); - std::vector *contextActions = reinterpret_cast *>(g_object_get_data(G_OBJECT(spw), "contextActions")); - if ( contextActions ) { - for (auto & contextAction : *contextActions) { - if ( setActive != gtk_action_is_sensitive(contextAction) ) { - gtk_action_set_sensitive( contextAction, setActive ); - } - } - } - - sp_selection_layout_widget_update(spw, selection); - } -} - -static void -sp_object_layout_any_value_changed(GtkAdjustment *adj, GObject *tbl) -{ - if (g_object_get_data(tbl, "update")) { - return; - } - - UnitTracker *tracker = reinterpret_cast(g_object_get_data(tbl, "tracker")); - if ( !tracker || tracker->isUpdating() ) { - /* - * When only units are being changed, don't treat changes - * to adjuster values as object changes. - */ - return; - } - g_object_set_data(tbl, "update", GINT_TO_POINTER(TRUE)); - - SPDesktop *desktop = SP_ACTIVE_DESKTOP; - Inkscape::Selection *selection = desktop->getSelection(); - SPDocument *document = desktop->getDocument(); - - document->ensureUpToDate (); - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - - Geom::OptRect bbox_vis = selection->visualBounds(); - Geom::OptRect bbox_geom = selection->geometricBounds(); - - int prefs_bbox = prefs->getInt("/tools/bounding_box"); - SPItem::BBoxType bbox_type = (prefs_bbox == 0)? - SPItem::VISUAL_BBOX : SPItem::GEOMETRIC_BBOX; - Geom::OptRect bbox_user = selection->bounds(bbox_type); - - if ( !bbox_user ) { - g_object_set_data(tbl, "update", GINT_TO_POINTER(FALSE)); - return; - } - - gdouble x0 = 0; - gdouble y0 = 0; - gdouble x1 = 0; - gdouble y1 = 0; - gdouble xrel = 0; - gdouble yrel = 0; - Unit const *unit = tracker->getActiveUnit(); - g_return_if_fail(unit != nullptr); - - GtkAdjustment* a_x = GTK_ADJUSTMENT( g_object_get_data( tbl, "X" ) ); - GtkAdjustment* a_y = GTK_ADJUSTMENT( g_object_get_data( tbl, "Y" ) ); - GtkAdjustment* a_w = GTK_ADJUSTMENT( g_object_get_data( tbl, "width" ) ); - GtkAdjustment* a_h = GTK_ADJUSTMENT( g_object_get_data( tbl, "height" ) ); - - if (unit->type == Inkscape::Util::UNIT_TYPE_LINEAR) { - x0 = Quantity::convert(gtk_adjustment_get_value(a_x), unit, "px"); - y0 = Quantity::convert(gtk_adjustment_get_value(a_y), unit, "px"); - x1 = x0 + Quantity::convert(gtk_adjustment_get_value(a_w), unit, "px"); - xrel = Quantity::convert(gtk_adjustment_get_value(a_w), unit, "px") / bbox_user->dimensions()[Geom::X]; - y1 = y0 + Quantity::convert(gtk_adjustment_get_value(a_h), unit, "px");; - yrel = Quantity::convert(gtk_adjustment_get_value(a_h), unit, "px") / bbox_user->dimensions()[Geom::Y]; - } else { - double const x0_propn = gtk_adjustment_get_value (a_x) / 100 / unit->factor; - x0 = bbox_user->min()[Geom::X] * x0_propn; - double const y0_propn = gtk_adjustment_get_value (a_y) / 100 / unit->factor; - y0 = y0_propn * bbox_user->min()[Geom::Y]; - xrel = gtk_adjustment_get_value (a_w) / (100 / unit->factor); - x1 = x0 + xrel * bbox_user->dimensions()[Geom::X]; - yrel = gtk_adjustment_get_value (a_h) / (100 / unit->factor); - y1 = y0 + yrel * bbox_user->dimensions()[Geom::Y]; - } - - // Keep proportions if lock is on - GtkToggleAction *lock = GTK_TOGGLE_ACTION( g_object_get_data(tbl, "lock") ); - if ( gtk_toggle_action_get_active(lock) ) { - if (adj == a_h) { - x1 = x0 + yrel * bbox_user->dimensions()[Geom::X]; - } else if (adj == a_w) { - y1 = y0 + xrel * bbox_user->dimensions()[Geom::Y]; - } - } - - // scales and moves, in px - double mh = fabs(x0 - bbox_user->min()[Geom::X]); - double sh = fabs(x1 - bbox_user->max()[Geom::X]); - double mv = fabs(y0 - bbox_user->min()[Geom::Y]); - double sv = fabs(y1 - bbox_user->max()[Geom::Y]); - - // unless the unit is %, convert the scales and moves to the unit - if (unit->type == Inkscape::Util::UNIT_TYPE_LINEAR) { - mh = Quantity::convert(mh, "px", unit); - sh = Quantity::convert(sh, "px", unit); - mv = Quantity::convert(mv, "px", unit); - sv = Quantity::convert(sv, "px", unit); - } - - // do the action only if one of the scales/moves is greater than half the last significant - // digit in the spinbox (currently spinboxes have 3 fractional digits, so that makes 0.0005). If - // the value was changed by the user, the difference will be at least that much; otherwise it's - // just rounding difference between the spinbox value and actual value, so no action is - // performed - char const * const actionkey = ( mh > 5e-4 ? "selector:toolbar:move:horizontal" : - sh > 5e-4 ? "selector:toolbar:scale:horizontal" : - mv > 5e-4 ? "selector:toolbar:move:vertical" : - sv > 5e-4 ? "selector:toolbar:scale:vertical" : nullptr ); - - if (actionkey != nullptr) { - - // FIXME: fix for GTK breakage, see comment in SelectedStyle::on_opacity_changed - desktop->getCanvas()->forceFullRedrawAfterInterruptions(0); - - bool transform_stroke = prefs->getBool("/options/transform/stroke", true); - bool preserve = prefs->getBool("/options/preservetransform/value", false); - - Geom::Affine scaler; - if (bbox_type == SPItem::VISUAL_BBOX) { - scaler = get_scale_transform_for_variable_stroke (*bbox_vis, *bbox_geom, transform_stroke, preserve, x0, y0, x1, y1); - } else { - // 1) We could have use the newer get_scale_transform_for_variable_stroke() here, but to avoid regressions - // we'll just use the old get_scale_transform_for_uniform_stroke() for now. - // 2) get_scale_transform_for_uniform_stroke() is intended for visual bounding boxes, not geometrical ones! - // we'll trick it into using a geometric bounding box though, by setting the stroke width to zero - scaler = get_scale_transform_for_uniform_stroke (*bbox_geom, 0, 0, false, false, x0, y0, x1, y1); - } - - selection->applyAffine(scaler); - DocumentUndo::maybeDone(document, actionkey, SP_VERB_CONTEXT_SELECT, - _("Transform by toolbar")); - - // resume interruptibility - desktop->getCanvas()->endForcedFullRedraws(); - } - - g_object_set_data(tbl, "update", GINT_TO_POINTER(FALSE)); -} // toggle button callbacks and updaters @@ -330,15 +117,6 @@ static void toggle_lock( GtkToggleAction *act, gpointer /*data*/ ) { } } -static void destroy_tracker( GObject* obj, gpointer /*user_data*/ ) -{ - UnitTracker *tracker = reinterpret_cast(g_object_get_data(obj, "tracker")); - if ( tracker ) { - delete tracker; - g_object_set_data( obj, "tracker", nullptr ); - } -} - static void trigger_sp_action( GtkAction* /*act*/, gpointer user_data ) { SPAction* targetAction = SP_ACTION(user_data); @@ -360,70 +138,78 @@ static GtkAction* create_action_for_verb( Inkscape::Verb* verb, Inkscape::UI::Vi return act; } -void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) +namespace Inkscape { +namespace UI { +namespace Toolbar { + +SelectToolbar::SelectToolbar(SPDesktop *desktop) : + Toolbar(desktop), + _context_actions(new std::vector()), + _tracker(new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR)), + _update(false) +{} + +SelectToolbar::~SelectToolbar() +{ + delete _tracker; +} + +GtkWidget * +SelectToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) { + auto holder = new SelectToolbar(desktop); + Inkscape::UI::View::View *view = desktop; GtkIconSize secondarySize = Inkscape::UI::ToolboxFactory::prefToSize("/toolbox/secondary", 1); Inkscape::Preferences *prefs = Inkscape::Preferences::get(); GtkAction* act = nullptr; - GtkActionGroup* selectionActions = mainActions; // temporary - std::vector* contextActions = new std::vector(); + holder->_selection_actions = mainActions; // temporary act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_EDIT_SELECT_ALL), view, secondarySize ); - gtk_action_group_add_action( selectionActions, act ); + gtk_action_group_add_action( holder->_selection_actions, act ); act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_EDIT_SELECT_ALL_IN_ALL_LAYERS), view, secondarySize ); - gtk_action_group_add_action( selectionActions, act ); + gtk_action_group_add_action( holder->_selection_actions, act ); act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_EDIT_DESELECT), view, secondarySize ); - gtk_action_group_add_action( selectionActions, act ); - contextActions->push_back( act ); + gtk_action_group_add_action( holder->_selection_actions, act ); + holder->_context_actions->push_back( act ); act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_OBJECT_ROTATE_90_CCW), view, secondarySize ); - gtk_action_group_add_action( selectionActions, act ); - contextActions->push_back( act ); + gtk_action_group_add_action( holder->_selection_actions, act ); + holder->_context_actions->push_back( act ); act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_OBJECT_ROTATE_90_CW), view, secondarySize ); - gtk_action_group_add_action( selectionActions, act ); - contextActions->push_back( act ); + gtk_action_group_add_action( holder->_selection_actions, act ); + holder->_context_actions->push_back( act ); act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_OBJECT_FLIP_HORIZONTAL), view, secondarySize ); - gtk_action_group_add_action( selectionActions, act ); - contextActions->push_back( act ); + gtk_action_group_add_action( holder->_selection_actions, act ); + holder->_context_actions->push_back( act ); act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_OBJECT_FLIP_VERTICAL), view, secondarySize ); - gtk_action_group_add_action( selectionActions, act ); - contextActions->push_back( act ); + gtk_action_group_add_action( holder->_selection_actions, act ); + holder->_context_actions->push_back( act ); act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_SELECTION_TO_BACK), view, secondarySize ); - gtk_action_group_add_action( selectionActions, act ); - contextActions->push_back( act ); + gtk_action_group_add_action( holder->_selection_actions, act ); + holder->_context_actions->push_back( act ); act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_SELECTION_LOWER), view, secondarySize ); - gtk_action_group_add_action( selectionActions, act ); - contextActions->push_back( act ); + gtk_action_group_add_action( holder->_selection_actions, act ); + holder->_context_actions->push_back( act ); act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_SELECTION_RAISE), view, secondarySize ); - gtk_action_group_add_action( selectionActions, act ); - contextActions->push_back( act ); + gtk_action_group_add_action( holder->_selection_actions, act ); + holder->_context_actions->push_back( act ); act = create_action_for_verb( Inkscape::Verb::get(SP_VERB_SELECTION_TO_FRONT), view, secondarySize ); - gtk_action_group_add_action( selectionActions, act ); - contextActions->push_back( act ); + gtk_action_group_add_action( holder->_selection_actions, act ); + holder->_context_actions->push_back( act ); // Create the parent widget for x y w h tracker. - GtkWidget *spw = sp_widget_new_global(); - - // Remember the desktop's canvas widget, to be used for defocusing. - g_object_set_data(G_OBJECT(spw), "dtw", desktop->getCanvas()); - // The vb frame holds all other widgets and is used to set sensitivity depending on selection state. auto vb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_set_homogeneous(GTK_BOX(vb), FALSE); gtk_widget_show(vb); - gtk_container_add(GTK_CONTAINER(spw), vb); // Create the units menu. - UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR); - tracker->addUnit(unit_table.getUnit("%")); - tracker->setActiveUnit( desktop->getNamedView()->display_units ); - - g_object_set_data( G_OBJECT(spw), "tracker", tracker ); - g_signal_connect( G_OBJECT(spw), "destroy", G_CALLBACK(destroy_tracker), spw ); + holder->_tracker->addUnit(unit_table.getUnit("%")); + holder->_tracker->setActiveUnit( desktop->getNamedView()->display_units ); EgeAdjustmentAction* eact = nullptr; @@ -437,16 +223,18 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb "/tools/select/X", /* path */ 0.0, /* def(default) */ GTK_WIDGET(desktop->canvas), /* focusTarget */ - G_OBJECT(spw), /* dataKludge */ + nullptr, /* dataKludge */ TRUE, "altx", /* altx, altx_mark */ -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP, /* lower, upper, step, page */ - nullptr, nullptr, 0, /* descrLabels, descrValues, descrCount */ - sp_object_layout_any_value_changed, /* callback */ - tracker, /* unit_tracker */ + nullptr, nullptr, 0, /* descrLabels, descrValues, descrCount */ + nullptr, /* callback */ + holder->_tracker, /* unit_tracker */ SPIN_STEP, 3, 1); /* climb, digits, factor */ - gtk_action_group_add_action( selectionActions, GTK_ACTION(eact) ); - contextActions->push_back( GTK_ACTION(eact) ); + holder->_adj_x = Glib::wrap(GTK_ADJUSTMENT(ege_adjustment_action_get_adjustment(eact))); + holder->_adj_x->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &SelectToolbar::any_value_changed), holder->_adj_x)); + gtk_action_group_add_action( holder->_selection_actions, GTK_ACTION(eact) ); + holder->_context_actions->push_back( GTK_ACTION(eact) ); eact = create_adjustment_action( "YAction", /* name */ @@ -456,16 +244,18 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb "/tools/select/Y", /* path */ 0.0, /* def(default) */ GTK_WIDGET(desktop->canvas), /* focusTarget */ - G_OBJECT(spw), /* dataKludge */ + nullptr, /* dataKludge */ TRUE, "altx", /* altx, altx_mark */ -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP, /* lower, upper, step, page */ nullptr, nullptr, 0, /* descrLabels, descrValues, descrCount */ - sp_object_layout_any_value_changed, /* callback */ - tracker, /* unit_tracker */ + nullptr, /* callback */ + holder->_tracker, /* unit_tracker */ SPIN_STEP, 3, 1); /* climb, digits, factor */ - gtk_action_group_add_action( selectionActions, GTK_ACTION(eact) ); - contextActions->push_back( GTK_ACTION(eact) ); + holder->_adj_y = Glib::wrap(GTK_ADJUSTMENT(ege_adjustment_action_get_adjustment(eact))); + holder->_adj_y->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &SelectToolbar::any_value_changed), holder->_adj_y)); + gtk_action_group_add_action( holder->_selection_actions, GTK_ACTION(eact) ); + holder->_context_actions->push_back( GTK_ACTION(eact) ); eact = create_adjustment_action( "WidthAction", /* name */ @@ -475,28 +265,29 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb "/tools/select/width", /* path */ 0.0, /* def(default) */ GTK_WIDGET(desktop->canvas), /* focusTarget */ - G_OBJECT(spw), /* dataKludge */ + nullptr, /* dataKludge */ TRUE, "altx", /* altx, altx_mark */ 0.0, 1e6, SPIN_STEP, SPIN_PAGE_STEP, /* lower, upper, step, page */ nullptr, nullptr, 0, /* descrLabels, descrValues, descrCount */ - sp_object_layout_any_value_changed, /* callback */ - tracker, /* unit_tracker */ + nullptr, /* callback */ + holder->_tracker, /* unit_tracker */ SPIN_STEP, 3, 1); /* climb, digits, factor */ - gtk_action_group_add_action( selectionActions, GTK_ACTION(eact) ); - contextActions->push_back( GTK_ACTION(eact) ); + holder->_adj_w = Glib::wrap(GTK_ADJUSTMENT(ege_adjustment_action_get_adjustment(eact))); + holder->_adj_w->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &SelectToolbar::any_value_changed), holder->_adj_w)); + gtk_action_group_add_action( holder->_selection_actions, GTK_ACTION(eact) ); + holder->_context_actions->push_back( GTK_ACTION(eact) ); // lock toggle { - InkToggleAction* itact = ink_toggle_action_new( "LockAction", - _("Lock width and height"), - _("When locked, change both width and height by the same proportion"), - INKSCAPE_ICON("object-unlocked"), - GTK_ICON_SIZE_MENU ); - g_object_set( itact, "short_label", "Lock", NULL ); - g_object_set_data( G_OBJECT(spw), "lock", itact ); - g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(toggle_lock), desktop) ; - gtk_action_group_add_action( mainActions, GTK_ACTION(itact) ); + holder->_lock = GTK_TOGGLE_ACTION(ink_toggle_action_new( "LockAction", + _("Lock width and height"), + _("When locked, change both width and height by the same proportion"), + INKSCAPE_ICON("object-unlocked"), + GTK_ICON_SIZE_MENU )); + gtk_action_set_short_label( GTK_ACTION(holder->_lock), "Lock" ); + g_signal_connect_after( G_OBJECT(holder->_lock), "toggled", G_CALLBACK(toggle_lock), desktop) ; + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_lock) ); } eact = create_adjustment_action( @@ -507,50 +298,44 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb "/tools/select/height", /* path */ 0.0, /* def(default) */ GTK_WIDGET(desktop->canvas), /* focusTarget */ - G_OBJECT(spw), /* dataKludge */ + nullptr, /* dataKludge */ TRUE, "altx", /* altx, altx_mark */ 0.0, 1e6, SPIN_STEP, SPIN_PAGE_STEP, /* lower, upper, step, page */ nullptr, nullptr, 0, /* descrLabels, descrValues, descrCount */ - sp_object_layout_any_value_changed, /* callback */ - tracker, /* unit_tracker */ + nullptr, /* callback */ + holder->_tracker, /* unit_tracker */ SPIN_STEP, 3, 1); /* climb, digits, factor */ - gtk_action_group_add_action( selectionActions, GTK_ACTION(eact) ); - contextActions->push_back( GTK_ACTION(eact) ); + holder->_adj_h = Glib::wrap(GTK_ADJUSTMENT(ege_adjustment_action_get_adjustment(eact))); + holder->_adj_h->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*holder, &SelectToolbar::any_value_changed), holder->_adj_h)); + gtk_action_group_add_action( holder->_selection_actions, GTK_ACTION(eact) ); + holder->_context_actions->push_back( GTK_ACTION(eact) ); // Add the units menu. { - InkSelectOneAction* act = tracker->createAction( "UnitsAction", _("Units"), ("") ); - gtk_action_group_add_action( selectionActions, act->gobj() ); + InkSelectOneAction* act = holder->_tracker->createAction( "UnitsAction", _("Units"), ("") ); + gtk_action_group_add_action( holder->_selection_actions, act->gobj() ); } - g_object_set_data( G_OBJECT(spw), "selectionActions", selectionActions ); - g_object_set_data( G_OBJECT(spw), "contextActions", contextActions ); - // Force update when selection changes. - g_signal_connect(G_OBJECT(spw), "modify_selection", G_CALLBACK(sp_selection_layout_widget_modify_selection), desktop); - g_signal_connect(G_OBJECT(spw), "change_selection", G_CALLBACK(sp_selection_layout_widget_change_selection), desktop); + INKSCAPE.signal_selection_modified.connect(sigc::mem_fun(*holder, &SelectToolbar::on_inkscape_selection_modified)); + INKSCAPE.signal_selection_changed.connect(sigc::mem_fun(*holder, &SelectToolbar::on_inkscape_selection_changed)); // Update now. - sp_selection_layout_widget_update(SP_WIDGET(spw), SP_ACTIVE_DESKTOP ? SP_ACTIVE_DESKTOP->getSelection() : nullptr); + holder->layout_widget_update(SP_ACTIVE_DESKTOP ? SP_ACTIVE_DESKTOP->getSelection() : nullptr); - for (auto & contextAction : *contextActions) { + for (auto & contextAction : *holder->_context_actions) { if ( gtk_action_is_sensitive(contextAction) ) { gtk_action_set_sensitive( contextAction, FALSE ); } } - // Insert spw into the toolbar. - if ( GTK_IS_BOX(holder) ) { - gtk_box_pack_start(GTK_BOX(holder), spw, FALSE, FALSE, 0); - } else if ( GTK_IS_TOOLBAR(holder) ) { - GtkToolItem *spw_toolitem = gtk_tool_item_new(); - gtk_container_add(GTK_CONTAINER(spw_toolitem), spw); - gtk_toolbar_insert(GTK_TOOLBAR(holder), spw_toolitem, -1); - } else { - g_warning("Unexpected holder type"); - } + // Insert vb into the toolbar. + GtkToolItem *vb_toolitem = gtk_tool_item_new(); + gtk_container_add(GTK_CONTAINER(vb_toolitem), vb); + holder->insert(*Glib::wrap(vb_toolitem), -1); + // "Transform with object" buttons { @@ -596,8 +381,218 @@ void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GOb g_signal_connect_after( G_OBJECT(itact), "toggled", G_CALLBACK(toggle_pattern), desktop) ; gtk_action_group_add_action( mainActions, GTK_ACTION(itact) ); } + + return GTK_WIDGET(holder->gobj()); } +void +SelectToolbar::any_value_changed(Glib::RefPtr& adj) +{ + if (_update) { + return; + } + + if ( !_tracker || _tracker->isUpdating() ) { + /* + * When only units are being changed, don't treat changes + * to adjuster values as object changes. + */ + return; + } + _update = true; + + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + Inkscape::Selection *selection = desktop->getSelection(); + SPDocument *document = desktop->getDocument(); + + document->ensureUpToDate (); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + + Geom::OptRect bbox_vis = selection->visualBounds(); + Geom::OptRect bbox_geom = selection->geometricBounds(); + + int prefs_bbox = prefs->getInt("/tools/bounding_box"); + SPItem::BBoxType bbox_type = (prefs_bbox == 0)? + SPItem::VISUAL_BBOX : SPItem::GEOMETRIC_BBOX; + Geom::OptRect bbox_user = selection->bounds(bbox_type); + + if ( !bbox_user ) { + _update = false; + return; + } + + gdouble x0 = 0; + gdouble y0 = 0; + gdouble x1 = 0; + gdouble y1 = 0; + gdouble xrel = 0; + gdouble yrel = 0; + Unit const *unit = _tracker->getActiveUnit(); + g_return_if_fail(unit != nullptr); + + if (unit->type == Inkscape::Util::UNIT_TYPE_LINEAR) { + x0 = Quantity::convert(_adj_x->get_value(), unit, "px"); + y0 = Quantity::convert(_adj_y->get_value(), unit, "px"); + x1 = x0 + Quantity::convert(_adj_w->get_value(), unit, "px"); + xrel = Quantity::convert(_adj_w->get_value(), unit, "px") / bbox_user->dimensions()[Geom::X]; + y1 = y0 + Quantity::convert(_adj_h->get_value(), unit, "px");; + yrel = Quantity::convert(_adj_h->get_value(), unit, "px") / bbox_user->dimensions()[Geom::Y]; + } else { + double const x0_propn = _adj_x->get_value() / 100 / unit->factor; + x0 = bbox_user->min()[Geom::X] * x0_propn; + double const y0_propn = _adj_y->get_value() / 100 / unit->factor; + y0 = y0_propn * bbox_user->min()[Geom::Y]; + xrel = _adj_w->get_value() / (100 / unit->factor); + x1 = x0 + xrel * bbox_user->dimensions()[Geom::X]; + yrel = _adj_h->get_value() / (100 / unit->factor); + y1 = y0 + yrel * bbox_user->dimensions()[Geom::Y]; + } + + // Keep proportions if lock is on + if ( gtk_toggle_action_get_active(_lock) ) { + if (adj == _adj_h) { + x1 = x0 + yrel * bbox_user->dimensions()[Geom::X]; + } else if (adj == _adj_w) { + y1 = y0 + xrel * bbox_user->dimensions()[Geom::Y]; + } + } + + // scales and moves, in px + double mh = fabs(x0 - bbox_user->min()[Geom::X]); + double sh = fabs(x1 - bbox_user->max()[Geom::X]); + double mv = fabs(y0 - bbox_user->min()[Geom::Y]); + double sv = fabs(y1 - bbox_user->max()[Geom::Y]); + + // unless the unit is %, convert the scales and moves to the unit + if (unit->type == Inkscape::Util::UNIT_TYPE_LINEAR) { + mh = Quantity::convert(mh, "px", unit); + sh = Quantity::convert(sh, "px", unit); + mv = Quantity::convert(mv, "px", unit); + sv = Quantity::convert(sv, "px", unit); + } + + // do the action only if one of the scales/moves is greater than half the last significant + // digit in the spinbox (currently spinboxes have 3 fractional digits, so that makes 0.0005). If + // the value was changed by the user, the difference will be at least that much; otherwise it's + // just rounding difference between the spinbox value and actual value, so no action is + // performed + char const * const actionkey = ( mh > 5e-4 ? "selector:toolbar:move:horizontal" : + sh > 5e-4 ? "selector:toolbar:scale:horizontal" : + mv > 5e-4 ? "selector:toolbar:move:vertical" : + sv > 5e-4 ? "selector:toolbar:scale:vertical" : nullptr ); + + if (actionkey != nullptr) { + + // FIXME: fix for GTK breakage, see comment in SelectedStyle::on_opacity_changed + desktop->getCanvas()->forceFullRedrawAfterInterruptions(0); + + bool transform_stroke = prefs->getBool("/options/transform/stroke", true); + bool preserve = prefs->getBool("/options/preservetransform/value", false); + + Geom::Affine scaler; + if (bbox_type == SPItem::VISUAL_BBOX) { + scaler = get_scale_transform_for_variable_stroke (*bbox_vis, *bbox_geom, transform_stroke, preserve, x0, y0, x1, y1); + } else { + // 1) We could have use the newer get_scale_transform_for_variable_stroke() here, but to avoid regressions + // we'll just use the old get_scale_transform_for_uniform_stroke() for now. + // 2) get_scale_transform_for_uniform_stroke() is intended for visual bounding boxes, not geometrical ones! + // we'll trick it into using a geometric bounding box though, by setting the stroke width to zero + scaler = get_scale_transform_for_uniform_stroke (*bbox_geom, 0, 0, false, false, x0, y0, x1, y1); + } + + selection->applyAffine(scaler); + DocumentUndo::maybeDone(document, actionkey, SP_VERB_CONTEXT_SELECT, + _("Transform by toolbar")); + + // resume interruptibility + desktop->getCanvas()->endForcedFullRedraws(); + } + + _update = false; +} + +void +SelectToolbar::layout_widget_update(Inkscape::Selection *sel) +{ + if (_update) { + return; + } + + _update = true; + + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + using Geom::X; + using Geom::Y; + if ( sel && !sel->isEmpty() ) { + int prefs_bbox = prefs->getInt("/tools/bounding_box", 0); + SPItem::BBoxType bbox_type = (prefs_bbox ==0)? + SPItem::VISUAL_BBOX : SPItem::GEOMETRIC_BBOX; + Geom::OptRect const bbox(sel->bounds(bbox_type)); + if ( bbox ) { + Unit const *unit = _tracker->getActiveUnit(); + g_return_if_fail(unit != nullptr); + + struct { char const *key; double val; } const keyval[] = { + { "X", bbox->min()[X] }, + { "Y", bbox->min()[Y] }, + { "width", bbox->dimensions()[X] }, + { "height", bbox->dimensions()[Y] } + }; + + if (unit->type == Inkscape::Util::UNIT_TYPE_DIMENSIONLESS) { + double const val = unit->factor * 100; + _adj_x->set_value(val); + _adj_y->set_value(val); + _adj_w->set_value(val); + _adj_h->set_value(val); + _tracker->setFullVal( _adj_x->gobj(), keyval[0].val ); + _tracker->setFullVal( _adj_y->gobj(), keyval[1].val ); + _tracker->setFullVal( _adj_w->gobj(), keyval[2].val ); + _tracker->setFullVal( _adj_h->gobj(), keyval[3].val ); + } else { + _adj_x->set_value(Quantity::convert(keyval[0].val, "px", unit)); + _adj_y->set_value(Quantity::convert(keyval[1].val, "px", unit)); + _adj_w->set_value(Quantity::convert(keyval[2].val, "px", unit)); + _adj_h->set_value(Quantity::convert(keyval[3].val, "px", unit)); + } + } + } + + _update = false; +} + +void +SelectToolbar::on_inkscape_selection_modified(Inkscape::Selection *selection, guint flags) +{ + if ((_desktop->getSelection() == selection) // only respond to changes in our desktop + && (flags & (SP_OBJECT_MODIFIED_FLAG | + SP_OBJECT_PARENT_MODIFIED_FLAG | + SP_OBJECT_CHILD_MODIFIED_FLAG ))) + { + layout_widget_update(selection); + } +} + +void +SelectToolbar::on_inkscape_selection_changed(Inkscape::Selection *selection) +{ + if (_desktop->getSelection() == selection) { // only respond to changes in our desktop + gboolean setActive = (selection && !selection->isEmpty()); + if ( _context_actions ) { + for (auto & contextAction : *_context_actions) { + if ( setActive != gtk_action_is_sensitive(contextAction) ) { + gtk_action_set_sensitive( contextAction, setActive ); + } + } + } + + layout_widget_update(selection); + } +} + +} +} +} /* Local Variables: diff --git a/src/ui/toolbar/select-toolbar.h b/src/ui/toolbar/select-toolbar.h index d4862600e..1ad4a628d 100644 --- a/src/ui/toolbar/select-toolbar.h +++ b/src/ui/toolbar/select-toolbar.h @@ -15,14 +15,54 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" + class SPDesktop; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; -void sp_select_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +namespace Inkscape { +class Selection; + +namespace UI { + +namespace Widget { +class UnitTracker; +} + +namespace Toolbar { + +class SelectToolbar : public Toolbar { +private: + UI::Widget::UnitTracker *_tracker; + + Glib::RefPtr _adj_x; + Glib::RefPtr _adj_y; + Glib::RefPtr _adj_w; + Glib::RefPtr _adj_h; + GtkToggleAction *_lock; + + GtkActionGroup *_selection_actions; + std::vector *_context_actions; + + bool _update; + + void any_value_changed(Glib::RefPtr& adj); + void layout_widget_update(Inkscape::Selection *sel); + void on_inkscape_selection_modified(Inkscape::Selection *selection, guint flags); + void on_inkscape_selection_changed(Inkscape::Selection *selection); + +protected: + SelectToolbar(SPDesktop *desktop); + ~SelectToolbar(); +public: + static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); +}; +} +} +} #endif /* !SEEN_SELECT_TOOLBAR_H */ /* diff --git a/src/ui/toolbar/spiral-toolbar.cpp b/src/ui/toolbar/spiral-toolbar.cpp index 289dbfee6..acdf82b3b 100644 --- a/src/ui/toolbar/spiral-toolbar.cpp +++ b/src/ui/toolbar/spiral-toolbar.cpp @@ -53,38 +53,151 @@ using Inkscape::DocumentUndo; using Inkscape::UI::ToolboxFactory; using Inkscape::UI::PrefPusher; -//######################## -//## Spiral ## -//######################## +static Inkscape::XML::NodeEventVector spiral_tb_repr_events = { + nullptr, /* child_added */ + nullptr, /* child_removed */ + Inkscape::UI::Toolbar::SpiralToolbar::event_attr_changed, + nullptr, /* content_changed */ + nullptr /* order_changed */ +}; + +namespace Inkscape { +namespace UI { +namespace Toolbar { +SpiralToolbar::~SpiralToolbar() +{ + if(_repr) { + _repr->removeListenerByData(this); + GC::release(_repr); + _repr = nullptr; + } + + if(_connection) { + _connection->disconnect(); + delete _connection; + } +} -static void sp_spl_tb_value_changed(GtkAdjustment *adj, GObject *tbl, Glib::ustring const &value_name) +GtkWidget * +SpiralToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) { - SPDesktop *desktop = static_cast(g_object_get_data( tbl, "desktop" )); + auto toolbar = new SpiralToolbar(desktop); + + EgeAdjustmentAction* eact = nullptr; + GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); + + { + toolbar->_mode_action = ege_output_action_new( "SpiralStateAction", _("New:"), "", nullptr ); + ege_output_action_set_use_markup( toolbar->_mode_action, TRUE ); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_mode_action ) ); + } + + /* Revolution */ + { + gchar const* labels[] = {_("just a curve"), nullptr, _("one full revolution"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; + gdouble values[] = {0.01, 0.5, 1, 2, 3, 5, 10, 20, 50, 100}; + eact = create_adjustment_action( "SpiralRevolutionAction", + _("Number of turns"), _("Turns:"), _("Number of revolutions"), + "/tools/shapes/spiral/revolution", 3.0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + TRUE, "altx-spiral", + 0.01, 1024.0, 0.1, 1.0, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + nullptr /*unit tracker*/, 1, 2); + toolbar->_revolution_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + toolbar->_revolution_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*toolbar, &SpiralToolbar::value_changed), + toolbar->_revolution_adj, "revolution")); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + } + + /* Expansion */ + { + gchar const* labels[] = {_("circle"), _("edge is much denser"), _("edge is denser"), _("even"), _("center is denser"), _("center is much denser"), nullptr}; + gdouble values[] = {0, 0.1, 0.5, 1, 1.5, 5, 20}; + eact = create_adjustment_action( "SpiralExpansionAction", + _("Divergence"), _("Divergence:"), _("How much denser/sparser are outer revolutions; 1 = uniform"), + "/tools/shapes/spiral/expansion", 1.0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + 0.0, 1000.0, 0.01, 1.0, + labels, values, G_N_ELEMENTS(labels), + nullptr // dataKludge + ); + toolbar->_expansion_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + toolbar->_expansion_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*toolbar, &SpiralToolbar::value_changed), + toolbar->_expansion_adj, "expansion")); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + } - if (DocumentUndo::getUndoSensitive(desktop->getDocument())) { + /* T0 */ + { + gchar const* labels[] = {_("starts from center"), _("starts mid-way"), _("starts near edge")}; + gdouble values[] = {0, 0.5, 0.9}; + eact = create_adjustment_action( "SpiralT0Action", + _("Inner radius"), _("Inner radius:"), _("Radius of the innermost revolution (relative to the spiral size)"), + "/tools/shapes/spiral/t0", 0.0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + 0.0, 0.999, 0.01, 1.0, + labels, values, G_N_ELEMENTS(labels), + nullptr // callback + ); + toolbar->_t0_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + toolbar->_t0_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*toolbar, &SpiralToolbar::value_changed), + toolbar->_t0_adj, "t0")); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + } + + /* Reset */ + { + InkAction* inky = ink_action_new( "SpiralResetAction", + _("Defaults"), + _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"), + INKSCAPE_ICON("edit-clear"), + secondarySize ); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(&SpiralToolbar::defaults), toolbar ); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + } + + + toolbar->_connection = new sigc::connection( + desktop->getSelection()->connectChanged(sigc::mem_fun(*toolbar, &SpiralToolbar::selection_changed))); + + return GTK_WIDGET(toolbar->gobj()); +} + +void +SpiralToolbar::value_changed(Glib::RefPtr &adj, + Glib::ustring const &value_name) +{ + if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); prefs->setDouble("/tools/shapes/spiral/" + value_name, - gtk_adjustment_get_value(adj)); + adj->get_value()); } // quit if run by the attr_changed listener - if (g_object_get_data( tbl, "freeze" )) { + if (_freeze) { return; } // in turn, prevent listener from responding - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + _freeze = true; gchar* namespaced_name = g_strconcat("sodipodi:", value_name.data(), NULL); bool modmade = false; - auto itemlist= desktop->getSelection()->items(); + auto itemlist= _desktop->getSelection()->items(); for(auto i=itemlist.begin();i!=itemlist.end(); ++i){ SPItem *item = *i; if (SP_IS_SPIRAL(item)) { Inkscape::XML::Node *repr = item->getRepr(); sp_repr_set_svg_double( repr, namespaced_name, - gtk_adjustment_get_value(adj) ); + adj->get_value() ); item->updateRepr(); modmade = true; } @@ -93,112 +206,47 @@ static void sp_spl_tb_value_changed(GtkAdjustment *adj, GObject *tbl, Glib::ustr g_free(namespaced_name); if (modmade) { - DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_SPIRAL, + DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_SPIRAL, _("Change spiral")); } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + _freeze = false; } -static void sp_spl_tb_revolution_value_changed(GtkAdjustment *adj, GObject *tbl) +void +SpiralToolbar::defaults(GtkWidget * /*widget*/, GObject *obj) { - sp_spl_tb_value_changed(adj, tbl, "revolution"); -} - -static void 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, GObject *tbl) -{ - sp_spl_tb_value_changed(adj, tbl, "t0"); -} - -static void sp_spl_tb_defaults(GtkWidget * /*widget*/, GObject *obj) -{ - GtkWidget *tbl = GTK_WIDGET(obj); - - GtkAdjustment *adj; + auto toolbar = reinterpret_cast(obj); // fixme: make settable gdouble rev = 3; gdouble exp = 1.0; gdouble t0 = 0.0; - adj = GTK_ADJUSTMENT(g_object_get_data(obj, "revolution")); - gtk_adjustment_set_value(adj, rev); - -#if !GTK_CHECK_VERSION(3,18,0) - gtk_adjustment_value_changed(adj); -#endif - - adj = GTK_ADJUSTMENT(g_object_get_data(obj, "expansion")); - gtk_adjustment_set_value(adj, exp); - gtk_adjustment_value_changed(adj); - - adj = GTK_ADJUSTMENT(g_object_get_data(obj, "t0")); - gtk_adjustment_set_value(adj, t0); + toolbar->_revolution_adj->set_value(rev); + toolbar->_expansion_adj->set_value(exp); + toolbar->_t0_adj->set_value(t0); #if !GTK_CHECK_VERSION(3,18,0) - gtk_adjustment_value_changed(adj); + toolbar->_revolution_adj->value_changed(); + toolbar->_expansion_adj->value_changed(); + toolbar->_t0_adj->value_changed(); #endif - spinbutton_defocus(tbl); + if(toolbar->_desktop->canvas) gtk_widget_grab_focus(GTK_WIDGET(toolbar->_desktop->canvas)); } - -static void spiral_tb_event_attr_changed(Inkscape::XML::Node *repr, - gchar const * /*name*/, - gchar const * /*old_value*/, - gchar const * /*new_value*/, - bool /*is_interactive*/, - gpointer data) -{ - GtkWidget *tbl = GTK_WIDGET(data); - - // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { - return; - } - - // in turn, prevent callbacks from responding - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(TRUE)); - - GtkAdjustment *adj; - adj = GTK_ADJUSTMENT(g_object_get_data(G_OBJECT(tbl), "revolution")); - double revolution = 3.0; - sp_repr_get_double(repr, "sodipodi:revolution", &revolution); - gtk_adjustment_set_value(adj, revolution); - - adj = GTK_ADJUSTMENT(g_object_get_data(G_OBJECT(tbl), "expansion")); - double expansion = 1.0; - sp_repr_get_double(repr, "sodipodi:expansion", &expansion); - gtk_adjustment_set_value(adj, expansion); - - adj = GTK_ADJUSTMENT(g_object_get_data(G_OBJECT(tbl), "t0")); - double t0 = 0.0; - sp_repr_get_double(repr, "sodipodi:t0", &t0); - gtk_adjustment_set_value(adj, t0); - - g_object_set_data(G_OBJECT(tbl), "freeze", GINT_TO_POINTER(FALSE)); -} - - -static Inkscape::XML::NodeEventVector spiral_tb_repr_events = { - nullptr, /* child_added */ - nullptr, /* child_removed */ - spiral_tb_event_attr_changed, - nullptr, /* content_changed */ - nullptr /* order_changed */ -}; - -static void sp_spiral_toolbox_selection_changed(Inkscape::Selection *selection, GObject *tbl) +void +SpiralToolbar::selection_changed(Inkscape::Selection *selection) { int n_selected = 0; Inkscape::XML::Node *repr = nullptr; - purge_repr_listener( tbl, tbl ); + if ( _repr ) { + _repr->removeListenerByData(this); + GC::release(_repr); + _repr = nullptr; + } auto itemlist= selection->items(); for(auto i=itemlist.begin();i!=itemlist.end(); ++i){ @@ -209,100 +257,60 @@ static void sp_spiral_toolbox_selection_changed(Inkscape::Selection *selection, } } - EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( tbl, "mode_action" ) ); - if (n_selected == 0) { - g_object_set( G_OBJECT(act), "label", _("New:"), NULL ); + gtk_action_set_label(GTK_ACTION(_mode_action), _("New:")); } else if (n_selected == 1) { - g_object_set( G_OBJECT(act), "label", _("Change:"), NULL ); + gtk_action_set_label(GTK_ACTION(_mode_action), _("Change:")); if (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); + _repr = repr; + Inkscape::GC::anchor(_repr); + _repr->addListener(&spiral_tb_repr_events, this); + _repr->synthesizeEvents(&spiral_tb_repr_events, this); } } else { // FIXME: implement averaging of all parameters for multiple selected //gtk_label_set_markup(GTK_LABEL(l), _("Average:")); - g_object_set( G_OBJECT(act), "label", _("Change:"), NULL ); + gtk_action_set_label(GTK_ACTION(_mode_action), _("Change:")); } } - -void sp_spiral_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) +void +SpiralToolbar::event_attr_changed(Inkscape::XML::Node *repr, + gchar const * /*name*/, + gchar const * /*old_value*/, + gchar const * /*new_value*/, + bool /*is_interactive*/, + gpointer data) { - EgeAdjustmentAction* eact = nullptr; - GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); - - { - EgeOutputAction* act = ege_output_action_new( "SpiralStateAction", _("New:"), "", nullptr ); - 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 ); - } + auto toolbar = reinterpret_cast(data); - /* Revolution */ - { - gchar const* labels[] = {_("just a curve"), nullptr, _("one full revolution"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr}; - gdouble values[] = {0.01, 0.5, 1, 2, 3, 5, 10, 20, 50, 100}; - eact = create_adjustment_action( "SpiralRevolutionAction", - _("Number of turns"), _("Turns:"), _("Number of revolutions"), - "/tools/shapes/spiral/revolution", 3.0, - GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-spiral", - 0.01, 1024.0, 0.1, 1.0, - labels, values, G_N_ELEMENTS(labels), - sp_spl_tb_revolution_value_changed, nullptr /*unit tracker*/, 1, 2); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + // quit if run by the _changed callbacks + if (toolbar->_freeze) { + return; } - /* Expansion */ - { - gchar const* labels[] = {_("circle"), _("edge is much denser"), _("edge is denser"), _("even"), _("center is denser"), _("center is much denser"), nullptr}; - gdouble values[] = {0, 0.1, 0.5, 1, 1.5, 5, 20}; - eact = create_adjustment_action( "SpiralExpansionAction", - _("Divergence"), _("Divergence:"), _("How much denser/sparser are outer revolutions; 1 = uniform"), - "/tools/shapes/spiral/expansion", 1.0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, - 0.0, 1000.0, 0.01, 1.0, - labels, values, G_N_ELEMENTS(labels), - sp_spl_tb_expansion_value_changed); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - } + // in turn, prevent callbacks from responding + toolbar->_freeze = true; - /* T0 */ - { - gchar const* labels[] = {_("starts from center"), _("starts mid-way"), _("starts near edge")}; - gdouble values[] = {0, 0.5, 0.9}; - eact = create_adjustment_action( "SpiralT0Action", - _("Inner radius"), _("Inner radius:"), _("Radius of the innermost revolution (relative to the spiral size)"), - "/tools/shapes/spiral/t0", 0.0, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, - 0.0, 0.999, 0.01, 1.0, - labels, values, G_N_ELEMENTS(labels), - sp_spl_tb_t0_value_changed); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - } + double revolution = 3.0; + sp_repr_get_double(repr, "sodipodi:revolution", &revolution); + toolbar->_revolution_adj->set_value(revolution); - /* Reset */ - { - InkAction* inky = ink_action_new( "SpiralResetAction", - _("Defaults"), - _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"), - INKSCAPE_ICON("edit-clear"), - secondarySize ); - g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_spl_tb_defaults), holder ); - gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); - } + double expansion = 1.0; + sp_repr_get_double(repr, "sodipodi:expansion", &expansion); + toolbar->_expansion_adj->set_value(expansion); + double t0 = 0.0; + sp_repr_get_double(repr, "sodipodi:t0", &t0); + toolbar->_t0_adj->set_value(t0); - sigc::connection *connection = new sigc::connection( - desktop->getSelection()->connectChanged(sigc::bind(sigc::ptr_fun(sp_spiral_toolbox_selection_changed), holder)) - ); - g_signal_connect( holder, "destroy", G_CALLBACK(delete_connection), connection ); - g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder ); + toolbar->_freeze = false; } +} +} +} /* Local Variables: diff --git a/src/ui/toolbar/spiral-toolbar.h b/src/ui/toolbar/spiral-toolbar.h index d57b4fa09..cec8ddae4 100644 --- a/src/ui/toolbar/spiral-toolbar.h +++ b/src/ui/toolbar/spiral-toolbar.h @@ -28,11 +28,65 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" + +#include + class SPDesktop; +typedef struct _EgeOutputAction EgeOutputAction; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; -void sp_spiral_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +namespace Inkscape { +class Selection; + +namespace XML { +class Node; +} + +namespace UI { +namespace Toolbar { +class SpiralToolbar : public Toolbar { +private: + EgeOutputAction *_mode_action; + + Glib::RefPtr _revolution_adj; + Glib::RefPtr _expansion_adj; + Glib::RefPtr _t0_adj; + + bool _freeze; + + XML::Node *_repr; + + void value_changed(Glib::RefPtr &adj, + Glib::ustring const &value_name); + static void defaults(GtkWidget *widget, + GObject *obj); + void selection_changed(Inkscape::Selection *selection); + + sigc::connection *_connection; + +protected: + SpiralToolbar(SPDesktop *desktop) : + Toolbar(desktop), + _freeze(false), + _repr(nullptr) + {} + + ~SpiralToolbar(); + +public: + static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); + + static void event_attr_changed(Inkscape::XML::Node *repr, + gchar const *name, + gchar const *old_value, + gchar const *new_value, + bool is_interactive, + gpointer data); +}; +} +} +} #endif /* !SEEN_SPIRAL_TOOLBAR_H */ diff --git a/src/ui/toolbar/spray-toolbar.cpp b/src/ui/toolbar/spray-toolbar.cpp index a8bfabac9..c0c945ffe 100644 --- a/src/ui/toolbar/spray-toolbar.cpp +++ b/src/ui/toolbar/spray-toolbar.cpp @@ -26,9 +26,9 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ -#include - #include "spray-toolbar.h" + + #include "desktop.h" #include "inkscape.h" #include "widgets/ege-adjustment-action.h" @@ -54,75 +54,6 @@ using Inkscape::UI::PrefPusher; //## Spray ## //######################## -static void sp_stb_update_widgets( GObject *tbl ) -{ - GtkAction* offset = GTK_ACTION( g_object_get_data(tbl, "offset") ); - GtkAction* spray_scale = GTK_ACTION( g_object_get_data(tbl, "spray_scale") ); - GtkAdjustment *adj_offset = ege_adjustment_action_get_adjustment( EGE_ADJUSTMENT_ACTION(offset) ); - GtkAdjustment *adj_scale = ege_adjustment_action_get_adjustment( EGE_ADJUSTMENT_ACTION(spray_scale) ); - GtkAction *no_overlap_action = GTK_ACTION( g_object_get_data(tbl, "no_overlap") ); - GtkToggleAction *no_overlap = GTK_TOGGLE_ACTION( g_object_get_data(tbl, "no_overlap") ); - GtkAction *picker_action = GTK_ACTION( g_object_get_data(tbl, "picker") ); - GtkToggleAction *picker = GTK_TOGGLE_ACTION( g_object_get_data(tbl, "picker") ); - GtkToggleAction *usepressurescale = GTK_TOGGLE_ACTION( g_object_get_data(tbl, "usepressurescale") ); - GtkAction *pick_fill = GTK_ACTION( g_object_get_data(tbl, "pick_fill") ); - GtkAction *pick_stroke = GTK_ACTION( g_object_get_data(tbl, "pick_stroke") ); - GtkAction *pick_inverse_value = GTK_ACTION( g_object_get_data(tbl, "pick_inverse_value") ); - GtkAction *pick_center = GTK_ACTION( g_object_get_data(tbl, "pick_center") ); - gtk_adjustment_set_value( adj_offset, 100.0 ); - if (gtk_toggle_action_get_active(no_overlap) && gtk_action_get_visible(no_overlap_action)) { - gtk_action_set_visible( offset, true ); - } else { - gtk_action_set_visible( offset, false ); - } - if (gtk_toggle_action_get_active(usepressurescale)) { - gtk_adjustment_set_value( adj_scale, 0.0 ); - gtk_action_set_sensitive( spray_scale, false ); - } else { - gtk_action_set_sensitive( spray_scale, true ); - } - if(gtk_toggle_action_get_active(picker) && gtk_action_get_visible(picker_action)){ - gtk_action_set_visible( pick_fill, true ); - gtk_action_set_visible( pick_stroke, true ); - gtk_action_set_visible( pick_inverse_value, true ); - gtk_action_set_visible( pick_center, true ); - } else { - gtk_action_set_visible( pick_fill, false ); - gtk_action_set_visible( pick_stroke, false ); - gtk_action_set_visible( pick_inverse_value, false ); - gtk_action_set_visible( pick_center, false ); - } -} - -static void sp_spray_init( GObject *tbl){ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - int mode = prefs->getInt("/tools/spray/mode", 0); - - bool show = true; - if(mode == 3 || mode == 2){ - show = false; - } - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "no_overlap") ), show ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "over_no_transparent") ), show ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "over_transparent") ), show ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "pick_no_overlap") ), show ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "pick_stroke") ), show ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "pick_fill") ), show ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "pick_inverse_value") ), show ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "pick_center") ), show ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "picker") ), show ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "offset") ), show ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "pick_fill") ), show ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "pick_stroke") ), show ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "pick_inverse_value") ), show ); - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "pick_center") ), show ); - if(mode == 2){ - show = true; - } - gtk_action_set_visible( GTK_ACTION( g_object_get_data(tbl, "spray_rotation") ), show ); - sp_stb_update_widgets( tbl ); -} - Inkscape::UI::Dialog::CloneTiler *get_clone_tiler_panel(SPDesktop *desktop) { if (Inkscape::UI::Dialog::PanelDialogBase *panel_dialog = @@ -137,152 +68,21 @@ Inkscape::UI::Dialog::CloneTiler *get_clone_tiler_panel(SPDesktop *desktop) return nullptr; } -static void sp_spray_width_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/spray/width", - gtk_adjustment_get_value(adj)); -} - -static void sp_spray_mean_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/spray/mean", - gtk_adjustment_get_value(adj)); -} - -static void sp_spray_standard_deviation_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/spray/standard_deviation", - gtk_adjustment_get_value(adj)); -} - -static void sp_spray_mode_changed( GObject *tbl, int mode ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setInt("/tools/spray/mode", mode); - sp_spray_init(tbl); -} - -static void sp_spray_population_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/spray/population", - gtk_adjustment_get_value(adj)); -} -static void sp_spray_rotation_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ ) +namespace Inkscape { +namespace UI { +namespace Toolbar { +SprayToolbar::~SprayToolbar() { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/spray/rotation_variation", - gtk_adjustment_get_value(adj)); + delete _usepressurewidth_pusher; + delete _usepressurepopulation_pusher; } -static void sp_spray_scale_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ ) +GtkWidget * +SprayToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/spray/scale_variation", - gtk_adjustment_get_value(adj)); -} + auto holder = new SprayToolbar(desktop); -static void sp_spray_offset_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/spray/offset", - gtk_adjustment_get_value(adj)); -} - -static void sp_toggle_no_overlap( GtkToggleAction* act, gpointer data) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - gboolean active = gtk_toggle_action_get_active(act); - prefs->setBool("/tools/spray/no_overlap", active); - GObject *tbl = G_OBJECT(data); - sp_stb_update_widgets(tbl); -} - -static void sp_toggle_pressure_scale( GtkToggleAction* act, gpointer data) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - gboolean active = gtk_toggle_action_get_active(act); - prefs->setBool("/tools/spray/usepressurescale", active); - if(active){ - prefs->setDouble("/tools/spray/scale_variation", 0); - } - GObject *tbl = G_OBJECT(data); - sp_stb_update_widgets( tbl ); -} - -static void sp_toggle_over_no_transparent( GtkToggleAction* act, gpointer data) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - gboolean active = gtk_toggle_action_get_active(act); - prefs->setBool("/tools/spray/over_no_transparent", active); -} - -static void sp_toggle_over_transparent( GtkToggleAction* act, gpointer data) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - gboolean active = gtk_toggle_action_get_active(act); - prefs->setBool("/tools/spray/over_transparent", active); -} - - -static void sp_toggle_picker( GtkToggleAction* act, gpointer data ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - gboolean active = gtk_toggle_action_get_active(act); - prefs->setBool("/tools/spray/picker", active); - if(active){ - prefs->setBool("/dialogs/clonetiler/dotrace", false); - SPDesktop *dt = SP_ACTIVE_DESKTOP; - if (Inkscape::UI::Dialog::CloneTiler *ct = get_clone_tiler_panel(dt)){ - dt->_dlg_mgr->showDialog("CloneTiler"); - ct->show_page_trace(); - } - } - GObject *tbl = G_OBJECT(data); - sp_stb_update_widgets(tbl); -} - -static void sp_toggle_pick_center( GtkToggleAction* act, gpointer data ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - gboolean active = gtk_toggle_action_get_active(act); - prefs->setBool("/tools/spray/pick_center", active); -} - -static void sp_toggle_pick_fill( GtkToggleAction* act, gpointer data ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - gboolean active = gtk_toggle_action_get_active(act); - prefs->setBool("/tools/spray/pick_fill", active); -} - -static void sp_toggle_pick_stroke( GtkToggleAction* act, gpointer data ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - gboolean active = gtk_toggle_action_get_active(act); - prefs->setBool("/tools/spray/pick_stroke", active); -} - -static void sp_toggle_pick_no_overlap( GtkToggleAction* act, gpointer data ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - gboolean active = gtk_toggle_action_get_active(act); - prefs->setBool("/tools/spray/pick_no_overlap", active); -} - -static void sp_toggle_pick_inverse_value( GtkToggleAction* act, gpointer data ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - gboolean active = gtk_toggle_action_get_active(act); - prefs->setBool("/tools/spray/pick_inverse_value", active); -} - -void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) -{ GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); Inkscape::Preferences *prefs = Inkscape::Preferences::get(); { @@ -292,10 +92,15 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj EgeAdjustmentAction *eact = create_adjustment_action( "SprayWidthAction", _("Width"), _("Width:"), _("The width of the spray area (relative to the visible canvas area)"), "/tools/spray/width", 15, - GTK_WIDGET(desktop->canvas), holder, true, "altx-spray", + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + true, "altx-spray", 1, 100, 1.0, 10.0, labels, values, G_N_ELEMENTS(labels), - sp_spray_width_value_changed, nullptr /*unit tracker*/, 1, 0 ); + nullptr, // callback + nullptr /*unit tracker*/, 1, 0 ); + holder->_width_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + holder->_width_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &SprayToolbar::width_value_changed)); ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), true ); @@ -309,9 +114,7 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj INKSCAPE_ICON("draw-use-pressure"), GTK_ICON_SIZE_MENU ); gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); - PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/spray/usepressurewidth"); - g_signal_connect(holder, "destroy", G_CALLBACK(delete_prefspusher), pusher); - + holder->_usepressurewidth_pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/spray/usepressurewidth"); } { @@ -321,10 +124,15 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj EgeAdjustmentAction *eact = create_adjustment_action( "SprayMeanAction", _("Focus"), _("Focus:"), _("0 to spray a spot; increase to enlarge the ring radius"), "/tools/spray/mean", 0, - GTK_WIDGET(desktop->canvas), holder, true, "spray-mean", + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + true, "spray-mean", 0, 100, 1.0, 10.0, labels, values, G_N_ELEMENTS(labels), - sp_spray_mean_value_changed, nullptr /*unit tracker*/, 1, 0 ); + nullptr, // callback + nullptr /*unit tracker*/, 1, 0 ); + holder->_mean_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + holder->_mean_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &SprayToolbar::mean_value_changed)); ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), true ); @@ -337,10 +145,15 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj EgeAdjustmentAction *eact = create_adjustment_action( "SprayStandard_deviationAction", C_("Spray tool", "Scatter"), C_("Spray tool", "Scatter:"), _("Increase to scatter sprayed objects"), "/tools/spray/standard_deviation", 70, - GTK_WIDGET(desktop->canvas), holder, true, "spray-standard_deviation", + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + true, "spray-standard_deviation", 1, 100, 1.0, 10.0, labels, values, G_N_ELEMENTS(labels), - sp_spray_standard_deviation_value_changed, nullptr /*unit tracker*/, 1, 0 ); + nullptr, // callback + nullptr /*unit tracker*/, 1, 0 ); + holder->_sd_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + holder->_sd_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &SprayToolbar::standard_deviation_value_changed)); ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), true ); @@ -380,39 +193,40 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj row[columns.col_icon ] = INKSCAPE_ICON("draw-eraser"); row[columns.col_sensitive] = true; - InkSelectOneAction* act = + holder->_spray_tool_mode = InkSelectOneAction::create( "SprayModeAction", // Name _("Mode"), // Label "", // Tooltip "Not Used", // Icon store ); // Tree store - act->use_radio( true ); - act->use_group_label( true ); + holder->_spray_tool_mode->use_radio( true ); + holder->_spray_tool_mode->use_group_label( true ); gint mode = prefs->getInt("/tools/spray/mode", 1); - act->set_active( mode ); - - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( holder, "spray_tool_mode", act ); - - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_spray_mode_changed), holder)); + holder->_spray_tool_mode->set_active( mode ); + gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_spray_tool_mode->gobj() )); + holder->_spray_tool_mode->signal_changed().connect(sigc::mem_fun(*holder, &SprayToolbar::mode_changed)); } { /* Population */ gchar const* labels[] = {_("(low population)"), nullptr, nullptr, nullptr, _("(default)"), nullptr, _("(high population)")}; gdouble values[] = {5, 20, 35, 50, 70, 85, 100}; - EgeAdjustmentAction *eact = create_adjustment_action( "SprayPopulationAction", + holder->_spray_population = create_adjustment_action( "SprayPopulationAction", _("Amount"), _("Amount:"), _("Adjusts the number of items sprayed per click"), "/tools/spray/population", 70, - GTK_WIDGET(desktop->canvas), holder, true, "spray-population", + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + true, "spray-population", 1, 100, 1.0, 10.0, labels, values, G_N_ELEMENTS(labels), - sp_spray_population_value_changed, nullptr /*unit tracker*/, 1, 0 ); - ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - gtk_action_set_sensitive( GTK_ACTION(eact), true ); - g_object_set_data( holder, "spray_population", eact ); + nullptr, // callback + nullptr /*unit tracker*/, 1, 0 ); + holder->_population_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_spray_population)); + holder->_population_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &SprayToolbar::population_value_changed)); + ege_adjustment_action_set_appearance( holder->_spray_population, TOOLBAR_SLIDER_HINT ); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_spray_population) ); + gtk_action_set_sensitive( GTK_ACTION(holder->_spray_population), true ); } /* Use Pressure Population button */ @@ -423,196 +237,433 @@ void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj INKSCAPE_ICON("draw-use-pressure"), GTK_ICON_SIZE_MENU ); gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); - PrefPusher *pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/spray/usepressurepopulation"); - g_signal_connect(holder, "destroy", G_CALLBACK(delete_prefspusher), pusher); - + holder->_usepressurepopulation_pusher = new PrefPusher(GTK_TOGGLE_ACTION(act), "/tools/spray/usepressurepopulation"); } { /* Rotation */ gchar const* labels[] = {_("(default)"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, _("(high rotation variation)")}; gdouble values[] = {0, 10, 25, 35, 50, 60, 80, 100}; - EgeAdjustmentAction *eact = create_adjustment_action( "SprayRotationAction", - _("Rotation"), _("Rotation:"), - // xgettext:no-c-format - _("Variation of the rotation of the sprayed objects; 0% for the same rotation than the original object"), - "/tools/spray/rotation_variation", 0, - GTK_WIDGET(desktop->canvas), holder, true, "spray-rotation", - 0, 100, 1.0, 10.0, - labels, values, G_N_ELEMENTS(labels), - sp_spray_rotation_value_changed, nullptr /*unit tracker*/, 1, 0 ); - ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - gtk_action_set_sensitive( GTK_ACTION(eact), true ); - g_object_set_data( holder, "spray_rotation", eact ); + holder->_spray_rotation = create_adjustment_action( "SprayRotationAction", + _("Rotation"), _("Rotation:"), + // xgettext:no-c-format + _("Variation of the rotation of the sprayed objects; 0% for the same rotation than the original object"), + "/tools/spray/rotation_variation", 0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + true, "spray-rotation", + 0, 100, 1.0, 10.0, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + nullptr /*unit tracker*/, 1, 0 ); + holder->_rotation_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_spray_rotation)); + holder->_rotation_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &SprayToolbar::rotation_value_changed)); + ege_adjustment_action_set_appearance(holder->_spray_rotation, TOOLBAR_SLIDER_HINT ); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_spray_rotation) ); + gtk_action_set_sensitive( GTK_ACTION(holder->_spray_rotation), true ); } { /* Scale */ gchar const* labels[] = {_("(default)"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, _("(high scale variation)")}; gdouble values[] = {0, 10, 25, 35, 50, 60, 80, 100}; - EgeAdjustmentAction *eact = create_adjustment_action( "SprayScaleAction", + holder->_spray_scale = create_adjustment_action( "SprayScaleAction", C_("Spray tool", "Scale"), C_("Spray tool", "Scale:"), // xgettext:no-c-format _("Variation in the scale of the sprayed objects; 0% for the same scale than the original object"), "/tools/spray/scale_variation", 0, - GTK_WIDGET(desktop->canvas), holder, true, "spray-scale", + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + true, "spray-scale", 0, 100, 1.0, 10.0, labels, values, G_N_ELEMENTS(labels), - sp_spray_scale_value_changed, nullptr /*unit tracker*/, 1, 0 ); - ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - gtk_action_set_sensitive( GTK_ACTION(eact), true ); - g_object_set_data( holder, "spray_scale", eact ); + nullptr, // callback + nullptr /*unit tracker*/, 1, 0 ); + holder->_scale_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_spray_scale)); + holder->_scale_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &SprayToolbar::scale_value_changed)); + ege_adjustment_action_set_appearance( holder->_spray_scale, TOOLBAR_SLIDER_HINT ); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_spray_scale) ); + gtk_action_set_sensitive( GTK_ACTION(holder->_spray_scale), true ); } /* Use Pressure Scale button */ { - InkToggleAction* act = ink_toggle_action_new( "SprayPressureScaleAction", - _("Pressure"), - _("Use the pressure of the input device to alter the scale of new items"), - INKSCAPE_ICON("draw-use-pressure"), - GTK_ICON_SIZE_MENU); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/usepressurescale", false) ); - g_object_set_data( holder, "usepressurescale", act ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_pressure_scale), holder) ; - gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); + holder->_usepressurescale = ink_toggle_action_new( "SprayPressureScaleAction", + _("Pressure"), + _("Use the pressure of the input device to alter the scale of new items"), + INKSCAPE_ICON("draw-use-pressure"), + GTK_ICON_SIZE_MENU); + gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(holder->_usepressurescale), prefs->getBool("/tools/spray/usepressurescale", false)); + g_signal_connect(G_OBJECT(holder->_usepressurescale), "toggled", G_CALLBACK(&SprayToolbar::toggle_pressure_scale), holder); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_usepressurescale) ); } /* Picker */ { - InkToggleAction* act = ink_toggle_action_new( "SprayPickColorAction", + holder->_picker = ink_toggle_action_new( "SprayPickColorAction", _("Pick color from the drawing. You can use clonetiler trace dialog for advanced effects. In clone mode original fill or stroke colors must be unset."), _("Pick color from the drawing. You can use clonetiler trace dialog for advanced effects. In clone mode original fill or stroke colors must be unset."), INKSCAPE_ICON("color-picker"), secondarySize ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/picker", false) ); - g_object_set_data( holder, "picker", act ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_picker), holder) ; - gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_picker), prefs->getBool("/tools/spray/picker", false) ); + g_signal_connect(G_OBJECT(holder->_picker), "toggled", G_CALLBACK(&SprayToolbar::toggle_picker), holder); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_picker) ); } /* Pick from center */ { - InkToggleAction* act = ink_toggle_action_new( "SprayPickCenterAction", + holder->_pick_center = ink_toggle_action_new( "SprayPickCenterAction", _("Pick from center instead average area."), _("Pick from center instead average area."), INKSCAPE_ICON("snap-bounding-box-center"), secondarySize ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/pick_center", true) ); - g_object_set_data( holder, "pick_center", act ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_pick_center), holder) ; - gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_pick_center), prefs->getBool("/tools/spray/pick_center", true) ); + g_signal_connect(G_OBJECT(holder->_pick_center), "toggled", G_CALLBACK(&SprayToolbar::toggle_pick_center), holder); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_pick_center) ); } /* Inverse Value Size */ { - InkToggleAction* act = ink_toggle_action_new( "SprayPickInverseValueAction", + holder->_pick_inverse_value = ink_toggle_action_new( "SprayPickInverseValueAction", _("Inverted pick value, retaining color in advanced trace mode"), _("Inverted pick value, retaining color in advanced trace mode"), INKSCAPE_ICON("object-tweak-shrink"), secondarySize ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/pick_inverse_value", false) ); - g_object_set_data( holder, "pick_inverse_value", act ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_pick_inverse_value), holder) ; - gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_pick_inverse_value), prefs->getBool("/tools/spray/pick_inverse_value", false) ); + g_signal_connect(G_OBJECT(holder->_pick_inverse_value), "toggled", G_CALLBACK(&SprayToolbar::toggle_pick_inverse_value), holder); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_pick_inverse_value) ); } /* Pick Fill */ { - InkToggleAction* act = ink_toggle_action_new( "SprayPickFillAction", + holder->_pick_fill = ink_toggle_action_new( "SprayPickFillAction", _("Apply picked color to fill"), _("Apply picked color to fill"), INKSCAPE_ICON("paint-solid"), secondarySize ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/pick_fill", false) ); - g_object_set_data( holder, "pick_fill", act ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_pick_fill), holder) ; - gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_pick_fill), prefs->getBool("/tools/spray/pick_fill", false) ); + g_signal_connect(G_OBJECT(holder->_pick_fill), "toggled", G_CALLBACK(&SprayToolbar::toggle_pick_fill), holder); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_pick_fill) ); } /* Pick Stroke */ { - InkToggleAction* act = ink_toggle_action_new( "SprayPickStrokeAction", + holder->_pick_stroke = ink_toggle_action_new( "SprayPickStrokeAction", _("Apply picked color to stroke"), _("Apply picked color to stroke"), INKSCAPE_ICON("no-marker"), secondarySize ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/pick_stroke", false) ); - g_object_set_data( holder, "pick_stroke", act ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_pick_stroke), holder) ; - gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_pick_stroke), prefs->getBool("/tools/spray/pick_stroke", false) ); + g_signal_connect(G_OBJECT(holder->_pick_stroke), "toggled", G_CALLBACK(&SprayToolbar::toggle_pick_stroke), holder); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_pick_stroke) ); } /* Pick No Overlap */ { - InkToggleAction* act = ink_toggle_action_new( "SprayPickNoOverlapAction", + holder->_pick_no_overlap = ink_toggle_action_new( "SprayPickNoOverlapAction", _("No overlap between colors"), _("No overlap between colors"), INKSCAPE_ICON("symbol-bigger"), secondarySize ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/pick_no_overlap", false) ); - g_object_set_data( holder, "pick_no_overlap", act ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_pick_no_overlap), holder) ; - gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_pick_no_overlap), prefs->getBool("/tools/spray/pick_no_overlap", false) ); + g_signal_connect(G_OBJECT(holder->_pick_no_overlap), "toggled", G_CALLBACK(&SprayToolbar::toggle_pick_no_overlap), holder); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_pick_no_overlap) ); } /* Over Transparent */ { - InkToggleAction* act = ink_toggle_action_new( "SprayOverTransparentAction", + holder->_over_transparent = ink_toggle_action_new( "SprayOverTransparentAction", _("Apply over transparent areas"), _("Apply over transparent areas"), INKSCAPE_ICON("object-hidden"), secondarySize ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/over_transparent", true) ); - g_object_set_data( holder, "over_transparent", act ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_over_transparent), holder) ; - gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_over_transparent), prefs->getBool("/tools/spray/over_transparent", true) ); + g_signal_connect(G_OBJECT(holder->_over_transparent), "toggled", G_CALLBACK(&SprayToolbar::toggle_over_transparent), holder); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_over_transparent) ); } /* Over No Transparent */ { - InkToggleAction* act = ink_toggle_action_new( "SprayOverNoTransparentAction", + holder->_over_no_transparent = ink_toggle_action_new( "SprayOverNoTransparentAction", _("Apply over no transparent areas"), _("Apply over no transparent areas"), INKSCAPE_ICON("object-visible"), secondarySize ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/over_no_transparent", true) ); - g_object_set_data( holder, "over_no_transparent", act ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_over_no_transparent), holder) ; - gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_over_no_transparent), prefs->getBool("/tools/spray/over_no_transparent", true) ); + g_signal_connect(G_OBJECT(holder->_over_no_transparent), "toggled", G_CALLBACK(&SprayToolbar::toggle_over_no_transparent), holder); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_over_no_transparent) ); } /* Overlap */ { - InkToggleAction* act = ink_toggle_action_new( "SprayNoOverlapAction", + holder->_no_overlap = ink_toggle_action_new( "SprayNoOverlapAction", _("Prevent overlapping objects"), _("Prevent overlapping objects"), INKSCAPE_ICON("distribute-randomize"), secondarySize ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/spray/no_overlap", false) ); - g_object_set_data( holder, "no_overlap", act ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_toggle_no_overlap), holder) ; - gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_no_overlap), prefs->getBool("/tools/spray/no_overlap", false) ); + g_signal_connect(G_OBJECT(holder->_no_overlap), "toggled", G_CALLBACK(&SprayToolbar::toggle_no_overlap), holder); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_no_overlap) ); } /* Offset */ { gchar const* labels[] = {_("(minimum offset)"), nullptr, nullptr, nullptr, _("(default)"), nullptr, nullptr, _("(maximum offset)")}; gdouble values[] = {0, 25, 50, 75, 100, 150, 200, 1000}; - EgeAdjustmentAction *eact = create_adjustment_action( "SprayToolOffsetAction", + holder->_offset = create_adjustment_action( "SprayToolOffsetAction", _("Offset %"), _("Offset %:"), _("Increase to segregate objects more (value in percent)"), "/tools/spray/offset", 100, - GTK_WIDGET(desktop->canvas), holder, FALSE, nullptr, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, 0, 1000, 1, 4, labels, values, G_N_ELEMENTS(labels), - sp_spray_offset_value_changed, nullptr, 0 , 0); - g_object_set_data( holder, "offset", eact ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + nullptr, // callback + nullptr, 0 , 0); + holder->_offset_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_offset)); + holder->_offset_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &SprayToolbar::offset_value_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_offset) ); + } + holder->init(); + + return GTK_WIDGET(holder->gobj()); +} + +void +SprayToolbar::width_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/spray/width", + _width_adj->get_value()); +} + +void +SprayToolbar::mean_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/spray/mean", + _mean_adj->get_value()); +} + +void +SprayToolbar::standard_deviation_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/spray/standard_deviation", + _sd_adj->get_value()); +} + +void +SprayToolbar::mode_changed(int mode) +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setInt("/tools/spray/mode", mode); + init(); +} + +void +SprayToolbar::init(){ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + int mode = prefs->getInt("/tools/spray/mode", 0); + + bool show = true; + if(mode == 3 || mode == 2){ + show = false; + } + gtk_action_set_visible( GTK_ACTION(_no_overlap), show ); + gtk_action_set_visible( GTK_ACTION(_over_no_transparent), show ); + gtk_action_set_visible( GTK_ACTION(_over_transparent), show ); + gtk_action_set_visible( GTK_ACTION(_pick_no_overlap), show ); + gtk_action_set_visible( GTK_ACTION(_pick_stroke), show ); + gtk_action_set_visible( GTK_ACTION(_pick_fill), show ); + gtk_action_set_visible( GTK_ACTION(_pick_inverse_value), show ); + gtk_action_set_visible( GTK_ACTION(_pick_center), show ); + gtk_action_set_visible( GTK_ACTION(_picker), show ); + gtk_action_set_visible( GTK_ACTION(_offset), show ); + gtk_action_set_visible( GTK_ACTION(_pick_fill), show ); + gtk_action_set_visible( GTK_ACTION(_pick_stroke), show ); + gtk_action_set_visible( GTK_ACTION(_pick_inverse_value), show ); + gtk_action_set_visible( GTK_ACTION(_pick_center), show ); + if(mode == 2){ + show = true; + } + gtk_action_set_visible( GTK_ACTION(_spray_rotation), show ); + update_widgets(); +} + +void +SprayToolbar::population_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/spray/population", + _population_adj->get_value()); +} + +void +SprayToolbar::rotation_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/spray/rotation_variation", + _rotation_adj->get_value()); +} + +void +SprayToolbar::update_widgets() +{ + _offset_adj->set_value(100.0); + + if (gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(_no_overlap)) && + gtk_action_get_visible(GTK_ACTION(_no_overlap))) + { + gtk_action_set_visible( GTK_ACTION(_offset), true ); + } else { + gtk_action_set_visible( GTK_ACTION(_offset), false ); + } + if (gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(_usepressurescale))) { + _scale_adj->set_value(0.0); + gtk_action_set_sensitive( GTK_ACTION(_spray_scale), false ); + } else { + gtk_action_set_sensitive( GTK_ACTION(_spray_scale), true ); + } + if(gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(_picker)) && + gtk_action_get_visible(GTK_ACTION(_picker))){ + gtk_action_set_visible( GTK_ACTION(_pick_fill), true ); + gtk_action_set_visible( GTK_ACTION(_pick_stroke), true ); + gtk_action_set_visible( GTK_ACTION(_pick_inverse_value), true ); + gtk_action_set_visible( GTK_ACTION(_pick_center), true ); + } else { + gtk_action_set_visible( GTK_ACTION(_pick_fill), false ); + gtk_action_set_visible( GTK_ACTION(_pick_stroke), false ); + gtk_action_set_visible( GTK_ACTION(_pick_inverse_value), false ); + gtk_action_set_visible( GTK_ACTION(_pick_center), false ); + } +} + +void +SprayToolbar::toggle_no_overlap(GtkToggleAction *toggleaction, + gpointer user_data) +{ + auto toolbar = reinterpret_cast(user_data); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + gboolean active = gtk_toggle_action_get_active(toggleaction); + prefs->setBool("/tools/spray/no_overlap", active); + toolbar->update_widgets(); +} + +void +SprayToolbar::scale_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/spray/scale_variation", + _scale_adj->get_value()); +} + +void +SprayToolbar::offset_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/spray/offset", + _offset_adj->get_value()); +} + +void +SprayToolbar::toggle_pressure_scale(GtkToggleAction *toggleaction, + gpointer user_data) +{ + auto toolbar = reinterpret_cast(user_data); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + gboolean active = gtk_toggle_action_get_active(toggleaction); + prefs->setBool("/tools/spray/usepressurescale", active); + if(active){ + prefs->setDouble("/tools/spray/scale_variation", 0); } - sp_spray_init(holder); + toolbar->update_widgets(); } +void +SprayToolbar::toggle_over_no_transparent(GtkToggleAction *toggleaction, + gpointer /* user_data */) +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + gboolean active = gtk_toggle_action_get_active(toggleaction); + prefs->setBool("/tools/spray/over_no_transparent", active); +} +void +SprayToolbar::toggle_over_transparent(GtkToggleAction *toggleaction, + gpointer /* user_data */) +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + gboolean active = gtk_toggle_action_get_active(toggleaction); + prefs->setBool("/tools/spray/over_transparent", active); +} + +void +SprayToolbar::toggle_picker(GtkToggleAction *toggleaction, + gpointer user_data) +{ + auto toolbar = reinterpret_cast(user_data); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + gboolean active = gtk_toggle_action_get_active(toggleaction); + prefs->setBool("/tools/spray/picker", active); + if(active){ + prefs->setBool("/dialogs/clonetiler/dotrace", false); + SPDesktop *dt = SP_ACTIVE_DESKTOP; + if (Inkscape::UI::Dialog::CloneTiler *ct = get_clone_tiler_panel(dt)){ + dt->_dlg_mgr->showDialog("CloneTiler"); + ct->show_page_trace(); + } + } + toolbar->update_widgets(); +} + +void +SprayToolbar::toggle_pick_center(GtkToggleAction *toggleaction, + gpointer /* user_data */) +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + gboolean active = gtk_toggle_action_get_active(toggleaction); + prefs->setBool("/tools/spray/pick_center", active); +} + +void +SprayToolbar::toggle_pick_fill(GtkToggleAction *toggleaction, + gpointer /* user_data */) +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + gboolean active = gtk_toggle_action_get_active(toggleaction); + prefs->setBool("/tools/spray/pick_fill", active); +} + +void +SprayToolbar::toggle_pick_stroke(GtkToggleAction *toggleaction, + gpointer /* user_data */) +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + gboolean active = gtk_toggle_action_get_active(toggleaction); + prefs->setBool("/tools/spray/pick_stroke", active); +} + +void +SprayToolbar::toggle_pick_no_overlap(GtkToggleAction *toggleaction, + gpointer /* user_data */) +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + gboolean active = gtk_toggle_action_get_active(toggleaction); + prefs->setBool("/tools/spray/pick_no_overlap", active); +} + +void +SprayToolbar::toggle_pick_inverse_value(GtkToggleAction *toggleaction, + gpointer /* user_data */) +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + gboolean active = gtk_toggle_action_get_active(toggleaction); + prefs->setBool("/tools/spray/pick_inverse_value", active); +} + +} +} +} /* Local Variables: diff --git a/src/ui/toolbar/spray-toolbar.h b/src/ui/toolbar/spray-toolbar.h index 9133575d1..af3ef8082 100644 --- a/src/ui/toolbar/spray-toolbar.h +++ b/src/ui/toolbar/spray-toolbar.h @@ -28,11 +28,94 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" + +#include + +class InkSelectOneAction; class SPDesktop; +typedef struct _EgeAdjustmentAction EgeAdjustmentAction; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; +typedef struct _InkToggleAction InkToggleAction; + +namespace Inkscape { +namespace UI { +class PrefPusher; + +namespace Toolbar { +class SprayToolbar : public Toolbar { +private: + Glib::RefPtr _width_adj; + Glib::RefPtr _mean_adj; + Glib::RefPtr _sd_adj; + Glib::RefPtr _population_adj; + Glib::RefPtr _rotation_adj; + Glib::RefPtr _offset_adj; + Glib::RefPtr _scale_adj; + + PrefPusher *_usepressurewidth_pusher; + PrefPusher *_usepressurepopulation_pusher; + + InkSelectOneAction *_spray_tool_mode; + EgeAdjustmentAction *_spray_population; + EgeAdjustmentAction *_spray_rotation; + EgeAdjustmentAction *_spray_scale; + InkToggleAction * _usepressurescale; + InkToggleAction *_picker; + InkToggleAction *_pick_center; + InkToggleAction *_pick_inverse_value; + InkToggleAction *_pick_fill; + InkToggleAction *_pick_stroke; + InkToggleAction *_pick_no_overlap; + InkToggleAction *_over_transparent; + InkToggleAction *_over_no_transparent; + InkToggleAction *_no_overlap; + EgeAdjustmentAction *_offset; + + void width_value_changed(); + void mean_value_changed(); + void standard_deviation_value_changed(); + void mode_changed(int mode); + void init(); + void population_value_changed(); + void rotation_value_changed(); + void update_widgets(); + void scale_value_changed(); + void offset_value_changed(); + static void toggle_no_overlap (GtkToggleAction *toggleaction, + gpointer user_data); + static void toggle_pressure_scale (GtkToggleAction *toggleaction, + gpointer user_data); + static void toggle_over_no_transparent(GtkToggleAction *toggleaction, + gpointer user_data); + static void toggle_over_transparent (GtkToggleAction *toggleaction, + gpointer user_data); + static void toggle_picker (GtkToggleAction *toggleaction, + gpointer user_data); + static void toggle_pick_center (GtkToggleAction *toggleaction, + gpointer user_data); + static void toggle_pick_fill (GtkToggleAction *toggleaction, + gpointer user_data); + static void toggle_pick_stroke (GtkToggleAction *toggleaction, + gpointer user_data); + static void toggle_pick_no_overlap (GtkToggleAction *toggleaction, + gpointer user_data); + static void toggle_pick_inverse_value (GtkToggleAction *toggleaction, + gpointer user_data); + +protected: + SprayToolbar(SPDesktop *desktop) : + Toolbar(desktop) + {} + + ~SprayToolbar(); -void sp_spray_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +public: + static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); +}; +} +} +} #endif /* !SEEN_SELECT_TOOLBAR_H */ diff --git a/src/ui/toolbar/star-toolbar.cpp b/src/ui/toolbar/star-toolbar.cpp index 2fa354f42..5aa88f1e0 100644 --- a/src/ui/toolbar/star-toolbar.cpp +++ b/src/ui/toolbar/star-toolbar.cpp @@ -58,324 +58,466 @@ using Inkscape::UI::PrefPusher; //## Star ## //######################## -static void sp_star_magnitude_value_changed( GtkAdjustment *adj, GObject *dataKludge ) +static Inkscape::XML::NodeEventVector star_tb_repr_events = { - SPDesktop *desktop = static_cast(g_object_get_data( dataKludge, "desktop" )); + nullptr, /* child_added */ + nullptr, /* child_removed */ + Inkscape::UI::Toolbar::StarToolbar::event_attr_changed, + nullptr, /* content_changed */ + nullptr /* order_changed */ +}; - if (DocumentUndo::getUndoSensitive(desktop->getDocument())) { - // do not remember prefs if this call is initiated by an undo change, because undoing object - // creation sets bogus values to its attributes before it is deleted +namespace Inkscape { +namespace UI { +namespace Toolbar { +StarToolbar::~StarToolbar() +{ + if (_repr) { // remove old listener + _repr->removeListenerByData(this); + Inkscape::GC::release(_repr); + _repr = nullptr; + } +} + +GtkWidget * +StarToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) +{ + auto holder = new StarToolbar(desktop); + + GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); + + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + bool isFlatSided = prefs->getBool("/tools/shapes/star/isflatsided", true); + + EgeAdjustmentAction* eact = nullptr; + + { + holder->_mode_action = ege_output_action_new( "StarStateAction", _("New:"), "", nullptr ); + ege_output_action_set_use_markup( holder->_mode_action, TRUE ); + gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_mode_action ) ); + } + + /* Flatsided checkbox */ + { + InkSelectOneActionColumns columns; + + Glib::RefPtr store = Gtk::ListStore::create(columns); + + Gtk::TreeModel::Row row; + + row = *(store->append()); + row[columns.col_label ] = _("Polygon"); + row[columns.col_tooltip ] = _("Regular polygon (with one handle) instead of a star"); + row[columns.col_icon ] = INKSCAPE_ICON("draw-polygon"); + row[columns.col_sensitive] = true; + + row = *(store->append()); + row[columns.col_label ] = _("Star"); + row[columns.col_tooltip ] = _("Star instead of a regular polygon (with one handle)"); + row[columns.col_icon ] = INKSCAPE_ICON("draw-star"); + row[columns.col_sensitive] = true; + + holder->_flat_action = + InkSelectOneAction::create( "FlatAction", // Name + (""), // Label + (""), // Tooltip + "Not Used", // Icon + store ); // Tree store + holder->_flat_action->use_radio( true ); + holder->_flat_action->use_label( false ); + holder->_flat_action->set_active( isFlatSided ? 0 : 1 ); + + gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_flat_action->gobj() )); + + holder->_flat_action->signal_changed().connect(sigc::mem_fun(*holder, &StarToolbar::side_mode_changed)); + } + + /* Magnitude */ + { + gchar const* labels[] = {_("triangle/tri-star"), _("square/quad-star"), _("pentagon/five-pointed star"), _("hexagon/six-pointed star"), nullptr, nullptr, nullptr, nullptr, nullptr}; + gdouble values[] = {3, 4, 5, 6, 7, 8, 10, 12, 20}; + eact = create_adjustment_action( "MagnitudeAction", + _("Corners"), _("Corners:"), _("Number of corners of a polygon or star"), + "/tools/shapes/star/magnitude", 3, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + 3, 1024, 1, 5, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + nullptr /*unit tracker*/, + 1.0, 0 ); + + holder->_magnitude_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + holder->_magnitude_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &StarToolbar::magnitude_value_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } + + /* Spoke ratio */ + { + gchar const* labels[] = {_("thin-ray star"), nullptr, _("pentagram"), _("hexagram"), _("heptagram"), _("octagram"), _("regular polygon")}; + gdouble values[] = {0.01, 0.2, 0.382, 0.577, 0.692, 0.765, 1}; + holder->_prop_action = create_adjustment_action( "SpokeAction", + _("Spoke ratio"), _("Spoke ratio:"), + // TRANSLATORS: Tip radius of a star is the distance from the center to the farthest handle. + // Base radius is the same for the closest handle. + _("Base radius to tip radius ratio"), + "/tools/shapes/star/proportion", 0.5, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + 0.01, 1.0, 0.01, 0.1, + labels, values, G_N_ELEMENTS(labels), + nullptr // callback + ); + holder->_spoke_adj = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_prop_action)); + holder->_spoke_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &StarToolbar::proportion_value_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_prop_action) ); + + if ( !isFlatSided ) { + gtk_action_set_visible( GTK_ACTION(holder->_prop_action), TRUE ); + } else { + gtk_action_set_visible( GTK_ACTION(holder->_prop_action), FALSE ); + } + } + + /* Roundedness */ + { + gchar const* labels[] = {_("stretched"), _("twisted"), _("slightly pinched"), _("NOT rounded"), _("slightly rounded"), + _("visibly rounded"), _("well rounded"), _("amply rounded"), nullptr, _("stretched"), _("blown up")}; + gdouble values[] = {-1, -0.2, -0.03, 0, 0.05, 0.1, 0.2, 0.3, 0.5, 1, 10}; + eact = create_adjustment_action( "RoundednessAction", + _("Rounded"), _("Rounded:"), _("How much rounded are the corners (0 for sharp)"), + "/tools/shapes/star/rounded", 0.0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + -10.0, 10.0, 0.01, 0.1, + labels, values, G_N_ELEMENTS(labels), + nullptr // callback + ); + holder->_roundedness_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + holder->_roundedness_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &StarToolbar::rounded_value_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } + + /* Randomization */ + { + gchar const* labels[] = {_("NOT randomized"), _("slightly irregular"), _("visibly randomized"), _("strongly randomized"), _("blown up")}; + gdouble values[] = {0, 0.01, 0.1, 0.5, 10}; + eact = create_adjustment_action( "RandomizationAction", + _("Randomized"), _("Randomized:"), _("Scatter randomly the corners and angles"), + "/tools/shapes/star/randomized", 0.0, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + FALSE, nullptr, + -10.0, 10.0, 0.001, 0.01, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + nullptr /*unit tracker*/, 0.1, 3 ); + holder->_randomization_adj = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + holder->_randomization_adj->signal_value_changed().connect(sigc::mem_fun(*holder, &StarToolbar::randomized_value_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); + gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); + } + + /* Reset */ + { + InkAction* inky = ink_action_new( "StarResetAction", + _("Defaults"), + _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"), + INKSCAPE_ICON("edit-clear"), + GTK_ICON_SIZE_SMALL_TOOLBAR); + g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(StarToolbar::defaults), holder); + gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); + gtk_action_set_sensitive( GTK_ACTION(inky), TRUE ); + } + + desktop->connectEventContextChanged(sigc::mem_fun(*holder, &StarToolbar::watch_ec)); + + return GTK_WIDGET(holder->gobj()); +} + +void +StarToolbar::side_mode_changed(int mode) +{ + bool flat = (mode == 0); + + if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setInt("/tools/shapes/star/magnitude", - (gint)gtk_adjustment_get_value(adj)); + prefs->setBool( "/tools/shapes/star/isflatsided", flat ); } // quit if run by the attr_changed listener - if (g_object_get_data( dataKludge, "freeze" )) { + if (_freeze) { return; } // in turn, prevent listener from responding - g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) ); + _freeze = true; + Inkscape::Selection *selection = _desktop->getSelection(); bool modmade = false; - Inkscape::Selection *selection = desktop->getSelection(); + if ( _prop_action ) { + gtk_action_set_visible( GTK_ACTION(_prop_action), !flat ); + } + auto itemlist= selection->items(); for(auto i=itemlist.begin();i!=itemlist.end();++i){ SPItem *item = *i; if (SP_IS_STAR(item)) { Inkscape::XML::Node *repr = item->getRepr(); - sp_repr_set_int(repr,"sodipodi:sides", - (gint)gtk_adjustment_get_value(adj)); - double arg1 = 0.5; - sp_repr_get_double(repr, "sodipodi:arg1", &arg1); - sp_repr_set_svg_double(repr, "sodipodi:arg2", - (arg1 + M_PI / (gint)gtk_adjustment_get_value(adj))); + repr->setAttribute("inkscape:flatsided", flat ? "true" : "false" ); item->updateRepr(); modmade = true; } } + if (modmade) { - DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_STAR, - _("Star: Change number of corners")); + DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_STAR, + flat ? _("Make polygon") : _("Make star")); } - g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) ); + _freeze = false; } -static void sp_star_proportion_value_changed( GtkAdjustment *adj, GObject *dataKludge ) +void +StarToolbar::magnitude_value_changed() { - SPDesktop *desktop = static_cast(g_object_get_data( dataKludge, "desktop" )); - - if (DocumentUndo::getUndoSensitive(desktop->getDocument())) { - if (!IS_NAN(gtk_adjustment_get_value(adj))) { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble("/tools/shapes/star/proportion", - gtk_adjustment_get_value(adj)); - } + if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) { + // do not remember prefs if this call is initiated by an undo change, because undoing object + // creation sets bogus values to its attributes before it is deleted + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setInt("/tools/shapes/star/magnitude", + (gint)_magnitude_adj->get_value()); } // quit if run by the attr_changed listener - if (g_object_get_data( dataKludge, "freeze" )) { + if (_freeze) { return; } // in turn, prevent listener from responding - g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) ); + _freeze = true; bool modmade = false; - Inkscape::Selection *selection = desktop->getSelection(); + + Inkscape::Selection *selection = _desktop->getSelection(); auto itemlist= selection->items(); for(auto i=itemlist.begin();i!=itemlist.end();++i){ SPItem *item = *i; if (SP_IS_STAR(item)) { Inkscape::XML::Node *repr = item->getRepr(); - - gdouble r1 = 1.0; - gdouble r2 = 1.0; - sp_repr_get_double(repr, "sodipodi:r1", &r1); - sp_repr_get_double(repr, "sodipodi:r2", &r2); - if (r2 < r1) { - sp_repr_set_svg_double(repr, "sodipodi:r2", - r1*gtk_adjustment_get_value(adj)); - } else { - sp_repr_set_svg_double(repr, "sodipodi:r1", - r2*gtk_adjustment_get_value(adj)); - } - + sp_repr_set_int(repr,"sodipodi:sides", + (gint)_magnitude_adj->get_value()); + double arg1 = 0.5; + sp_repr_get_double(repr, "sodipodi:arg1", &arg1); + sp_repr_set_svg_double(repr, "sodipodi:arg2", + (arg1 + M_PI / (gint)_magnitude_adj->get_value())); item->updateRepr(); modmade = true; } } - if (modmade) { - DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_STAR, - _("Star: Change spoke ratio")); + DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_STAR, + _("Star: Change number of corners")); } - g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) ); + _freeze = false; } -static void sp_star_side_mode_changed( GObject *dataKludge, int mode ) +void +StarToolbar::proportion_value_changed() { - bool flat = (mode == 0); - - SPDesktop *desktop = static_cast(g_object_get_data( dataKludge, "desktop" )); - - if (DocumentUndo::getUndoSensitive(desktop->getDocument())) { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setBool( "/tools/shapes/star/isflatsided", flat ); + if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) { + if (!IS_NAN(_spoke_adj->get_value())) { + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble("/tools/shapes/star/proportion", + _spoke_adj->get_value()); + } } // quit if run by the attr_changed listener - if (g_object_get_data( dataKludge, "freeze" )) { + if (_freeze) { return; } // in turn, prevent listener from responding - g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) ); + _freeze = true; - Inkscape::Selection *selection = desktop->getSelection(); - GtkAction* prop_action = GTK_ACTION( g_object_get_data( dataKludge, "prop_action" ) ); bool modmade = false; - - if ( prop_action ) { - gtk_action_set_visible( prop_action, !flat ); - } - + Inkscape::Selection *selection = _desktop->getSelection(); auto itemlist= selection->items(); for(auto i=itemlist.begin();i!=itemlist.end();++i){ SPItem *item = *i; if (SP_IS_STAR(item)) { Inkscape::XML::Node *repr = item->getRepr(); - repr->setAttribute("inkscape:flatsided", flat ? "true" : "false" ); + + gdouble r1 = 1.0; + gdouble r2 = 1.0; + sp_repr_get_double(repr, "sodipodi:r1", &r1); + sp_repr_get_double(repr, "sodipodi:r2", &r2); + if (r2 < r1) { + sp_repr_set_svg_double(repr, "sodipodi:r2", + r1*_spoke_adj->get_value()); + } else { + sp_repr_set_svg_double(repr, "sodipodi:r1", + r2*_spoke_adj->get_value()); + } + item->updateRepr(); modmade = true; } } if (modmade) { - DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_STAR, - flat ? _("Make polygon") : _("Make star")); + DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_STAR, + _("Star: Change spoke ratio")); } - g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) ); + _freeze = false; } -static void sp_star_rounded_value_changed( GtkAdjustment *adj, GObject *dataKludge ) +void +StarToolbar::rounded_value_changed() { - SPDesktop *desktop = static_cast(g_object_get_data( dataKludge, "desktop" )); - - if (DocumentUndo::getUndoSensitive(desktop->getDocument())) { + if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble("/tools/shapes/star/rounded", (gdouble) gtk_adjustment_get_value(adj)); + prefs->setDouble("/tools/shapes/star/rounded", (gdouble) _roundedness_adj->get_value()); } // quit if run by the attr_changed listener - if (g_object_get_data( dataKludge, "freeze" )) { + if (_freeze) { return; } // in turn, prevent listener from responding - g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) ); + _freeze = true; bool modmade = false; - Inkscape::Selection *selection = desktop->getSelection(); + Inkscape::Selection *selection = _desktop->getSelection(); auto itemlist= selection->items(); for(auto i=itemlist.begin();i!=itemlist.end();++i){ SPItem *item = *i; if (SP_IS_STAR(item)) { Inkscape::XML::Node *repr = item->getRepr(); sp_repr_set_svg_double(repr, "inkscape:rounded", - (gdouble) gtk_adjustment_get_value(adj)); + (gdouble) _roundedness_adj->get_value()); item->updateRepr(); modmade = true; } } if (modmade) { - DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_STAR, + DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_STAR, _("Star: Change rounding")); } - g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) ); + _freeze = false; } -static void sp_star_randomized_value_changed( GtkAdjustment *adj, GObject *dataKludge ) +void +StarToolbar::randomized_value_changed() { - SPDesktop *desktop = static_cast(g_object_get_data( dataKludge, "desktop" )); - - if (DocumentUndo::getUndoSensitive(desktop->getDocument())) { + if (DocumentUndo::getUndoSensitive(_desktop->getDocument())) { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); prefs->setDouble("/tools/shapes/star/randomized", - (gdouble) gtk_adjustment_get_value(adj)); + (gdouble) _randomization_adj->get_value()); } // quit if run by the attr_changed listener - if (g_object_get_data( dataKludge, "freeze" )) { + if (_freeze) { return; } // in turn, prevent listener from responding - g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(TRUE) ); + _freeze = true; bool modmade = false; - Inkscape::Selection *selection = desktop->getSelection(); + Inkscape::Selection *selection = _desktop->getSelection(); auto itemlist= selection->items(); for(auto i=itemlist.begin();i!=itemlist.end();++i){ SPItem *item = *i; if (SP_IS_STAR(item)) { Inkscape::XML::Node *repr = item->getRepr(); sp_repr_set_svg_double(repr, "inkscape:randomized", - (gdouble) gtk_adjustment_get_value(adj)); + (gdouble) _randomization_adj->get_value()); item->updateRepr(); modmade = true; } } if (modmade) { - DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_STAR, + DocumentUndo::done(_desktop->getDocument(), SP_VERB_CONTEXT_STAR, _("Star: Change randomization")); } - g_object_set_data( dataKludge, "freeze", GINT_TO_POINTER(FALSE) ); + _freeze = false; } - -static void star_tb_event_attr_changed(Inkscape::XML::Node *repr, gchar const *name, - gchar const * /*old_value*/, gchar const * /*new_value*/, - bool /*is_interactive*/, gpointer dataPointer) +void +StarToolbar::defaults(GtkWidget * /*widget*/, gpointer user_data) { - GObject *dataKludge = G_OBJECT( dataPointer ); - - // quit if run by the _changed callbacks - if (g_object_get_data(dataKludge, "freeze")) { - return; - } + auto toolbar = reinterpret_cast(user_data); - // in turn, prevent callbacks from responding - g_object_set_data(dataKludge, "freeze", GINT_TO_POINTER(TRUE)); + // 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 = nullptr; - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - bool isFlatSided = prefs->getBool("/tools/shapes/star/isflatsided", true); - - if (!strcmp(name, "inkscape:randomized")) { - - adj = GTK_ADJUSTMENT( g_object_get_data(dataKludge, "randomized") ); - double randomized = 0.0; - sp_repr_get_double(repr, "inkscape:randomized", &randomized); - gtk_adjustment_set_value(adj, randomized); - - } else if (!strcmp(name, "inkscape:rounded")) { - - adj = GTK_ADJUSTMENT( g_object_get_data(dataKludge, "rounded") ); - double rounded = 0.0; - sp_repr_get_double(repr, "inkscape:rounded", &rounded); - gtk_adjustment_set_value(adj, rounded); - - } else if (!strcmp(name, "inkscape:flatsided")) { - - GtkAction* prop_action = GTK_ACTION( g_object_get_data(dataKludge, "prop_action") ); - char const *flatsides = repr->attribute("inkscape:flatsided"); - - InkSelectOneAction* flat_action = - static_cast(g_object_get_data( dataKludge, "flat_action" ) ); - if ( flatsides && !strcmp(flatsides,"false") ) { - flat_action->set_active(1); - gtk_action_set_visible( prop_action, TRUE ); - } else { - flat_action->set_active(0); - gtk_action_set_visible( prop_action, FALSE ); - } + // fixme: make settable in prefs! + gint mag = 5; + gdouble prop = 0.5; + gboolean flat = FALSE; + gdouble randomized = 0; + gdouble rounded = 0; - } else if ((!strcmp(name, "sodipodi:r1") || !strcmp(name, "sodipodi:r2")) && (!isFlatSided) ) { + toolbar->_flat_action->set_active ( flat ? 0 : 1 ); - adj = GTK_ADJUSTMENT(g_object_get_data(dataKludge, "proportion")); - gdouble r1 = 1.0; - gdouble r2 = 1.0; - sp_repr_get_double(repr, "sodipodi:r1", &r1); - sp_repr_get_double(repr, "sodipodi:r2", &r2); - if (r2 < r1) { - gtk_adjustment_set_value(adj, r2/r1); - } else { - gtk_adjustment_set_value(adj, r1/r2); - } + gtk_action_set_visible( GTK_ACTION(toolbar->_prop_action), !flat ); - } else if (!strcmp(name, "sodipodi:sides")) { + toolbar->_magnitude_adj->set_value(mag); + toolbar->_spoke_adj->set_value(prop); + toolbar->_roundedness_adj->set_value(rounded); + toolbar->_randomization_adj->set_value(randomized); - adj = GTK_ADJUSTMENT(g_object_get_data(dataKludge, "magnitude")); - int sides = 0; - sp_repr_get_int(repr, "sodipodi:sides", &sides); - gtk_adjustment_set_value(adj, sides); - } - - g_object_set_data(dataKludge, "freeze", GINT_TO_POINTER(FALSE)); +#if !GTK_CHECK_VERSION(3,18,0) + toolbar->_magnitude_adj->value_changed(); + toolbar->_spoke_adj->value_changed(); + toolbar->_roundedness_adj->value_changed(); + toolbar->_randomization_adj->value_changed(); +#endif } - -static Inkscape::XML::NodeEventVector star_tb_repr_events = +void +StarToolbar::watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec) { - nullptr, /* child_added */ - nullptr, /* child_removed */ - star_tb_event_attr_changed, - nullptr, /* content_changed */ - nullptr /* order_changed */ -}; - + if (dynamic_cast(ec) != nullptr) { + _changed = desktop->getSelection()->connectChanged(sigc::mem_fun(*this, &StarToolbar::selection_changed)); + selection_changed(desktop->getSelection()); + } else { + if (_changed) + _changed.disconnect(); + } +} /** * \param selection Should not be NULL. */ -static void -sp_star_toolbox_selection_changed(Inkscape::Selection *selection, GObject *dataKludge) +void +StarToolbar::selection_changed(Inkscape::Selection *selection) { int n_selected = 0; Inkscape::XML::Node *repr = nullptr; - purge_repr_listener( dataKludge, dataKludge ); + if (_repr) { // remove old listener + _repr->removeListenerByData(this); + Inkscape::GC::release(_repr); + _repr = nullptr; + } auto itemlist= selection->items(); for(auto i=itemlist.begin();i!=itemlist.end();++i){ @@ -386,18 +528,16 @@ sp_star_toolbox_selection_changed(Inkscape::Selection *selection, GObject *dataK } } - EgeOutputAction* act = EGE_OUTPUT_ACTION( g_object_get_data( dataKludge, "mode_action" ) ); - if (n_selected == 0) { - g_object_set( G_OBJECT(act), "label", _("New:"), NULL ); + gtk_action_set_label(GTK_ACTION(_mode_action), _("New:")); } else if (n_selected == 1) { - g_object_set( G_OBJECT(act), "label", _("Change:"), NULL ); + gtk_action_set_label(GTK_ACTION(_mode_action), _("Change:")); if (repr) { - g_object_set_data( dataKludge, "repr", repr ); - Inkscape::GC::anchor(repr); - sp_repr_add_listener(repr, &star_tb_repr_events, dataKludge); - sp_repr_synthesize_events(repr, &star_tb_repr_events, dataKludge); + _repr = repr; + Inkscape::GC::anchor(_repr); + _repr->addListener(&star_tb_repr_events, this); + _repr->synthesizeEvents(&star_tb_repr_events, this); } } else { // FIXME: implement averaging of all parameters for multiple selected stars @@ -406,209 +546,62 @@ sp_star_toolbox_selection_changed(Inkscape::Selection *selection, GObject *dataK } } - -static void sp_star_defaults( GtkWidget * /*widget*/, GObject *dataKludge ) +void +StarToolbar::event_attr_changed(Inkscape::XML::Node *repr, gchar const *name, + gchar const * /*old_value*/, gchar const * /*new_value*/, + bool /*is_interactive*/, gpointer dataPointer) { - // 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 = nullptr; - - // fixme: make settable in prefs! - gint mag = 5; - gdouble prop = 0.5; - gboolean flat = FALSE; - gdouble randomized = 0; - gdouble rounded = 0; - - InkSelectOneAction* flat_action = - static_cast(g_object_get_data( dataKludge, "flat_action" ) ); - flat_action->set_active ( flat ? 0 : 1 ); + auto toolbar = reinterpret_cast(dataPointer); - GtkAction* sb2 = GTK_ACTION( g_object_get_data( dataKludge, "prop_action" ) ); - gtk_action_set_visible( sb2, !flat ); - - adj = GTK_ADJUSTMENT( g_object_get_data( dataKludge, "magnitude" ) ); - gtk_adjustment_set_value(adj, mag); - -#if !GTK_CHECK_VERSION(3,18,0) - gtk_adjustment_value_changed(adj); -#endif - - adj = GTK_ADJUSTMENT( g_object_get_data( dataKludge, "proportion" ) ); - gtk_adjustment_set_value(adj, prop); - -#if !GTK_CHECK_VERSION(3,18,0) - gtk_adjustment_value_changed(adj); -#endif - - adj = GTK_ADJUSTMENT( g_object_get_data( dataKludge, "rounded" ) ); - gtk_adjustment_set_value(adj, rounded); - -#if !GTK_CHECK_VERSION(3,18,0) - gtk_adjustment_value_changed(adj); -#endif - - adj = GTK_ADJUSTMENT( g_object_get_data( dataKludge, "randomized" ) ); - gtk_adjustment_set_value(adj, randomized); - -#if !GTK_CHECK_VERSION(3,18,0) - gtk_adjustment_value_changed(adj); -#endif -} - -static void star_toolbox_watch_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* dataKludge); + // quit if run by the _changed callbacks + if (toolbar->_freeze) { + return; + } -void sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* dataKludge) -{ - GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); + // in turn, prevent callbacks from responding + toolbar->_freeze = true; Inkscape::Preferences *prefs = Inkscape::Preferences::get(); bool isFlatSided = prefs->getBool("/tools/shapes/star/isflatsided", true); - EgeAdjustmentAction* eact = nullptr; - - { - EgeOutputAction* act = ege_output_action_new( "StarStateAction", _("New:"), "", nullptr ); - ege_output_action_set_use_markup( act, TRUE ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - g_object_set_data( dataKludge, "mode_action", act ); - } - - /* Flatsided checkbox */ - { - InkSelectOneActionColumns columns; - - Glib::RefPtr store = Gtk::ListStore::create(columns); - - Gtk::TreeModel::Row row; - - row = *(store->append()); - row[columns.col_label ] = _("Polygon"); - row[columns.col_tooltip ] = _("Regular polygon (with one handle) instead of a star"); - row[columns.col_icon ] = INKSCAPE_ICON("draw-polygon"); - row[columns.col_sensitive] = true; - - row = *(store->append()); - row[columns.col_label ] = _("Star"); - row[columns.col_tooltip ] = _("Star instead of a regular polygon (with one handle)"); - row[columns.col_icon ] = INKSCAPE_ICON("draw-star"); - row[columns.col_sensitive] = true; - - InkSelectOneAction* act = - InkSelectOneAction::create( "FlatAction", // Name - (""), // Label - (""), // Tooltip - "Not Used", // Icon - store ); // Tree store - act->use_radio( true ); - act->use_label( false ); - act->set_active( isFlatSided ? 0 : 1 ); - - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( dataKludge, "flat_action", act ); - - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_star_side_mode_changed), dataKludge)); - } - - /* Magnitude */ - { - gchar const* labels[] = {_("triangle/tri-star"), _("square/quad-star"), _("pentagon/five-pointed star"), _("hexagon/six-pointed star"), nullptr, nullptr, nullptr, nullptr, nullptr}; - gdouble values[] = {3, 4, 5, 6, 7, 8, 10, 12, 20}; - eact = create_adjustment_action( "MagnitudeAction", - _("Corners"), _("Corners:"), _("Number of corners of a polygon or star"), - "/tools/shapes/star/magnitude", 3, - GTK_WIDGET(desktop->canvas), dataKludge, FALSE, nullptr, - 3, 1024, 1, 5, - labels, values, G_N_ELEMENTS(labels), - sp_star_magnitude_value_changed, nullptr /*unit tracker*/, - 1.0, 0 ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); - } - - /* Spoke ratio */ - { - gchar const* labels[] = {_("thin-ray star"), nullptr, _("pentagram"), _("hexagram"), _("heptagram"), _("octagram"), _("regular polygon")}; - gdouble values[] = {0.01, 0.2, 0.382, 0.577, 0.692, 0.765, 1}; - eact = create_adjustment_action( "SpokeAction", - _("Spoke ratio"), _("Spoke ratio:"), - // TRANSLATORS: Tip radius of a star is the distance from the center to the farthest handle. - // Base radius is the same for the closest handle. - _("Base radius to tip radius ratio"), - "/tools/shapes/star/proportion", 0.5, - GTK_WIDGET(desktop->canvas), dataKludge, FALSE, nullptr, - 0.01, 1.0, 0.01, 0.1, - labels, values, G_N_ELEMENTS(labels), - sp_star_proportion_value_changed ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - g_object_set_data( dataKludge, "prop_action", eact ); - - if ( !isFlatSided ) { - gtk_action_set_visible( GTK_ACTION(eact), TRUE ); + if (!strcmp(name, "inkscape:randomized")) { + double randomized = 0.0; + sp_repr_get_double(repr, "inkscape:randomized", &randomized); + toolbar->_randomization_adj->set_value(randomized); + } else if (!strcmp(name, "inkscape:rounded")) { + double rounded = 0.0; + sp_repr_get_double(repr, "inkscape:rounded", &rounded); + toolbar->_roundedness_adj->set_value(rounded); + } else if (!strcmp(name, "inkscape:flatsided")) { + char const *flatsides = repr->attribute("inkscape:flatsided"); + if ( flatsides && !strcmp(flatsides,"false") ) { + toolbar->_flat_action->set_active(1); + gtk_action_set_visible( GTK_ACTION(toolbar->_prop_action), TRUE ); } else { - gtk_action_set_visible( GTK_ACTION(eact), FALSE ); + toolbar->_flat_action->set_active(0); + gtk_action_set_visible( GTK_ACTION(toolbar->_prop_action), FALSE ); } + } else if ((!strcmp(name, "sodipodi:r1") || !strcmp(name, "sodipodi:r2")) && (!isFlatSided) ) { + gdouble r1 = 1.0; + gdouble r2 = 1.0; + sp_repr_get_double(repr, "sodipodi:r1", &r1); + sp_repr_get_double(repr, "sodipodi:r2", &r2); + if (r2 < r1) { + toolbar->_spoke_adj->set_value(r2/r1); + } else { + toolbar->_spoke_adj->set_value(r1/r2); + } + } else if (!strcmp(name, "sodipodi:sides")) { + int sides = 0; + sp_repr_get_int(repr, "sodipodi:sides", &sides); + toolbar->_magnitude_adj->set_value(sides); } - /* Roundedness */ - { - gchar const* labels[] = {_("stretched"), _("twisted"), _("slightly pinched"), _("NOT rounded"), _("slightly rounded"), - _("visibly rounded"), _("well rounded"), _("amply rounded"), nullptr, _("stretched"), _("blown up")}; - gdouble values[] = {-1, -0.2, -0.03, 0, 0.05, 0.1, 0.2, 0.3, 0.5, 1, 10}; - eact = create_adjustment_action( "RoundednessAction", - _("Rounded"), _("Rounded:"), _("How much rounded are the corners (0 for sharp)"), - "/tools/shapes/star/rounded", 0.0, - GTK_WIDGET(desktop->canvas), dataKludge, FALSE, nullptr, - -10.0, 10.0, 0.01, 0.1, - labels, values, G_N_ELEMENTS(labels), - sp_star_rounded_value_changed ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); - } - - /* Randomization */ - { - gchar const* labels[] = {_("NOT randomized"), _("slightly irregular"), _("visibly randomized"), _("strongly randomized"), _("blown up")}; - gdouble values[] = {0, 0.01, 0.1, 0.5, 10}; - eact = create_adjustment_action( "RandomizationAction", - _("Randomized"), _("Randomized:"), _("Scatter randomly the corners and angles"), - "/tools/shapes/star/randomized", 0.0, - GTK_WIDGET(desktop->canvas), dataKludge, FALSE, nullptr, - -10.0, 10.0, 0.001, 0.01, - labels, values, G_N_ELEMENTS(labels), - sp_star_randomized_value_changed, nullptr /*unit tracker*/, 0.1, 3 ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); - } - - /* Reset */ - { - InkAction* inky = ink_action_new( "StarResetAction", - _("Defaults"), - _("Reset shape parameters to defaults (use Inkscape Preferences > Tools to change defaults)"), - INKSCAPE_ICON("edit-clear"), - GTK_ICON_SIZE_SMALL_TOOLBAR); - g_signal_connect_after( G_OBJECT(inky), "activate", G_CALLBACK(sp_star_defaults), dataKludge ); - gtk_action_group_add_action( mainActions, GTK_ACTION(inky) ); - gtk_action_set_sensitive( GTK_ACTION(inky), TRUE ); - } - - desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(star_toolbox_watch_ec), dataKludge)); - g_signal_connect(dataKludge, "destroy", G_CALLBACK(purge_repr_listener), dataKludge); + toolbar->_freeze = false; } -static void star_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec, GObject* dataKludge) -{ - static sigc::connection changed; - - if (dynamic_cast(ec) != nullptr) { - changed = desktop->getSelection()->connectChanged(sigc::bind(sigc::ptr_fun(sp_star_toolbox_selection_changed), dataKludge)); - sp_star_toolbox_selection_changed(desktop->getSelection(), dataKludge); - } else { - if (changed) - changed.disconnect(); - } +} +} } /* diff --git a/src/ui/toolbar/star-toolbar.h b/src/ui/toolbar/star-toolbar.h index 7ac306d86..3959bf5f7 100644 --- a/src/ui/toolbar/star-toolbar.h +++ b/src/ui/toolbar/star-toolbar.h @@ -28,11 +28,79 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" + +#include + +class InkSelectOneAction; class SPDesktop; +typedef struct _EgeAdjustmentAction EgeAdjustmentAction; +typedef struct _EgeOutputAction EgeOutputAction; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; -void sp_star_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +namespace Inkscape { +class Selection; + +namespace XML { +class Node; +} + +namespace UI { +namespace Tools { +class ToolBase; +} + +namespace Toolbar { +class StarToolbar : public Toolbar { +private: + EgeOutputAction *_mode_action; + InkSelectOneAction *_flat_action; + EgeAdjustmentAction *_prop_action; + + XML::Node *_repr; + + Glib::RefPtr _magnitude_adj; + Glib::RefPtr _spoke_adj; + Glib::RefPtr _roundedness_adj; + Glib::RefPtr _randomization_adj; + + bool _freeze; + sigc::connection _changed; + + void side_mode_changed(int mode); + void magnitude_value_changed(); + void proportion_value_changed(); + void rounded_value_changed(); + void randomized_value_changed(); + + static void defaults(GtkWidget *widget, + gpointer user_data); + + void watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec); + void selection_changed(Inkscape::Selection *selection); + +protected: + StarToolbar(SPDesktop *desktop) : + Toolbar(desktop), + _repr(nullptr) + {} + + ~StarToolbar(); + +public: + static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); + + static void event_attr_changed(Inkscape::XML::Node *repr, + gchar const *name, + gchar const *old_value, + gchar const *new_value, + bool is_interactive, + gpointer dataPointer); +}; + +} +} +} #endif /* !SEEN_SELECT_TOOLBAR_H */ diff --git a/src/ui/toolbar/text-toolbar.cpp b/src/ui/toolbar/text-toolbar.cpp index fc3e8cd7d..72bd5cdb0 100644 --- a/src/ui/toolbar/text-toolbar.cpp +++ b/src/ui/toolbar/text-toolbar.cpp @@ -123,128 +123,44 @@ static void sp_print_fontstyle( SPStyle *query ) { } #endif -static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/, GObject *tbl, bool subselection = false); - -// Font family -static void sp_text_fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, GObject *tbl ) -{ -#ifdef DEBUG_TEXT - std::cout << std::endl; - std::cout << "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM" << std::endl; - std::cout << "sp_text_fontfamily_value_changed: " << std::endl; -#endif - - // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { -#ifdef DEBUG_TEXT - std::cout << "sp_text_fontfamily_value_changed: frozen... return" << std::endl; - std::cout << "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM\n" << std::endl; -#endif - return; - } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); - - Glib::ustring new_family = ink_comboboxentry_action_get_active_text( act ); - css_font_family_unquote( new_family ); // Remove quotes around font family names. - - // TODO: Think about how to handle handle multiple selections. While - // the font-family may be the same for all, the styles might be different. - // See: TextEdit::onApply() for example of looping over selected items. - Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance(); -#ifdef DEBUG_TEXT - std::cout << " Old family: " << fontlister->get_font_family() << std::endl; - std::cout << " New family: " << new_family << std::endl; - std::cout << " Old active: " << fontlister->get_font_family_row() << std::endl; - std::cout << " New active: " << act->active << std::endl; -#endif - if( new_family.compare( fontlister->get_font_family() ) != 0 ) { - // Changed font-family - - if( act->active == -1 ) { - // New font-family, not in document, not on system (could be fallback list) - fontlister->insert_font_family( new_family ); - act->active = 0; // New family is always at top of list. - } - - fontlister->set_font_family( act->active ); - // active text set in sp_text_toolbox_selection_changed() +static bool is_relative( Unit const *unit ) { + return (unit->abbr == "" || unit->abbr == "em" || unit->abbr == "ex" || unit->abbr == "%"); +} - SPCSSAttr *css = sp_repr_css_attr_new (); - fontlister->fill_css( css ); +// Set property for object, but unset all descendents +// Should probably be moved to desktop_style.cpp +static void recursively_set_properties( SPObject* object, SPCSSAttr *css ) { + object->changeCSS (css, "style"); - SPDesktop *desktop = SP_ACTIVE_DESKTOP; - if( desktop->getSelection()->isEmpty() ) { - // Update default - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->mergeStyle("/tools/text/style", css); - } else { - // If there is a selection, update - sp_desktop_set_style (desktop, css, true, true); // Results in selection change called twice. - DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_TEXT, - _("Text: Change font family")); - } - sp_repr_css_attr_unref (css); + SPCSSAttr *css_unset = sp_repr_css_attr_unset_all( css ); + std::vector children = object->childList(false); + for (auto i: children) { + recursively_set_properties (i, css_unset); } - - // unfreeze - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); - -#ifdef DEBUG_TEXT - std::cout << "sp_text_toolbox_fontfamily_changes: exit" << std::endl; - std::cout << "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM" << std::endl; - std::cout << std::endl; -#endif + sp_repr_css_attr_unref (css_unset); } -// Font size -static void sp_text_fontsize_value_changed( Ink_ComboBoxEntry_Action *act, GObject *tbl ) -{ - // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { - return; - } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); - - gchar *text = ink_comboboxentry_action_get_active_text( act ); - gchar *endptr; - gdouble size = g_strtod( text, &endptr ); - if (endptr == text) { // Conversion failed, non-numeric input. - g_warning( "Conversion of size text to double failed, input: %s\n", text ); - g_free( text ); - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); - return; - } - g_free( text ); +// Apply line height changes (line-height value changed or line-height unit changed) +static void set_lineheight (SPCSSAttr *css) { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - int max_size = prefs->getInt("/dialogs/textandfont/maxFontSize", 10000); // somewhat arbitrary, but text&font preview freezes with too huge fontsizes - - if (size > max_size) - size = max_size; - - // Set css font size. - SPCSSAttr *css = sp_repr_css_attr_new (); - Inkscape::CSSOStringStream osfs; - int unit = prefs->getInt("/options/font/unitType", SP_CSS_UNIT_PT); - if (prefs->getBool("/options/font/textOutputPx", true)) { - osfs << sp_style_css_size_units_to_px(size, unit) << sp_style_get_css_unit_string(SP_CSS_UNIT_PX); - } else { - osfs << size << sp_style_get_css_unit_string(unit); - } - sp_repr_css_set_property (css, "font-size", osfs.str().c_str()); + bool outer = prefs->getInt("/tools/text/outer_style", false); + gint mode = prefs->getInt("/tools/text/line_spacing_mode", 0); + SPDesktop *desktop = SP_ACTIVE_DESKTOP; - // Apply font size to selected objects. // Calling sp_desktop_set_style will result in a call to TextTool::_styleSet() which // will set the style on selected text inside the element. If we want to set // the style on the outer objects we need to bypass this call. - bool outer = prefs->getInt("/tools/text/outer_style", false); - SPDesktop *desktop = SP_ACTIVE_DESKTOP; - if (outer) { + if ( mode == 3 && !outer ) { + // This will call sp_te_apply_style via signal + sp_desktop_set_style (desktop, css, true, true); + } else { Inkscape::Selection *selection = desktop->getSelection(); auto itemlist= selection->items(); - for(auto i=itemlist.begin();i!=itemlist.end(); ++i){ - if (dynamic_cast(*i) || dynamic_cast(*i)) { - SPItem *item = *i; + for (auto i: itemlist) { + + if (dynamic_cast(i) || dynamic_cast(i)) { + SPItem *item = i; // Scale by inverse of accumulated parent transform SPCSSAttr *css_set = sp_repr_css_attr_new(); @@ -255,830 +171,830 @@ static void sp_text_fontsize_value_changed( Ink_ComboBoxEntry_Action *act, GObje sp_css_attr_scale(css_set, 1/ex); } - item->changeCSS(css_set,"style"); - - sp_repr_css_attr_unref(css_set); + if ( mode == 1 || mode == 2 || mode == 3) { // Minimum, Even, or Adjustable w/ outer. + // We change only outer style + item->changeCSS(css_set,"style"); + } else { + // We change only inner style (Adaptive). + for (auto child: item->childList(false)) { + child->changeCSS(css_set,"style"); + } + } } } - } else { - sp_desktop_set_style (desktop, css, true, true); - } - - // If no selected objects, set default. - SPStyle query(SP_ACTIVE_DOCUMENT); - int result_numbers = - sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTNUMBERS); - if (result_numbers == QUERY_STYLE_NOTHING) - { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->mergeStyle("/tools/text/style", css); - } else { - // Save for undo - DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:size", SP_VERB_NONE, - _("Text: Change font size")); } - - sp_repr_css_attr_unref (css); - - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); } + /* - * Font style + * Set the default list of font sizes, scaled to the users preferred unit */ -static void sp_text_fontstyle_value_changed( Ink_ComboBoxEntry_Action *act, GObject *tbl ) +static void sp_text_set_sizes(GtkListStore* model_size, int unit) { - // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { - return; - } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + gtk_list_store_clear(model_size); - Glib::ustring new_style = ink_comboboxentry_action_get_active_text( act ); + // List of font sizes for drop-down menu + int sizes[] = { + 4, 6, 8, 9, 10, 11, 12, 13, 14, 16, 18, 20, 22, 24, 28, + 32, 36, 40, 48, 56, 64, 72, 144 + }; - Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance(); + // Array must be same length as SPCSSUnit in style.h + float ratios[] = {1, 1, 1, 10, 4, 40, 100, 16, 8, 0.16}; - if( new_style.compare( fontlister->get_font_style() ) != 0 ) { + for(int i : sizes) { + GtkTreeIter iter; + Glib::ustring size = Glib::ustring::format(i / (float)ratios[unit]); + gtk_list_store_append( model_size, &iter ); + gtk_list_store_set( model_size, &iter, 0, size.c_str(), -1 ); + } +} - fontlister->set_font_style( new_style ); - // active text set in sp_text_toolbox_seletion_changed() - SPCSSAttr *css = sp_repr_css_attr_new (); - fontlister->fill_css( css ); +// TODO: possibly share with font-selector by moving most code to font-lister (passing family name) +static void sp_text_toolbox_select_cb( GtkEntry* entry, GtkEntryIconPosition /*position*/, GdkEvent /*event*/, gpointer /*data*/ ) { - SPDesktop *desktop = SP_ACTIVE_DESKTOP; - sp_desktop_set_style (desktop, css, true, true); + Glib::ustring family = gtk_entry_get_text ( entry ); + //std::cout << "text_toolbox_missing_font_cb: selecting: " << family << std::endl; + // Get all items with matching font-family set (not inherited!). + std::vector selectList; - // If no selected objects, set default. - SPStyle query(SP_ACTIVE_DOCUMENT); - int result_style = - sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTSTYLE); - if (result_style == QUERY_STYLE_NOTHING) { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->mergeStyle("/tools/text/style", css); - } else { - // Save for undo - DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_TEXT, - _("Text: Change font style")); - } + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + SPDocument *document = desktop->getDocument(); + std::vector x,y; + std::vector allList = get_all_items(x, document->getRoot(), desktop, false, false, true, y); + for(std::vector::const_reverse_iterator i=allList.rbegin();i!=allList.rend(); ++i){ + SPItem *item = *i; + SPStyle *style = item->style; - sp_repr_css_attr_unref (css); + if (style) { + + Glib::ustring family_style; + if (style->font_family.set) { + family_style = style->font_family.value; + //std::cout << " family style from font_family: " << family_style << std::endl; + } + else if (style->font_specification.set) { + family_style = style->font_specification.value; + //std::cout << " family style from font_spec: " << family_style << std::endl; + } + if (family_style.compare( family ) == 0 ) { + //std::cout << " found: " << item->getId() << std::endl; + selectList.push_back(item); + } } + } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + // Update selection + Inkscape::Selection *selection = desktop->getSelection(); + selection->clear(); + //std::cout << " list length: " << g_slist_length ( selectList ) << std::endl; + selection->setList(selectList); } -// Changes selection to only text outer elements. -static void sp_text_outer_style_changed( InkToggleAction*act, GObject *tbl ) -{ - bool outer = gtk_toggle_action_get_active( GTK_TOGGLE_ACTION(act) ); - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setInt("/tools/text/outer_style", outer); +static void text_toolbox_watch_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder); - // Update widgets to reflect new state of Text Outer Style button. - sp_text_toolbox_selection_changed( nullptr, tbl ); -} +namespace Inkscape { +namespace UI { +namespace Toolbar { -// Unset line height on selection's inner text objects (tspan, etc.). -static void sp_text_lineheight_unset_changed( InkToggleAction*act, GObject *tbl ) +TextToolbar::TextToolbar(SPDesktop *desktop) + : Toolbar(desktop), + _freeze(false), + _tracker(new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR)) { - // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { - return; - } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); - - SPCSSAttr *css = sp_repr_css_attr_new(); - sp_repr_css_unset_property(css, "line-height"); + /* Line height unit tracker */ + _tracker->prependUnit(unit_table.getUnit("")); // No unit + _tracker->addUnit(unit_table.getUnit("%")); + _tracker->addUnit(unit_table.getUnit("em")); + _tracker->addUnit(unit_table.getUnit("ex")); + _tracker->setActiveUnit(unit_table.getUnit("%")); +} - SPDesktop *desktop = SP_ACTIVE_DESKTOP; - sp_desktop_set_style (desktop, css); +// Define all the "widgets" in the toolbar. +GtkWidget * +TextToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) +{ + auto toolbar = new TextToolbar(desktop); - sp_repr_css_attr_unref(css); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); - DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_TEXT, - _("Text: Unset line height.")); - - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); -} - -// Handles both Superscripts and Subscripts -static void sp_text_script_changed( InkToggleAction* act, GObject *tbl ) -{ - // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { - return; - } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); - - // Called by Superscript or Subscript button? - const gchar* name = gtk_action_get_name( GTK_ACTION( act ) ); - gint prop = (strcmp(name, "TextSuperscriptAction") == 0) ? 0 : 1; - -#ifdef DEBUG_TEXT - std::cout << "sp_text_script_changed: " << prop << std::endl; -#endif - - // Query baseline - SPStyle query(SP_ACTIVE_DOCUMENT); - int result_baseline = sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_BASELINES); - - bool setSuper = false; - bool setSub = false; - - if (Inkscape::is_query_style_updateable(result_baseline)) { - // If not set or mixed, turn on superscript or subscript - if( prop == 0 ) { - setSuper = true; - } else { - setSub = true; - } - } else { - // Superscript - gboolean superscriptSet = (query.baseline_shift.set && - query.baseline_shift.type == SP_BASELINE_SHIFT_LITERAL && - query.baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUPER ); + /* Font family */ + { + // Font list + Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance(); + fontlister->update_font_list( SP_ACTIVE_DESKTOP->getDocument()); + Glib::RefPtr store = fontlister->get_font_list(); + GtkListStore* model = store->gobj(); - // Subscript - gboolean subscriptSet = (query.baseline_shift.set && - query.baseline_shift.type == SP_BASELINE_SHIFT_LITERAL && - query.baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUB ); + toolbar->_font_family_action = + ink_comboboxentry_action_new( "TextFontFamilyAction", + _("Font Family"), + _("Select Font Family (Alt-X to access)"), + nullptr, + GTK_TREE_MODEL(model), + -1, // Entry width + 50, // Extra list width + (gpointer)font_lister_cell_data_func2, // Cell layout + (gpointer)font_lister_separator_func2, + GTK_WIDGET(desktop->canvas)); // Focus widget + ink_comboboxentry_action_popup_enable( toolbar->_font_family_action ); // Enable entry completion - setSuper = !superscriptSet && prop == 0; - setSub = !subscriptSet && prop == 1; - } + gchar *const info = _("Select all text with this font-family"); + ink_comboboxentry_action_set_info( toolbar->_font_family_action, info ); // Show selection icon + ink_comboboxentry_action_set_info_cb( toolbar->_font_family_action, (gpointer)sp_text_toolbox_select_cb ); - // Set css properties - SPCSSAttr *css = sp_repr_css_attr_new (); - if( setSuper || setSub ) { - // Openoffice 2.3 and Adobe use 58%, Microsoft Word 2002 uses 65%, LaTex about 70%. - // 58% looks too small to me, especially if a superscript is placed on a superscript. - // If you make a change here, consider making a change to baseline-shift amount - // in style.cpp. - sp_repr_css_set_property (css, "font-size", "65%"); - } else { - sp_repr_css_set_property (css, "font-size", ""); - } - if( setSuper ) { - sp_repr_css_set_property (css, "baseline-shift", "super"); - } else if( setSub ) { - sp_repr_css_set_property (css, "baseline-shift", "sub"); - } else { - sp_repr_css_set_property (css, "baseline-shift", "baseline"); - } + gchar *const warning = _("Font not found on system"); + ink_comboboxentry_action_set_warning( toolbar->_font_family_action, warning ); // Show icon w/ tooltip if font missing + ink_comboboxentry_action_set_warning_cb( toolbar->_font_family_action, (gpointer)sp_text_toolbox_select_cb ); - // Apply css to selected objects. - SPDesktop *desktop = SP_ACTIVE_DESKTOP; - sp_desktop_set_style (desktop, css, true, false); + //ink_comboboxentry_action_set_warning_callback( act, sp_text_fontfamily_select_all ); + ink_comboboxentry_action_set_altx_name( toolbar->_font_family_action, "altx-text" ); // Set Alt-X keyboard shortcut + g_signal_connect( G_OBJECT(toolbar->_font_family_action), "changed", G_CALLBACK(fontfamily_value_changed), (gpointer)toolbar ); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_font_family_action) ); - // Save for undo - if(result_baseline != QUERY_STYLE_NOTHING) { - DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:script", SP_VERB_NONE, - _("Text: Change superscript or subscript")); - } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); -} + // Change style of drop-down from menu to list + auto css_provider = gtk_css_provider_new(); + gtk_css_provider_load_from_data(css_provider, + "#TextFontFamilyAction_combobox {\n" + " -GtkComboBox-appears-as-list: true;\n" + "}\n", + -1, nullptr); -static void sp_text_align_mode_changed( GObject *tbl, int mode ) -{ - // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { - return; + auto screen = gdk_screen_get_default(); + gtk_style_context_add_provider_for_screen(screen, + GTK_STYLE_PROVIDER(css_provider), + GTK_STYLE_PROVIDER_PRIORITY_USER); } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setInt("/tools/text/align_mode", mode); + /* Font size */ + { + // List of font sizes for drop-down menu + GtkListStore* model_size = gtk_list_store_new( 1, G_TYPE_STRING ); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + int unit = prefs->getInt("/options/font/unitType", SP_CSS_UNIT_PT); - SPDesktop *desktop = SP_ACTIVE_DESKTOP; + sp_text_set_sizes(model_size, unit); - // move the x of all texts to preserve the same bbox - Inkscape::Selection *selection = desktop->getSelection(); - auto itemlist= selection->items(); - for(auto i=itemlist.begin();i!=itemlist.end(); ++i){ - if (SP_IS_TEXT(*i)) { - SPItem *item = *i; + Glib::ustring tooltip = Glib::ustring::format(_("Font size"), " (", sp_style_get_css_unit_string(unit), ")"); - unsigned writing_mode = item->style->writing_mode.value; - // below, variable names suggest horizontal move, but we check the writing direction - // and move in the corresponding axis - Geom::Dim2 axis; - if (writing_mode == SP_CSS_WRITING_MODE_LR_TB || writing_mode == SP_CSS_WRITING_MODE_RL_TB) { - axis = Geom::X; - } else { - axis = Geom::Y; - } + toolbar->_font_size_action = ink_comboboxentry_action_new( "TextFontSizeAction", + _("Font Size"), + _(tooltip.c_str()), + nullptr, + GTK_TREE_MODEL(model_size), + 8, // Width in characters + 0, // Extra list width + nullptr, // Cell layout + nullptr, // Separator + GTK_WIDGET(desktop->canvas)); // Focus widget - Geom::OptRect bbox = item->geometricBounds(); - if (!bbox) - continue; - double width = bbox->dimensions()[axis]; - // If you want to align within some frame, other than the text's own bbox, calculate - // the left and right (or top and bottom for tb text) slacks of the text inside that - // frame (currently unused) - double left_slack = 0; - double right_slack = 0; - unsigned old_align = item->style->text_align.value; - double move = 0; - if (old_align == SP_CSS_TEXT_ALIGN_START || old_align == SP_CSS_TEXT_ALIGN_LEFT) { - switch (mode) { - case 0: - move = -left_slack; - break; - case 1: - move = width/2 + (right_slack - left_slack)/2; - break; - case 2: - move = width + right_slack; - break; - } - } else if (old_align == SP_CSS_TEXT_ALIGN_CENTER) { - switch (mode) { - case 0: - move = -width/2 - left_slack; - break; - case 1: - move = (right_slack - left_slack)/2; - break; - case 2: - move = width/2 + right_slack; - break; - } - } else if (old_align == SP_CSS_TEXT_ALIGN_END || old_align == SP_CSS_TEXT_ALIGN_RIGHT) { - switch (mode) { - case 0: - move = -width - left_slack; - break; - case 1: - move = -width/2 + (right_slack - left_slack)/2; - break; - case 2: - move = right_slack; - break; - } - } - Geom::Point XY = SP_TEXT(item)->attributes.firstXY(); - if (axis == Geom::X) { - XY = XY + Geom::Point (move, 0); - } else { - XY = XY + Geom::Point (0, move); - } - SP_TEXT(item)->attributes.setFirstXY(XY); - item->updateRepr(); - item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG); - } + g_signal_connect( G_OBJECT(toolbar->_font_size_action), "changed", G_CALLBACK(fontsize_value_changed), (gpointer)toolbar ); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_font_size_action) ); } - SPCSSAttr *css = sp_repr_css_attr_new (); - switch (mode) + /* Font styles */ { - case 0: - { - sp_repr_css_set_property (css, "text-anchor", "start"); - sp_repr_css_set_property (css, "text-align", "start"); - break; - } - case 1: - { - sp_repr_css_set_property (css, "text-anchor", "middle"); - sp_repr_css_set_property (css, "text-align", "center"); - break; - } + Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance(); + Glib::RefPtr store = fontlister->get_style_list(); + GtkListStore* model_style = store->gobj(); - case 2: - { - sp_repr_css_set_property (css, "text-anchor", "end"); - sp_repr_css_set_property (css, "text-align", "end"); - break; - } + toolbar->_font_style_action = ink_comboboxentry_action_new( "TextFontStyleAction", + _("Font Style"), + _("Font style"), + nullptr, + GTK_TREE_MODEL(model_style), + 12, // Width in characters + 0, // Extra list width + nullptr, // Cell layout + nullptr, // Separator + GTK_WIDGET(desktop->canvas)); // Focus widget - case 3: - { - sp_repr_css_set_property (css, "text-anchor", "start"); - sp_repr_css_set_property (css, "text-align", "justify"); - break; - } + g_signal_connect( G_OBJECT(toolbar->_font_style_action), "changed", G_CALLBACK(fontstyle_value_changed), (gpointer)toolbar ); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_font_style_action) ); } - SPStyle query(SP_ACTIVE_DOCUMENT); - int result_numbers = - sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTNUMBERS); - - // If querying returned nothing, update default style. - if (result_numbers == QUERY_STYLE_NOTHING) + /* Style - Superscript */ { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->mergeStyle("/tools/text/style", css); + toolbar->_superscript_action = ink_toggle_action_new( "TextSuperscriptAction", // Name + _("Toggle Superscript"), // Label + _("Toggle superscript"), // Tooltip + "text_superscript", // Icon (inkId) + secondarySize ); // Icon size + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_superscript_action ) ); + g_signal_connect_after( G_OBJECT(toolbar->_superscript_action), "toggled", G_CALLBACK(script_changed), toolbar ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(toolbar->_superscript_action), prefs->getBool("/tools/text/super", false) ); } - sp_desktop_set_style (desktop, css, true, true); - if (result_numbers != QUERY_STYLE_NOTHING) + /* Style - Subscript */ { - DocumentUndo::done(SP_ACTIVE_DESKTOP->getDocument(), SP_VERB_CONTEXT_TEXT, - _("Text: Change alignment")); + toolbar->_subscript_action = ink_toggle_action_new( "TextSubscriptAction", // Name + _("Toggle Subscript"), // Label + _("Toggle subscript"), // Tooltip + "text_subscript", // Icon (inkId) + secondarySize ); // Icon size + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_subscript_action ) ); + g_signal_connect_after( G_OBJECT(toolbar->_subscript_action), "toggled", G_CALLBACK(script_changed), (gpointer)toolbar ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(toolbar->_subscript_action), prefs->getBool("/tools/text/sub", false) ); } - sp_repr_css_attr_unref (css); - gtk_widget_grab_focus (GTK_WIDGET(SP_ACTIVE_DESKTOP->canvas)); + /* Alignment */ + { + InkSelectOneActionColumns columns; - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); -} + Glib::RefPtr store = Gtk::ListStore::create(columns); -static bool is_relative( Unit const *unit ) { - return (unit->abbr == "" || unit->abbr == "em" || unit->abbr == "ex" || unit->abbr == "%"); -} + Gtk::TreeModel::Row row; -// Set property for object, but unset all descendents -// Should probably be moved to desktop_style.cpp -static void recursively_set_properties( SPObject* object, SPCSSAttr *css ) { - object->changeCSS (css, "style"); + row = *(store->append()); + row[columns.col_label ] = _("Align left"); + row[columns.col_tooltip ] = _("Align left"); + row[columns.col_icon ] = INKSCAPE_ICON("format-justify-left"); + row[columns.col_sensitive] = true; - SPCSSAttr *css_unset = sp_repr_css_attr_unset_all( css ); - std::vector children = object->childList(false); - for (auto i: children) { - recursively_set_properties (i, css_unset); + row = *(store->append()); + row[columns.col_label ] = _("Align center"); + row[columns.col_tooltip ] = _("Align center"); + row[columns.col_icon ] = INKSCAPE_ICON("format-justify-center"); + row[columns.col_sensitive] = true; + + row = *(store->append()); + row[columns.col_label ] = _("Align right"); + row[columns.col_tooltip ] = _("Align right"); + row[columns.col_icon ] = INKSCAPE_ICON("format-justify-right"); + row[columns.col_sensitive] = true; + + row = *(store->append()); + row[columns.col_label ] = _("Justify"); + row[columns.col_tooltip ] = _("Justify (only flowed text)"); + row[columns.col_icon ] = INKSCAPE_ICON("format-justify-fill"); + row[columns.col_sensitive] = false; + + toolbar->_align_action = + InkSelectOneAction::create( "TextAlignAction", // Name + _("Alignment"), // Label + _("Text alignment"), // Tooltip + "Not Used", // Icon + store ); // Tree store + toolbar->_align_action->use_radio( false ); + toolbar->_align_action->use_label( false ); + gint mode = prefs->getInt("/tools/text/align_mode", 0); + toolbar->_align_action->set_active( mode ); + + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_align_action->gobj() )); + + toolbar->_align_action->signal_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::align_mode_changed)); } - sp_repr_css_attr_unref (css_unset); -} -// Apply line height changes (line-height value changed or line-height unit changed) -static void set_lineheight (SPCSSAttr *css) { + /* Writing mode (Horizontal, Vertical-LR, Vertical-RL) */ + { + InkSelectOneActionColumns columns; - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - bool outer = prefs->getInt("/tools/text/outer_style", false); - gint mode = prefs->getInt("/tools/text/line_spacing_mode", 0); - SPDesktop *desktop = SP_ACTIVE_DESKTOP; + Glib::RefPtr store = Gtk::ListStore::create(columns); - // Calling sp_desktop_set_style will result in a call to TextTool::_styleSet() which - // will set the style on selected text inside the element. If we want to set - // the style on the outer objects we need to bypass this call. - if ( mode == 3 && !outer ) { - // This will call sp_te_apply_style via signal - sp_desktop_set_style (desktop, css, true, true); - } else { - Inkscape::Selection *selection = desktop->getSelection(); - auto itemlist= selection->items(); - for (auto i: itemlist) { + Gtk::TreeModel::Row row; - if (dynamic_cast(i) || dynamic_cast(i)) { - SPItem *item = i; + row = *(store->append()); + row[columns.col_label ] = _("Horizontal"); + row[columns.col_tooltip ] = _("Horizontal text"); + row[columns.col_icon ] = INKSCAPE_ICON("format-text-direction-horizontal"); + row[columns.col_sensitive] = true; - // Scale by inverse of accumulated parent transform - SPCSSAttr *css_set = sp_repr_css_attr_new(); - sp_repr_css_merge(css_set, css); - Geom::Affine const local(item->i2doc_affine()); - double const ex(local.descrim()); - if ( (ex != 0.0) && (ex != 1.0) ) { - sp_css_attr_scale(css_set, 1/ex); - } + row = *(store->append()); + row[columns.col_label ] = _("Vertical — RL"); + row[columns.col_tooltip ] = _("Vertical text — lines: right to left"); + row[columns.col_icon ] = INKSCAPE_ICON("format-text-direction-vertical"); + row[columns.col_sensitive] = true; - if ( mode == 1 || mode == 2 || mode == 3) { // Minimum, Even, or Adjustable w/ outer. - // We change only outer style - item->changeCSS(css_set,"style"); - } else { - // We change only inner style (Adaptive). - for (auto child: item->childList(false)) { - child->changeCSS(css_set,"style"); - } - } - } - } - } -} + row = *(store->append()); + row[columns.col_label ] = _("Vertical — LR"); + row[columns.col_tooltip ] = _("Vertical text — lines: left to right"); + row[columns.col_icon ] = INKSCAPE_ICON("format-text-direction-vertical-lr"); + row[columns.col_sensitive] = true; -static void sp_text_lineheight_value_changed( GtkAdjustment *adj, GObject *tbl ) -{ - // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { - return; + toolbar->_writing_mode_action = + InkSelectOneAction::create( "TextWritingModeAction", // Name + _("Writing mode"), // Label + _("Block progression"), // Tooltip + "Not Used", // Icon + store ); // Tree store + toolbar->_writing_mode_action->use_radio( false ); + toolbar->_writing_mode_action->use_label( false ); + gint mode = prefs->getInt("/tools/text/writing_mode", 0); + toolbar->_writing_mode_action->set_active( mode ); + + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_writing_mode_action->gobj() )); + + toolbar->_writing_mode_action->signal_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::writing_mode_changed)); } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + /* Text (glyph) orientation (Auto (mixed), Upright, Sideways) */ + { + InkSelectOneActionColumns columns; - // Get user selected unit and save as preference - UnitTracker *tracker = reinterpret_cast(g_object_get_data(tbl, "tracker")); - Unit const *unit = tracker->getActiveUnit(); - g_return_if_fail(unit != nullptr); - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + Glib::RefPtr store = Gtk::ListStore::create(columns); + Gtk::TreeModel::Row row; - // This nonsense is to get SP_CSS_UNIT_xx value corresponding to unit so - // we can save it (allows us to adjust line height value when unit changes). - SPILength temp_length; - Inkscape::CSSOStringStream temp_stream; - temp_stream << 1 << unit->abbr; - temp_length.read(temp_stream.str().c_str()); - prefs->setInt("/tools/text/lineheight/display_unit", temp_length.unit); - g_object_set_data( tbl, "lineheight_unit", GINT_TO_POINTER(temp_length.unit)); + row = *(store->append()); + row[columns.col_label ] = _("Auto"); + row[columns.col_tooltip ] = _("Auto glyph orientation"); + row[columns.col_icon ] = INKSCAPE_ICON("text-orientation-auto"); + row[columns.col_sensitive] = true; - // Set css line height. - SPCSSAttr *css = sp_repr_css_attr_new (); - Inkscape::CSSOStringStream osfs; - if ( is_relative(unit) ) { - osfs << gtk_adjustment_get_value(adj) << unit->abbr; - } else { - // Inside SVG file, always use "px" for absolute units. - osfs << Quantity::convert(gtk_adjustment_get_value(adj), unit, "px") << "px"; - } - sp_repr_css_set_property (css, "line-height", osfs.str().c_str()); + row = *(store->append()); + row[columns.col_label ] = _("Upright"); + row[columns.col_tooltip ] = _("Upright glyph orientation"); + row[columns.col_icon ] = INKSCAPE_ICON("text-orientation-upright"); + row[columns.col_sensitive] = true; - // Internal function to set line-height which is spacing mode dependent. - set_lineheight (css); + row = *(store->append()); + row[columns.col_label ] = _("Sideways"); + row[columns.col_tooltip ] = _("Sideways glyph orientation"); + row[columns.col_icon ] = INKSCAPE_ICON("text-orientation-sideways"); + row[columns.col_sensitive] = true; - // Only need to save for undo if a text item has been changed. - Inkscape::Selection *selection = SP_ACTIVE_DESKTOP->getSelection(); - bool modmade = false; - auto itemlist= selection->items(); - for(auto i=itemlist.begin();i!=itemlist.end(); ++i){ - if (dynamic_cast(*i) || dynamic_cast(*i)) { - modmade = true; - } - } + toolbar->_orientation_action = + InkSelectOneAction::create( "TextOrientationAction", // Name + _("Text orientation"), // Label + _("Text (glyph) orientation in vertical text."), // Tooltip + "Not Used", // Icon + store ); // List store + toolbar->_orientation_action->use_radio( false ); + toolbar->_orientation_action->use_label( false ); + gint mode = prefs->getInt("/tools/text/text_orientation", 0); + toolbar->_orientation_action->set_active( mode ); - // Save for undo - if (modmade) { - // Call ensureUpToDate() causes rebuild of text layout (with all proper style - // cascading, etc.). For multi-line text with sodipodi::role="line", we must explicitly - // save new 'x' and 'y' attribute values by calling updateRepr(). - // Partial fix for bug #1590141. - SP_ACTIVE_DESKTOP->getDocument()->ensureUpToDate(); - for(auto i=itemlist.begin();i!=itemlist.end(); ++i){ - if (dynamic_cast(*i) || dynamic_cast(*i)) { - (*i)->updateRepr(); - } - } - DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:line-height", SP_VERB_NONE, - _("Text: Change line-height")); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_orientation_action->gobj() )); + + toolbar->_orientation_action->signal_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::orientation_changed)); } - // If no selected objects, set default. - SPStyle query(SP_ACTIVE_DOCUMENT); - int result_numbers = - sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTNUMBERS); - if (result_numbers == QUERY_STYLE_NOTHING) + // Text direction (predominant direction of horizontal text). { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->mergeStyle("/tools/text/style", css); + InkSelectOneActionColumns columns; + + Glib::RefPtr store = Gtk::ListStore::create(columns); + + Gtk::TreeModel::Row row; + + row = *(store->append()); + row[columns.col_label ] = _("LTR"); + row[columns.col_tooltip ] = _("Left to right text"); + row[columns.col_icon ] = INKSCAPE_ICON("format-text-direction-horizontal"); + row[columns.col_sensitive] = true; + + row = *(store->append()); + row[columns.col_label ] = _("RTL"); + row[columns.col_tooltip ] = _("Right to left text"); + row[columns.col_icon ] = INKSCAPE_ICON("format-text-direction-r2l"); + row[columns.col_sensitive] = true; + + toolbar->_direction_action = + InkSelectOneAction::create( "TextDirectionAction", // Name + _("Text direction"), // Label + _("Text direction for normally horizontal text."), // Tooltip + "Not Used", // Icon + store ); // List store + toolbar->_direction_action->use_radio( false ); + toolbar->_direction_action->use_label( false ); + gint mode = prefs->getInt("/tools/text/text_direction", 0); + toolbar->_direction_action->set_active( mode ); + + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_direction_action->gobj() )); + + toolbar->_direction_action->signal_changed_after().connect(sigc::mem_fun(*toolbar, &TextToolbar::direction_changed)); } - sp_repr_css_attr_unref (css); + /* Line height */ + { + // Drop down menu + gchar const* labels[] = {_("Smaller spacing"), nullptr, nullptr, nullptr, nullptr, C_("Text tool", "Normal"), nullptr, nullptr, nullptr, nullptr, nullptr, _("Larger spacing")}; + gdouble values[] = { 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1,2, 1.3, 1.4, 1.5, 2.0}; - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); -} + toolbar->_line_height_action = create_adjustment_action( + "TextLineHeightAction", /* name */ + _("Line Height"), /* label */ + _("Line:"), /* short label */ + _("Spacing between baselines"), /* tooltip */ + "/tools/text/lineheight", /* preferences path */ + 0.0, /* default */ + GTK_WIDGET(desktop->canvas), /* focusTarget */ + nullptr, /* dataKludge */ + FALSE, /* set alt-x keyboard shortcut? */ + nullptr, /* altx_mark */ + 0.0, 1000.0, 0.1, 1.0, /* lower, upper, step (arrow up/down), page up/down */ + labels, values, G_N_ELEMENTS(labels), /* drop down menu */ + nullptr, /* callback */ + nullptr, // tracker, /* unit tracker */ + 0.1, /* step (used?) */ + 2, /* digits to show */ + 1.0 /* factor (multiplies default) */ + ); + toolbar->_line_height_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_line_height_action)); + toolbar->_line_height_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::lineheight_value_changed)); -static void sp_text_lineheight_unit_changed( GObject *tbl, int /* Not Used */ ) -{ - // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { - return; + //tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) ); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_line_height_action) ); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_line_height_action), TRUE ); + + // TODO: Create accessor method for this, instead of GObject property + g_object_set( G_OBJECT(toolbar->_line_height_action), "iconId", "text_line_spacing", NULL ); } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); - // Get old saved unit - int old_unit = GPOINTER_TO_INT( g_object_get_data(tbl, "lineheight_unit")); + /* Line height units */ + { + toolbar->_line_height_units_action = toolbar->_tracker->createAction( "TextLineHeightUnitsAction", _("Units"), ("") ); + gtk_action_group_add_action( mainActions, toolbar->_line_height_units_action->gobj() ); + toolbar->_line_height_units_action->signal_changed_after().connect(sigc::mem_fun(*toolbar, &TextToolbar::lineheight_unit_changed)); + } - // Get user selected unit and save as preference - UnitTracker *tracker = reinterpret_cast(g_object_get_data(tbl, "tracker")); - Unit const *unit = tracker->getActiveUnit(); - g_return_if_fail(unit != nullptr); - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + /* Line spacing mode */ + { + InkSelectOneActionColumns columns; - // This nonsense is to get SP_CSS_UNIT_xx value corresponding to unit. - SPILength temp_length; - Inkscape::CSSOStringStream temp_stream; - temp_stream << 1 << unit->abbr; - temp_length.read(temp_stream.str().c_str()); - prefs->setInt("/tools/text/lineheight/display_unit", temp_length.unit); - g_object_set_data( tbl, "lineheight_unit", GINT_TO_POINTER(temp_length.unit)); + Glib::RefPtr store = Gtk::ListStore::create(columns); - // Read current line height value - EgeAdjustmentAction *line_height_act = - reinterpret_cast(g_object_get_data(tbl, "TextLineHeightAction")); - GtkAdjustment *line_height_adj = ege_adjustment_action_get_adjustment( line_height_act ); - double line_height = gtk_adjustment_get_value(line_height_adj); + Gtk::TreeModel::Row row; - SPDesktop *desktop = SP_ACTIVE_DESKTOP; - Inkscape::Selection *selection = desktop->getSelection(); - auto itemlist = selection->items(); + row = *(store->append()); + row[columns.col_label ] = _("Adaptive"); + row[columns.col_tooltip ] = _("Line spacing adapts to font size."); + row[columns.col_icon ] = INKSCAPE_ICON("text_line_spacing"); + row[columns.col_sensitive] = true; - // Convert between units - if ((unit->abbr == "" || unit->abbr == "em") && - (old_unit == SP_CSS_UNIT_NONE || old_unit == SP_CSS_UNIT_EM)) { - // Do nothing - } else if ((unit->abbr == "" || unit->abbr == "em") && old_unit == SP_CSS_UNIT_EX) { - line_height *= 0.5; - } else if ((unit->abbr) == "ex" && (old_unit == SP_CSS_UNIT_EM || old_unit == SP_CSS_UNIT_NONE) ) { - line_height *= 2.0; - } else if ((unit->abbr == "" || unit->abbr == "em") && old_unit == SP_CSS_UNIT_PERCENT) { - line_height /= 100.0; - } else if ((unit->abbr) == "%" && (old_unit == SP_CSS_UNIT_EM || old_unit == SP_CSS_UNIT_NONE) ) { - line_height *= 100; - } else if ((unit->abbr) == "ex" && old_unit == SP_CSS_UNIT_PERCENT) { - line_height /= 50.0; - } else if ((unit->abbr) == "%" && old_unit == SP_CSS_UNIT_EX) { - line_height *= 50; - } else if (is_relative(unit)) { - // Convert absolute to relative... for the moment use average font-size - double font_size = 0; - int count = 0; - for(auto i=itemlist.begin();i!=itemlist.end(); ++i){ - if (SP_IS_TEXT (*i) || SP_IS_FLOWTEXT(*i)) { - double doc_scale = Geom::Affine((*i)->i2dt_affine()).descrim(); - font_size += (*i)->style->font_size.computed * doc_scale; - ++count; - } - } - if (count > 0) { - font_size /= count; - } else { - font_size = 20; - } + row = *(store->append()); + row[columns.col_label ] = _("Minimum"); + row[columns.col_tooltip ] = _("Line spacing adapts to fonts size with set minimum spacing."); + row[columns.col_icon ] = INKSCAPE_ICON("text_line_spacing"); + row[columns.col_sensitive] = true; + row = *(store->append()); + row[columns.col_label ] = _("Even"); + row[columns.col_tooltip ] = _("Lines evenly spaced."); + row[columns.col_icon ] = INKSCAPE_ICON("text_line_spacing"); + row[columns.col_sensitive] = true; - if (old_unit == SP_CSS_UNIT_NONE) old_unit = SP_CSS_UNIT_EM; - line_height = Quantity::convert(line_height, sp_style_get_css_unit_string(old_unit), "px"); + row = *(store->append()); + row[columns.col_label ] = _("Adjustable ☠"); + row[columns.col_tooltip ] = _("Line spacing fully adjustable"); + row[columns.col_icon ] = INKSCAPE_ICON("text_line_spacing"); + row[columns.col_sensitive] = true; - if (font_size > 0) { - line_height /= font_size; - } - if ((unit->abbr) == "%") { - line_height *= 100; - } else if ((unit->abbr) == "ex") { - line_height *= 2; - } - } else if (old_unit==SP_CSS_UNIT_NONE || old_unit==SP_CSS_UNIT_PERCENT || - old_unit==SP_CSS_UNIT_EM || old_unit==SP_CSS_UNIT_EX) { - // Convert relative to absolute... for the moment use average font-size - double font_size = 0; - int count = 0; - for(auto i=itemlist.begin();i!=itemlist.end(); ++i){ - if (SP_IS_TEXT (*i) || SP_IS_FLOWTEXT (*i)) { - double doc_scale = Geom::Affine((*i)->i2dt_affine()).descrim(); - font_size += (*i)->style->font_size.computed * doc_scale; - ++count; - } - } - if (count > 0) { - font_size /= count; - } else { - font_size = 20; - } + toolbar->_line_spacing_action = + InkSelectOneAction::create( "TextLineSpacingAction", // Name + _("Line Spacing Mode"), // Label + _("How should multiple baselines be spaced?\n Adaptive: Line spacing adapts to font size.\n Minimum: Like Adaptive, but with a set minimum.\n Even: Evenly spaced.\n Adjustable: No restrictions."), // Tooltip + "Not Used", // Icon + store ); // Tree store + toolbar->_line_spacing_action->use_radio( false ); + toolbar->_line_spacing_action->use_label( true ); + gint mode = prefs->getInt("/tools/text/line_spacing_mode", 0); + toolbar->_line_spacing_action->set_active( mode ); - if (old_unit == SP_CSS_UNIT_PERCENT) { - line_height /= 100.0; - } else if (old_unit == SP_CSS_UNIT_EX) { - line_height /= 2.0; - } - line_height *= font_size; - line_height = Quantity::convert(line_height, "px", unit); - } else { - // Convert between different absolute units (only used in GUI) - line_height = Quantity::convert(line_height, sp_style_get_css_unit_string(old_unit), unit); + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_line_spacing_action->gobj() )); + + toolbar->_line_spacing_action->signal_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::line_spacing_mode_changed)); } - // Set css line height. - SPCSSAttr *css = sp_repr_css_attr_new (); - Inkscape::CSSOStringStream osfs; - if ( is_relative(unit) ) { - osfs << line_height << unit->abbr; - } else { - osfs << Quantity::convert(line_height, unit, "px") << "px"; + /* Word spacing */ + { + // Drop down menu + gchar const* labels[] = {_("Negative spacing"), nullptr, nullptr, nullptr, C_("Text tool", "Normal"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, _("Positive spacing")}; + gdouble values[] = {-2.0, -1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0}; + + toolbar->_word_spacing_action = create_adjustment_action( + "TextWordSpacingAction", /* name */ + _("Word spacing"), /* label */ + _("Word:"), /* short label */ + _("Spacing between words (px)"), /* tooltip */ + "/tools/text/wordspacing", /* preferences path */ + 0.0, /* default */ + GTK_WIDGET(desktop->canvas), /* focusTarget */ + nullptr, /* dataKludge */ + FALSE, /* set alt-x keyboard shortcut? */ + nullptr, /* altx_mark */ + -100.0, 100.0, 0.01, 0.10, /* lower, upper, step (arrow up/down), page up/down */ + labels, values, G_N_ELEMENTS(labels), /* drop down menu */ + nullptr, /* callback */ + nullptr, /* unit tracker */ + 0.1, /* step (used?) */ + 2, /* digits to show */ + 1.0 /* factor (multiplies default) */ + ); + + toolbar->_word_spacing_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_word_spacing_action)); + toolbar->_word_spacing_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::wordspacing_value_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_word_spacing_action) ); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_word_spacing_action), TRUE ); + g_object_set( G_OBJECT(toolbar->_word_spacing_action), "iconId", "text_word_spacing", NULL ); } - sp_repr_css_set_property (css, "line-height", osfs.str().c_str()); - // Update GUI with line_height value. - gtk_adjustment_set_value(line_height_adj, line_height); + /* Letter spacing */ + { + // Drop down menu + gchar const* labels[] = {_("Negative spacing"), nullptr, nullptr, nullptr, C_("Text tool", "Normal"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, _("Positive spacing")}; + gdouble values[] = {-2.0, -1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0}; - // Update "climb rate" The custom action has a step property but no way to set it. - if (unit->abbr == "%") { - gtk_adjustment_set_step_increment (line_height_adj, 1.0); - gtk_adjustment_set_page_increment (line_height_adj, 10.0); - } else { - gtk_adjustment_set_step_increment (line_height_adj, 0.1); - gtk_adjustment_set_page_increment (line_height_adj, 1.0); + toolbar->_letter_spacing_action = create_adjustment_action( + "TextLetterSpacingAction", /* name */ + _("Letter spacing"), /* label */ + _("Letter:"), /* short label */ + _("Spacing between letters (px)"), /* tooltip */ + "/tools/text/letterspacing", /* preferences path */ + 0.0, /* default */ + GTK_WIDGET(desktop->canvas), /* focusTarget */ + nullptr, /* dataKludge */ + FALSE, /* set alt-x keyboard shortcut? */ + nullptr, /* altx_mark */ + -100.0, 100.0, 0.01, 0.10, /* lower, upper, step (arrow up/down), page up/down */ + labels, values, G_N_ELEMENTS(labels), /* drop down menu */ + nullptr, /* callback */ + nullptr, /* unit tracker */ + 0.1, /* step (used?) */ + 2, /* digits to show */ + 1.0 /* factor (multiplies default) */ + ); + toolbar->_letter_spacing_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_letter_spacing_action)); + toolbar->_letter_spacing_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::letterspacing_value_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_letter_spacing_action) ); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_letter_spacing_action), TRUE ); + g_object_set( G_OBJECT(toolbar->_letter_spacing_action), "iconId", "text_letter_spacing", NULL ); } - // Internal function to set line-height which is spacing mode dependent. - set_lineheight (css); + /* Character kerning (horizontal shift) */ + { + // Drop down menu + gchar const* labels[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }; + gdouble values[] = { -2.0, -1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5, 2.0, 2.5 }; - // Only need to save for undo if a text item has been changed. - bool modmade = false; - for(auto i=itemlist.begin();i!=itemlist.end(); ++i){ - if (dynamic_cast(*i) || dynamic_cast(*i)) { - modmade = true; - } + toolbar->_dx_action = create_adjustment_action( + "TextDxAction", /* name */ + _("Kerning"), /* label */ + _("Kern:"), /* short label */ + _("Horizontal kerning (px)"), /* tooltip */ + "/tools/text/dx", /* preferences path */ + 0.0, /* default */ + GTK_WIDGET(desktop->canvas), /* focusTarget */ + nullptr, /* dataKludge */ + FALSE, /* set alt-x keyboard shortcut? */ + nullptr, /* altx_mark */ + -100.0, 100.0, 0.01, 0.1, /* lower, upper, step (arrow up/down), page up/down */ + labels, values, G_N_ELEMENTS(labels), /* drop down menu */ + nullptr, /* callback */ + nullptr, /* unit tracker */ + 0.1, /* step (used?) */ + 2, /* digits to show */ + 1.0 /* factor (multiplies default) */ + ); + toolbar->_dx_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_dx_action)); + toolbar->_dx_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::dx_value_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_dx_action) ); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_dx_action), TRUE ); + g_object_set( G_OBJECT(toolbar->_dx_action), "iconId", "text_horz_kern", NULL ); } - // Save for undo - if(modmade) { - DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:line-height", SP_VERB_NONE, - _("Text: Change line-height unit")); + /* Character vertical shift */ + { + // Drop down menu + gchar const* labels[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }; + gdouble values[] = { -2.0, -1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5, 2.0, 2.5 }; + + toolbar->_dy_action = create_adjustment_action( + "TextDyAction", /* name */ + _("Vertical Shift"), /* label */ + _("Vert:"), /* short label */ + _("Vertical shift (px)"), /* tooltip */ + "/tools/text/dy", /* preferences path */ + 0.0, /* default */ + GTK_WIDGET(desktop->canvas), /* focusTarget */ + nullptr, /* dataKludge */ + FALSE, /* set alt-x keyboard shortcut? */ + nullptr, /* altx_mark */ + -100.0, 100.0, 0.01, 0.1, /* lower, upper, step (arrow up/down), page up/down */ + labels, values, G_N_ELEMENTS(labels), /* drop down menu */ + nullptr, /* callback */ + nullptr, /* unit tracker */ + 0.1, /* step (used?) */ + 2, /* digits to show */ + 1.0 /* factor (multiplies default) */ + ); + toolbar->_dy_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_dy_action)); + toolbar->_dy_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::dy_value_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_dy_action) ); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_dy_action), TRUE ); + g_object_set( G_OBJECT(toolbar->_dy_action), "iconId", "text_vert_kern", NULL ); } - // If no selected objects, set default. - SPStyle query(SP_ACTIVE_DOCUMENT); - int result_numbers = - sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTNUMBERS); - if (result_numbers == QUERY_STYLE_NOTHING) + /* Character rotation */ { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->mergeStyle("/tools/text/style", css); + // Drop down menu + gchar const* labels[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }; + gdouble values[] = { -90, -45, -30, -15, 0, 15, 30, 45, 90, 180 }; + + toolbar->_rotation_action = create_adjustment_action( + "TextRotationAction", /* name */ + _("Letter rotation"), /* label */ + _("Rot:"), /* short label */ + _("Character rotation (degrees)"), /* tooltip */ + "/tools/text/rotation", /* preferences path */ + 0.0, /* default */ + GTK_WIDGET(desktop->canvas), /* focusTarget */ + nullptr, /* dataKludge */ + FALSE, /* set alt-x keyboard shortcut? */ + nullptr, /* altx_mark */ + -180.0, 180.0, 0.1, 1.0, /* lower, upper, step (arrow up/down), page up/down */ + labels, values, G_N_ELEMENTS(labels), /* drop down menu */ + nullptr, /* callback */ + nullptr, /* unit tracker */ + 0.1, /* step (used?) */ + 2, /* digits to show */ + 1.0 /* factor (multiplies default) */ + ); + toolbar->_rotation_adj = Glib::wrap(ege_adjustment_action_get_adjustment(toolbar->_rotation_action)); + toolbar->_rotation_adj->signal_value_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::rotation_value_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_rotation_action) ); + gtk_action_set_sensitive( GTK_ACTION(toolbar->_rotation_action), TRUE ); + g_object_set( G_OBJECT(toolbar->_rotation_action), "iconId", "text_rotation", NULL ); } - sp_repr_css_attr_unref (css); + /* Text line height unset */ + { + toolbar->_line_height_unset_action = ink_toggle_action_new( "TextLineHeightUnsetAction", // Name + _("Unset line height"), // Label + _("If enabled, line height is set on part of selection. Click to unset."), + INKSCAPE_ICON("paint-unknown"), + secondarySize ); // Icon size + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_line_height_unset_action ) ); + g_signal_connect_after( G_OBJECT(toolbar->_line_height_unset_action), "toggled", G_CALLBACK(lineheight_unset_changed), (gpointer)toolbar ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(toolbar->_line_height_unset_action), prefs->getBool("/tools/text/line_height_unset", false) ); + } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + /* Text outer style */ + { + toolbar->_outer_style_action = ink_toggle_action_new( "TextOuterStyleAction", // Name + _("Show outer style"), // Label + _("Show style of outermost text element. The 'font-size' and 'line-height' values of the outermost text element determine the minimum line spacing in the block."), + INKSCAPE_ICON("text_outer_style"), + secondarySize ); // Icon size + gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_outer_style_action ) ); + g_signal_connect_after( G_OBJECT(toolbar->_outer_style_action), "toggled", G_CALLBACK(outer_style_changed), (gpointer)toolbar ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(toolbar->_outer_style_action), prefs->getBool("/tools/text/outer_style", false) ); + } + + // Is this necessary to call? Shouldn't hurt. + toolbar->selection_changed(desktop->getSelection()); + + desktop->connectEventContextChanged(sigc::mem_fun(*toolbar, &TextToolbar::watch_ec)); + + return GTK_WIDGET(toolbar->gobj()); } -// -static void sp_text_line_spacing_mode_changed( GObject *tbl, int mode ) +void +TextToolbar::fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, gpointer data ) { + auto toolbar = reinterpret_cast(data); - // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { +#ifdef DEBUG_TEXT + std::cout << std::endl; + std::cout << "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM" << std::endl; + std::cout << "sp_text_fontfamily_value_changed: " << std::endl; +#endif + + // quit if run by the _changed callbacks + if (toolbar->_freeze) { +#ifdef DEBUG_TEXT + std::cout << "sp_text_fontfamily_value_changed: frozen... return" << std::endl; + std::cout << "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM\n" << std::endl; +#endif return; } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + toolbar->_freeze = true; - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setInt("/tools/text/line_spacing_mode", mode); + Glib::ustring new_family = ink_comboboxentry_action_get_active_text( act ); + css_font_family_unquote( new_family ); // Remove quotes around font family names. - SPDesktop *desktop = SP_ACTIVE_DESKTOP; - - // Note: only and text elements are in selection! - // (No need to worry about , , ...) - Inkscape::Selection *selection = desktop->getSelection(); - std::vector vec(selection->items().begin(), selection->items().end()); - - for (auto i: vec) { - - // Only and , => SPFlowtext - if (dynamic_cast(i) || dynamic_cast(i)) { - SPStyle* text_style = i->style; - - // Make list of , , children - std::vector children = i->childList(false); - std::vector children_item; - for (auto j: children) { - if (dynamic_cast(j)) { - children_item.push_back( dynamic_cast(j) ); - } - } - - SPStyle tspans; // Also flowPara/flowSpan - int result_numbers = sp_desktop_query_style_from_list (children_item, &tspans, QUERY_STYLE_PROPERTY_FONTNUMBERS); - - Inkscape::CSSOStringStream osfs; - if (text_style->line_height.computed != 0 || text_style->line_height.normal) { - - if (mode != 1 || text_style->line_height.unit == SP_CSS_UNIT_NONE || text_style->line_height.normal) { - Glib::ustring line_height_string = text_style->line_height.write( SP_STYLE_FLAG_ALWAYS ); - line_height_string.erase(0, 12); // erase 'line-height:' - osfs << line_height_string; - } else { - // Convert to unitless value - double line_height_value = text_style->line_height.value; - // Percent values are stored as value/100; - if (text_style->line_height.unit == SP_CSS_UNIT_PERCENT) { - line_height_value *= 100; - } - osfs << sp_style_css_size_units_to_px( line_height_value, - text_style->line_height.unit, - text_style->font_size.computed) / - text_style->font_size.computed; - } - - } else { - - if (mode != 1 || tspans.line_height.unit == SP_CSS_UNIT_NONE || tspans.line_height.normal) { - Glib::ustring line_height_string = tspans.line_height.write( SP_STYLE_FLAG_ALWAYS ); - line_height_string.erase(0, 12); // erase 'line-height:' - osfs << line_height_string; - } else { - // Convert to unitless value - double line_height_value = tspans.line_height.value; - // Percent values are stored as value/100; - if (tspans.line_height.unit == SP_CSS_UNIT_PERCENT) { - line_height_value *= 100; - } - osfs << sp_style_css_size_units_to_px( line_height_value, - tspans.line_height.unit, - tspans.font_size.computed) / - tspans.font_size.computed; - } - } - - SPCSSAttr *css_text = sp_repr_css_attr_new(); - SPCSSAttr *css_tspan = sp_repr_css_attr_new(); - - sp_repr_css_set_property (css_text, "line-height", osfs.str().c_str()); - - switch (mode) { - case 0: // Adaptive - // : Zero text - sp_repr_css_set_property (css_text, "line-height", "0"); - // : Old text value. - sp_repr_css_set_property (css_tspan, "line-height", osfs.str().c_str()); - break; - - case 1: // Minimum - // : Set to old text (unitless) or if old text zero, set to old tspan. - sp_repr_css_set_property (css_text, "line-height", osfs.str().c_str()); - // : Unset - sp_repr_css_unset_property (css_tspan, "line-height"); - break; + // TODO: Think about how to handle handle multiple selections. While + // the font-family may be the same for all, the styles might be different. + // See: TextEdit::onApply() for example of looping over selected items. + Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance(); +#ifdef DEBUG_TEXT + std::cout << " Old family: " << fontlister->get_font_family() << std::endl; + std::cout << " New family: " << new_family << std::endl; + std::cout << " Old active: " << fontlister->get_font_family_row() << std::endl; + std::cout << " New active: " << act->active << std::endl; +#endif + if( new_family.compare( fontlister->get_font_family() ) != 0 ) { + // Changed font-family - case 2: // Even - // : Set to old text or if old text zero, set to old tspan. - sp_repr_css_set_property (css_text, "line-height", osfs.str().c_str()); - // : Set to zero - sp_repr_css_set_property (css_tspan, "line-height", "0"); - break; + if( act->active == -1 ) { + // New font-family, not in document, not on system (could be fallback list) + fontlister->insert_font_family( new_family ); + act->active = 0; // New family is always at top of list. + } - case 3: // Adjustable - // Do nothing ☠ - break; - } + fontlister->set_font_family( act->active ); + // active text set in sp_text_toolbox_selection_changed() - if (mode != 3) { - i->changeCSS (css_text, "style"); - for (auto j: children) { - recursively_set_properties (j, css_tspan); - //j->changeCSS (css_tspan, "style"); - } - } + SPCSSAttr *css = sp_repr_css_attr_new (); + fontlister->fill_css( css ); - sp_repr_css_attr_unref (css_text); - sp_repr_css_attr_unref (css_tspan); + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + if( desktop->getSelection()->isEmpty() ) { + // Update default + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->mergeStyle("/tools/text/style", css); + } else { + // If there is a selection, update + sp_desktop_set_style (desktop, css, true, true); // Results in selection change called twice. + DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_TEXT, + _("Text: Change font family")); } + sp_repr_css_attr_unref (css); } - // Set "Outer Style" toggle to match mode. - InkToggleAction* outerStyle = INK_TOGGLE_ACTION(g_object_get_data (tbl, "TextOuterStyleAction")); + // unfreeze + toolbar->_freeze = false; - switch (mode) { - case 0: // Adaptive - gtk_toggle_action_set_active( &(outerStyle->action), false ); - prefs->setInt("/tools/text/outer_style", false); - break; +#ifdef DEBUG_TEXT + std::cout << "sp_text_toolbox_fontfamily_changes: exit" << std::endl; + std::cout << "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM" << std::endl; + std::cout << std::endl; +#endif +} - case 1: // Minimum - case 2: // Even - gtk_toggle_action_set_active( &(outerStyle->action), true ); - prefs->setInt("/tools/text/outer_style", true); - break; +void +TextToolbar::fontsize_value_changed( Ink_ComboBoxEntry_Action *act, gpointer data) +{ + auto toolbar = reinterpret_cast(data); - case 3: // Adjustable - break; + // quit if run by the _changed callbacks + if (toolbar->_freeze) { + return; } + toolbar->_freeze = true; - // Outer style toggle set per mode so that line height widget should be enabled. - GtkAction* lineHeightAction = GTK_ACTION( g_object_get_data( tbl, "TextLineHeightAction" ) ); - gtk_action_set_sensitive (lineHeightAction, true); + gchar *text = ink_comboboxentry_action_get_active_text( act ); + gchar *endptr; + gdouble size = g_strtod( text, &endptr ); + if (endptr == text) { // Conversion failed, non-numeric input. + g_warning( "Conversion of size text to double failed, input: %s\n", text ); + g_free( text ); + toolbar->_freeze = false; + return; + } + g_free( text ); - // Update "climb rate" - EgeAdjustmentAction *line_height_act = - reinterpret_cast(g_object_get_data(tbl, "TextLineHeightAction")); - GtkAdjustment *line_height_adj = ege_adjustment_action_get_adjustment( line_height_act ); - UnitTracker *tracker = reinterpret_cast(g_object_get_data(tbl, "tracker")); - Unit const *unit = tracker->getActiveUnit(); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + int max_size = prefs->getInt("/dialogs/textandfont/maxFontSize", 10000); // somewhat arbitrary, but text&font preview freezes with too huge fontsizes - if (unit->abbr == "%") { - gtk_adjustment_set_step_increment (line_height_adj, 1.0); - gtk_adjustment_set_page_increment (line_height_adj, 10.0); + if (size > max_size) + size = max_size; + + // Set css font size. + SPCSSAttr *css = sp_repr_css_attr_new (); + Inkscape::CSSOStringStream osfs; + int unit = prefs->getInt("/options/font/unitType", SP_CSS_UNIT_PT); + if (prefs->getBool("/options/font/textOutputPx", true)) { + osfs << sp_style_css_size_units_to_px(size, unit) << sp_style_get_css_unit_string(SP_CSS_UNIT_PX); } else { - gtk_adjustment_set_step_increment (line_height_adj, 0.1); - gtk_adjustment_set_page_increment (line_height_adj, 1.0); + osfs << size << sp_style_get_css_unit_string(unit); } + sp_repr_css_set_property (css, "font-size", osfs.str().c_str()); - DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_TEXT, - _("Text: Change line spacing mode")); + // Apply font size to selected objects. + // Calling sp_desktop_set_style will result in a call to TextTool::_styleSet() which + // will set the style on selected text inside the element. If we want to set + // the style on the outer objects we need to bypass this call. + bool outer = prefs->getInt("/tools/text/outer_style", false); + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + if (outer) { + Inkscape::Selection *selection = desktop->getSelection(); + auto itemlist= selection->items(); + for(auto i=itemlist.begin();i!=itemlist.end(); ++i){ + if (dynamic_cast(*i) || dynamic_cast(*i)) { + SPItem *item = *i; - gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); + // Scale by inverse of accumulated parent transform + SPCSSAttr *css_set = sp_repr_css_attr_new(); + sp_repr_css_merge(css_set, css); + Geom::Affine const local(item->i2doc_affine()); + double const ex(local.descrim()); + if ( (ex != 0.0) && (ex != 1.0) ) { + sp_css_attr_scale(css_set, 1/ex); + } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); -} + item->changeCSS(css_set,"style"); -static void sp_text_wordspacing_value_changed( GtkAdjustment *adj, GObject *tbl ) -{ - // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { - return; + sp_repr_css_attr_unref(css_set); + } + } + } else { + sp_desktop_set_style (desktop, css, true, true); } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); - - // At the moment this handles only numerical values (i.e. no em unit). - // Set css word-spacing - SPCSSAttr *css = sp_repr_css_attr_new (); - Inkscape::CSSOStringStream osfs; - osfs << gtk_adjustment_get_value(adj) << "px"; // For now always use px - sp_repr_css_set_property (css, "word-spacing", osfs.str().c_str()); - - // Apply word-spacing to selected objects. - SPDesktop *desktop = SP_ACTIVE_DESKTOP; - sp_desktop_set_style (desktop, css, true, false); // If no selected objects, set default. SPStyle query(SP_ACTIVE_DOCUMENT); @@ -1090,193 +1006,266 @@ static void sp_text_wordspacing_value_changed( GtkAdjustment *adj, GObject *tbl prefs->mergeStyle("/tools/text/style", css); } else { // Save for undo - DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:word-spacing", SP_VERB_NONE, - _("Text: Change word-spacing")); + DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:size", SP_VERB_NONE, + _("Text: Change font size")); } sp_repr_css_attr_unref (css); - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + toolbar->_freeze = false; } -static void sp_text_letterspacing_value_changed( GtkAdjustment *adj, GObject *tbl ) +void +TextToolbar::fontstyle_value_changed( Ink_ComboBoxEntry_Action *act, gpointer data) { + auto toolbar = reinterpret_cast(data); + // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { + if (toolbar->_freeze) { return; } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); - - // At the moment this handles only numerical values (i.e. no em unit). - // Set css letter-spacing - SPCSSAttr *css = sp_repr_css_attr_new (); - Inkscape::CSSOStringStream osfs; - osfs << gtk_adjustment_get_value(adj) << "px"; // For now always use px - sp_repr_css_set_property (css, "letter-spacing", osfs.str().c_str()); + toolbar->_freeze = true; - // Apply letter-spacing to selected objects. - SPDesktop *desktop = SP_ACTIVE_DESKTOP; - sp_desktop_set_style (desktop, css, true, false); + Glib::ustring new_style = ink_comboboxentry_action_get_active_text( act ); - // If no selected objects, set default. - SPStyle query(SP_ACTIVE_DOCUMENT); - int result_numbers = - sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTNUMBERS); - if (result_numbers == QUERY_STYLE_NOTHING) - { - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->mergeStyle("/tools/text/style", css); - } - else - { - // Save for undo - DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:letter-spacing", SP_VERB_NONE, - _("Text: Change letter-spacing")); - } + Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance(); - sp_repr_css_attr_unref (css); + if( new_style.compare( fontlister->get_font_style() ) != 0 ) { - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); -} + fontlister->set_font_style( new_style ); + // active text set in sp_text_toolbox_seletion_changed() + SPCSSAttr *css = sp_repr_css_attr_new (); + fontlister->fill_css( css ); -static void sp_text_dx_value_changed( GtkAdjustment *adj, GObject *tbl ) -{ - // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { - return; - } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + sp_desktop_set_style (desktop, css, true, true); - gdouble new_dx = gtk_adjustment_get_value(adj); - bool modmade = false; - if( SP_IS_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context) ) { - Inkscape::UI::Tools::TextTool *const tc = SP_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context); - if( tc ) { - unsigned char_index = -1; - TextTagAttributes *attributes = - text_tag_attributes_at_position( tc->text, std::min(tc->text_sel_start, tc->text_sel_end), &char_index ); - if( attributes ) { - double old_dx = attributes->getDx( char_index ); - double delta_dx = new_dx - old_dx; - sp_te_adjust_dx( tc->text, tc->text_sel_start, tc->text_sel_end, SP_ACTIVE_DESKTOP, delta_dx ); - modmade = true; - } + // If no selected objects, set default. + SPStyle query(SP_ACTIVE_DOCUMENT); + int result_style = + sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTSTYLE); + if (result_style == QUERY_STYLE_NOTHING) { + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->mergeStyle("/tools/text/style", css); + } else { + // Save for undo + DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_TEXT, + _("Text: Change font style")); } - } - if(modmade) { - // Save for undo - DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:dx", SP_VERB_NONE, - _("Text: Change dx (kern)")); + sp_repr_css_attr_unref (css); + } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + + toolbar->_freeze = false; } -static void sp_text_dy_value_changed( GtkAdjustment *adj, GObject *tbl ) +// Handles both Superscripts and Subscripts +void +TextToolbar::script_changed( InkToggleAction* act, gpointer data) { + auto toolbar = reinterpret_cast(data); // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { + if (toolbar->_freeze) { return; } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + toolbar->_freeze = true; - gdouble new_dy = gtk_adjustment_get_value(adj); - bool modmade = false; + // Called by Superscript or Subscript button? + const gchar* name = gtk_action_get_name( GTK_ACTION( act ) ); + gint prop = (strcmp(name, "TextSuperscriptAction") == 0) ? 0 : 1; - if( SP_IS_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context) ) { - Inkscape::UI::Tools::TextTool *const tc = SP_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context); - if( tc ) { - unsigned char_index = -1; - TextTagAttributes *attributes = - text_tag_attributes_at_position( tc->text, std::min(tc->text_sel_start, tc->text_sel_end), &char_index ); - if( attributes ) { - double old_dy = attributes->getDy( char_index ); - double delta_dy = new_dy - old_dy; - sp_te_adjust_dy( tc->text, tc->text_sel_start, tc->text_sel_end, SP_ACTIVE_DESKTOP, delta_dy ); - modmade = true; - } +#ifdef DEBUG_TEXT + std::cout << "sp_text_script_changed: " << prop << std::endl; +#endif + + // Query baseline + SPStyle query(SP_ACTIVE_DOCUMENT); + int result_baseline = sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_BASELINES); + + bool setSuper = false; + bool setSub = false; + + if (Inkscape::is_query_style_updateable(result_baseline)) { + // If not set or mixed, turn on superscript or subscript + if( prop == 0 ) { + setSuper = true; + } else { + setSub = true; } + } else { + // Superscript + gboolean superscriptSet = (query.baseline_shift.set && + query.baseline_shift.type == SP_BASELINE_SHIFT_LITERAL && + query.baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUPER ); + + // Subscript + gboolean subscriptSet = (query.baseline_shift.set && + query.baseline_shift.type == SP_BASELINE_SHIFT_LITERAL && + query.baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUB ); + + setSuper = !superscriptSet && prop == 0; + setSub = !subscriptSet && prop == 1; } - if(modmade) { - // Save for undo - DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:dy", SP_VERB_NONE, - _("Text: Change dy")); + // Set css properties + SPCSSAttr *css = sp_repr_css_attr_new (); + if( setSuper || setSub ) { + // Openoffice 2.3 and Adobe use 58%, Microsoft Word 2002 uses 65%, LaTex about 70%. + // 58% looks too small to me, especially if a superscript is placed on a superscript. + // If you make a change here, consider making a change to baseline-shift amount + // in style.cpp. + sp_repr_css_set_property (css, "font-size", "65%"); + } else { + sp_repr_css_set_property (css, "font-size", ""); } + if( setSuper ) { + sp_repr_css_set_property (css, "baseline-shift", "super"); + } else if( setSub ) { + sp_repr_css_set_property (css, "baseline-shift", "sub"); + } else { + sp_repr_css_set_property (css, "baseline-shift", "baseline"); + } + + // Apply css to selected objects. + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + sp_desktop_set_style (desktop, css, true, false); - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + // Save for undo + if(result_baseline != QUERY_STYLE_NOTHING) { + DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:script", SP_VERB_NONE, + _("Text: Change superscript or subscript")); + } + toolbar->_freeze = false; } -static void sp_text_rotation_value_changed( GtkAdjustment *adj, GObject *tbl ) +void +TextToolbar::align_mode_changed(int mode) { // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { + if (_freeze) { return; } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + _freeze = true; - gdouble new_degrees = gtk_adjustment_get_value(adj); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setInt("/tools/text/align_mode", mode); - bool modmade = false; - if( SP_IS_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context) ) { - Inkscape::UI::Tools::TextTool *const tc = SP_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context); - if( tc ) { - unsigned char_index = -1; - TextTagAttributes *attributes = - text_tag_attributes_at_position( tc->text, std::min(tc->text_sel_start, tc->text_sel_end), &char_index ); - if( attributes ) { - double old_degrees = attributes->getRotate( char_index ); - double delta_deg = new_degrees - old_degrees; - sp_te_adjust_rotation( tc->text, tc->text_sel_start, tc->text_sel_end, SP_ACTIVE_DESKTOP, delta_deg ); - modmade = true; - } - } - } + SPDesktop *desktop = SP_ACTIVE_DESKTOP; - // Save for undo - if(modmade) { - DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:rotate", SP_VERB_NONE, - _("Text: Change rotate")); - } + // move the x of all texts to preserve the same bbox + Inkscape::Selection *selection = desktop->getSelection(); + auto itemlist= selection->items(); + for(auto i=itemlist.begin();i!=itemlist.end(); ++i){ + if (SP_IS_TEXT(*i)) { + SPItem *item = *i; - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); -} + unsigned writing_mode = item->style->writing_mode.value; + // below, variable names suggest horizontal move, but we check the writing direction + // and move in the corresponding axis + Geom::Dim2 axis; + if (writing_mode == SP_CSS_WRITING_MODE_LR_TB || writing_mode == SP_CSS_WRITING_MODE_RL_TB) { + axis = Geom::X; + } else { + axis = Geom::Y; + } -static void sp_writing_mode_changed( GObject* tbl, int mode ) -{ - // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { - return; + Geom::OptRect bbox = item->geometricBounds(); + if (!bbox) + continue; + double width = bbox->dimensions()[axis]; + // If you want to align within some frame, other than the text's own bbox, calculate + // the left and right (or top and bottom for tb text) slacks of the text inside that + // frame (currently unused) + double left_slack = 0; + double right_slack = 0; + unsigned old_align = item->style->text_align.value; + double move = 0; + if (old_align == SP_CSS_TEXT_ALIGN_START || old_align == SP_CSS_TEXT_ALIGN_LEFT) { + switch (mode) { + case 0: + move = -left_slack; + break; + case 1: + move = width/2 + (right_slack - left_slack)/2; + break; + case 2: + move = width + right_slack; + break; + } + } else if (old_align == SP_CSS_TEXT_ALIGN_CENTER) { + switch (mode) { + case 0: + move = -width/2 - left_slack; + break; + case 1: + move = (right_slack - left_slack)/2; + break; + case 2: + move = width/2 + right_slack; + break; + } + } else if (old_align == SP_CSS_TEXT_ALIGN_END || old_align == SP_CSS_TEXT_ALIGN_RIGHT) { + switch (mode) { + case 0: + move = -width - left_slack; + break; + case 1: + move = -width/2 + (right_slack - left_slack)/2; + break; + case 2: + move = right_slack; + break; + } + } + Geom::Point XY = SP_TEXT(item)->attributes.firstXY(); + if (axis == Geom::X) { + XY = XY + Geom::Point (move, 0); + } else { + XY = XY + Geom::Point (0, move); + } + SP_TEXT(item)->attributes.setFirstXY(XY); + item->updateRepr(); + item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG); + } } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); - SPCSSAttr *css = sp_repr_css_attr_new (); + SPCSSAttr *css = sp_repr_css_attr_new (); switch (mode) { case 0: { - sp_repr_css_set_property (css, "writing-mode", "lr-tb"); + 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, "writing-mode", "tb-rl"); + 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, "writing-mode", "vertical-lr"); + 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"); + break; + } + } SPStyle query(SP_ACTIVE_DOCUMENT); int result_numbers = - sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_WRITINGMODES); + sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTNUMBERS); // If querying returned nothing, update default style. if (result_numbers == QUERY_STYLE_NOTHING) @@ -1285,47 +1274,48 @@ static void sp_writing_mode_changed( GObject* tbl, int mode ) prefs->mergeStyle("/tools/text/style", css); } - sp_desktop_set_style (SP_ACTIVE_DESKTOP, css, true, true); - if(result_numbers != QUERY_STYLE_NOTHING) + sp_desktop_set_style (desktop, css, true, true); + if (result_numbers != QUERY_STYLE_NOTHING) { DocumentUndo::done(SP_ACTIVE_DESKTOP->getDocument(), SP_VERB_CONTEXT_TEXT, - _("Text: Change writing mode")); + _("Text: Change alignment")); } sp_repr_css_attr_unref (css); gtk_widget_grab_focus (GTK_WIDGET(SP_ACTIVE_DESKTOP->canvas)); - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + _freeze = false; } -static void sp_text_orientation_changed( GObject* tbl, int mode ) +void +TextToolbar::writing_mode_changed(int mode) { // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { + if (_freeze) { return; } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + _freeze = true; SPCSSAttr *css = sp_repr_css_attr_new (); switch (mode) { case 0: - { - sp_repr_css_set_property (css, "text-orientation", "auto"); - break; - } + { + sp_repr_css_set_property (css, "writing-mode", "lr-tb"); + break; + } case 1: - { - sp_repr_css_set_property (css, "text-orientation", "upright"); - break; - } + { + sp_repr_css_set_property (css, "writing-mode", "tb-rl"); + break; + } case 2: - { - sp_repr_css_set_property (css, "text-orientation", "sideways"); - break; - } + { + sp_repr_css_set_property (css, "writing-mode", "vertical-lr"); + break; + } } SPStyle query(SP_ACTIVE_DOCUMENT); @@ -1343,35 +1333,42 @@ static void sp_text_orientation_changed( GObject* tbl, int mode ) if(result_numbers != QUERY_STYLE_NOTHING) { DocumentUndo::done(SP_ACTIVE_DESKTOP->getDocument(), SP_VERB_CONTEXT_TEXT, - _("Text: Change orientation")); + _("Text: Change writing mode")); } sp_repr_css_attr_unref (css); gtk_widget_grab_focus (GTK_WIDGET(SP_ACTIVE_DESKTOP->canvas)); - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + _freeze = false; } -static void sp_text_direction_changed( GObject *tbl, int mode ) +void +TextToolbar::orientation_changed(int mode) { // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { + if (_freeze) { return; } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + _freeze = true; SPCSSAttr *css = sp_repr_css_attr_new (); switch (mode) { case 0: { - sp_repr_css_set_property (css, "direction", "ltr"); + sp_repr_css_set_property (css, "text-orientation", "auto"); break; } case 1: { - sp_repr_css_set_property (css, "direction", "rtl"); + sp_repr_css_set_property (css, "text-orientation", "upright"); + break; + } + + case 2: + { + sp_repr_css_set_property (css, "text-orientation", "sideways"); break; } } @@ -1391,471 +1388,590 @@ static void sp_text_direction_changed( GObject *tbl, int mode ) if(result_numbers != QUERY_STYLE_NOTHING) { DocumentUndo::done(SP_ACTIVE_DESKTOP->getDocument(), SP_VERB_CONTEXT_TEXT, - _("Text: Change direction")); + _("Text: Change orientation")); } sp_repr_css_attr_unref (css); gtk_widget_grab_focus (GTK_WIDGET(SP_ACTIVE_DESKTOP->canvas)); - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); + _freeze = false; } -/* - * Set the default list of font sizes, scaled to the users preferred unit - */ -static void sp_text_set_sizes(GtkListStore* model_size, int unit) +void +TextToolbar::direction_changed(int mode) { - gtk_list_store_clear(model_size); - - // List of font sizes for drop-down menu - int sizes[] = { - 4, 6, 8, 9, 10, 11, 12, 13, 14, 16, 18, 20, 22, 24, 28, - 32, 36, 40, 48, 56, 64, 72, 144 - }; - - // Array must be same length as SPCSSUnit in style.h - float ratios[] = {1, 1, 1, 10, 4, 40, 100, 16, 8, 0.16}; - - for(int i : sizes) { - GtkTreeIter iter; - Glib::ustring size = Glib::ustring::format(i / (float)ratios[unit]); - gtk_list_store_append( model_size, &iter ); - gtk_list_store_set( model_size, &iter, 0, size.c_str(), -1 ); + // quit if run by the _changed callbacks + if (_freeze) { + return; } -} + _freeze = true; + SPCSSAttr *css = sp_repr_css_attr_new (); + switch (mode) + { + case 0: + { + sp_repr_css_set_property (css, "direction", "ltr"); + break; + } -/* - * This function sets up the text-tool tool-controls, setting the entry boxes - * etc. to the values from the current selection or the default if no selection. - * It is called whenever a text selection is changed, including stepping cursor - * through text, or setting focus to text. - */ -static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/, GObject *tbl, bool subselection) // don't bother to update font list if subsel changed -{ + case 1: + { + sp_repr_css_set_property (css, "direction", "rtl"); + break; + } + } -#ifdef DEBUG_TEXT - static int count = 0; - ++count; - std::cout << std::endl; - std::cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << std::endl; - std::cout << "sp_text_toolbox_selection_changed: start " << count << std::endl; + SPStyle query(SP_ACTIVE_DOCUMENT); + int result_numbers = + sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_WRITINGMODES); - Inkscape::Selection *selection = (SP_ACTIVE_DESKTOP)->getSelection(); - auto itemlist0= selection->items(); - for(auto i=itemlist0.begin();i!=itemlist0.end(); ++i) { - const gchar* id = (*i)->getId(); - std::cout << " " << id << std::endl; + // If querying returned nothing, update default style. + if (result_numbers == QUERY_STYLE_NOTHING) + { + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->mergeStyle("/tools/text/style", css); } - Glib::ustring selected_text = sp_text_get_selected_text((SP_ACTIVE_DESKTOP)->event_context); - std::cout << " Selected text: |" << selected_text << "|" << std::endl; -#endif - // quit if run by the _changed callbacks - if (g_object_get_data(G_OBJECT(tbl), "freeze")) { -#ifdef DEBUG_TEXT - std::cout << " Frozen, returning" << std::endl; - std::cout << "sp_text_toolbox_selection_changed: exit " << count << std::endl; - std::cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << std::endl; - std::cout << std::endl; -#endif - return; + sp_desktop_set_style (SP_ACTIVE_DESKTOP, css, true, true); + if(result_numbers != QUERY_STYLE_NOTHING) + { + DocumentUndo::done(SP_ACTIVE_DESKTOP->getDocument(), SP_VERB_CONTEXT_TEXT, + _("Text: Change direction")); } - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(TRUE) ); + sp_repr_css_attr_unref (css); - Ink_ComboBoxEntry_Action* fontFamilyAction = - INK_COMBOBOXENTRY_ACTION( g_object_get_data( tbl, "TextFontFamilyAction" ) ); - Ink_ComboBoxEntry_Action* fontStyleAction = - INK_COMBOBOXENTRY_ACTION( g_object_get_data( tbl, "TextFontStyleAction" ) ); + gtk_widget_grab_focus (GTK_WIDGET(SP_ACTIVE_DESKTOP->canvas)); - Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance(); - fontlister->update_font_list (SP_ACTIVE_DESKTOP->getDocument()); - fontlister->selection_update(); + _freeze = false; +} - // Update font list, but only if widget already created. - if( fontFamilyAction->combobox != nullptr ) { - ink_comboboxentry_action_set_active_text( fontFamilyAction, fontlister->get_font_family().c_str(), fontlister->get_font_family_row() ); - ink_comboboxentry_action_set_active_text( fontStyleAction, fontlister->get_font_style().c_str() ); +void +TextToolbar::lineheight_value_changed() +{ + // quit if run by the _changed callbacks + if (_freeze) { + return; } + _freeze = true; - // Only flowed text can be justified, only normal text can be kerned... - // Find out if we have flowed text now so we can use it several places - gboolean isFlow = false; - auto itemlist= SP_ACTIVE_DESKTOP->getSelection()->items(); - for(auto i=itemlist.begin();i!=itemlist.end(); ++i){ - // std::cout << " " << ((*i)->getId()?(*i)->getId():"null") << std::endl; - if( SP_IS_FLOWTEXT(*i)) { - isFlow = true; - // std::cout << " Found flowed text" << std::endl; - break; - } - } + // Get user selected unit and save as preference + Unit const *unit = _tracker->getActiveUnit(); + g_return_if_fail(unit != nullptr); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - /* - * Query from current selection: - * Font family (font-family) - * Style (font-weight, font-style, font-stretch, font-variant, font-align) - * Numbers (font-size, letter-spacing, word-spacing, line-height, text-anchor, writing-mode) - * Font specification (Inkscape private attribute) - */ - SPStyle query(SP_ACTIVE_DOCUMENT); - int result_family = sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTFAMILY); - int result_style = sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTSTYLE); - int result_baseline = sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_BASELINES); - int result_wmode = sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_WRITINGMODES); + // This nonsense is to get SP_CSS_UNIT_xx value corresponding to unit so + // we can save it (allows us to adjust line height value when unit changes). + SPILength temp_length; + Inkscape::CSSOStringStream temp_stream; + temp_stream << 1 << unit->abbr; + temp_length.read(temp_stream.str().c_str()); + prefs->setInt("/tools/text/lineheight/display_unit", temp_length.unit); + _lineheight_unit = temp_length.unit; - // Calling sp_desktop_query_style will result in a call to TextTool::_styleQueried(). - // This returns the style of the selected text inside the element... which - // is often the style of one or more s. If we want the style of the outer - // objects then we need to bypass the call to TextTool::_styleQueried(). - // The desktop selection never includes the elements inside the element. - int result_numbers = 0; - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - SPDesktop *desktop = SP_ACTIVE_DESKTOP; - bool outer = prefs->getInt("/tools/text/outer_style", false); - if (outer) { - Inkscape::Selection *selection = desktop->getSelection(); - std::vector vec(selection->items().begin(), selection->items().end()); - result_numbers = sp_desktop_query_style_from_list (vec, &query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + // Set css line height. + SPCSSAttr *css = sp_repr_css_attr_new (); + Inkscape::CSSOStringStream osfs; + if ( is_relative(unit) ) { + osfs << _line_height_adj->get_value() << unit->abbr; } else { - result_numbers = sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + // Inside SVG file, always use "px" for absolute units. + osfs << Quantity::convert(_line_height_adj->get_value(), unit, "px") << "px"; } + sp_repr_css_set_property (css, "line-height", osfs.str().c_str()); - /* - * If no text in selection (querying returned nothing), read the style from - * the /tools/text preferencess (default style for new texts). Return if - * tool bar already set to these preferences. - */ - if (result_family == QUERY_STYLE_NOTHING || - result_style == QUERY_STYLE_NOTHING || - result_numbers == QUERY_STYLE_NOTHING || - result_wmode == QUERY_STYLE_NOTHING ) { - // There are no texts in selection, read from preferences. - query.readFromPrefs("/tools/text"); -#ifdef DEBUG_TEXT - std::cout << " read style from prefs:" << std::endl; - sp_print_font( &query ); -#endif - if (g_object_get_data(tbl, "text_style_from_prefs")) { - // Do not reset the toolbar style from prefs if we already did it last time - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); -#ifdef DEBUG_TEXT - std::cout << " text_style_from_prefs: toolbar already set" << std:: endl; - std::cout << "sp_text_toolbox_selection_changed: exit " << count << std::endl; - std::cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << std::endl; - std::cout << std::endl; -#endif - return; + // Internal function to set line-height which is spacing mode dependent. + set_lineheight (css); + + // Only need to save for undo if a text item has been changed. + Inkscape::Selection *selection = SP_ACTIVE_DESKTOP->getSelection(); + bool modmade = false; + auto itemlist= selection->items(); + for(auto i=itemlist.begin();i!=itemlist.end(); ++i){ + if (dynamic_cast(*i) || dynamic_cast(*i)) { + modmade = true; } + } - // To ensure the value of the combobox is properly set on start-up, only mark - // the prefs set if the combobox has already been constructed. - if( fontFamilyAction->combobox != nullptr ) { - g_object_set_data(tbl, "text_style_from_prefs", GINT_TO_POINTER(TRUE)); + // Save for undo + if (modmade) { + // Call ensureUpToDate() causes rebuild of text layout (with all proper style + // cascading, etc.). For multi-line text with sodipodi::role="line", we must explicitly + // save new 'x' and 'y' attribute values by calling updateRepr(). + // Partial fix for bug #1590141. + SP_ACTIVE_DESKTOP->getDocument()->ensureUpToDate(); + for(auto i=itemlist.begin();i!=itemlist.end(); ++i){ + if (dynamic_cast(*i) || dynamic_cast(*i)) { + (*i)->updateRepr(); + } } - } else { - g_object_set_data(tbl, "text_style_from_prefs", GINT_TO_POINTER(FALSE)); + DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:line-height", SP_VERB_NONE, + _("Text: Change line-height")); } - // If we have valid query data for text (font-family, font-specification) set toolbar accordingly. + // If no selected objects, set default. + SPStyle query(SP_ACTIVE_DOCUMENT); + int result_numbers = + sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + if (result_numbers == QUERY_STYLE_NOTHING) { - // Size (average of text selected) Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - int unit = prefs->getInt("/options/font/unitType", SP_CSS_UNIT_PT); - double size = sp_style_css_size_px_to_units(query.font_size.computed, unit); + prefs->mergeStyle("/tools/text/style", css); + } - //gchar size_text[G_ASCII_DTOSTR_BUF_SIZE]; - //g_ascii_dtostr (size_text, sizeof (size_text), size); + sp_repr_css_attr_unref (css); - Inkscape::CSSOStringStream os; - os << size; + _freeze = false; +} - Ink_ComboBoxEntry_Action* fontSizeAction = - INK_COMBOBOXENTRY_ACTION( g_object_get_data( tbl, "TextFontSizeAction" ) ); +void +TextToolbar::lineheight_unit_changed(int /* Not Used */) +{ + // quit if run by the _changed callbacks + if (_freeze) { + return; + } + _freeze = true; - // Freeze to ignore callbacks. - //g_object_freeze_notify( G_OBJECT( fontSizeAction->combobox ) ); - sp_text_set_sizes(GTK_LIST_STORE(ink_comboboxentry_action_get_model(fontSizeAction)), unit); - //g_object_thaw_notify( G_OBJECT( fontSizeAction->combobox ) ); + // Get old saved unit + int old_unit = _lineheight_unit; - ink_comboboxentry_action_set_active_text( fontSizeAction, os.str().c_str() ); + // Get user selected unit and save as preference + Unit const *unit = _tracker->getActiveUnit(); + g_return_if_fail(unit != nullptr); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - Glib::ustring tooltip = Glib::ustring::format(_("Font size"), " (", sp_style_get_css_unit_string(unit), ")"); - ink_comboboxentry_action_set_tooltip ( fontSizeAction, tooltip.c_str()); + // This nonsense is to get SP_CSS_UNIT_xx value corresponding to unit. + SPILength temp_length; + Inkscape::CSSOStringStream temp_stream; + temp_stream << 1 << unit->abbr; + temp_length.read(temp_stream.str().c_str()); + prefs->setInt("/tools/text/lineheight/display_unit", temp_length.unit); + _lineheight_unit = temp_length.unit; - // Superscript - gboolean superscriptSet = - ((result_baseline == QUERY_STYLE_SINGLE || result_baseline == QUERY_STYLE_MULTIPLE_SAME ) && - query.baseline_shift.set && - query.baseline_shift.type == SP_BASELINE_SHIFT_LITERAL && - query.baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUPER ); + // Read current line height value + double line_height = _line_height_adj->get_value(); - InkToggleAction* textSuperscriptAction = INK_TOGGLE_ACTION( g_object_get_data( tbl, "TextSuperscriptAction" ) ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(textSuperscriptAction), superscriptSet ); + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + Inkscape::Selection *selection = desktop->getSelection(); + auto itemlist = selection->items(); + // Convert between units + if ((unit->abbr == "" || unit->abbr == "em") && + (old_unit == SP_CSS_UNIT_NONE || old_unit == SP_CSS_UNIT_EM)) { + // Do nothing + } else if ((unit->abbr == "" || unit->abbr == "em") && old_unit == SP_CSS_UNIT_EX) { + line_height *= 0.5; + } else if ((unit->abbr) == "ex" && (old_unit == SP_CSS_UNIT_EM || old_unit == SP_CSS_UNIT_NONE) ) { + line_height *= 2.0; + } else if ((unit->abbr == "" || unit->abbr == "em") && old_unit == SP_CSS_UNIT_PERCENT) { + line_height /= 100.0; + } else if ((unit->abbr) == "%" && (old_unit == SP_CSS_UNIT_EM || old_unit == SP_CSS_UNIT_NONE) ) { + line_height *= 100; + } else if ((unit->abbr) == "ex" && old_unit == SP_CSS_UNIT_PERCENT) { + line_height /= 50.0; + } else if ((unit->abbr) == "%" && old_unit == SP_CSS_UNIT_EX) { + line_height *= 50; + } else if (is_relative(unit)) { + // Convert absolute to relative... for the moment use average font-size + double font_size = 0; + int count = 0; + for(auto i=itemlist.begin();i!=itemlist.end(); ++i){ + if (SP_IS_TEXT (*i) || SP_IS_FLOWTEXT(*i)) { + double doc_scale = Geom::Affine((*i)->i2dt_affine()).descrim(); + font_size += (*i)->style->font_size.computed * doc_scale; + ++count; + } + } + if (count > 0) { + font_size /= count; + } else { + font_size = 20; + } - // Subscript - gboolean subscriptSet = - ((result_baseline == QUERY_STYLE_SINGLE || result_baseline == QUERY_STYLE_MULTIPLE_SAME ) && - query.baseline_shift.set && - query.baseline_shift.type == SP_BASELINE_SHIFT_LITERAL && - query.baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUB ); + if (old_unit == SP_CSS_UNIT_NONE) old_unit = SP_CSS_UNIT_EM; + line_height = Quantity::convert(line_height, sp_style_get_css_unit_string(old_unit), "px"); - InkToggleAction* textSubscriptAction = INK_TOGGLE_ACTION( g_object_get_data( tbl, "TextSubscriptAction" ) ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(textSubscriptAction), subscriptSet ); + if (font_size > 0) { + line_height /= font_size; + } + if ((unit->abbr) == "%") { + line_height *= 100; + } else if ((unit->abbr) == "ex") { + line_height *= 2; + } + } else if (old_unit==SP_CSS_UNIT_NONE || old_unit==SP_CSS_UNIT_PERCENT || + old_unit==SP_CSS_UNIT_EM || old_unit==SP_CSS_UNIT_EX) { + // Convert relative to absolute... for the moment use average font-size + double font_size = 0; + int count = 0; + for(auto i=itemlist.begin();i!=itemlist.end(); ++i){ + if (SP_IS_TEXT (*i) || SP_IS_FLOWTEXT (*i)) { + double doc_scale = Geom::Affine((*i)->i2dt_affine()).descrim(); + font_size += (*i)->style->font_size.computed * doc_scale; + ++count; + } + } + if (count > 0) { + font_size /= count; + } else { + font_size = 20; + } + if (old_unit == SP_CSS_UNIT_PERCENT) { + line_height /= 100.0; + } else if (old_unit == SP_CSS_UNIT_EX) { + line_height /= 2.0; + } + line_height *= font_size; + line_height = Quantity::convert(line_height, "px", unit); + } else { + // Convert between different absolute units (only used in GUI) + line_height = Quantity::convert(line_height, sp_style_get_css_unit_string(old_unit), unit); + } - // Alignment - InkSelectOneAction* textAlignAction = - static_cast( g_object_get_data( tbl, "TextAlignAction" ) ); + // Set css line height. + SPCSSAttr *css = sp_repr_css_attr_new (); + Inkscape::CSSOStringStream osfs; + if ( is_relative(unit) ) { + osfs << line_height << unit->abbr; + } else { + osfs << Quantity::convert(line_height, unit, "px") << "px"; + } + sp_repr_css_set_property (css, "line-height", osfs.str().c_str()); - // Note: SVG 1.1 doesn't include text-align, SVG 1.2 Tiny doesn't include text-align="justify" - // text-align="justify" was a draft SVG 1.2 item (along with flowed text). - // Only flowed text can be left and right justified at the same time. - // Disable button if we don't have flowed text. + // Update GUI with line_height value. + _line_height_adj->set_value(line_height); - Glib::RefPtr store = textAlignAction->get_store(); - Gtk::TreeModel::Row row = *(store->get_iter("3")); // Justify entry - InkSelectOneActionColumns columns; - row[columns.col_sensitive] = isFlow; + // Update "climb rate" The custom action has a step property but no way to set it. + if (unit->abbr == "%") { + _line_height_adj->set_step_increment(1.0); + _line_height_adj->set_page_increment(10.0); + } else { + _line_height_adj->set_step_increment(0.1); + _line_height_adj->set_page_increment(1.0); + } - int activeButton = 0; - if (query.text_align.computed == SP_CSS_TEXT_ALIGN_JUSTIFY) - { - activeButton = 3; - } else { - // This should take 'direction' into account - if (query.text_anchor.computed == SP_CSS_TEXT_ANCHOR_START) activeButton = 0; - if (query.text_anchor.computed == SP_CSS_TEXT_ANCHOR_MIDDLE) activeButton = 1; - if (query.text_anchor.computed == SP_CSS_TEXT_ANCHOR_END) activeButton = 2; - } - textAlignAction->set_active( activeButton ); + // Internal function to set line-height which is spacing mode dependent. + set_lineheight (css); - // Line height (spacing) and line height unit - double height; - int line_height_unit = -1; - if (query.line_height.normal) { - height = Inkscape::Text::Layout::LINE_HEIGHT_NORMAL; - line_height_unit = SP_CSS_UNIT_NONE; - } else { - height = query.line_height.value; - line_height_unit = query.line_height.unit; + // Only need to save for undo if a text item has been changed. + bool modmade = false; + for(auto i=itemlist.begin();i!=itemlist.end(); ++i){ + if (dynamic_cast(*i) || dynamic_cast(*i)) { + modmade = true; } + } - switch (line_height_unit) { - case SP_CSS_UNIT_NONE: - case SP_CSS_UNIT_EM: - case SP_CSS_UNIT_EX: - break; - case SP_CSS_UNIT_PERCENT: - height *= 100.0; // Inkscape store % as fraction in .value - break; - case SP_CSS_UNIT_PX: - // If unit is set to 'px', use the preferred display unit (if absolute). - line_height_unit = - prefs->getInt("/tools/text/lineheight/display_unit", SP_CSS_UNIT_PT); - // But not if preferred unit is relative - if (line_height_unit != SP_CSS_UNIT_NONE && - line_height_unit != SP_CSS_UNIT_EM && - line_height_unit != SP_CSS_UNIT_EX && - line_height_unit != SP_CSS_UNIT_PERCENT) { - height = - Quantity::convert(height, "px", sp_style_get_css_unit_string(line_height_unit)); + // Save for undo + if(modmade) { + DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:line-height", SP_VERB_NONE, + _("Text: Change line-height unit")); + } + + // If no selected objects, set default. + SPStyle query(SP_ACTIVE_DOCUMENT); + int result_numbers = + sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + if (result_numbers == QUERY_STYLE_NOTHING) + { + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->mergeStyle("/tools/text/style", css); + } + + sp_repr_css_attr_unref (css); + + _freeze = false; +} + +void +TextToolbar::line_spacing_mode_changed(int mode) +{ + // quit if run by the _changed callbacks + if (_freeze) { + return; + } + _freeze = true; + + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setInt("/tools/text/line_spacing_mode", mode); + + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + + // Note: only and text elements are in selection! + // (No need to worry about , , ...) + Inkscape::Selection *selection = desktop->getSelection(); + std::vector vec(selection->items().begin(), selection->items().end()); + + for (auto i: vec) { + + // Only and , => SPFlowtext + if (dynamic_cast(i) || dynamic_cast(i)) { + SPStyle* text_style = i->style; + + // Make list of , , children + std::vector children = i->childList(false); + std::vector children_item; + for (auto j: children) { + if (dynamic_cast(j)) { + children_item.push_back( dynamic_cast(j) ); + } + } + + SPStyle tspans; // Also flowPara/flowSpan + int result_numbers = sp_desktop_query_style_from_list (children_item, &tspans, QUERY_STYLE_PROPERTY_FONTNUMBERS); + + Inkscape::CSSOStringStream osfs; + if (text_style->line_height.computed != 0 || text_style->line_height.normal) { + + if (mode != 1 || text_style->line_height.unit == SP_CSS_UNIT_NONE || text_style->line_height.normal) { + Glib::ustring line_height_string = text_style->line_height.write( SP_STYLE_FLAG_ALWAYS ); + line_height_string.erase(0, 12); // erase 'line-height:' + osfs << line_height_string; } else { - line_height_unit = SP_CSS_UNIT_PX; + // Convert to unitless value + double line_height_value = text_style->line_height.value; + // Percent values are stored as value/100; + if (text_style->line_height.unit == SP_CSS_UNIT_PERCENT) { + line_height_value *= 100; + } + osfs << sp_style_css_size_units_to_px( line_height_value, + text_style->line_height.unit, + text_style->font_size.computed) / + text_style->font_size.computed; } - break; - default: - // If unit has been set by an external program to something other than 'px', use - // that unit. But height is average of computed values (px) so we need to convert - // back. - height = - Quantity::convert(height, "px", sp_style_get_css_unit_string(line_height_unit)); + + } else { + + if (mode != 1 || tspans.line_height.unit == SP_CSS_UNIT_NONE || tspans.line_height.normal) { + Glib::ustring line_height_string = tspans.line_height.write( SP_STYLE_FLAG_ALWAYS ); + line_height_string.erase(0, 12); // erase 'line-height:' + osfs << line_height_string; + } else { + // Convert to unitless value + double line_height_value = tspans.line_height.value; + // Percent values are stored as value/100; + if (tspans.line_height.unit == SP_CSS_UNIT_PERCENT) { + line_height_value *= 100; + } + osfs << sp_style_css_size_units_to_px( line_height_value, + tspans.line_height.unit, + tspans.font_size.computed) / + tspans.font_size.computed; + } + } + + SPCSSAttr *css_text = sp_repr_css_attr_new(); + SPCSSAttr *css_tspan = sp_repr_css_attr_new(); + + sp_repr_css_set_property (css_text, "line-height", osfs.str().c_str()); + + switch (mode) { + case 0: // Adaptive + // : Zero text + sp_repr_css_set_property (css_text, "line-height", "0"); + // : Old text value. + sp_repr_css_set_property (css_tspan, "line-height", osfs.str().c_str()); + break; + + case 1: // Minimum + // : Set to old text (unitless) or if old text zero, set to old tspan. + sp_repr_css_set_property (css_text, "line-height", osfs.str().c_str()); + // : Unset + sp_repr_css_unset_property (css_tspan, "line-height"); + break; + + case 2: // Even + // : Set to old text or if old text zero, set to old tspan. + sp_repr_css_set_property (css_text, "line-height", osfs.str().c_str()); + // : Set to zero + sp_repr_css_set_property (css_tspan, "line-height", "0"); + break; + + case 3: // Adjustable + // Do nothing ☠ + break; + } + + if (mode != 3) { + i->changeCSS (css_text, "style"); + for (auto j: children) { + recursively_set_properties (j, css_tspan); + //j->changeCSS (css_tspan, "style"); + } + } + + sp_repr_css_attr_unref (css_text); + sp_repr_css_attr_unref (css_tspan); } + } + + // Set "Outer Style" toggle to match mode. + switch (mode) { + case 0: // Adaptive + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(_outer_style_action), false ); + prefs->setInt("/tools/text/outer_style", false); + break; + + case 1: // Minimum + case 2: // Even + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(_outer_style_action), true ); + prefs->setInt("/tools/text/outer_style", true); + break; - GtkAction* lineHeightAction = GTK_ACTION( g_object_get_data( tbl, "TextLineHeightAction" ) ); - GtkAdjustment *lineHeightAdjustment = - ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( lineHeightAction )); - gtk_adjustment_set_value( lineHeightAdjustment, height ); + case 3: // Adjustable + break; + } - // Update "climb rate" - if (line_height_unit == SP_CSS_UNIT_PERCENT) { - gtk_adjustment_set_step_increment (lineHeightAdjustment, 1.0); - gtk_adjustment_set_page_increment (lineHeightAdjustment, 10.0); - } else { - gtk_adjustment_set_step_increment (lineHeightAdjustment, 0.1); - gtk_adjustment_set_page_increment (lineHeightAdjustment, 1.0); - } + // Outer style toggle set per mode so that line height widget should be enabled. + gtk_action_set_sensitive(GTK_ACTION(_line_height_action), true); - UnitTracker* tracker = reinterpret_cast( g_object_get_data( tbl, "tracker" ) ); - if( line_height_unit == SP_CSS_UNIT_NONE ) { - // Function 'sp_style_get_css_unit_string' returns 'px' for unit none. - // We need to avoid this. - tracker->setActiveUnitByAbbr(""); - } else { - tracker->setActiveUnitByAbbr(sp_style_get_css_unit_string(line_height_unit)); - } - // Save unit so we can do conversions between new/old units. - g_object_set_data( tbl, "lineheight_unit", GINT_TO_POINTER(line_height_unit)); + // Update "climb rate" + Unit const *unit = _tracker->getActiveUnit(); - // Enable and turn on only if selection includes an object with line height set. - InkToggleAction* lineHeightUnset = - INK_TOGGLE_ACTION( g_object_get_data( tbl, "TextLineHeightUnsetAction")); - gtk_action_set_sensitive(GTK_ACTION(lineHeightUnset), query.line_height.set ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(lineHeightUnset), query.line_height.set ); + if (unit->abbr == "%") { + _line_height_adj->set_step_increment(1.0); + _line_height_adj->set_page_increment(10.0); + } else { + _line_height_adj->set_step_increment(0.1); + _line_height_adj->set_page_increment(1.0); + } + DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_TEXT, + _("Text: Change line spacing mode")); - // Line spacing mode: requires calculating mode for each element and the s within. - Inkscape::Selection *selection = desktop->getSelection(); - std::vector vec(selection->items().begin(), selection->items().end()); - int mode[4] = {0, 0, 0, 0}; - for (auto i: vec) { - if (dynamic_cast(i) || dynamic_cast(i) ) { - bool text_line_height_set = false; - bool text_line_height_zero = false; - bool text_line_height_has_units = false; - bool tspan_line_height_all_unset = true; - bool tspan_line_height_all_zero = true; - bool tspan_line_height_all_non_zero = true; - if (i->style && i->style->line_height.set) { - text_line_height_set = true; - if (i->style->line_height.computed == 0 && !(i->style->line_height.normal)) { - text_line_height_zero = true; - } - if (i->style->line_height.unit != SP_CSS_UNIT_NONE && !(i->style->line_height.normal)) { - text_line_height_has_units = true; - } - } - // TO DO: recursively check children - std::vector children = i->childList(false); - for (auto j: children) { - if (dynamic_cast(j) || dynamic_cast(j) || dynamic_cast(j) ) { - if (j->style && j->style->line_height.set) { - tspan_line_height_all_unset = false; - if (j->style->line_height.computed != 0 || j->style->line_height.normal) { - tspan_line_height_all_zero = false; - } else { - tspan_line_height_all_non_zero = false; - } - } - } - } + gtk_widget_grab_focus (GTK_WIDGET(desktop->canvas)); - if ( text_line_height_zero && tspan_line_height_all_non_zero) mode[0]++; - else if (!text_line_height_has_units && tspan_line_height_all_unset) mode[1]++; - else if ( text_line_height_has_units && tspan_line_height_all_unset) mode[3]++; - else if ( tspan_line_height_all_zero ) mode[2]++; - else mode[3]++; - } - } + _freeze = false; +} - int activeButtonLS = 3; - if (mode[0] > 0 && mode[1] == 0 && mode[2] == 0 && mode[3] == 0) activeButtonLS = 0; - if (mode[0] == 0 && mode[1] > 0 && mode[2] == 0 && mode[3] == 0) activeButtonLS = 1; - if (mode[0] == 0 && mode[1] == 0 && mode[2] > 0 && mode[3] == 0) activeButtonLS = 2; - // std::cout << " modes: " << mode[0] - // << ", "<< mode[1] - // << ", "<< mode[2] - // << ", "<< mode[3] << std::endl; - InkSelectOneAction* textLineSpacingAction = - static_cast( g_object_get_data( tbl, "TextLineSpacingAction" ) ); - textLineSpacingAction->set_active( activeButtonLS ); +void +TextToolbar::wordspacing_value_changed() +{ + // quit if run by the _changed callbacks + if (_freeze) { + return; + } + _freeze = true; - // Enable/disable line height widget based on mode and Outer Style toggle. - if ( (activeButtonLS == 0 && outer) || // Adaptive - (activeButtonLS == 1 && !outer) || // Minimum - (activeButtonLS == 2 && !outer) // Even - ) { - gtk_action_set_sensitive (lineHeightAction, false); - } else { - gtk_action_set_sensitive (lineHeightAction, true); - } + // At the moment this handles only numerical values (i.e. no em unit). + // Set css word-spacing + SPCSSAttr *css = sp_repr_css_attr_new (); + Inkscape::CSSOStringStream osfs; + osfs << _word_spacing_adj->get_value() << "px"; // For now always use px + sp_repr_css_set_property (css, "word-spacing", osfs.str().c_str()); - // In Minimum and Adaptive modes, don't allow unit change (must remain unitless). - InkSelectOneAction* textLineHeightUnitsAction = - static_cast(g_object_get_data( tbl, "TextLineHeightUnitsAction") ); - if (activeButtonLS == 0 || (activeButtonLS == 1 && outer)) { - textLineHeightUnitsAction->set_sensitive(false); - } else { - textLineHeightUnitsAction->set_sensitive(true); - } + // Apply word-spacing to selected objects. + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + sp_desktop_set_style (desktop, css, true, false); - // Word spacing - double wordSpacing; - if (query.word_spacing.normal) wordSpacing = 0.0; - else wordSpacing = query.word_spacing.computed; // Assume no units (change in desktop-style.cpp) + // If no selected objects, set default. + SPStyle query(SP_ACTIVE_DOCUMENT); + int result_numbers = + sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + if (result_numbers == QUERY_STYLE_NOTHING) + { + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->mergeStyle("/tools/text/style", css); + } else { + // Save for undo + DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:word-spacing", SP_VERB_NONE, + _("Text: Change word-spacing")); + } - GtkAction* wordSpacingAction = GTK_ACTION( g_object_get_data( tbl, "TextWordSpacingAction" ) ); - GtkAdjustment *wordSpacingAdjustment = - ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( wordSpacingAction )); - gtk_adjustment_set_value( wordSpacingAdjustment, wordSpacing ); + sp_repr_css_attr_unref (css); + _freeze = false; +} - // Letter spacing - double letterSpacing; - if (query.letter_spacing.normal) letterSpacing = 0.0; - else letterSpacing = query.letter_spacing.computed; // Assume no units (change in desktop-style.cpp) +void +TextToolbar::letterspacing_value_changed() +{ + // quit if run by the _changed callbacks + if (_freeze) { + return; + } + _freeze = true; + + // At the moment this handles only numerical values (i.e. no em unit). + // Set css letter-spacing + SPCSSAttr *css = sp_repr_css_attr_new (); + Inkscape::CSSOStringStream osfs; + osfs << _letter_spacing_adj->get_value() << "px"; // For now always use px + sp_repr_css_set_property (css, "letter-spacing", osfs.str().c_str()); - GtkAction* letterSpacingAction = GTK_ACTION( g_object_get_data( tbl, "TextLetterSpacingAction" ) ); - GtkAdjustment *letterSpacingAdjustment = - ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( letterSpacingAction )); - gtk_adjustment_set_value( letterSpacingAdjustment, letterSpacing ); + // Apply letter-spacing to selected objects. + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + sp_desktop_set_style (desktop, css, true, false); + // If no selected objects, set default. + SPStyle query(SP_ACTIVE_DOCUMENT); + int result_numbers = + sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + if (result_numbers == QUERY_STYLE_NOTHING) + { + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->mergeStyle("/tools/text/style", css); + } + else + { + // Save for undo + DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:letter-spacing", SP_VERB_NONE, + _("Text: Change letter-spacing")); + } - // Writing mode - int activeButton2 = 0; - if (query.writing_mode.computed == SP_CSS_WRITING_MODE_LR_TB) activeButton2 = 0; - if (query.writing_mode.computed == SP_CSS_WRITING_MODE_TB_RL) activeButton2 = 1; - if (query.writing_mode.computed == SP_CSS_WRITING_MODE_TB_LR) activeButton2 = 2; + sp_repr_css_attr_unref (css); - InkSelectOneAction* writingModeAction = - static_cast( g_object_get_data( tbl, "TextWritingModeAction" ) ); - writingModeAction->set_active( activeButton2 ); + _freeze = false; +} - // Orientation - int activeButton3 = 0; - if (query.text_orientation.computed == SP_CSS_TEXT_ORIENTATION_MIXED ) activeButton3 = 0; - if (query.text_orientation.computed == SP_CSS_TEXT_ORIENTATION_UPRIGHT ) activeButton3 = 1; - if (query.text_orientation.computed == SP_CSS_TEXT_ORIENTATION_SIDEWAYS) activeButton3 = 2; +void +TextToolbar::dx_value_changed() +{ + // quit if run by the _changed callbacks + if (_freeze) { + return; + } + _freeze = true; - InkSelectOneAction* textOrientationAction = - static_cast( g_object_get_data( tbl, "TextOrientationAction" ) ); - textOrientationAction->set_active( activeButton3 ); + gdouble new_dx = _dx_adj->get_value(); + bool modmade = false; - // Disable text orientation for horizontal text... - textOrientationAction->set_sensitive( activeButton2 != 0 ); + if( SP_IS_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context) ) { + Inkscape::UI::Tools::TextTool *const tc = SP_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context); + if( tc ) { + unsigned char_index = -1; + TextTagAttributes *attributes = + text_tag_attributes_at_position( tc->text, std::min(tc->text_sel_start, tc->text_sel_end), &char_index ); + if( attributes ) { + double old_dx = attributes->getDx( char_index ); + double delta_dx = new_dx - old_dx; + sp_te_adjust_dx( tc->text, tc->text_sel_start, tc->text_sel_end, SP_ACTIVE_DESKTOP, delta_dx ); + modmade = true; + } + } + } - // Direction - int activeButton4 = 0; - if (query.direction.computed == SP_CSS_DIRECTION_LTR ) activeButton4 = 0; - if (query.direction.computed == SP_CSS_DIRECTION_RTL ) activeButton4 = 1; - InkSelectOneAction* textDirectionAction = - static_cast( g_object_get_data( tbl, "TextDirectionAction" ) ); - textDirectionAction->set_active( activeButton4 ); + if(modmade) { + // Save for undo + DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:dx", SP_VERB_NONE, + _("Text: Change dx (kern)")); } + _freeze = false; +} -#ifdef DEBUG_TEXT - std::cout << " GUI: fontfamily.value: " - << (query.font_family.value ? query.font_family.value : "No value") - << std::endl; - std::cout << " GUI: font_size.computed: " << query.font_size.computed << std::endl; - std::cout << " GUI: font_weight.computed: " << query.font_weight.computed << std::endl; - std::cout << " GUI: font_style.computed: " << query.font_style.computed << std::endl; - std::cout << " GUI: text_anchor.computed: " << query.text_anchor.computed << std::endl; - std::cout << " GUI: text_align.computed: " << query.text_align.computed << std::endl; - std::cout << " GUI: line_height.computed: " << query.line_height.computed - << " line_height.value: " << query.line_height.value - << " line_height.unit: " << query.line_height.unit << std::endl; - std::cout << " GUI: word_spacing.computed: " << query.word_spacing.computed - << " word_spacing.value: " << query.word_spacing.value - << " word_spacing.unit: " << query.word_spacing.unit << std::endl; - std::cout << " GUI: letter_spacing.computed: " << query.letter_spacing.computed - << " letter_spacing.value: " << query.letter_spacing.value - << " letter_spacing.unit: " << query.letter_spacing.unit << std::endl; - std::cout << " GUI: writing_mode.computed: " << query.writing_mode.computed << std::endl; -#endif +void +TextToolbar::dy_value_changed() +{ + // quit if run by the _changed callbacks + if (_freeze) { + return; + } + _freeze = true; + + gdouble new_dy = _dy_adj->get_value(); + bool modmade = false; - // Kerning (xshift), yshift, rotation. NB: These are not CSS attributes. if( SP_IS_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context) ) { Inkscape::UI::Tools::TextTool *const tc = SP_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context); if( tc ) { @@ -1863,722 +1979,547 @@ static void sp_text_toolbox_selection_changed(Inkscape::Selection */*selection*/ TextTagAttributes *attributes = text_tag_attributes_at_position( tc->text, std::min(tc->text_sel_start, tc->text_sel_end), &char_index ); if( attributes ) { + double old_dy = attributes->getDy( char_index ); + double delta_dy = new_dy - old_dy; + sp_te_adjust_dy( tc->text, tc->text_sel_start, tc->text_sel_end, SP_ACTIVE_DESKTOP, delta_dy ); + modmade = true; + } + } + } - // Dx - double dx = attributes->getDx( char_index ); - GtkAction* dxAction = GTK_ACTION( g_object_get_data( tbl, "TextDxAction" )); - GtkAdjustment *dxAdjustment = - ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( dxAction )); - gtk_adjustment_set_value( dxAdjustment, dx ); + if(modmade) { + // Save for undo + DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:dy", SP_VERB_NONE, + _("Text: Change dy")); + } - // Dy - double dy = attributes->getDy( char_index ); - GtkAction* dyAction = GTK_ACTION( g_object_get_data( tbl, "TextDyAction" )); - GtkAdjustment *dyAdjustment = - ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( dyAction )); - gtk_adjustment_set_value( dyAdjustment, dy ); + _freeze = false; +} - // Rotation - double rotation = attributes->getRotate( char_index ); - /* SVG value is between 0 and 360 but we're using -180 to 180 in widget */ - if( rotation > 180.0 ) rotation -= 360.0; - GtkAction* rotationAction = GTK_ACTION( g_object_get_data( tbl, "TextRotationAction" )); - GtkAdjustment *rotationAdjustment = - ege_adjustment_action_get_adjustment(EGE_ADJUSTMENT_ACTION( rotationAction )); - gtk_adjustment_set_value( rotationAdjustment, rotation ); +void +TextToolbar::rotation_value_changed() +{ + // quit if run by the _changed callbacks + if (_freeze) { + return; + } + _freeze = true; -#ifdef DEBUG_TEXT - std::cout << " GUI: Dx: " << dx << std::endl; - std::cout << " GUI: Dy: " << dy << std::endl; - std::cout << " GUI: Rotation: " << rotation << std::endl; -#endif + gdouble new_degrees = _rotation_adj->get_value(); + + bool modmade = false; + if( SP_IS_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context) ) { + Inkscape::UI::Tools::TextTool *const tc = SP_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context); + if( tc ) { + unsigned char_index = -1; + TextTagAttributes *attributes = + text_tag_attributes_at_position( tc->text, std::min(tc->text_sel_start, tc->text_sel_end), &char_index ); + if( attributes ) { + double old_degrees = attributes->getRotate( char_index ); + double delta_deg = new_degrees - old_degrees; + sp_te_adjust_rotation( tc->text, tc->text_sel_start, tc->text_sel_end, SP_ACTIVE_DESKTOP, delta_deg ); + modmade = true; } } } - { - // Set these here as we don't always have kerning/rotating attributes - GtkAction* dxAction = GTK_ACTION( g_object_get_data( tbl, "TextDxAction" )); - gtk_action_set_sensitive( GTK_ACTION(dxAction), !isFlow ); - - GtkAction* dyAction = GTK_ACTION( g_object_get_data( tbl, "TextDyAction" )); - gtk_action_set_sensitive( GTK_ACTION(dyAction), !isFlow ); - - GtkAction* rotationAction = GTK_ACTION( g_object_get_data( tbl, "TextRotationAction" )); - gtk_action_set_sensitive( GTK_ACTION(rotationAction), !isFlow ); + // Save for undo + if(modmade) { + DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:rotate", SP_VERB_NONE, + _("Text: Change rotate")); } -#ifdef DEBUG_TEXT - std::cout << "sp_text_toolbox_selection_changed: exit " << count << std::endl; - std::cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << std::endl; - std::cout << std::endl; -#endif - - g_object_set_data( tbl, "freeze", GINT_TO_POINTER(FALSE) ); -} - -static void sp_text_toolbox_selection_modified(Inkscape::Selection *selection, guint /*flags*/, GObject *tbl) -{ - sp_text_toolbox_selection_changed (selection, tbl); + _freeze = false; } -static void -sp_text_toolbox_subselection_changed (gpointer /*tc*/, GObject *tbl) +// Unset line height on selection's inner text objects (tspan, etc.). +void +TextToolbar::lineheight_unset_changed(InkToggleAction*act, gpointer data) { - sp_text_toolbox_selection_changed (nullptr, tbl, true); -} - -// TODO: possibly share with font-selector by moving most code to font-lister (passing family name) -static void sp_text_toolbox_select_cb( GtkEntry* entry, GtkEntryIconPosition /*position*/, GdkEvent /*event*/, gpointer /*data*/ ) { - - Glib::ustring family = gtk_entry_get_text ( entry ); - //std::cout << "text_toolbox_missing_font_cb: selecting: " << family << std::endl; + auto toolbar = reinterpret_cast(data); - // Get all items with matching font-family set (not inherited!). - std::vector selectList; + // quit if run by the _changed callbacks + if (toolbar->_freeze) { + return; + } + toolbar->_freeze = true; - SPDesktop *desktop = SP_ACTIVE_DESKTOP; - SPDocument *document = desktop->getDocument(); - std::vector x,y; - std::vector allList = get_all_items(x, document->getRoot(), desktop, false, false, true, y); - for(std::vector::const_reverse_iterator i=allList.rbegin();i!=allList.rend(); ++i){ - SPItem *item = *i; - SPStyle *style = item->style; + SPCSSAttr *css = sp_repr_css_attr_new(); + sp_repr_css_unset_property(css, "line-height"); - if (style) { + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + sp_desktop_set_style (desktop, css); - Glib::ustring family_style; - if (style->font_family.set) { - family_style = style->font_family.value; - //std::cout << " family style from font_family: " << family_style << std::endl; - } - else if (style->font_specification.set) { - family_style = style->font_specification.value; - //std::cout << " family style from font_spec: " << family_style << std::endl; - } + sp_repr_css_attr_unref(css); - if (family_style.compare( family ) == 0 ) { - //std::cout << " found: " << item->getId() << std::endl; - selectList.push_back(item); - } - } - } + DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_TEXT, + _("Text: Unset line height.")); - // Update selection - Inkscape::Selection *selection = desktop->getSelection(); - selection->clear(); - //std::cout << " list length: " << g_slist_length ( selectList ) << std::endl; - selection->setList(selectList); + toolbar->_freeze = false; } -static void text_toolbox_watch_ec(SPDesktop* dt, Inkscape::UI::Tools::ToolBase* ec, GObject* holder); - -// Define all the "widgets" in the toolbar. -void sp_text_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) +// Changes selection to only text outer elements. +void +TextToolbar::outer_style_changed( InkToggleAction *act, gpointer data ) { + auto toolbar = reinterpret_cast(data); + bool outer = gtk_toggle_action_get_active( GTK_TOGGLE_ACTION(act) ); Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); - - /* Font family */ - { - // Font list - Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance(); - fontlister->update_font_list( SP_ACTIVE_DESKTOP->getDocument()); - Glib::RefPtr store = fontlister->get_font_list(); - GtkListStore* model = store->gobj(); - - Ink_ComboBoxEntry_Action* act = - ink_comboboxentry_action_new( "TextFontFamilyAction", - _("Font Family"), - _("Select Font Family (Alt-X to access)"), - nullptr, - GTK_TREE_MODEL(model), - -1, // Entry width - 50, // Extra list width - (gpointer)font_lister_cell_data_func2, // Cell layout - (gpointer)font_lister_separator_func2, - GTK_WIDGET(desktop->canvas)); // Focus widget - ink_comboboxentry_action_popup_enable( act ); // Enable entry completion - - gchar *const info = _("Select all text with this font-family"); - ink_comboboxentry_action_set_info( act, info ); // Show selection icon - ink_comboboxentry_action_set_info_cb( act, (gpointer)sp_text_toolbox_select_cb ); - - gchar *const warning = _("Font not found on system"); - ink_comboboxentry_action_set_warning( act, warning ); // Show icon w/ tooltip if font missing - ink_comboboxentry_action_set_warning_cb( act, (gpointer)sp_text_toolbox_select_cb ); + prefs->setInt("/tools/text/outer_style", outer); - //ink_comboboxentry_action_set_warning_callback( act, sp_text_fontfamily_select_all ); - ink_comboboxentry_action_set_altx_name( act, "altx-text" ); // Set Alt-X keyboard shortcut - g_signal_connect( G_OBJECT(act), "changed", G_CALLBACK(sp_text_fontfamily_value_changed), holder ); - gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); - g_object_set_data( holder, "TextFontFamilyAction", act ); + // Update widgets to reflect new state of Text Outer Style button. + toolbar->selection_changed(nullptr); +} - // Change style of drop-down from menu to list - auto css_provider = gtk_css_provider_new(); - gtk_css_provider_load_from_data(css_provider, - "#TextFontFamilyAction_combobox {\n" - " -GtkComboBox-appears-as-list: true;\n" - "}\n", - -1, nullptr); +/* + * This function sets up the text-tool tool-controls, setting the entry boxes + * etc. to the values from the current selection or the default if no selection. + * It is called whenever a text selection is changed, including stepping cursor + * through text, or setting focus to text. + */ +void +TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subselection) // don't bother to update font list if subsel changed +{ +#ifdef DEBUG_TEXT + static int count = 0; + ++count; + std::cout << std::endl; + std::cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << std::endl; + std::cout << "sp_text_toolbox_selection_changed: start " << count << std::endl; - auto screen = gdk_screen_get_default(); - gtk_style_context_add_provider_for_screen(screen, - GTK_STYLE_PROVIDER(css_provider), - GTK_STYLE_PROVIDER_PRIORITY_USER); + Inkscape::Selection *selection = (SP_ACTIVE_DESKTOP)->getSelection(); + auto itemlist0= selection->items(); + for(auto i=itemlist0.begin();i!=itemlist0.end(); ++i) { + const gchar* id = (*i)->getId(); + std::cout << " " << id << std::endl; } + Glib::ustring selected_text = sp_text_get_selected_text((SP_ACTIVE_DESKTOP)->event_context); + std::cout << " Selected text: |" << selected_text << "|" << std::endl; +#endif - /* Font size */ - { - // List of font sizes for drop-down menu - GtkListStore* model_size = gtk_list_store_new( 1, G_TYPE_STRING ); - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - int unit = prefs->getInt("/options/font/unitType", SP_CSS_UNIT_PT); - - sp_text_set_sizes(model_size, unit); - - Glib::ustring tooltip = Glib::ustring::format(_("Font size"), " (", sp_style_get_css_unit_string(unit), ")"); - - Ink_ComboBoxEntry_Action* act = ink_comboboxentry_action_new( "TextFontSizeAction", - _("Font Size"), - _(tooltip.c_str()), - nullptr, - GTK_TREE_MODEL(model_size), - 8, // Width in characters - 0, // Extra list width - nullptr, // Cell layout - nullptr, // Separator - GTK_WIDGET(desktop->canvas)); // Focus widget - - g_signal_connect( G_OBJECT(act), "changed", G_CALLBACK(sp_text_fontsize_value_changed), holder ); - gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); - g_object_set_data( holder, "TextFontSizeAction", act ); + // quit if run by the _changed callbacks + if (_freeze) { +#ifdef DEBUG_TEXT + std::cout << " Frozen, returning" << std::endl; + std::cout << "sp_text_toolbox_selection_changed: exit " << count << std::endl; + std::cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << std::endl; + std::cout << std::endl; +#endif + return; } + _freeze = true; - /* Font styles */ - { - Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance(); - Glib::RefPtr store = fontlister->get_style_list(); - GtkListStore* model_style = store->gobj(); - - Ink_ComboBoxEntry_Action* act = ink_comboboxentry_action_new( "TextFontStyleAction", - _("Font Style"), - _("Font style"), - nullptr, - GTK_TREE_MODEL(model_style), - 12, // Width in characters - 0, // Extra list width - nullptr, // Cell layout - nullptr, // Separator - GTK_WIDGET(desktop->canvas)); // Focus widget - - g_signal_connect( G_OBJECT(act), "changed", G_CALLBACK(sp_text_fontstyle_value_changed), holder ); - gtk_action_group_add_action( mainActions, GTK_ACTION(act) ); - g_object_set_data( holder, "TextFontStyleAction", act ); - } + Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance(); + fontlister->update_font_list (SP_ACTIVE_DESKTOP->getDocument()); + fontlister->selection_update(); - /* Style - Superscript */ - { - InkToggleAction* act = ink_toggle_action_new( "TextSuperscriptAction", // Name - _("Toggle Superscript"), // Label - _("Toggle superscript"), // Tooltip - "text_superscript", // Icon (inkId) - secondarySize ); // Icon size - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_text_script_changed), holder ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/text/super", false) ); - g_object_set_data( holder, "TextSuperscriptAction", act ); + // Update font list, but only if widget already created. + if( _font_family_action->combobox != nullptr ) { + ink_comboboxentry_action_set_active_text( _font_family_action, fontlister->get_font_family().c_str(), fontlister->get_font_family_row() ); + ink_comboboxentry_action_set_active_text( _font_style_action, fontlister->get_font_style().c_str() ); } - /* Style - Subscript */ - { - InkToggleAction* act = ink_toggle_action_new( "TextSubscriptAction", // Name - _("Toggle Subscript"), // Label - _("Toggle subscript"), // Tooltip - "text_subscript", // Icon (inkId) - secondarySize ); // Icon size - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_text_script_changed), holder ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/text/sub", false) ); - g_object_set_data( holder, "TextSubscriptAction", act ); + // Only flowed text can be justified, only normal text can be kerned... + // Find out if we have flowed text now so we can use it several places + gboolean isFlow = false; + auto itemlist= SP_ACTIVE_DESKTOP->getSelection()->items(); + for(auto i=itemlist.begin();i!=itemlist.end(); ++i){ + // std::cout << " " << ((*i)->getId()?(*i)->getId():"null") << std::endl; + if( SP_IS_FLOWTEXT(*i)) { + isFlow = true; + // std::cout << " Found flowed text" << std::endl; + break; + } } - /* Alignment */ - { - InkSelectOneActionColumns columns; - - Glib::RefPtr store = Gtk::ListStore::create(columns); - - Gtk::TreeModel::Row row; - - row = *(store->append()); - row[columns.col_label ] = _("Align left"); - row[columns.col_tooltip ] = _("Align left"); - row[columns.col_icon ] = INKSCAPE_ICON("format-justify-left"); - row[columns.col_sensitive] = true; - - row = *(store->append()); - row[columns.col_label ] = _("Align center"); - row[columns.col_tooltip ] = _("Align center"); - row[columns.col_icon ] = INKSCAPE_ICON("format-justify-center"); - row[columns.col_sensitive] = true; - - row = *(store->append()); - row[columns.col_label ] = _("Align right"); - row[columns.col_tooltip ] = _("Align right"); - row[columns.col_icon ] = INKSCAPE_ICON("format-justify-right"); - row[columns.col_sensitive] = true; - - row = *(store->append()); - row[columns.col_label ] = _("Justify"); - row[columns.col_tooltip ] = _("Justify (only flowed text)"); - row[columns.col_icon ] = INKSCAPE_ICON("format-justify-fill"); - row[columns.col_sensitive] = false; + /* + * Query from current selection: + * Font family (font-family) + * Style (font-weight, font-style, font-stretch, font-variant, font-align) + * Numbers (font-size, letter-spacing, word-spacing, line-height, text-anchor, writing-mode) + * Font specification (Inkscape private attribute) + */ + SPStyle query(SP_ACTIVE_DOCUMENT); + int result_family = sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTFAMILY); + int result_style = sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTSTYLE); + int result_baseline = sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_BASELINES); + int result_wmode = sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_WRITINGMODES); - InkSelectOneAction* act = - InkSelectOneAction::create( "TextAlignAction", // Name - _("Alignment"), // Label - _("Text alignment"), // Tooltip - "Not Used", // Icon - store ); // Tree store - act->use_radio( false ); - act->use_label( false ); - gint mode = prefs->getInt("/tools/text/align_mode", 0); - act->set_active( mode ); + // Calling sp_desktop_query_style will result in a call to TextTool::_styleQueried(). + // This returns the style of the selected text inside the element... which + // is often the style of one or more s. If we want the style of the outer + // objects then we need to bypass the call to TextTool::_styleQueried(). + // The desktop selection never includes the elements inside the element. + int result_numbers = 0; + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + bool outer = prefs->getInt("/tools/text/outer_style", false); + if (outer) { + Inkscape::Selection *selection = desktop->getSelection(); + std::vector vec(selection->items().begin(), selection->items().end()); + result_numbers = sp_desktop_query_style_from_list (vec, &query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + } else { + result_numbers = sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTNUMBERS); + } - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( holder, "TextAlignAction", act ); + /* + * If no text in selection (querying returned nothing), read the style from + * the /tools/text preferencess (default style for new texts). Return if + * tool bar already set to these preferences. + */ + if (result_family == QUERY_STYLE_NOTHING || + result_style == QUERY_STYLE_NOTHING || + result_numbers == QUERY_STYLE_NOTHING || + result_wmode == QUERY_STYLE_NOTHING ) { + // There are no texts in selection, read from preferences. + query.readFromPrefs("/tools/text"); +#ifdef DEBUG_TEXT + std::cout << " read style from prefs:" << std::endl; + sp_print_font( &query ); +#endif + if (_text_style_from_prefs) { + // Do not reset the toolbar style from prefs if we already did it last time + _freeze = false; +#ifdef DEBUG_TEXT + std::cout << " text_style_from_prefs: toolbar already set" << std:: endl; + std::cout << "sp_text_toolbox_selection_changed: exit " << count << std::endl; + std::cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << std::endl; + std::cout << std::endl; +#endif + return; + } - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_text_align_mode_changed), holder)); + // To ensure the value of the combobox is properly set on start-up, only mark + // the prefs set if the combobox has already been constructed. + if( _font_family_action->combobox != nullptr ) { + _text_style_from_prefs = true; + } + } else { + _text_style_from_prefs = false; } - /* Writing mode (Horizontal, Vertical-LR, Vertical-RL) */ + // If we have valid query data for text (font-family, font-specification) set toolbar accordingly. { - InkSelectOneActionColumns columns; - - Glib::RefPtr store = Gtk::ListStore::create(columns); - - Gtk::TreeModel::Row row; - - row = *(store->append()); - row[columns.col_label ] = _("Horizontal"); - row[columns.col_tooltip ] = _("Horizontal text"); - row[columns.col_icon ] = INKSCAPE_ICON("format-text-direction-horizontal"); - row[columns.col_sensitive] = true; - - row = *(store->append()); - row[columns.col_label ] = _("Vertical — RL"); - row[columns.col_tooltip ] = _("Vertical text — lines: right to left"); - row[columns.col_icon ] = INKSCAPE_ICON("format-text-direction-vertical"); - row[columns.col_sensitive] = true; - - row = *(store->append()); - row[columns.col_label ] = _("Vertical — LR"); - row[columns.col_tooltip ] = _("Vertical text — lines: left to right"); - row[columns.col_icon ] = INKSCAPE_ICON("format-text-direction-vertical-lr"); - row[columns.col_sensitive] = true; - - InkSelectOneAction* act = - InkSelectOneAction::create( "TextWritingModeAction", // Name - _("Writing mode"), // Label - _("Block progression"), // Tooltip - "Not Used", // Icon - store ); // Tree store - act->use_radio( false ); - act->use_label( false ); - gint mode = prefs->getInt("/tools/text/writing_mode", 0); - act->set_active( mode ); - - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( holder, "TextWritingModeAction", act ); + // Size (average of text selected) + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + int unit = prefs->getInt("/options/font/unitType", SP_CSS_UNIT_PT); + double size = sp_style_css_size_px_to_units(query.font_size.computed, unit); - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_writing_mode_changed), holder)); - } + //gchar size_text[G_ASCII_DTOSTR_BUF_SIZE]; + //g_ascii_dtostr (size_text, sizeof (size_text), size); - /* Text (glyph) orientation (Auto (mixed), Upright, Sideways) */ - { - InkSelectOneActionColumns columns; + Inkscape::CSSOStringStream os; + os << size; - Glib::RefPtr store = Gtk::ListStore::create(columns); + // Freeze to ignore callbacks. + //g_object_freeze_notify( G_OBJECT( fontSizeAction->combobox ) ); + sp_text_set_sizes(GTK_LIST_STORE(ink_comboboxentry_action_get_model(_font_size_action)), unit); + //g_object_thaw_notify( G_OBJECT( fontSizeAction->combobox ) ); - Gtk::TreeModel::Row row; + ink_comboboxentry_action_set_active_text( _font_size_action, os.str().c_str() ); - row = *(store->append()); - row[columns.col_label ] = _("Auto"); - row[columns.col_tooltip ] = _("Auto glyph orientation"); - row[columns.col_icon ] = INKSCAPE_ICON("text-orientation-auto"); - row[columns.col_sensitive] = true; + Glib::ustring tooltip = Glib::ustring::format(_("Font size"), " (", sp_style_get_css_unit_string(unit), ")"); + ink_comboboxentry_action_set_tooltip ( _font_size_action, tooltip.c_str()); - row = *(store->append()); - row[columns.col_label ] = _("Upright"); - row[columns.col_tooltip ] = _("Upright glyph orientation"); - row[columns.col_icon ] = INKSCAPE_ICON("text-orientation-upright"); - row[columns.col_sensitive] = true; + // Superscript + gboolean superscriptSet = + ((result_baseline == QUERY_STYLE_SINGLE || result_baseline == QUERY_STYLE_MULTIPLE_SAME ) && + query.baseline_shift.set && + query.baseline_shift.type == SP_BASELINE_SHIFT_LITERAL && + query.baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUPER ); - row = *(store->append()); - row[columns.col_label ] = _("Sideways"); - row[columns.col_tooltip ] = _("Sideways glyph orientation"); - row[columns.col_icon ] = INKSCAPE_ICON("text-orientation-sideways"); - row[columns.col_sensitive] = true; + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(_superscript_action), superscriptSet ); - InkSelectOneAction* act = - InkSelectOneAction::create( "TextOrientationAction", // Name - _("Text orientation"), // Label - _("Text (glyph) orientation in vertical text."), // Tooltip - "Not Used", // Icon - store ); // List store - act->use_radio( false ); - act->use_label( false ); - gint mode = prefs->getInt("/tools/text/text_orientation", 0); - act->set_active( mode ); + // Subscript + gboolean subscriptSet = + ((result_baseline == QUERY_STYLE_SINGLE || result_baseline == QUERY_STYLE_MULTIPLE_SAME ) && + query.baseline_shift.set && + query.baseline_shift.type == SP_BASELINE_SHIFT_LITERAL && + query.baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUB ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( holder, "TextOrientationAction", act ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(_subscript_action), subscriptSet ); - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_text_orientation_changed), holder)); - } + // Alignment + // Note: SVG 1.1 doesn't include text-align, SVG 1.2 Tiny doesn't include text-align="justify" + // text-align="justify" was a draft SVG 1.2 item (along with flowed text). + // Only flowed text can be left and right justified at the same time. + // Disable button if we don't have flowed text. - // Text direction (predominant direction of horizontal text). - { + Glib::RefPtr store = _align_action->get_store(); + Gtk::TreeModel::Row row = *(store->get_iter("3")); // Justify entry InkSelectOneActionColumns columns; + row[columns.col_sensitive] = isFlow; - Glib::RefPtr store = Gtk::ListStore::create(columns); - - Gtk::TreeModel::Row row; + int activeButton = 0; + if (query.text_align.computed == SP_CSS_TEXT_ALIGN_JUSTIFY) + { + activeButton = 3; + } else { + // This should take 'direction' into account + if (query.text_anchor.computed == SP_CSS_TEXT_ANCHOR_START) activeButton = 0; + if (query.text_anchor.computed == SP_CSS_TEXT_ANCHOR_MIDDLE) activeButton = 1; + if (query.text_anchor.computed == SP_CSS_TEXT_ANCHOR_END) activeButton = 2; + } + _align_action->set_active( activeButton ); - row = *(store->append()); - row[columns.col_label ] = _("LTR"); - row[columns.col_tooltip ] = _("Left to right text"); - row[columns.col_icon ] = INKSCAPE_ICON("format-text-direction-horizontal"); - row[columns.col_sensitive] = true; + // Line height (spacing) and line height unit + double height; + int line_height_unit = -1; + if (query.line_height.normal) { + height = Inkscape::Text::Layout::LINE_HEIGHT_NORMAL; + line_height_unit = SP_CSS_UNIT_NONE; + } else { + height = query.line_height.value; + line_height_unit = query.line_height.unit; + } - row = *(store->append()); - row[columns.col_label ] = _("RTL"); - row[columns.col_tooltip ] = _("Right to left text"); - row[columns.col_icon ] = INKSCAPE_ICON("format-text-direction-r2l"); - row[columns.col_sensitive] = true; + switch (line_height_unit) { + case SP_CSS_UNIT_NONE: + case SP_CSS_UNIT_EM: + case SP_CSS_UNIT_EX: + break; + case SP_CSS_UNIT_PERCENT: + height *= 100.0; // Inkscape store % as fraction in .value + break; + case SP_CSS_UNIT_PX: + // If unit is set to 'px', use the preferred display unit (if absolute). + line_height_unit = + prefs->getInt("/tools/text/lineheight/display_unit", SP_CSS_UNIT_PT); + // But not if preferred unit is relative + if (line_height_unit != SP_CSS_UNIT_NONE && + line_height_unit != SP_CSS_UNIT_EM && + line_height_unit != SP_CSS_UNIT_EX && + line_height_unit != SP_CSS_UNIT_PERCENT) { + height = + Quantity::convert(height, "px", sp_style_get_css_unit_string(line_height_unit)); + } else { + line_height_unit = SP_CSS_UNIT_PX; + } + break; + default: + // If unit has been set by an external program to something other than 'px', use + // that unit. But height is average of computed values (px) so we need to convert + // back. + height = + Quantity::convert(height, "px", sp_style_get_css_unit_string(line_height_unit)); + } - InkSelectOneAction* act = - InkSelectOneAction::create( "TextDirectionAction", // Name - _("Text direction"), // Label - _("Text direction for normally horizontal text."), // Tooltip - "Not Used", // Icon - store ); // List store - act->use_radio( false ); - act->use_label( false ); - gint mode = prefs->getInt("/tools/text/text_direction", 0); - act->set_active( mode ); + _line_height_adj->set_value(height); - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( holder, "TextDirectionAction", act ); + // Update "climb rate" + if (line_height_unit == SP_CSS_UNIT_PERCENT) { + _line_height_adj->set_step_increment(1.0); + _line_height_adj->set_page_increment(10.0); + } else { + _line_height_adj->set_step_increment(0.1); + _line_height_adj->set_page_increment(1.0); + } - act->signal_changed_after().connect(sigc::bind<0>(sigc::ptr_fun(&sp_text_direction_changed), holder)); - } + if( line_height_unit == SP_CSS_UNIT_NONE ) { + // Function 'sp_style_get_css_unit_string' returns 'px' for unit none. + // We need to avoid this. + _tracker->setActiveUnitByAbbr(""); + } else { + _tracker->setActiveUnitByAbbr(sp_style_get_css_unit_string(line_height_unit)); + } + // Save unit so we can do conversions between new/old units. + _lineheight_unit = line_height_unit; - /* Line height unit tracker */ - UnitTracker* tracker = new UnitTracker(Inkscape::Util::UNIT_TYPE_LINEAR); - tracker->prependUnit(unit_table.getUnit("")); // No unit - tracker->addUnit(unit_table.getUnit("%")); - tracker->addUnit(unit_table.getUnit("em")); - tracker->addUnit(unit_table.getUnit("ex")); - tracker->setActiveUnit(unit_table.getUnit("%")); - g_object_set_data( holder, "tracker", tracker ); + // Enable and turn on only if selection includes an object with line height set. + gtk_action_set_sensitive(GTK_ACTION(_line_height_unset_action), query.line_height.set ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(_line_height_unset_action), query.line_height.set ); - /* Line height */ - { - // Drop down menu - gchar const* labels[] = {_("Smaller spacing"), nullptr, nullptr, nullptr, nullptr, C_("Text tool", "Normal"), nullptr, nullptr, nullptr, nullptr, nullptr, _("Larger spacing")}; - gdouble values[] = { 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1,2, 1.3, 1.4, 1.5, 2.0}; + // Line spacing mode: requires calculating mode for each element and the s within. + Inkscape::Selection *selection = desktop->getSelection(); + std::vector vec(selection->items().begin(), selection->items().end()); + int mode[4] = {0, 0, 0, 0}; + for (auto i: vec) { + if (dynamic_cast(i) || dynamic_cast(i) ) { + bool text_line_height_set = false; + bool text_line_height_zero = false; + bool text_line_height_has_units = false; + bool tspan_line_height_all_unset = true; + bool tspan_line_height_all_zero = true; + bool tspan_line_height_all_non_zero = true; + if (i->style && i->style->line_height.set) { + text_line_height_set = true; + if (i->style->line_height.computed == 0 && !(i->style->line_height.normal)) { + text_line_height_zero = true; + } + if (i->style->line_height.unit != SP_CSS_UNIT_NONE && !(i->style->line_height.normal)) { + text_line_height_has_units = true; + } + } + // TO DO: recursively check children + std::vector children = i->childList(false); + for (auto j: children) { + if (dynamic_cast(j) || dynamic_cast(j) || dynamic_cast(j) ) { + if (j->style && j->style->line_height.set) { + tspan_line_height_all_unset = false; + if (j->style->line_height.computed != 0 || j->style->line_height.normal) { + tspan_line_height_all_zero = false; + } else { + tspan_line_height_all_non_zero = false; + } + } + } + } - EgeAdjustmentAction *eact = create_adjustment_action( - "TextLineHeightAction", /* name */ - _("Line Height"), /* label */ - _("Line:"), /* short label */ - _("Spacing between baselines"), /* tooltip */ - "/tools/text/lineheight", /* preferences path */ - 0.0, /* default */ - GTK_WIDGET(desktop->canvas), /* focusTarget */ - holder, /* dataKludge */ - FALSE, /* set alt-x keyboard shortcut? */ - nullptr, /* altx_mark */ - 0.0, 1000.0, 0.1, 1.0, /* lower, upper, step (arrow up/down), page up/down */ - labels, values, G_N_ELEMENTS(labels), /* drop down menu */ - sp_text_lineheight_value_changed, /* callback */ - nullptr, // tracker, /* unit tracker */ - 0.1, /* step (used?) */ - 2, /* digits to show */ - 1.0 /* factor (multiplies default) */ - ); - //tracker->addAdjustment( ege_adjustment_action_get_adjustment(eact) ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); - g_object_set_data( holder, "TextLineHeightAction", eact ); - g_object_set( G_OBJECT(eact), "iconId", "text_line_spacing", NULL ); - } + if ( text_line_height_zero && tspan_line_height_all_non_zero) mode[0]++; + else if (!text_line_height_has_units && tspan_line_height_all_unset) mode[1]++; + else if ( text_line_height_has_units && tspan_line_height_all_unset) mode[3]++; + else if ( tspan_line_height_all_zero ) mode[2]++; + else mode[3]++; + } + } - /* Line height units */ - { - InkSelectOneAction* act = tracker->createAction( "TextLineHeightUnitsAction", _("Units"), ("") ); - gtk_action_group_add_action( mainActions, act->gobj() ); - act->signal_changed_after().connect(sigc::bind<0>(sigc::ptr_fun(&sp_text_lineheight_unit_changed), holder)); - g_object_set_data( holder, "TextLineHeightUnitsAction", act ); - } + int activeButtonLS = 3; + if (mode[0] > 0 && mode[1] == 0 && mode[2] == 0 && mode[3] == 0) activeButtonLS = 0; + if (mode[0] == 0 && mode[1] > 0 && mode[2] == 0 && mode[3] == 0) activeButtonLS = 1; + if (mode[0] == 0 && mode[1] == 0 && mode[2] > 0 && mode[3] == 0) activeButtonLS = 2; + // std::cout << " modes: " << mode[0] + // << ", "<< mode[1] + // << ", "<< mode[2] + // << ", "<< mode[3] << std::endl; + _line_spacing_action->set_active( activeButtonLS ); - /* Line spacing mode */ - { - InkSelectOneActionColumns columns; + // Enable/disable line height widget based on mode and Outer Style toggle. + if ( (activeButtonLS == 0 && outer) || // Adaptive + (activeButtonLS == 1 && !outer) || // Minimum + (activeButtonLS == 2 && !outer) // Even + ) { + gtk_action_set_sensitive (GTK_ACTION(_line_height_action), false); + } else { + gtk_action_set_sensitive (GTK_ACTION(_line_height_action), true); + } - Glib::RefPtr store = Gtk::ListStore::create(columns); + // In Minimum and Adaptive modes, don't allow unit change (must remain unitless). + if (activeButtonLS == 0 || (activeButtonLS == 1 && outer)) { + _line_height_units_action->set_sensitive(false); + } else { + _line_height_units_action->set_sensitive(true); + } - Gtk::TreeModel::Row row; + // Word spacing + double wordSpacing; + if (query.word_spacing.normal) wordSpacing = 0.0; + else wordSpacing = query.word_spacing.computed; // Assume no units (change in desktop-style.cpp) - row = *(store->append()); - row[columns.col_label ] = _("Adaptive"); - row[columns.col_tooltip ] = _("Line spacing adapts to font size."); - row[columns.col_icon ] = INKSCAPE_ICON("text_line_spacing"); - row[columns.col_sensitive] = true; + _word_spacing_adj->set_value(wordSpacing); - row = *(store->append()); - row[columns.col_label ] = _("Minimum"); - row[columns.col_tooltip ] = _("Line spacing adapts to fonts size with set minimum spacing."); - row[columns.col_icon ] = INKSCAPE_ICON("text_line_spacing"); - row[columns.col_sensitive] = true; - row = *(store->append()); - row[columns.col_label ] = _("Even"); - row[columns.col_tooltip ] = _("Lines evenly spaced."); - row[columns.col_icon ] = INKSCAPE_ICON("text_line_spacing"); - row[columns.col_sensitive] = true; + // Letter spacing + double letterSpacing; + if (query.letter_spacing.normal) letterSpacing = 0.0; + else letterSpacing = query.letter_spacing.computed; // Assume no units (change in desktop-style.cpp) - row = *(store->append()); - row[columns.col_label ] = _("Adjustable ☠"); - row[columns.col_tooltip ] = _("Line spacing fully adjustable"); - row[columns.col_icon ] = INKSCAPE_ICON("text_line_spacing"); - row[columns.col_sensitive] = true; + _letter_spacing_adj->set_value(letterSpacing); - InkSelectOneAction* act = - InkSelectOneAction::create( "TextLineSpacingAction", // Name - _("Line Spacing Mode"), // Label - _("How should multiple baselines be spaced?\n Adaptive: Line spacing adapts to font size.\n Minimum: Like Adaptive, but with a set minimum.\n Even: Evenly spaced.\n Adjustable: No restrictions."), // Tooltip - "Not Used", // Icon - store ); // Tree store - act->use_radio( false ); - act->use_label( true ); - gint mode = prefs->getInt("/tools/text/line_spacing_mode", 0); - act->set_active( mode ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( holder, "TextLineSpacingAction", act ); + // Writing mode + int activeButton2 = 0; + if (query.writing_mode.computed == SP_CSS_WRITING_MODE_LR_TB) activeButton2 = 0; + if (query.writing_mode.computed == SP_CSS_WRITING_MODE_TB_RL) activeButton2 = 1; + if (query.writing_mode.computed == SP_CSS_WRITING_MODE_TB_LR) activeButton2 = 2; - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_text_line_spacing_mode_changed), holder)); - } + _writing_mode_action->set_active( activeButton2 ); - /* Word spacing */ - { - // Drop down menu - gchar const* labels[] = {_("Negative spacing"), nullptr, nullptr, nullptr, C_("Text tool", "Normal"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, _("Positive spacing")}; - gdouble values[] = {-2.0, -1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0}; + // Orientation + int activeButton3 = 0; + if (query.text_orientation.computed == SP_CSS_TEXT_ORIENTATION_MIXED ) activeButton3 = 0; + if (query.text_orientation.computed == SP_CSS_TEXT_ORIENTATION_UPRIGHT ) activeButton3 = 1; + if (query.text_orientation.computed == SP_CSS_TEXT_ORIENTATION_SIDEWAYS) activeButton3 = 2; - EgeAdjustmentAction *eact = create_adjustment_action( - "TextWordSpacingAction", /* name */ - _("Word spacing"), /* label */ - _("Word:"), /* short label */ - _("Spacing between words (px)"), /* tooltip */ - "/tools/text/wordspacing", /* preferences path */ - 0.0, /* default */ - GTK_WIDGET(desktop->canvas), /* focusTarget */ - holder, /* dataKludge */ - FALSE, /* set alt-x keyboard shortcut? */ - nullptr, /* altx_mark */ - -100.0, 100.0, 0.01, 0.10, /* lower, upper, step (arrow up/down), page up/down */ - labels, values, G_N_ELEMENTS(labels), /* drop down menu */ - sp_text_wordspacing_value_changed, /* callback */ - nullptr, /* unit tracker */ - 0.1, /* step (used?) */ - 2, /* digits to show */ - 1.0 /* factor (multiplies default) */ - ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); - g_object_set_data( holder, "TextWordSpacingAction", eact ); - g_object_set( G_OBJECT(eact), "iconId", "text_word_spacing", NULL ); - } + _orientation_action->set_active( activeButton3 ); - /* Letter spacing */ - { - // Drop down menu - gchar const* labels[] = {_("Negative spacing"), nullptr, nullptr, nullptr, C_("Text tool", "Normal"), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, _("Positive spacing")}; - gdouble values[] = {-2.0, -1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0}; + // Disable text orientation for horizontal text... + _orientation_action->set_sensitive( activeButton2 != 0 ); - EgeAdjustmentAction *eact = create_adjustment_action( - "TextLetterSpacingAction", /* name */ - _("Letter spacing"), /* label */ - _("Letter:"), /* short label */ - _("Spacing between letters (px)"), /* tooltip */ - "/tools/text/letterspacing", /* preferences path */ - 0.0, /* default */ - GTK_WIDGET(desktop->canvas), /* focusTarget */ - holder, /* dataKludge */ - FALSE, /* set alt-x keyboard shortcut? */ - nullptr, /* altx_mark */ - -100.0, 100.0, 0.01, 0.10, /* lower, upper, step (arrow up/down), page up/down */ - labels, values, G_N_ELEMENTS(labels), /* drop down menu */ - sp_text_letterspacing_value_changed, /* callback */ - nullptr, /* unit tracker */ - 0.1, /* step (used?) */ - 2, /* digits to show */ - 1.0 /* factor (multiplies default) */ - ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); - g_object_set_data( holder, "TextLetterSpacingAction", eact ); - g_object_set( G_OBJECT(eact), "iconId", "text_letter_spacing", NULL ); + // Direction + int activeButton4 = 0; + if (query.direction.computed == SP_CSS_DIRECTION_LTR ) activeButton4 = 0; + if (query.direction.computed == SP_CSS_DIRECTION_RTL ) activeButton4 = 1; + _direction_action->set_active( activeButton4 ); } - /* Character kerning (horizontal shift) */ - { - // Drop down menu - gchar const* labels[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }; - gdouble values[] = { -2.0, -1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5, 2.0, 2.5 }; - - EgeAdjustmentAction *eact = create_adjustment_action( - "TextDxAction", /* name */ - _("Kerning"), /* label */ - _("Kern:"), /* short label */ - _("Horizontal kerning (px)"), /* tooltip */ - "/tools/text/dx", /* preferences path */ - 0.0, /* default */ - GTK_WIDGET(desktop->canvas), /* focusTarget */ - holder, /* dataKludge */ - FALSE, /* set alt-x keyboard shortcut? */ - nullptr, /* altx_mark */ - -100.0, 100.0, 0.01, 0.1, /* lower, upper, step (arrow up/down), page up/down */ - labels, values, G_N_ELEMENTS(labels), /* drop down menu */ - sp_text_dx_value_changed, /* callback */ - nullptr, /* unit tracker */ - 0.1, /* step (used?) */ - 2, /* digits to show */ - 1.0 /* factor (multiplies default) */ - ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); - g_object_set_data( holder, "TextDxAction", eact ); - g_object_set( G_OBJECT(eact), "iconId", "text_horz_kern", NULL ); - } +#ifdef DEBUG_TEXT + std::cout << " GUI: fontfamily.value: " + << (query.font_family.value ? query.font_family.value : "No value") + << std::endl; + std::cout << " GUI: font_size.computed: " << query.font_size.computed << std::endl; + std::cout << " GUI: font_weight.computed: " << query.font_weight.computed << std::endl; + std::cout << " GUI: font_style.computed: " << query.font_style.computed << std::endl; + std::cout << " GUI: text_anchor.computed: " << query.text_anchor.computed << std::endl; + std::cout << " GUI: text_align.computed: " << query.text_align.computed << std::endl; + std::cout << " GUI: line_height.computed: " << query.line_height.computed + << " line_height.value: " << query.line_height.value + << " line_height.unit: " << query.line_height.unit << std::endl; + std::cout << " GUI: word_spacing.computed: " << query.word_spacing.computed + << " word_spacing.value: " << query.word_spacing.value + << " word_spacing.unit: " << query.word_spacing.unit << std::endl; + std::cout << " GUI: letter_spacing.computed: " << query.letter_spacing.computed + << " letter_spacing.value: " << query.letter_spacing.value + << " letter_spacing.unit: " << query.letter_spacing.unit << std::endl; + std::cout << " GUI: writing_mode.computed: " << query.writing_mode.computed << std::endl; +#endif - /* Character vertical shift */ - { - // Drop down menu - gchar const* labels[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }; - gdouble values[] = { -2.0, -1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5, 2.0, 2.5 }; + // Kerning (xshift), yshift, rotation. NB: These are not CSS attributes. + if( SP_IS_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context) ) { + Inkscape::UI::Tools::TextTool *const tc = SP_TEXT_CONTEXT((SP_ACTIVE_DESKTOP)->event_context); + if( tc ) { + unsigned char_index = -1; + TextTagAttributes *attributes = + text_tag_attributes_at_position( tc->text, std::min(tc->text_sel_start, tc->text_sel_end), &char_index ); + if( attributes ) { - EgeAdjustmentAction *eact = create_adjustment_action( - "TextDyAction", /* name */ - _("Vertical Shift"), /* label */ - _("Vert:"), /* short label */ - _("Vertical shift (px)"), /* tooltip */ - "/tools/text/dy", /* preferences path */ - 0.0, /* default */ - GTK_WIDGET(desktop->canvas), /* focusTarget */ - holder, /* dataKludge */ - FALSE, /* set alt-x keyboard shortcut? */ - nullptr, /* altx_mark */ - -100.0, 100.0, 0.01, 0.1, /* lower, upper, step (arrow up/down), page up/down */ - labels, values, G_N_ELEMENTS(labels), /* drop down menu */ - sp_text_dy_value_changed, /* callback */ - nullptr, /* unit tracker */ - 0.1, /* step (used?) */ - 2, /* digits to show */ - 1.0 /* factor (multiplies default) */ - ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); - g_object_set_data( holder, "TextDyAction", eact ); - g_object_set( G_OBJECT(eact), "iconId", "text_vert_kern", NULL ); - } + // Dx + double dx = attributes->getDx( char_index ); + _dx_adj->set_value(dx); - /* Character rotation */ - { - // Drop down menu - gchar const* labels[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }; - gdouble values[] = { -90, -45, -30, -15, 0, 15, 30, 45, 90, 180 }; + // Dy + double dy = attributes->getDy( char_index ); + _dy_adj->set_value(dy); - EgeAdjustmentAction *eact = create_adjustment_action( - "TextRotationAction", /* name */ - _("Letter rotation"), /* label */ - _("Rot:"), /* short label */ - _("Character rotation (degrees)"), /* tooltip */ - "/tools/text/rotation", /* preferences path */ - 0.0, /* default */ - GTK_WIDGET(desktop->canvas), /* focusTarget */ - holder, /* dataKludge */ - FALSE, /* set alt-x keyboard shortcut? */ - nullptr, /* altx_mark */ - -180.0, 180.0, 0.1, 1.0, /* lower, upper, step (arrow up/down), page up/down */ - labels, values, G_N_ELEMENTS(labels), /* drop down menu */ - sp_text_rotation_value_changed, /* callback */ - nullptr, /* unit tracker */ - 0.1, /* step (used?) */ - 2, /* digits to show */ - 1.0 /* factor (multiplies default) */ - ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); - g_object_set_data( holder, "TextRotationAction", eact ); - g_object_set( G_OBJECT(eact), "iconId", "text_rotation", NULL ); - } + // Rotation + double rotation = attributes->getRotate( char_index ); + /* SVG value is between 0 and 360 but we're using -180 to 180 in widget */ + if( rotation > 180.0 ) rotation -= 360.0; + _rotation_adj->set_value(rotation); - /* Text line height unset */ - { - InkToggleAction* act = ink_toggle_action_new( "TextLineHeightUnsetAction", // Name - _("Unset line height"), // Label - _("If enabled, line height is set on part of selection. Click to unset."), - INKSCAPE_ICON("paint-unknown"), - secondarySize ); // Icon size - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_text_lineheight_unset_changed), holder ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/text/line_height_unset", false) ); - g_object_set_data( holder, "TextLineHeightUnsetAction", act ); +#ifdef DEBUG_TEXT + std::cout << " GUI: Dx: " << dx << std::endl; + std::cout << " GUI: Dy: " << dy << std::endl; + std::cout << " GUI: Rotation: " << rotation << std::endl; +#endif + } + } } - /* Text outer style */ { - InkToggleAction* act = ink_toggle_action_new( "TextOuterStyleAction", // Name - _("Show outer style"), // Label - _("Show style of outermost text element. The 'font-size' and 'line-height' values of the outermost text element determine the minimum line spacing in the block."), - INKSCAPE_ICON("text_outer_style"), - secondarySize ); // Icon size - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(sp_text_outer_style_changed), holder ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/text/outer_style", false) ); - g_object_set_data( holder, "TextOuterStyleAction", act ); + // Set these here as we don't always have kerning/rotating attributes + gtk_action_set_sensitive( GTK_ACTION(_dx_action), !isFlow ); + gtk_action_set_sensitive( GTK_ACTION(_dy_action), !isFlow ); + gtk_action_set_sensitive( GTK_ACTION(_rotation_action), !isFlow ); } - // Is this necessary to call? Shouldn't hurt. - sp_text_toolbox_selection_changed(desktop->getSelection(), holder); - - desktop->connectEventContextChanged(sigc::bind(sigc::ptr_fun(text_toolbox_watch_ec), holder)); - - g_signal_connect( holder, "destroy", G_CALLBACK(purge_repr_listener), holder ); +#ifdef DEBUG_TEXT + std::cout << "sp_text_toolbox_selection_changed: exit " << count << std::endl; + std::cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << std::endl; + std::cout << std::endl; +#endif + _freeze = false; } -static void text_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec, GObject* holder) { - using sigc::connection; - using sigc::bind; - using sigc::ptr_fun; - - static connection c_selection_changed; - static connection c_selection_modified; - static connection c_subselection_changed; - +void +TextToolbar::watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec) { if (SP_IS_TEXT_CONTEXT(ec)) { // Watch selection // Ensure FontLister is updated here first.................. VVVVV - c_selection_changed = desktop->getSelection()->connectChangedFirst(bind(ptr_fun(sp_text_toolbox_selection_changed), holder, false)); - c_selection_modified = desktop->getSelection()->connectModifiedFirst(bind(ptr_fun(sp_text_toolbox_selection_modified), holder)); - c_subselection_changed = desktop->connectToolSubselectionChanged(bind(ptr_fun(sp_text_toolbox_subselection_changed), holder)); + c_selection_changed = desktop->getSelection()->connectChangedFirst(sigc::bind(sigc::mem_fun(*this, &TextToolbar::selection_changed), false)); + c_selection_modified = desktop->getSelection()->connectModifiedFirst(sigc::mem_fun(*this, &TextToolbar::selection_modified)); + c_subselection_changed = desktop->connectToolSubselectionChanged(sigc::mem_fun(*this, &TextToolbar::subselection_changed)); } else { if (c_selection_changed) c_selection_changed.disconnect(); @@ -2588,6 +2529,23 @@ static void text_toolbox_watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolB c_subselection_changed.disconnect(); } } + +void +TextToolbar::selection_modified(Inkscape::Selection *selection, guint /*flags*/) +{ + selection_changed(selection); +} + +void +TextToolbar::subselection_changed(gpointer /*tc*/) +{ + selection_changed(nullptr, true); +} + +} +} +} + /* Local Variables: mode:c++ diff --git a/src/ui/toolbar/text-toolbar.h b/src/ui/toolbar/text-toolbar.h index 9c988217d..acc6f3268 100644 --- a/src/ui/toolbar/text-toolbar.h +++ b/src/ui/toolbar/text-toolbar.h @@ -28,11 +28,112 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" + +#include + +class InkSelectOneAction; class SPDesktop; +typedef struct _EgeAdjustmentAction EgeAdjustmentAction; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; +typedef struct _Ink_ComboBoxEntry_Action Ink_ComboBoxEntry_Action; +typedef struct _InkToggleAction InkToggleAction; + +namespace Inkscape { +class Selection; + +namespace UI { +namespace Tools { +class ToolBase; +} + +namespace Widget { +class UnitTracker; +} + +namespace Toolbar { +class TextToolbar : public Toolbar { +private: + bool _freeze; + bool _text_style_from_prefs; + + UI::Widget::UnitTracker *_tracker; + + Ink_ComboBoxEntry_Action *_font_family_action; + Ink_ComboBoxEntry_Action *_font_size_action; + Ink_ComboBoxEntry_Action *_font_style_action; + InkToggleAction *_superscript_action; + InkToggleAction *_subscript_action; + InkToggleAction *_outer_style_action; + InkToggleAction *_line_height_unset_action; + InkSelectOneAction *_align_action; + InkSelectOneAction *_writing_mode_action; + InkSelectOneAction *_orientation_action; + InkSelectOneAction *_direction_action; + InkSelectOneAction *_line_height_units_action; + InkSelectOneAction *_line_spacing_action; + + EgeAdjustmentAction *_line_height_action; + EgeAdjustmentAction *_word_spacing_action; + EgeAdjustmentAction *_letter_spacing_action; + EgeAdjustmentAction *_dx_action; + EgeAdjustmentAction *_dy_action; + EgeAdjustmentAction *_rotation_action; + + Glib::RefPtr _line_height_adj; + Glib::RefPtr _word_spacing_adj; + Glib::RefPtr _letter_spacing_adj; + Glib::RefPtr _dx_adj; + Glib::RefPtr _dy_adj; + Glib::RefPtr _rotation_adj; + + int _lineheight_unit; + + sigc::connection c_selection_changed; + sigc::connection c_selection_modified; + sigc::connection c_subselection_changed; + + static void fontfamily_value_changed(Ink_ComboBoxEntry_Action *act, + gpointer data); + static void fontsize_value_changed (Ink_ComboBoxEntry_Action *act, + gpointer data); + static void fontstyle_value_changed (Ink_ComboBoxEntry_Action *act, + gpointer data); + static void script_changed (InkToggleAction *act, + gpointer data); + static void lineheight_unset_changed(InkToggleAction *act, + gpointer data); + static void outer_style_changed (InkToggleAction *act, + gpointer data); + + void align_mode_changed(int mode); + void writing_mode_changed(int mode); + void orientation_changed(int mode); + void direction_changed(int mode); + void lineheight_value_changed(); + void lineheight_unit_changed(int not_used); + void line_spacing_mode_changed(int mode); + void wordspacing_value_changed(); + void letterspacing_value_changed(); + void dx_value_changed(); + void dy_value_changed(); + void rotation_value_changed(); + void selection_changed(Inkscape::Selection *selection, + bool subselection = false); + void selection_modified(Inkscape::Selection *selection, guint flags); + void subselection_changed(gpointer tc); + void watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec); + +protected: + TextToolbar(SPDesktop *desktop); + +public: + static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); +}; -void sp_text_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +} +} +} #endif /* !SEEN_TEXT_TOOLBAR_H */ diff --git a/src/ui/toolbar/tweak-toolbar.cpp b/src/ui/toolbar/tweak-toolbar.cpp index 47a90910a..e85e1d7a5 100644 --- a/src/ui/toolbar/tweak-toolbar.cpp +++ b/src/ui/toolbar/tweak-toolbar.cpp @@ -52,52 +52,12 @@ using Inkscape::UI::PrefPusher; //## Tweak ## //######################## -static void sp_tweak_width_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/tweak/width", - gtk_adjustment_get_value(adj) * 0.01 ); -} - -static void sp_tweak_force_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/tweak/force", - gtk_adjustment_get_value(adj) * 0.01 ); -} - static void sp_tweak_pressure_state_changed( GtkToggleAction *act, gpointer /*data*/ ) { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); prefs->setBool("/tools/tweak/usepressure", gtk_toggle_action_get_active(act)); } -static void sp_tweak_mode_changed( GObject *tbl, int mode ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setInt("/tools/tweak/mode", mode); - - static gchar const* names[] = {"tweak_doh", "tweak_dos", "tweak_dol", "tweak_doo", "tweak_channels_label"}; - bool flag = ((mode == Inkscape::UI::Tools::TWEAK_MODE_COLORPAINT) || - (mode == Inkscape::UI::Tools::TWEAK_MODE_COLORJITTER)); - for (auto & name : names) { - GtkAction *act = GTK_ACTION(g_object_get_data( tbl, name )); - if (act) { - gtk_action_set_visible(act, flag); - } - } - GtkAction *fid = GTK_ACTION(g_object_get_data( tbl, "tweak_fidelity")); - if (fid) { - gtk_action_set_visible(fid, !flag); - } -} - -static void sp_tweak_fidelity_value_changed( GtkAdjustment *adj, GObject * /*tbl*/ ) -{ - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setDouble( "/tools/tweak/fidelity", - gtk_adjustment_get_value(adj) * 0.01 ); -} static void tweak_toggle_doh(GtkToggleAction *act, gpointer /*data*/) { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); @@ -116,8 +76,14 @@ static void tweak_toggle_doo(GtkToggleAction *act, gpointer /*data*/) { prefs->setBool("/tools/tweak/doo", gtk_toggle_action_get_active(act)); } -void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder) +namespace Inkscape { +namespace UI { +namespace Toolbar { +GtkWidget * +TweakToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) { + auto holder = new TweakToolbar(desktop); + GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); Inkscape::Preferences *prefs = Inkscape::Preferences::get(); @@ -128,10 +94,16 @@ void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj EgeAdjustmentAction *eact = create_adjustment_action( "TweakWidthAction", _("Width"), _("Width:"), _("The width of the tweak area (relative to the visible canvas area)"), "/tools/tweak/width", 15, - GTK_WIDGET(desktop->canvas), holder, TRUE, "altx-tweak", + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + TRUE, "altx-tweak", 1, 100, 1.0, 10.0, labels, values, G_N_ELEMENTS(labels), - sp_tweak_width_value_changed, nullptr /*unit tracker*/, 0.01, 0, 100 ); + nullptr, // callback + nullptr /*unit tracker*/, 0.01, 0, 100 ); + + holder->_adj_tweak_width = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + holder->_adj_tweak_width->signal_value_changed().connect(sigc::mem_fun(*holder, &TweakToolbar::tweak_width_value_changed)); ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); @@ -145,10 +117,15 @@ void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj EgeAdjustmentAction *eact = create_adjustment_action( "TweakForceAction", _("Force"), _("Force:"), _("The force of the tweak action"), "/tools/tweak/force", 20, - GTK_WIDGET(desktop->canvas), holder, TRUE, "tweak-force", + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + TRUE, "tweak-force", 1, 100, 1.0, 10.0, labels, values, G_N_ELEMENTS(labels), - sp_tweak_force_value_changed, nullptr /*unit tracker*/, 0.01, 0, 100 ); + nullptr, // callback + nullptr /*unit tracker*/, 0.01, 0, 100 ); + holder->_adj_tweak_force = Glib::wrap(ege_adjustment_action_get_adjustment(eact)); + holder->_adj_tweak_force->signal_value_changed().connect(sigc::mem_fun(*holder, &TweakToolbar::tweak_force_value_changed)); ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); gtk_action_set_sensitive( GTK_ACTION(eact), TRUE ); @@ -240,120 +217,119 @@ void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj row[columns.col_icon ] = INKSCAPE_ICON("object-tweak-blur"); row[columns.col_sensitive] = true; - InkSelectOneAction* act = + holder->_tweak_tool_mode = InkSelectOneAction::create( "TweakModeAction", // Name _("Mode"), // Label (""), // Tooltip "Not Used", // Icon store ); // Tree store - act->use_radio( true ); - act->use_icon( true ); - act->use_label( false ); - act->use_group_label( true ); + holder->_tweak_tool_mode->use_radio( true ); + holder->_tweak_tool_mode->use_icon( true ); + holder->_tweak_tool_mode->use_label( false ); + holder->_tweak_tool_mode->use_group_label( true ); int mode = prefs->getInt("/tools/tweak/mode", 0); - act->set_active( mode ); + holder->_tweak_tool_mode->set_active( mode ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act->gobj() )); - g_object_set_data( holder, "tweak_tool_mode", act ); + gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_tweak_tool_mode->gobj() )); - act->signal_changed().connect(sigc::bind<0>(sigc::ptr_fun(&sp_tweak_mode_changed), holder)); + holder->_tweak_tool_mode->signal_changed().connect(sigc::mem_fun(*holder, &TweakToolbar::tweak_mode_changed)); } guint mode = prefs->getInt("/tools/tweak/mode", 0); { - EgeOutputAction* act = ege_output_action_new( "TweakChannelsLabel", _("Channels:"), "", nullptr ); - ege_output_action_set_use_markup( act, TRUE ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); + holder->_tweak_channels_label = ege_output_action_new( "TweakChannelsLabel", _("Channels:"), "", nullptr ); + ege_output_action_set_use_markup( holder->_tweak_channels_label, TRUE ); + gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_tweak_channels_label ) ); if (mode != Inkscape::UI::Tools::TWEAK_MODE_COLORPAINT && mode != Inkscape::UI::Tools::TWEAK_MODE_COLORJITTER) { - gtk_action_set_visible (GTK_ACTION(act), FALSE); + gtk_action_set_visible (GTK_ACTION(holder->_tweak_channels_label), FALSE); } - g_object_set_data( holder, "tweak_channels_label", act); } { - InkToggleAction* act = ink_toggle_action_new( "TweakDoH", + holder->_tweak_doh = ink_toggle_action_new( "TweakDoH", _("Hue"), _("In color mode, act on objects' hue"), nullptr, GTK_ICON_SIZE_MENU ); //TRANSLATORS: "H" here stands for hue - g_object_set( act, "short_label", C_("Hue", "H"), NULL ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_doh), desktop ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/doh", true) ); + gtk_action_set_short_label(GTK_ACTION(holder->_tweak_doh), C_("Hue", "H")); + gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_tweak_doh ) ); + g_signal_connect_after( G_OBJECT(holder->_tweak_doh), "toggled", G_CALLBACK(tweak_toggle_doh), desktop ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_tweak_doh), prefs->getBool("/tools/tweak/doh", true) ); if (mode != Inkscape::UI::Tools::TWEAK_MODE_COLORPAINT && mode != Inkscape::UI::Tools::TWEAK_MODE_COLORJITTER) { - gtk_action_set_visible (GTK_ACTION(act), FALSE); + gtk_action_set_visible (GTK_ACTION(holder->_tweak_doh), FALSE); } - g_object_set_data( holder, "tweak_doh", act); } { - InkToggleAction* act = ink_toggle_action_new( "TweakDoS", - _("Saturation"), - _("In color mode, act on objects' saturation"), - nullptr, - GTK_ICON_SIZE_MENU ); + holder->_tweak_dos = ink_toggle_action_new( "TweakDoS", + _("Saturation"), + _("In color mode, act on objects' saturation"), + nullptr, + GTK_ICON_SIZE_MENU ); //TRANSLATORS: "S" here stands for Saturation - g_object_set( act, "short_label", C_("Saturation", "S"), NULL ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_dos), desktop ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/dos", true) ); + gtk_action_set_short_label( GTK_ACTION(holder->_tweak_dos), C_("Saturation", "S")); + gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_tweak_dos ) ); + g_signal_connect_after( G_OBJECT(holder->_tweak_dos), "toggled", G_CALLBACK(tweak_toggle_dos), desktop ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_tweak_dos), prefs->getBool("/tools/tweak/dos", true) ); if (mode != Inkscape::UI::Tools::TWEAK_MODE_COLORPAINT && mode != Inkscape::UI::Tools::TWEAK_MODE_COLORJITTER) { - gtk_action_set_visible (GTK_ACTION(act), FALSE); + gtk_action_set_visible (GTK_ACTION(holder->_tweak_dos), FALSE); } - g_object_set_data( holder, "tweak_dos", act ); } { - InkToggleAction* act = ink_toggle_action_new( "TweakDoL", - _("Lightness"), - _("In color mode, act on objects' lightness"), - nullptr, - GTK_ICON_SIZE_MENU ); + holder->_tweak_dol = ink_toggle_action_new( "TweakDoL", + _("Lightness"), + _("In color mode, act on objects' lightness"), + nullptr, + GTK_ICON_SIZE_MENU ); //TRANSLATORS: "L" here stands for Lightness - g_object_set( act, "short_label", C_("Lightness", "L"), NULL ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_dol), desktop ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/dol", true) ); + gtk_action_set_short_label( GTK_ACTION(holder->_tweak_dol), C_("Lightness", "L")); + gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_tweak_dol ) ); + g_signal_connect_after( G_OBJECT(holder->_tweak_dol), "toggled", G_CALLBACK(tweak_toggle_dol), desktop ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_tweak_dol), prefs->getBool("/tools/tweak/dol", true) ); if (mode != Inkscape::UI::Tools::TWEAK_MODE_COLORPAINT && mode != Inkscape::UI::Tools::TWEAK_MODE_COLORJITTER) { - gtk_action_set_visible (GTK_ACTION(act), FALSE); + gtk_action_set_visible (GTK_ACTION(holder->_tweak_dol), FALSE); } - g_object_set_data( holder, "tweak_dol", act ); } { - InkToggleAction* act = ink_toggle_action_new( "TweakDoO", - _("Opacity"), - _("In color mode, act on objects' opacity"), - nullptr, - GTK_ICON_SIZE_MENU ); + holder->_tweak_doo = ink_toggle_action_new( "TweakDoO", + _("Opacity"), + _("In color mode, act on objects' opacity"), + nullptr, + GTK_ICON_SIZE_MENU ); //TRANSLATORS: "O" here stands for Opacity - g_object_set( act, "short_label", C_("Opacity", "O"), NULL ); - gtk_action_group_add_action( mainActions, GTK_ACTION( act ) ); - g_signal_connect_after( G_OBJECT(act), "toggled", G_CALLBACK(tweak_toggle_doo), desktop ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/doo", true) ); + gtk_action_set_short_label( GTK_ACTION(holder->_tweak_doo), C_("Opacity", "O")); + gtk_action_group_add_action( mainActions, GTK_ACTION( holder->_tweak_doo ) ); + g_signal_connect_after( G_OBJECT(holder->_tweak_doo), "toggled", G_CALLBACK(tweak_toggle_doo), desktop ); + gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(holder->_tweak_doo), prefs->getBool("/tools/tweak/doo", true) ); if (mode != Inkscape::UI::Tools::TWEAK_MODE_COLORPAINT && mode != Inkscape::UI::Tools::TWEAK_MODE_COLORJITTER) { - gtk_action_set_visible (GTK_ACTION(act), FALSE); + gtk_action_set_visible (GTK_ACTION(holder->_tweak_doo), FALSE); } - g_object_set_data( holder, "tweak_doo", act ); } { /* Fidelity */ gchar const* labels[] = {_("(rough, simplified)"), nullptr, nullptr, _("(default)"), nullptr, nullptr, _("(fine, but many nodes)")}; gdouble values[] = {10, 25, 35, 50, 60, 80, 100}; - EgeAdjustmentAction *eact = create_adjustment_action( "TweakFidelityAction", - _("Fidelity"), _("Fidelity:"), - _("Low fidelity simplifies paths; high fidelity preserves path features but may generate a lot of new nodes"), - "/tools/tweak/fidelity", 50, - GTK_WIDGET(desktop->canvas), holder, TRUE, "tweak-fidelity", - 1, 100, 1.0, 10.0, - labels, values, G_N_ELEMENTS(labels), - sp_tweak_fidelity_value_changed, nullptr /*unit tracker*/, 0.01, 0, 100 ); - gtk_action_group_add_action( mainActions, GTK_ACTION(eact) ); - gtk_action_set_visible( GTK_ACTION(eact), TRUE ); + holder->_tweak_fidelity = create_adjustment_action( "TweakFidelityAction", + _("Fidelity"), _("Fidelity:"), + _("Low fidelity simplifies paths; high fidelity preserves path features but may generate a lot of new nodes"), + "/tools/tweak/fidelity", 50, + GTK_WIDGET(desktop->canvas), + nullptr, // dataKludge + TRUE, "tweak-fidelity", + 1, 100, 1.0, 10.0, + labels, values, G_N_ELEMENTS(labels), + nullptr, // callback + nullptr /*unit tracker*/, 0.01, 0, 100 ); + + holder->_adj_tweak_fidelity = Glib::wrap(ege_adjustment_action_get_adjustment(holder->_tweak_fidelity)); + holder->_adj_tweak_fidelity->signal_value_changed().connect(sigc::mem_fun(*holder, &TweakToolbar::tweak_fidelity_value_changed)); + gtk_action_group_add_action( mainActions, GTK_ACTION(holder->_tweak_fidelity) ); + gtk_action_set_visible( GTK_ACTION(holder->_tweak_fidelity), TRUE ); if (mode == Inkscape::UI::Tools::TWEAK_MODE_COLORPAINT || mode == Inkscape::UI::Tools::TWEAK_MODE_COLORJITTER) { - gtk_action_set_visible (GTK_ACTION(eact), FALSE); + gtk_action_set_visible (GTK_ACTION(holder->_tweak_fidelity), FALSE); } - g_object_set_data( holder, "tweak_fidelity", eact ); } @@ -369,8 +345,56 @@ void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObj gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(act), prefs->getBool("/tools/tweak/usepressure", true) ); } + return GTK_WIDGET(holder->gobj()); +} + +void +TweakToolbar::tweak_width_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/tweak/width", + _adj_tweak_width->get_value() * 0.01 ); +} + +void +TweakToolbar::tweak_force_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/tweak/force", + _adj_tweak_force->get_value() * 0.01 ); } +void +TweakToolbar::tweak_mode_changed(int mode) +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setInt("/tools/tweak/mode", mode); + + bool flag = ((mode == Inkscape::UI::Tools::TWEAK_MODE_COLORPAINT) || + (mode == Inkscape::UI::Tools::TWEAK_MODE_COLORJITTER)); + + gtk_action_set_visible(GTK_ACTION(_tweak_doh), flag); + gtk_action_set_visible(GTK_ACTION(_tweak_dos), flag); + gtk_action_set_visible(GTK_ACTION(_tweak_dol), flag); + gtk_action_set_visible(GTK_ACTION(_tweak_doo), flag); + gtk_action_set_visible(GTK_ACTION(_tweak_channels_label), flag); + + if (_tweak_fidelity) { + gtk_action_set_visible(GTK_ACTION(_tweak_fidelity), !flag); + } +} + +void +TweakToolbar::tweak_fidelity_value_changed() +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setDouble( "/tools/tweak/fidelity", + _adj_tweak_fidelity->get_value() * 0.01 ); +} + +} +} +} /* Local Variables: diff --git a/src/ui/toolbar/tweak-toolbar.h b/src/ui/toolbar/tweak-toolbar.h index d6015d918..6489bd234 100644 --- a/src/ui/toolbar/tweak-toolbar.h +++ b/src/ui/toolbar/tweak-toolbar.h @@ -28,11 +28,50 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "toolbar.h" + +class InkSelectOneAction; class SPDesktop; +typedef struct _EgeAdjustmentAction EgeAdjustmentAction; +typedef struct _EgeOutputAction EgeOutputAction; typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _GObject GObject; +typedef struct _InkToggleAction InkToggleAction; + +namespace Inkscape { +namespace UI { +namespace Toolbar { +class TweakToolbar : public Toolbar { +private: + Glib::RefPtr _adj_tweak_width; + Glib::RefPtr _adj_tweak_force; + Glib::RefPtr _adj_tweak_fidelity; + + InkSelectOneAction *_tweak_tool_mode; + + EgeOutputAction *_tweak_channels_label; + InkToggleAction *_tweak_doh; + InkToggleAction *_tweak_dos; + InkToggleAction *_tweak_dol; + InkToggleAction *_tweak_doo; + + EgeAdjustmentAction *_tweak_fidelity; + + void tweak_width_value_changed(); + void tweak_force_value_changed(); + void tweak_mode_changed(int mode); + void tweak_fidelity_value_changed(); + +protected: + TweakToolbar(SPDesktop *_desktop) + : Toolbar(_desktop) + {} -void sp_tweak_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GObject* holder); +public: + static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); +}; +} +} +} #endif /* !SEEN_SELECT_TOOLBAR_H */ -- cgit v1.2.3