diff options
Diffstat (limited to 'src/ui')
27 files changed, 1395 insertions, 1026 deletions
diff --git a/src/ui/CMakeLists.txt b/src/ui/CMakeLists.txt index bf773ba6f..d4f906836 100644 --- a/src/ui/CMakeLists.txt +++ b/src/ui/CMakeLists.txt @@ -162,6 +162,7 @@ set(ui_SRC widget/color-scales.cpp widget/color-slider.cpp widget/color-wheel-selector.cpp + widget/combo-box-entry-tool-item.cpp widget/combo-tool-item.cpp widget/dash-selector.cpp widget/dock-item.cpp @@ -179,7 +180,6 @@ set(ui_SRC widget/imagetoggler.cpp widget/ink-color-wheel.cpp widget/ink-flow-box.cpp - widget/ink-select-one-action.cpp widget/ink-spinscale.cpp widget/insertordericon.cpp widget/label-tool-item.cpp @@ -396,6 +396,7 @@ set(ui_SRC widget/color-slider.h widget/color-wheel-selector.h widget/combo-enums.h + widget/combo-box-entry-tool-item.h widget/combo-tool-item.h widget/dash-selector.h widget/dock-item.h @@ -414,7 +415,6 @@ set(ui_SRC widget/imagetoggler.h widget/ink-color-wheel.h widget/ink-flow-box.h - widget/ink-select-one-action.h widget/ink-spinscale.h widget/label-tool-item.h widget/labelled.h diff --git a/src/ui/toolbar/arc-toolbar.h b/src/ui/toolbar/arc-toolbar.h index 08acc136b..b0b04500b 100644 --- a/src/ui/toolbar/arc-toolbar.h +++ b/src/ui/toolbar/arc-toolbar.h @@ -32,7 +32,6 @@ #include <gtkmm/adjustment.h> -class InkSelectOneAction; class SPDesktop; class SPItem; diff --git a/src/ui/toolbar/box3d-toolbar.h b/src/ui/toolbar/box3d-toolbar.h index c5970bf3b..dc74664ee 100644 --- a/src/ui/toolbar/box3d-toolbar.h +++ b/src/ui/toolbar/box3d-toolbar.h @@ -37,10 +37,6 @@ class Persp3D; class SPDesktop; -typedef struct _EgeAdjustmentAction EgeAdjustmentAction; -typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _InkToggleAction InkToggleAction; - namespace Inkscape { class Selection; diff --git a/src/ui/toolbar/lpe-toolbar.cpp b/src/ui/toolbar/lpe-toolbar.cpp index 067687f02..ef5a2ce1c 100644 --- a/src/ui/toolbar/lpe-toolbar.cpp +++ b/src/ui/toolbar/lpe-toolbar.cpp @@ -173,6 +173,12 @@ LPEToolbar::LPEToolbar(SPDesktop *desktop) show_all(); } +void +LPEToolbar::set_mode(int mode) +{ + _mode_buttons[mode]->set_active(); +} + GtkWidget * LPEToolbar::create(SPDesktop *desktop) { diff --git a/src/ui/toolbar/lpe-toolbar.h b/src/ui/toolbar/lpe-toolbar.h index 1609f3915..23647a73c 100644 --- a/src/ui/toolbar/lpe-toolbar.h +++ b/src/ui/toolbar/lpe-toolbar.h @@ -92,6 +92,7 @@ protected: public: static GtkWidget * create(SPDesktop *desktop); + void set_mode(int mode); }; } diff --git a/src/ui/toolbar/rect-toolbar.h b/src/ui/toolbar/rect-toolbar.h index 3aee3b563..58d4b2c1c 100644 --- a/src/ui/toolbar/rect-toolbar.h +++ b/src/ui/toolbar/rect-toolbar.h @@ -36,10 +36,6 @@ class SPDesktop; class SPItem; class SPRect; -typedef struct _EgeAdjustmentAction EgeAdjustmentAction; -typedef struct _EgeOutputAction EgeOutputAction; -typedef struct _InkAction InkAction; - namespace Gtk { class Toolbutton; } diff --git a/src/ui/toolbar/select-toolbar.cpp b/src/ui/toolbar/select-toolbar.cpp index e405b914f..87682b127 100644 --- a/src/ui/toolbar/select-toolbar.cpp +++ b/src/ui/toolbar/select-toolbar.cpp @@ -37,7 +37,6 @@ #include "ui/icon-names.h" #include "ui/widget/combo-tool-item.h" -#include "ui/widget/ink-select-one-action.h" #include "ui/widget/spin-button-tool-item.h" #include "ui/widget/unit-tracker.h" diff --git a/src/ui/toolbar/spray-toolbar.cpp b/src/ui/toolbar/spray-toolbar.cpp index 620351a99..9e7c4e820 100644 --- a/src/ui/toolbar/spray-toolbar.cpp +++ b/src/ui/toolbar/spray-toolbar.cpp @@ -528,6 +528,12 @@ SprayToolbar::on_pref_toggled(Gtk::ToggleToolButton *btn, prefs->setBool(path, active); } +void +SprayToolbar::set_mode(int mode) +{ + _mode_buttons[mode]->set_active(); +} + } } } diff --git a/src/ui/toolbar/spray-toolbar.h b/src/ui/toolbar/spray-toolbar.h index 8c8d9172b..4587cf033 100644 --- a/src/ui/toolbar/spray-toolbar.h +++ b/src/ui/toolbar/spray-toolbar.h @@ -97,6 +97,8 @@ protected: public: static GtkWidget * create(SPDesktop *desktop); + + void set_mode(int mode); }; } } diff --git a/src/ui/toolbar/text-toolbar.cpp b/src/ui/toolbar/text-toolbar.cpp index 3b55f8b08..8e747cb39 100644 --- a/src/ui/toolbar/text-toolbar.cpp +++ b/src/ui/toolbar/text-toolbar.cpp @@ -35,8 +35,6 @@ #include "desktop.h" #include "document-undo.h" #include "document.h" -#include "widgets/ink-toggle-action.h" -#include "widgets/toolbox.h" #include "inkscape.h" #include "selection-chemistry.h" #include "text-editing.h" @@ -55,15 +53,14 @@ #include "ui/icon-names.h" #include "ui/tools/text-tool.h" -#include "ui/widget/ink-select-one-action.h" +#include "ui/widget/combo-box-entry-tool-item.h" +#include "ui/widget/combo-tool-item.h" +#include "ui/widget/spin-button-tool-item.h" #include "ui/widget/unit-tracker.h" -#include "widgets/ege-adjustment-action.h" -#include "widgets/ink-comboboxentry-action.h" #include "widgets/style-utils.h" using Inkscape::DocumentUndo; -using Inkscape::UI::ToolboxFactory; using Inkscape::Util::Unit; using Inkscape::Util::Quantity; using Inkscape::Util::unit_table; @@ -270,16 +267,8 @@ TextToolbar::TextToolbar(SPDesktop *desktop) _tracker->addUnit(unit_table.getUnit("em")); _tracker->addUnit(unit_table.getUnit("ex")); _tracker->setActiveUnit(unit_table.getUnit("%")); -} - -// Define all the "widgets" in the toolbar. -GtkWidget * -TextToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) -{ - auto toolbar = new TextToolbar(desktop); Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - GtkIconSize secondarySize = ToolboxFactory::prefToSize("/toolbox/secondary", 1); /* Font family */ { @@ -289,31 +278,30 @@ TextToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) Glib::RefPtr<Gtk::ListStore> store = fontlister->get_font_list(); GtkListStore* model = store->gobj(); - 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 + _font_family_item = + Gtk::manage(new UI::Widget::ComboBoxEntryToolItem( "TextFontFamilyAction", + _("Font Family"), + _("Select Font Family (Alt-X to access)"), + 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 + _font_family_item->popup_enable(); // Enable entry completion 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 ); + _font_family_item->set_info( info ); // Show selection icon + _font_family_item->set_info_cb( (gpointer)sp_text_toolbox_select_cb ); 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 ); + _font_family_item->set_warning( warning ); // Show icon w/ tooltip if font missing + _font_family_item->set_warning_cb( (gpointer)sp_text_toolbox_select_cb ); //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) ); + _font_family_item->set_altx_name( "altx-text" ); // Set Alt-X keyboard shortcut + _font_family_item->signal_changed().connect( sigc::mem_fun(*this, &TextToolbar::fontfamily_value_changed) ); + add(*_font_family_item); // Change style of drop-down from menu to list auto css_provider = gtk_css_provider_new(); @@ -329,6 +317,39 @@ TextToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) GTK_STYLE_PROVIDER_PRIORITY_USER); } + /* Font styles */ + { + Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance(); + Glib::RefPtr<Gtk::ListStore> store = fontlister->get_style_list(); + GtkListStore* model_style = store->gobj(); + + _font_style_item = Gtk::manage(new UI::Widget::ComboBoxEntryToolItem( "TextFontStyleAction", + _("Font Style"), + _("Font style"), + GTK_TREE_MODEL(model_style), + 12, // Width in characters + 0, // Extra list width + nullptr, // Cell layout + nullptr, // Separator + GTK_WIDGET(desktop->canvas))); // Focus widget + + _font_style_item->signal_changed().connect(sigc::mem_fun(*this, &TextToolbar::fontstyle_value_changed)); + add(*_font_style_item); + } + + add_separator(); + + /* Text outer style */ + { + _outer_style_item = Gtk::manage(new Gtk::ToggleToolButton()); + _outer_style_item->set_label(_("Show outer style")); + _outer_style_item->set_tooltip_text(_("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.")); + _outer_style_item->set_icon_name(INKSCAPE_ICON("text_outer_style")); + add(*_outer_style_item); + _outer_style_item->signal_toggled().connect(sigc::mem_fun(*this, &TextToolbar::outer_style_changed)); + _outer_style_item->set_active(prefs->getBool("/tools/text/outer_style", false)); + } + /* Font size */ { // List of font sizes for drop-down menu @@ -338,71 +359,111 @@ TextToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) sp_text_set_sizes(model_size, unit); - Glib::ustring tooltip = Glib::ustring::format(_("Font size"), " (", sp_style_get_css_unit_string(unit), ")"); + auto unit_str = sp_style_get_css_unit_string(unit); + Glib::ustring tooltip = Glib::ustring::format(_("Font size"), " (", unit_str, ")"); - 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 + _font_size_item = Gtk::manage(new UI::Widget::ComboBoxEntryToolItem( "TextFontSizeAction", + _("Font Size"), + tooltip, + 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(toolbar->_font_size_action), "changed", G_CALLBACK(fontsize_value_changed), (gpointer)toolbar ); - gtk_action_group_add_action( mainActions, GTK_ACTION(toolbar->_font_size_action) ); + _font_size_item->signal_changed().connect(sigc::mem_fun(*this, &TextToolbar::fontsize_value_changed)); + add(*_font_size_item); } - /* Font styles */ + /* Line height */ { - Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance(); - Glib::RefPtr<Gtk::ListStore> store = fontlister->get_style_list(); - GtkListStore* model_style = store->gobj(); - - 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 + // Drop down menu + std::vector<Glib::ustring> labels = {_("Smaller spacing"), "", "", "", "", C_("Text tool", "Normal"), "", "", "", "", "", _("Larger spacing")}; + std::vector<double> 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}; + + auto line_height_val = prefs->getDouble("/tools/text/lineheight", 0.0); + _line_height_adj = Gtk::Adjustment::create(line_height_val, 0.0, 1000.0, 0.1, 1.0); + _line_height_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("text-line-height", _("Line:"), _line_height_adj, 0.1, 2)); + _line_height_item->set_tooltip_text(_("Spacing between baselines")); + _line_height_item->set_custom_numeric_menu_data(values, labels); + _line_height_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); + _line_height_adj->signal_value_changed().connect(sigc::mem_fun(*this, &TextToolbar::lineheight_value_changed)); + //_tracker->addAdjustment(_line_height_adj->gobj()); // (Alex V) Why is this commented out? + add(*_line_height_item); + _line_height_item->set_sensitive(true); + _line_height_item->set_icon(INKSCAPE_ICON("text_line_spacing")); + } - 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) ); + /* Line height units */ + { + _line_height_units_item = _tracker->create_tool_item( _("Units"), ("") ); + add(*_line_height_units_item); + _line_height_units_item->signal_changed_after().connect(sigc::mem_fun(*this, &TextToolbar::lineheight_unit_changed)); } - /* Style - Superscript */ + /* Text line height unset */ { - 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) ); + _line_height_unset_item = Gtk::manage(new Gtk::ToggleToolButton()); + _line_height_unset_item->set_label(_("Unset line height")); + _line_height_unset_item->set_tooltip_text(_("If enabled, line height is set on part of selection. Click to unset.")); + _line_height_unset_item->set_icon_name(INKSCAPE_ICON("paint-unknown")); + add(*_line_height_unset_item); + _line_height_unset_item->signal_toggled().connect(sigc::mem_fun(*this, &TextToolbar::lineheight_unset_changed)); + _line_height_unset_item->set_active(prefs->getBool("/tools/text/line_height_unset", false)); } - /* Style - Subscript */ + /* Line spacing mode */ { - 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) ); + UI::Widget::ComboToolItemColumns columns; + + Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns); + + Gtk::TreeModel::Row row; + + 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; + + 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; + + 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; + + _line_spacing_item = + UI::Widget::ComboToolItem::create(_("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 + _line_spacing_item->use_icon(true); + _line_spacing_item->use_label(true); + gint mode = prefs->getInt("/tools/text/line_spacing_mode", 0); + _line_spacing_item->set_active( mode ); + + add(*_line_spacing_item); + + _line_spacing_item->signal_changed().connect(sigc::mem_fun(*this, &TextToolbar::line_spacing_mode_changed)); } + add_separator(); + /* Alignment */ { - InkSelectOneActionColumns columns; + UI::Widget::ComboToolItemColumns columns; Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns); @@ -432,25 +493,135 @@ TextToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) 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 ); + _align_item = + UI::Widget::ComboToolItem::create(_("Alignment"), // Label + _("Text alignment"), // Tooltip + "Not Used", // Icon + store ); // Tree store + _align_item->use_icon( true ); + _align_item->use_label( false ); gint mode = prefs->getInt("/tools/text/align_mode", 0); - toolbar->_align_action->set_active( mode ); + _align_item->set_active( mode ); - gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_align_action->gobj() )); + add(*_align_item); - toolbar->_align_action->signal_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::align_mode_changed)); + _align_item->signal_changed().connect(sigc::mem_fun(*this, &TextToolbar::align_mode_changed)); } + add_separator(); + + /* Style - Superscript */ + { + _superscript_item = Gtk::manage(new Gtk::ToggleToolButton()); + _superscript_item->set_label(_("Toggle superscript")); + _superscript_item->set_tooltip_text(_("Toggle superscript")); + _superscript_item->set_icon_name(INKSCAPE_ICON("text_superscript")); + _superscript_item->set_name("text-superscript"); + add(*_superscript_item); + _superscript_item->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &TextToolbar::script_changed), _superscript_item)); + _superscript_item->set_active(prefs->getBool("/tools/text/super", false)); + } + + /* Style - Subscript */ + { + _subscript_item = Gtk::manage(new Gtk::ToggleToolButton()); + _subscript_item->set_label(_("Toggle subscript")); + _subscript_item->set_tooltip_text(_("Toggle subscript")); + _subscript_item->set_icon_name(INKSCAPE_ICON("text_subscript")); + _subscript_item->set_name("text-subscript"); + add(*_subscript_item); + _subscript_item->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &TextToolbar::script_changed), _subscript_item)); + _subscript_item->set_active(prefs->getBool("/tools/text/sub", false)); + } + + add_separator(); + + /* Letter spacing */ + { + // Drop down menu + std::vector<Glib::ustring> labels = {_("Negative spacing"), "", "", "", C_("Text tool", "Normal"), "", "", "", "", "", "", "", _("Positive spacing")}; + std::vector<double> 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}; + auto letter_spacing_val = prefs->getDouble("/tools/text/letterspacing", 0.0); + _letter_spacing_adj = Gtk::Adjustment::create(letter_spacing_val, -100.0, 100.0, 0.01, 0.10); + _letter_spacing_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("text-letter-spacing", _("Letter:"), _letter_spacing_adj, 0.1, 2)); + _letter_spacing_item->set_tooltip_text(_("Spacing between letters (px)")); + _letter_spacing_item->set_custom_numeric_menu_data(values, labels); + _letter_spacing_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); + _letter_spacing_adj->signal_value_changed().connect(sigc::mem_fun(*this, &TextToolbar::letterspacing_value_changed)); + add(*_letter_spacing_item); + _letter_spacing_item->set_sensitive(true); + _letter_spacing_item->set_icon(INKSCAPE_ICON("text_letter_spacing")); + } + + /* Word spacing */ + { + // Drop down menu + std::vector<Glib::ustring> labels = {_("Negative spacing"), "", "", "", C_("Text tool", "Normal"), "", "", "", "", "", "", "", _("Positive spacing")}; + std::vector<double> 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}; + auto word_spacing_val = prefs->getDouble("/tools/text/wordspacing", 0.0); + _word_spacing_adj = Gtk::Adjustment::create(word_spacing_val, -100.0, 100.0, 0.01, 0.10); + _word_spacing_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("text-word-spacing", _("Word:"), _word_spacing_adj, 0.1, 2)); + _word_spacing_item->set_tooltip_text(_("Spacing between words (px)")); + _word_spacing_item->set_custom_numeric_menu_data(values, labels); + _word_spacing_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); + _word_spacing_adj->signal_value_changed().connect(sigc::mem_fun(*this, &TextToolbar::wordspacing_value_changed)); + add(*_word_spacing_item); + _word_spacing_item->set_sensitive(true); + _word_spacing_item->set_icon(INKSCAPE_ICON("text_word_spacing")); + } + + /* Character kerning (horizontal shift) */ + { + // Drop down menu + std::vector<double> values = { -2.0, -1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5, 2.0, 2.5 }; + auto dx_val = prefs->getDouble("/tools/text/dx", 0.0); + _dx_adj = Gtk::Adjustment::create(dx_val, -100.0, 100.0, 0.01, 0.1); + _dx_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("text-dx", _("Kern:"), _dx_adj, 0.1, 2)); + _dx_item->set_custom_numeric_menu_data(values); + _dx_item->set_tooltip_text(_("Horizontal kerning (px)")); + _dx_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); + _dx_adj->signal_value_changed().connect(sigc::mem_fun(*this, &TextToolbar::dx_value_changed)); + add(*_dx_item); + _dx_item->set_sensitive(true); + _dx_item->set_icon(INKSCAPE_ICON("text_horz_kern")); + } + + /* Character vertical shift */ + { + // Drop down menu + std::vector<double> values = { -2.0, -1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5, 2.0, 2.5 }; + auto dy_val = prefs->getDouble("/tools/text/dy", 0.0); + _dy_adj = Gtk::Adjustment::create(dy_val, -100.0, 100.0, 0.01, 0.1); + _dy_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("text-dy", _("Vert:"), _dy_adj, 0.1, 2)); + _dy_item->set_tooltip_text(_("Vertical kerning (px)")); + _dy_item->set_custom_numeric_menu_data(values); + _dy_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); + _dy_adj->signal_value_changed().connect(sigc::mem_fun(*this, &TextToolbar::dy_value_changed)); + _dy_item->set_sensitive(true); + _dy_item->set_icon(INKSCAPE_ICON("text_vert_kern")); + add(*_dy_item); + } + + /* Character rotation */ + { + std::vector<double> values = { -90, -45, -30, -15, 0, 15, 30, 45, 90, 180 }; + auto rotation_val = prefs->getDouble("/tools/text/rotation", 0.0); + _rotation_adj = Gtk::Adjustment::create(rotation_val, -180.0, 180.0, 0.1, 1.0); + _rotation_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("text-rotation", _("Rot:"), _rotation_adj, 0.1, 2)); + _rotation_item->set_tooltip_text(_("Character rotation (degrees)")); + _rotation_item->set_custom_numeric_menu_data(values); + _rotation_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); + _rotation_adj->signal_value_changed().connect(sigc::mem_fun(*this, &TextToolbar::rotation_value_changed)); + _rotation_item->set_sensitive(); + _rotation_item->set_icon(INKSCAPE_ICON("text_rotation")); + add(*_rotation_item); + } + + add_separator(); + /* Writing mode (Horizontal, Vertical-LR, Vertical-RL) */ { - InkSelectOneActionColumns columns; + UI::Widget::ComboToolItemColumns columns; Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns); @@ -474,25 +645,25 @@ TextToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) row[columns.col_icon ] = INKSCAPE_ICON("format-text-direction-vertical-lr"); row[columns.col_sensitive] = true; - 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 ); + _writing_mode_item = + UI::Widget::ComboToolItem::create( _("Writing mode"), // Label + _("Block progression"), // Tooltip + "Not Used", // Icon + store ); // Tree store + _writing_mode_item->use_icon(true); + _writing_mode_item->use_label( false ); gint mode = prefs->getInt("/tools/text/writing_mode", 0); - toolbar->_writing_mode_action->set_active( mode ); + _writing_mode_item->set_active( mode ); - gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_writing_mode_action->gobj() )); + add(*_writing_mode_item); - toolbar->_writing_mode_action->signal_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::writing_mode_changed)); + _writing_mode_item->signal_changed().connect(sigc::mem_fun(*this, &TextToolbar::writing_mode_changed)); } + /* Text (glyph) orientation (Auto (mixed), Upright, Sideways) */ { - InkSelectOneActionColumns columns; + UI::Widget::ComboToolItemColumns columns; Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns); @@ -516,25 +687,24 @@ TextToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) row[columns.col_icon ] = INKSCAPE_ICON("text-orientation-sideways"); row[columns.col_sensitive] = 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 ); + _orientation_item = + UI::Widget::ComboToolItem::create(_("Text orientation"), // Label + _("Text (glyph) orientation in vertical text."), // Tooltip + "Not Used", // Icon + store ); // List store + _orientation_item->use_icon(true); + _orientation_item->use_label( false ); gint mode = prefs->getInt("/tools/text/text_orientation", 0); - toolbar->_orientation_action->set_active( mode ); + _orientation_item->set_active( mode ); - gtk_action_group_add_action( mainActions, GTK_ACTION( toolbar->_orientation_action->gobj() )); + add(*_orientation_item); - toolbar->_orientation_action->signal_changed().connect(sigc::mem_fun(*toolbar, &TextToolbar::orientation_changed)); + _orientation_item->signal_changed().connect(sigc::mem_fun(*this, &TextToolbar::orientation_changed)); } // Text direction (predominant direction of horizontal text). { - InkSelectOneActionColumns columns; + UI::Widget::ComboToolItemColumns columns; Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns); @@ -552,299 +722,31 @@ TextToolbar::prep(SPDesktop *desktop, GtkActionGroup* mainActions) 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 ); + _direction_item = + UI::Widget::ComboToolItem::create( _("Text direction"), // Label + _("Text direction for normally horizontal text."), // Tooltip + "Not Used", // Icon + store ); // List store + _direction_item->use_icon(true); + _direction_item->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() )); + _direction_item->set_active( mode ); - toolbar->_direction_action->signal_changed_after().connect(sigc::mem_fun(*toolbar, &TextToolbar::direction_changed)); + add(*_direction_item); + _direction_item->signal_changed_after().connect(sigc::mem_fun(*this, &TextToolbar::direction_changed)); } - /* 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}; - - 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 */ - 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, // tracker, /* unit tracker */ - 0.1, /* step (used?) */ - 2, /* digits to show */ - 1.0 /* factor (multiplies default) */ - ); - ege_adjustment_action_set_focuswidget(toolbar->_line_height_action, GTK_WIDGET(desktop->canvas)); - - 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)); - - //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 ); - } - - /* 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)); - } - - /* Line spacing mode */ - { - InkSelectOneActionColumns columns; - - Glib::RefPtr<Gtk::ListStore> store = Gtk::ListStore::create(columns); - - Gtk::TreeModel::Row row; - - 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; - - 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; - - 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; - - 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 ); - - 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)); - } - - /* 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 */ - 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, /* unit tracker */ - 0.1, /* step (used?) */ - 2, /* digits to show */ - 1.0 /* factor (multiplies default) */ - ); - ege_adjustment_action_set_focuswidget(toolbar->_word_spacing_action, GTK_WIDGET(desktop->canvas)); - - 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 ); - } - - /* 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}; - - 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 */ - 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, /* unit tracker */ - 0.1, /* step (used?) */ - 2, /* digits to show */ - 1.0 /* factor (multiplies default) */ - ); - ege_adjustment_action_set_focuswidget(toolbar->_letter_spacing_action, GTK_WIDGET(desktop->canvas)); - 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 ); - } - - /* 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 }; - - 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 */ - 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, /* unit tracker */ - 0.1, /* step (used?) */ - 2, /* digits to show */ - 1.0 /* factor (multiplies default) */ - ); - ege_adjustment_action_set_focuswidget(toolbar->_dx_action, GTK_WIDGET(desktop->canvas)); - 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 ); - } - - /* 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 */ - 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, /* unit tracker */ - 0.1, /* step (used?) */ - 2, /* digits to show */ - 1.0 /* factor (multiplies default) */ - ); - ege_adjustment_action_set_focuswidget(toolbar->_dy_action, GTK_WIDGET(desktop->canvas)); - 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 ); - } - - /* 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 }; - - 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 */ - 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, /* unit tracker */ - 0.1, /* step (used?) */ - 2, /* digits to show */ - 1.0 /* factor (multiplies default) */ - ); - ege_adjustment_action_set_focuswidget(toolbar->_rotation_action, GTK_WIDGET(desktop->canvas)); - 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 ); - } - - /* 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) ); - } - - /* 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) ); - } + show_all(); // Is this necessary to call? Shouldn't hurt. - toolbar->selection_changed(desktop->getSelection()); + selection_changed(desktop->getSelection()); - desktop->connectEventContextChanged(sigc::mem_fun(*toolbar, &TextToolbar::watch_ec)); - - return GTK_WIDGET(toolbar->gobj()); + desktop->connectEventContextChanged(sigc::mem_fun(*this, &TextToolbar::watch_ec)); } void -TextToolbar::fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, gpointer data ) +TextToolbar::fontfamily_value_changed() { - auto toolbar = reinterpret_cast<TextToolbar *>(data); - #ifdef DEBUG_TEXT std::cout << std::endl; std::cout << "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM" << std::endl; @@ -852,16 +754,16 @@ TextToolbar::fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, gpointer d #endif // quit if run by the _changed callbacks - if (toolbar->_freeze) { + if (_freeze) { #ifdef DEBUG_TEXT std::cout << "sp_text_fontfamily_value_changed: frozen... return" << std::endl; std::cout << "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM\n" << std::endl; #endif return; } - toolbar->_freeze = true; + _freeze = true; - Glib::ustring new_family = ink_comboboxentry_action_get_active_text( act ); + Glib::ustring new_family = _font_family_item->get_active_text(); css_font_family_unquote( new_family ); // Remove quotes around font family names. // TODO: Think about how to handle handle multiple selections. While @@ -877,13 +779,16 @@ TextToolbar::fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, gpointer d if( new_family.compare( fontlister->get_font_family() ) != 0 ) { // Changed font-family - if( act->active == -1 ) { + if( _font_family_item->get_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. + + // This just sets a variable in the ComboBoxEntryAction object... + // shouldn't we also set the actual active row in the combobox? + _font_family_item->set_active(0); // New family is always at top of list. } - fontlister->set_font_family( act->active ); + fontlister->set_font_family( _font_family_item->get_active() ); // active text set in sp_text_toolbox_selection_changed() SPCSSAttr *css = sp_repr_css_attr_new (); @@ -904,7 +809,7 @@ TextToolbar::fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, gpointer d } // unfreeze - toolbar->_freeze = false; + _freeze = false; #ifdef DEBUG_TEXT std::cout << "sp_text_toolbox_fontfamily_changes: exit" << std::endl; @@ -913,24 +818,29 @@ TextToolbar::fontfamily_value_changed( Ink_ComboBoxEntry_Action *act, gpointer d #endif } -void -TextToolbar::fontsize_value_changed( Ink_ComboBoxEntry_Action *act, gpointer data) +GtkWidget * +TextToolbar::create(SPDesktop *desktop) { - auto toolbar = reinterpret_cast<TextToolbar *>(data); + auto tb = Gtk::manage(new TextToolbar(desktop)); + return GTK_WIDGET(tb->gobj()); +} +void +TextToolbar::fontsize_value_changed() +{ // quit if run by the _changed callbacks - if (toolbar->_freeze) { + if (_freeze) { return; } - toolbar->_freeze = true; + _freeze = true; - gchar *text = ink_comboboxentry_action_get_active_text( act ); + gchar *text = _font_size_item->get_active_text(); 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; + _freeze = false; return; } g_free( text ); @@ -999,21 +909,19 @@ TextToolbar::fontsize_value_changed( Ink_ComboBoxEntry_Action *act, gpointer dat sp_repr_css_attr_unref (css); - toolbar->_freeze = false; + _freeze = false; } void -TextToolbar::fontstyle_value_changed( Ink_ComboBoxEntry_Action *act, gpointer data) +TextToolbar::fontstyle_value_changed() { - auto toolbar = reinterpret_cast<TextToolbar *>(data); - // quit if run by the _changed callbacks - if (toolbar->_freeze) { + if (_freeze) { return; } - toolbar->_freeze = true; + _freeze = true; - Glib::ustring new_style = ink_comboboxentry_action_get_active_text( act ); + Glib::ustring new_style = _font_style_item->get_active_text(); Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance(); @@ -1046,26 +954,26 @@ TextToolbar::fontstyle_value_changed( Ink_ComboBoxEntry_Action *act, gpointer da } - toolbar->_freeze = false; + _freeze = false; } // Handles both Superscripts and Subscripts void -TextToolbar::script_changed( InkToggleAction* act, gpointer data) +TextToolbar::script_changed(Gtk::ToggleToolButton *btn) { - auto toolbar = reinterpret_cast<TextToolbar *>(data); // quit if run by the _changed callbacks - if (toolbar->_freeze) { + if (_freeze) { return; } - toolbar->_freeze = true; + + _freeze = 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; + auto name = btn->get_name(); + gint prop = (strcmp(name.c_str(), "TextSuperscriptAction") == 0) ? 0 : 1; #ifdef DEBUG_TEXT - std::cout << "sp_text_script_changed: " << prop << std::endl; + std::cout << "TextToolbar::script_changed: " << prop << std::endl; #endif // Query baseline @@ -1125,7 +1033,7 @@ TextToolbar::script_changed( InkToggleAction* act, gpointer data) DocumentUndo::maybeDone(SP_ACTIVE_DESKTOP->getDocument(), "ttb:script", SP_VERB_NONE, _("Text: Change superscript or subscript")); } - toolbar->_freeze = false; + _freeze = false; } void @@ -1796,13 +1704,13 @@ TextToolbar::line_spacing_mode_changed(int mode) // Set "Outer Style" toggle to match mode. switch (mode) { case 0: // Adaptive - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(_outer_style_action), false ); + _outer_style_item->set_active(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 ); + _outer_style_item->set_active(true); prefs->setInt("/tools/text/outer_style", true); break; @@ -1811,7 +1719,7 @@ TextToolbar::line_spacing_mode_changed(int mode) } // Outer style toggle set per mode so that line height widget should be enabled. - gtk_action_set_sensitive(GTK_ACTION(_line_height_action), true); + _line_height_item->set_sensitive(true); // Update "climb rate" Unit const *unit = _tracker->getActiveUnit(); @@ -2021,15 +1929,12 @@ TextToolbar::rotation_value_changed() // Unset line height on selection's inner text objects (tspan, etc.). void -TextToolbar::lineheight_unset_changed(InkToggleAction*act, gpointer data) +TextToolbar::lineheight_unset_changed() { - auto toolbar = reinterpret_cast<TextToolbar *>(data); - // quit if run by the _changed callbacks - if (toolbar->_freeze) { + if (_freeze) { return; } - toolbar->_freeze = true; SPCSSAttr *css = sp_repr_css_attr_new(); sp_repr_css_unset_property(css, "line-height"); @@ -2042,20 +1947,19 @@ TextToolbar::lineheight_unset_changed(InkToggleAction*act, gpointer data) DocumentUndo::done(desktop->getDocument(), SP_VERB_CONTEXT_TEXT, _("Text: Unset line height.")); - toolbar->_freeze = false; + _freeze = false; } // Changes selection to only text outer elements. void -TextToolbar::outer_style_changed( InkToggleAction *act, gpointer data ) +TextToolbar::outer_style_changed() { - auto toolbar = reinterpret_cast<TextToolbar *>(data); - bool outer = gtk_toggle_action_get_active( GTK_TOGGLE_ACTION(act) ); + bool outer = _outer_style_item->get_active(); Inkscape::Preferences *prefs = Inkscape::Preferences::get(); prefs->setInt("/tools/text/outer_style", outer); // Update widgets to reflect new state of Text Outer Style button. - toolbar->selection_changed(nullptr); + selection_changed(nullptr); } /* @@ -2100,9 +2004,9 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele fontlister->selection_update(); // 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() ); + if( _font_family_item->get_combobox() != nullptr ) { + _font_family_item->set_active_text( fontlister->get_font_family().c_str(), fontlister->get_font_family_row() ); + _font_style_item->set_active_text( fontlister->get_font_style().c_str() ); } // Only flowed text can be justified, only normal text can be kerned... @@ -2177,7 +2081,7 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele // 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 ) { + if( _font_family_item->get_combobox() != nullptr ) { _text_style_from_prefs = true; } } else { @@ -2199,13 +2103,13 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele // 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); + sp_text_set_sizes(GTK_LIST_STORE(_font_size_item->get_model()), unit); //g_object_thaw_notify( G_OBJECT( fontSizeAction->combobox ) ); - ink_comboboxentry_action_set_active_text( _font_size_action, os.str().c_str() ); + _font_size_item->set_active_text( os.str().c_str() ); 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()); + _font_size_item->set_tooltip (tooltip.c_str()); // Superscript gboolean superscriptSet = @@ -2214,7 +2118,7 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele query.baseline_shift.type == SP_BASELINE_SHIFT_LITERAL && query.baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUPER ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(_superscript_action), superscriptSet ); + _superscript_item->set_active(superscriptSet); // Subscript gboolean subscriptSet = @@ -2223,7 +2127,7 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele query.baseline_shift.type == SP_BASELINE_SHIFT_LITERAL && query.baseline_shift.literal == SP_CSS_BASELINE_SHIFT_SUB ); - gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(_subscript_action), subscriptSet ); + _subscript_item->set_active(subscriptSet); // Alignment @@ -2232,9 +2136,9 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele // Only flowed text can be left and right justified at the same time. // Disable button if we don't have flowed text. - Glib::RefPtr<Gtk::ListStore> store = _align_action->get_store(); + Glib::RefPtr<Gtk::ListStore> store = _align_item->get_store(); Gtk::TreeModel::Row row = *(store->get_iter("3")); // Justify entry - InkSelectOneActionColumns columns; + UI::Widget::ComboToolItemColumns columns; row[columns.col_sensitive] = isFlow; int activeButton = 0; @@ -2247,7 +2151,7 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele 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 ); + _align_item->set_active( activeButton ); // Line height (spacing) and line height unit double height; @@ -2313,8 +2217,8 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele _lineheight_unit = line_height_unit; // 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_unset_item->set_sensitive(query.line_height.set); + _line_height_unset_item->set_active(query.line_height.set); // Line spacing mode: requires calculating mode for each <text> element and the <tspan>s within. Inkscape::Selection *selection = desktop->getSelection(); @@ -2368,23 +2272,23 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele // << ", "<< mode[1] // << ", "<< mode[2] // << ", "<< mode[3] << std::endl; - _line_spacing_action->set_active( activeButtonLS ); + _line_spacing_item->set_active( activeButtonLS ); // 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); + _line_height_item->set_sensitive(false); } else { - gtk_action_set_sensitive (GTK_ACTION(_line_height_action), true); + _line_height_item->set_sensitive(true); } // 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); + _line_height_units_item->set_sensitive(false); } else { - _line_height_units_action->set_sensitive(true); + _line_height_units_item->set_sensitive(true); } // Word spacing @@ -2408,7 +2312,7 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele 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; - _writing_mode_action->set_active( activeButton2 ); + _writing_mode_item->set_active( activeButton2 ); // Orientation int activeButton3 = 0; @@ -2416,16 +2320,16 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele if (query.text_orientation.computed == SP_CSS_TEXT_ORIENTATION_UPRIGHT ) activeButton3 = 1; if (query.text_orientation.computed == SP_CSS_TEXT_ORIENTATION_SIDEWAYS) activeButton3 = 2; - _orientation_action->set_active( activeButton3 ); + _orientation_item->set_active( activeButton3 ); // Disable text orientation for horizontal text... - _orientation_action->set_sensitive( activeButton2 != 0 ); + _orientation_item->set_sensitive( activeButton2 != 0 ); // 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 ); + _direction_item->set_active( activeButton4 ); } #ifdef DEBUG_TEXT @@ -2483,9 +2387,9 @@ TextToolbar::selection_changed(Inkscape::Selection * /*selection*/, bool subsele { // 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 ); + _dx_item->set_sensitive(!isFlow); + _dy_item->set_sensitive(!isFlow); + _rotation_item->set_sensitive(!isFlow); } #ifdef DEBUG_TEXT diff --git a/src/ui/toolbar/text-toolbar.h b/src/ui/toolbar/text-toolbar.h index acc6f3268..00632b663 100644 --- a/src/ui/toolbar/text-toolbar.h +++ b/src/ui/toolbar/text-toolbar.h @@ -32,13 +32,12 @@ #include <gtkmm/adjustment.h> -class InkSelectOneAction; class SPDesktop; -typedef struct _EgeAdjustmentAction EgeAdjustmentAction; -typedef struct _GtkActionGroup GtkActionGroup; -typedef struct _Ink_ComboBoxEntry_Action Ink_ComboBoxEntry_Action; -typedef struct _InkToggleAction InkToggleAction; +namespace Gtk { +class ComboBoxText; +class ToggleToolButton; +} namespace Inkscape { class Selection; @@ -49,6 +48,9 @@ class ToolBase; } namespace Widget { +class ComboBoxEntryToolItem; +class ComboToolItem; +class SpinButtonToolItem; class UnitTracker; } @@ -60,26 +62,26 @@ private: 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; + UI::Widget::ComboBoxEntryToolItem *_font_family_item; + UI::Widget::ComboBoxEntryToolItem *_font_size_item; + UI::Widget::ComboBoxEntryToolItem *_font_style_item; + Gtk::ToggleToolButton *_superscript_item; + Gtk::ToggleToolButton *_subscript_item; + Gtk::ToggleToolButton *_outer_style_item; + Gtk::ToggleToolButton *_line_height_unset_item; + UI::Widget::ComboToolItem *_align_item; + UI::Widget::ComboToolItem *_writing_mode_item; + UI::Widget::ComboToolItem *_orientation_item; + UI::Widget::ComboToolItem *_direction_item; + UI::Widget::ComboToolItem *_line_height_units_item; + UI::Widget::ComboToolItem *_line_spacing_item; + + UI::Widget::SpinButtonToolItem *_line_height_item; + UI::Widget::SpinButtonToolItem *_word_spacing_item; + UI::Widget::SpinButtonToolItem *_letter_spacing_item; + UI::Widget::SpinButtonToolItem *_dx_item; + UI::Widget::SpinButtonToolItem *_dy_item; + UI::Widget::SpinButtonToolItem *_rotation_item; Glib::RefPtr<Gtk::Adjustment> _line_height_adj; Glib::RefPtr<Gtk::Adjustment> _word_spacing_adj; @@ -94,19 +96,12 @@ private: 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 fontfamily_value_changed(); + void fontsize_value_changed(); + void fontstyle_value_changed(); + void script_changed(Gtk::ToggleToolButton *btn); + void lineheight_unset_changed(); + void outer_style_changed(); void align_mode_changed(int mode); void writing_mode_changed(int mode); void orientation_changed(int mode); @@ -124,12 +119,13 @@ private: void selection_modified(Inkscape::Selection *selection, guint flags); void subselection_changed(gpointer tc); void watch_ec(SPDesktop* desktop, Inkscape::UI::Tools::ToolBase* ec); + void set_sizes(int unit); protected: TextToolbar(SPDesktop *desktop); public: - static GtkWidget * prep(SPDesktop *desktop, GtkActionGroup* mainActions); + static GtkWidget * create(SPDesktop *desktop); }; } diff --git a/src/ui/toolbar/tweak-toolbar.cpp b/src/ui/toolbar/tweak-toolbar.cpp index 16c9b6009..dc5352ccf 100644 --- a/src/ui/toolbar/tweak-toolbar.cpp +++ b/src/ui/toolbar/tweak-toolbar.cpp @@ -243,6 +243,12 @@ TweakToolbar::TweakToolbar(SPDesktop *desktop) } } +void +TweakToolbar::set_mode(int mode) +{ + _mode_buttons[mode]->set_active(); +} + GtkWidget * TweakToolbar::create(SPDesktop *desktop) { diff --git a/src/ui/toolbar/tweak-toolbar.h b/src/ui/toolbar/tweak-toolbar.h index 8995c64e2..cd1c7d048 100644 --- a/src/ui/toolbar/tweak-toolbar.h +++ b/src/ui/toolbar/tweak-toolbar.h @@ -79,6 +79,8 @@ protected: public: static GtkWidget * create(SPDesktop *desktop); + + void set_mode(int mode); }; } } diff --git a/src/ui/tools/lpe-tool.cpp b/src/ui/tools/lpe-tool.cpp index 55ec014ab..d1e7e186c 100644 --- a/src/ui/tools/lpe-tool.cpp +++ b/src/ui/tools/lpe-tool.cpp @@ -36,6 +36,7 @@ #include "util/units.h" +#include "ui/toolbar/lpe-toolbar.h" #include "ui/tools/lpe-tool.h" #include "ui/shape-editor.h" @@ -309,7 +310,13 @@ lpetool_context_switch_mode(LpeTool *lc, Inkscape::LivePathEffect::EffectType co int index = lpetool_mode_to_index(type); if (index != -1) { lc->mode = type; - lc->desktop->setToolboxSelectOneValue ("lpetool_mode_action", index); + auto tb = dynamic_cast<UI::Toolbar::LPEToolbar*>(lc->desktop->get_toolbar_by_name("LPEToolToolbar")); + + if(tb) { + tb->set_mode(index); + } else { + std::cerr << "Could not access LPE toolbar" << std::endl; + } } else { g_warning ("Invalid mode selected: %d", type); return; diff --git a/src/ui/tools/spray-tool.cpp b/src/ui/tools/spray-tool.cpp index 28990bd2d..5fed9e806 100644 --- a/src/ui/tools/spray-tool.cpp +++ b/src/ui/tools/spray-tool.cpp @@ -62,6 +62,7 @@ #include "svg/svg.h" #include "svg/svg-color.h" +#include "ui/toolbar/spray-toolbar.h" #include "ui/tools/spray-tool.h" #include "ui/dialog/dialog-manager.h" @@ -1210,7 +1211,14 @@ static void sp_spray_update_area(SprayTool *tc) static void sp_spray_switch_mode(SprayTool *tc, gint mode, bool with_shift) { // Select the button mode - SP_EVENT_CONTEXT(tc)->desktop->setToolboxSelectOneValue("spray_tool_mode", mode); + auto tb = dynamic_cast<UI::Toolbar::SprayToolbar*>(SP_EVENT_CONTEXT(tc)->desktop->get_toolbar_by_name("SprayToolbar")); + + if(tb) { + tb->set_mode(mode); + } else { + std::cerr << "Could not access Spray toolbar" << std::endl; + } + // Need to set explicitly, because the prefs may not have changed by the previous tc->mode = mode; tc->update_cursor(with_shift); diff --git a/src/ui/tools/tweak-tool.cpp b/src/ui/tools/tweak-tool.cpp index b8cf5549c..42e3520a0 100644 --- a/src/ui/tools/tweak-tool.cpp +++ b/src/ui/tools/tweak-tool.cpp @@ -74,6 +74,8 @@ #include "svg/svg.h" +#include "ui/toolbar/tweak-toolbar.h" + #include "ui/tools/tweak-tool.h" using Inkscape::DocumentUndo; @@ -1121,7 +1123,14 @@ sp_tweak_update_area (TweakTool *tc) static void sp_tweak_switch_mode (TweakTool *tc, gint mode, bool with_shift) { - SP_EVENT_CONTEXT(tc)->desktop->setToolboxSelectOneValue ("tweak_tool_mode", mode); + auto tb = dynamic_cast<UI::Toolbar::TweakToolbar*>(SP_EVENT_CONTEXT(tc)->desktop->get_toolbar_by_name("TweakToolbar")); + + if(tb) { + tb->set_mode(mode); + } else { + std::cerr << "Could not access Tweak toolbar" << std::endl; + } + // need to set explicitly, because the prefs may not have changed by the previous tc->mode = mode; tc->update_cursor(with_shift); @@ -1133,7 +1142,15 @@ sp_tweak_switch_mode_temporarily (TweakTool *tc, gint mode, bool with_shift) Inkscape::Preferences *prefs = Inkscape::Preferences::get(); // Juggling about so that prefs have the old value but tc->mode and the button show new mode: gint now_mode = prefs->getInt("/tools/tweak/mode", 0); - SP_EVENT_CONTEXT(tc)->desktop->setToolboxSelectOneValue ("tweak_tool_mode", mode); + + auto tb = dynamic_cast<UI::Toolbar::TweakToolbar*>(SP_EVENT_CONTEXT(tc)->desktop->get_toolbar_by_name("TweakToolbar")); + + if(tb) { + tb->set_mode(mode); + } else { + std::cerr << "Could not access Tweak toolbar" << std::endl; + } + // button has changed prefs, restore prefs->setInt("/tools/tweak/mode", now_mode); // changing prefs changed tc->mode, restore back :) diff --git a/src/ui/view/edit-widget-interface.h b/src/ui/view/edit-widget-interface.h index 1bbbbc8bd..eb3e33bb5 100644 --- a/src/ui/view/edit-widget-interface.h +++ b/src/ui/view/edit-widget-interface.h @@ -17,7 +17,8 @@ #include <2geom/point.h> namespace Gtk { -class Window; + class Toolbar; + class Window; } namespace Glib { @@ -132,15 +133,14 @@ struct EditWidgetInterface /// Temporarily block signals and update rotation display virtual void updateRotation() = 0; + virtual Gtk::Toolbar* get_toolbar_by_name(const Glib::ustring&) = 0; + /// In auxiliary toolbox, set focus to widget having specific id virtual void setToolboxFocusTo (const gchar *) = 0; /// In auxiliary toolbox, set value of adjustment with specific id virtual void setToolboxAdjustmentValue (const gchar *, double) = 0; - /// In auxiliary toolbox, select one of the "select one" options (usually radio toggles) - virtual void setToolboxSelectOneValue (const gchar *, gint) = 0; - /// In auxiliary toolbox, return true if specific togglebutton is active virtual bool isToolboxButtonActive (gchar const*) = 0; diff --git a/src/ui/widget/combo-box-entry-tool-item.cpp b/src/ui/widget/combo-box-entry-tool-item.cpp new file mode 100644 index 000000000..2c3a37693 --- /dev/null +++ b/src/ui/widget/combo-box-entry-tool-item.cpp @@ -0,0 +1,684 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * A subclass of GtkAction that wraps a GtkComboBoxEntry. + * Features: + * Setting GtkEntryBox width in characters. + * Passing a function for formatting cells. + * Displaying a warning if entry text isn't in list. + * Check comma separated values in text against list. (Useful for font-family fallbacks.) + * Setting names for GtkComboBoxEntry and GtkEntry (actionName_combobox, actionName_entry) + * to allow setting resources. + * + * Author(s): + * Tavmjong Bah + * Jon A. Cruz <jon@joncruz.org> + * + * Copyright (C) 2010 Authors + * + * Released under GNU GPL v2+, read the file 'COPYING' for more information. + */ + +/* + * We must provide for both a toolbar item and a menu item. + * As we don't know which widgets are used (or even constructed), + * we must keep track of things like active entry ourselves. + */ + +#include "combo-box-entry-tool-item.h" + +#include <iostream> +#include <cstring> +#include <glibmm/ustring.h> + +#include <gtk/gtk.h> +#include <gdk/gdkkeysyms.h> +#include <gdkmm/display.h> + +#include "ui/icon-names.h" + +static GQuark gDataName = 0; + + //gDataName = g_quark_from_string("ink_comboboxentry-action"); + +namespace Inkscape { +namespace UI { +namespace Widget { + +ComboBoxEntryToolItem::ComboBoxEntryToolItem(Glib::ustring name, + Glib::ustring label, + Glib::ustring tooltip, + GtkTreeModel *model, + gint entry_width, + gint extra_width, + void *cell_data_func, + void *separator_func, + GtkWidget *focusWidget) + : _label(std::move(label)), + _tooltip(std::move(tooltip)), + _model(model), + _entry_width(entry_width), + _extra_width(extra_width), + _cell_data_func(cell_data_func), + _separator_func(separator_func), + _focusWidget(focusWidget), + _active(-1), + _text(strdup("")), + _entry_completion(nullptr), + _indicator(nullptr), + _popup(false), + _info(nullptr), + _info_cb(nullptr), + _info_cb_id(0), + _info_cb_blocked(false), + _warning(nullptr), + _warning_cb(nullptr), + _warning_cb_id(0), + _warning_cb_blocked(false), + _altx_name(nullptr) +{ + set_name(name); + + gchar *action_name = g_strdup( get_name().c_str() ); + gchar *combobox_name = g_strjoin( nullptr, action_name, "_combobox", NULL ); + gchar *entry_name = g_strjoin( nullptr, action_name, "_entry", NULL ); + g_free( action_name ); + + GtkWidget* comboBoxEntry = gtk_combo_box_new_with_model_and_entry (_model); + gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (comboBoxEntry), 0); + + // Name it so we can muck with it using an RC file + gtk_widget_set_name( comboBoxEntry, combobox_name ); + g_free( combobox_name ); + + { + gtk_widget_set_halign(comboBoxEntry, GTK_ALIGN_START); + gtk_widget_set_hexpand(comboBoxEntry, FALSE); + gtk_widget_set_vexpand(comboBoxEntry, FALSE); + add(*Glib::wrap(comboBoxEntry)); + } + + _combobox = GTK_COMBO_BOX (comboBoxEntry); + + //gtk_combo_box_set_active( GTK_COMBO_BOX( comboBoxEntry ), ink_comboboxentry_action->active ); + gtk_combo_box_set_active( GTK_COMBO_BOX( comboBoxEntry ), 0 ); + + g_signal_connect( G_OBJECT(comboBoxEntry), "changed", G_CALLBACK(combo_box_changed_cb), this ); + + // Optionally add separator function... + if( _separator_func != nullptr ) { + gtk_combo_box_set_row_separator_func( _combobox, + GtkTreeViewRowSeparatorFunc (_separator_func), + nullptr, nullptr ); + } + + // FIXME: once gtk3 migration is done this can be removed + // https://bugzilla.gnome.org/show_bug.cgi?id=734915 + gtk_widget_show_all (comboBoxEntry); + + // Optionally add formatting... + if( _cell_data_func != nullptr ) { + GtkCellRenderer *cell = gtk_cell_renderer_text_new(); + gtk_cell_layout_clear( GTK_CELL_LAYOUT( comboBoxEntry ) ); + gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( comboBoxEntry ), cell, true ); + gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT( comboBoxEntry ), cell, + GtkCellLayoutDataFunc (_cell_data_func), + nullptr, nullptr ); + } + + // Optionally widen the combobox width... which widens the drop-down list in list mode. + if( _extra_width > 0 ) { + GtkRequisition req; + gtk_widget_get_preferred_size(GTK_WIDGET(_combobox), &req, nullptr); + gtk_widget_set_size_request( GTK_WIDGET( _combobox ), + req.width + _extra_width, -1 ); + } + + // Get reference to GtkEntry and fiddle a bit with it. + GtkWidget *child = gtk_bin_get_child( GTK_BIN(comboBoxEntry) ); + + // Name it so we can muck with it using an RC file + gtk_widget_set_name( child, entry_name ); + g_free( entry_name ); + + if( child && GTK_IS_ENTRY( child ) ) { + + _entry = GTK_ENTRY(child); + + // Change width + if( _entry_width > 0 ) { + gtk_entry_set_width_chars (GTK_ENTRY (child), _entry_width ); + } + + // Add pop-up entry completion if required + if( _popup ) { + popup_enable(); + } + + // Add altx_name if required + if( _altx_name ) { + g_object_set_data( G_OBJECT( child ), _altx_name, _entry ); + } + + // Add signal for GtkEntry to check if finished typing. + g_signal_connect( G_OBJECT(child), "activate", G_CALLBACK(entry_activate_cb), this ); + g_signal_connect( G_OBJECT(child), "key-press-event", G_CALLBACK(keypress_cb), this ); + } + + set_tooltip(tooltip.c_str()); + + show_all(); +} + +// Setters/Getters --------------------------------------------------- + +gchar* +ComboBoxEntryToolItem::get_active_text() +{ + gchar* text = g_strdup( _text ); + return text; +} + +/* + * For the font-family list we need to handle two cases: + * Text is in list store: + * In this case we use row number as the font-family list can have duplicate + * entries, one in the document font part and one in the system font part. In + * order that scrolling through the list works properly we must distinguish + * between the two. + * Text is not in the list store (i.e. default font-family is not on system): + * In this case we have a row number of -1, and the text must be set by hand. + */ +gboolean +ComboBoxEntryToolItem::set_active_text(const gchar* text, int row) +{ + if( strcmp( _text, text ) != 0 ) { + g_free( _text ); + _text = g_strdup( text ); + } + + // Get active row or -1 if none + if( row < 0 ) { + row = get_active_row_from_text(this, _text); + } + _active = row; + + // Set active row, check that combobox has been created. + if( _combobox ) { + gtk_combo_box_set_active( GTK_COMBO_BOX( _combobox ), _active ); + } + + // Fiddle with entry + if( _entry ) { + + // Explicitly set text in GtkEntry box (won't be set if text not in list). + gtk_entry_set_text( _entry, text ); + + // Show or hide warning -- this might be better moved to text-toolbox.cpp + if( _info_cb_id != 0 && + !_info_cb_blocked ) { + g_signal_handler_block (G_OBJECT(_entry), + _info_cb_id ); + _info_cb_blocked = true; + } + if( _warning_cb_id != 0 && + !_warning_cb_blocked ) { + g_signal_handler_block (G_OBJECT(_entry), + _warning_cb_id ); + _warning_cb_blocked = true; + } + + bool set = false; + if( _warning != nullptr ) { + Glib::ustring missing = check_comma_separated_text(); + if( !missing.empty() ) { + gtk_entry_set_icon_from_icon_name( _entry, + GTK_ENTRY_ICON_SECONDARY, + INKSCAPE_ICON("dialog-warning") ); + // Can't add tooltip until icon set + Glib::ustring warning = _warning; + warning += ": "; + warning += missing; + gtk_entry_set_icon_tooltip_text( _entry, + GTK_ENTRY_ICON_SECONDARY, + warning.c_str() ); + + if( _warning_cb ) { + + // Add callback if we haven't already + if( _warning_cb_id == 0 ) { + _warning_cb_id = + g_signal_connect( G_OBJECT(_entry), + "icon-press", + G_CALLBACK(_warning_cb), + this); + } + // Unblock signal + if( _warning_cb_blocked ) { + g_signal_handler_unblock (G_OBJECT(_entry), + _warning_cb_id ); + _warning_cb_blocked = false; + } + } + set = true; + } + } + + if( !set && _info != nullptr ) { + gtk_entry_set_icon_from_icon_name( GTK_ENTRY(_entry), + GTK_ENTRY_ICON_SECONDARY, + INKSCAPE_ICON("edit-select-all") ); + gtk_entry_set_icon_tooltip_text( _entry, + GTK_ENTRY_ICON_SECONDARY, + _info ); + + if( _info_cb ) { + // Add callback if we haven't already + if( _info_cb_id == 0 ) { + _info_cb_id = + g_signal_connect( G_OBJECT(_entry), + "icon-press", + G_CALLBACK(_info_cb), + this); + } + // Unblock signal + if( _info_cb_blocked ) { + g_signal_handler_unblock (G_OBJECT(_entry), + _info_cb_id ); + _info_cb_blocked = false; + } + } + set = true; + } + + if( !set ) { + gtk_entry_set_icon_from_icon_name( GTK_ENTRY(_entry), + GTK_ENTRY_ICON_SECONDARY, + nullptr ); + } + } + + // Return if active text in list + gboolean found = ( _active != -1 ); + return found; +} + +void +ComboBoxEntryToolItem::set_entry_width(gint entry_width) +{ + _entry_width = entry_width; + + // Clamp to limits + if(entry_width < -1) entry_width = -1; + if(entry_width > 100) entry_width = 100; + + // Widget may not have been created.... + if( _entry ) { + gtk_entry_set_width_chars( GTK_ENTRY(_entry), entry_width ); + } +} + +void +ComboBoxEntryToolItem::set_extra_width( gint extra_width ) +{ + _extra_width = extra_width; + + // Clamp to limits + if(extra_width < -1) extra_width = -1; + if(extra_width > 500) extra_width = 500; + + // Widget may not have been created.... + if( _combobox ) { + GtkRequisition req; + gtk_widget_get_preferred_size(GTK_WIDGET(_combobox), &req, nullptr); + gtk_widget_set_size_request( GTK_WIDGET( _combobox ), req.width + _extra_width, -1 ); + } +} + +void +ComboBoxEntryToolItem::popup_enable() +{ + _popup = true; + + // Widget may not have been created.... + if( _entry ) { + + // Check we don't already have a GtkEntryCompletion + if( _entry_completion ) return; + + _entry_completion = gtk_entry_completion_new(); + + gtk_entry_set_completion( _entry, _entry_completion ); + gtk_entry_completion_set_model( _entry_completion, _model ); + gtk_entry_completion_set_text_column( _entry_completion, 0 ); + gtk_entry_completion_set_popup_completion( _entry_completion, true ); + gtk_entry_completion_set_inline_completion( _entry_completion, false ); + gtk_entry_completion_set_inline_selection( _entry_completion, true ); + + g_signal_connect (G_OBJECT (_entry_completion), "match-selected", G_CALLBACK (match_selected_cb), this); + } +} + +void +ComboBoxEntryToolItem::popup_disable() +{ + _popup = false; + + if( _entry_completion ) { + gtk_widget_destroy(GTK_WIDGET(_entry_completion)); + _entry_completion = nullptr; + } +} + +void +ComboBoxEntryToolItem::set_tooltip(const gchar* tooltip) +{ + set_tooltip_text(tooltip); + gtk_widget_set_tooltip_text ( GTK_WIDGET(_combobox), tooltip); + + // Widget may not have been created.... + if( _entry ) { + gtk_widget_set_tooltip_text ( GTK_WIDGET(_entry), tooltip); + } +} + +void +ComboBoxEntryToolItem::set_info(const gchar* info) +{ + g_free( _info ); + _info = g_strdup( info ); + + // Widget may not have been created.... + if( _entry ) { + gtk_entry_set_icon_tooltip_text( GTK_ENTRY(_entry), + GTK_ENTRY_ICON_SECONDARY, + _info ); + } +} + +void +ComboBoxEntryToolItem::set_info_cb(gpointer info_cb) +{ + _info_cb = info_cb; +} + +void +ComboBoxEntryToolItem::set_warning(const gchar* warning) +{ + g_free( _warning ); + _warning = g_strdup( warning ); + + // Widget may not have been created.... + if( _entry ) { + gtk_entry_set_icon_tooltip_text( GTK_ENTRY(_entry), + GTK_ENTRY_ICON_SECONDARY, + _warning ); + } +} + +void +ComboBoxEntryToolItem::set_warning_cb(gpointer warning_cb) +{ + _warning_cb = warning_cb; +} + +void +ComboBoxEntryToolItem::set_altx_name(const gchar* altx_name) +{ + g_free(_altx_name); + _altx_name = g_strdup( altx_name ); + + // Widget may not have been created.... + if(_entry) { + g_object_set_data( G_OBJECT(_entry), _altx_name, _entry ); + } +} + +// Internal --------------------------------------------------- + +// Return row of active text or -1 if not found. If exclude is true, +// use 3d colunm if available to exclude row from checking (useful to +// skip rows added for font-families included in doc and not on +// system) +gint +ComboBoxEntryToolItem::get_active_row_from_text(ComboBoxEntryToolItem *action, + const gchar *target_text, + gboolean exclude, + gboolean ignore_case ) +{ + // Check if text in list + gint row = 0; + gboolean found = false; + GtkTreeIter iter; + gboolean valid = gtk_tree_model_get_iter_first( action->_model, &iter ); + while ( valid ) { + + // See if we should exclude a row + gboolean check = true; // If true, font-family is on system. + if( exclude && gtk_tree_model_get_n_columns( action->_model ) > 2 ) { + gtk_tree_model_get( action->_model, &iter, 2, &check, -1 ); + } + + if( check ) { + // Get text from list entry + gchar* text = nullptr; + gtk_tree_model_get( action->_model, &iter, 0, &text, -1 ); // Column 0 + + if( !ignore_case ) { + // Case sensitive compare + if( strcmp( target_text, text ) == 0 ){ + found = true; + break; + } + } else { + // Case insensitive compare + gchar* target_text_casefolded = g_utf8_casefold( target_text, -1 ); + gchar* text_casefolded = g_utf8_casefold( text, -1 ); + gboolean equal = (strcmp( target_text_casefolded, text_casefolded ) == 0 ); + g_free( text_casefolded ); + g_free( target_text_casefolded ); + if( equal ) { + found = true; + break; + } + } + } + + ++row; + valid = gtk_tree_model_iter_next( action->_model, &iter ); + } + + if( !found ) row = -1; + + return row; +} + +// Checks if all comma separated text fragments are in the list and +// returns a ustring with a list of missing fragments. +// This is useful for checking if all fonts in a font-family fallback +// list are available on the system. +// +// This routine could also create a Pango Markup string to show which +// fragments are invalid in the entry box itself. See: +// http://developer.gnome.org/pango/stable/PangoMarkupFormat.html +// However... it appears that while one can retrieve the PangoLayout +// for a GtkEntry box, it is only a copy and changing it has no effect. +// PangoLayout * pl = gtk_entry_get_layout( entry ); +// pango_layout_set_markup( pl, "NEW STRING", -1 ); // DOESN'T WORK +Glib::ustring +ComboBoxEntryToolItem::check_comma_separated_text() +{ + Glib::ustring missing; + + // Parse fallback_list using a comma as deliminator + gchar** tokens = g_strsplit( _text, ",", 0 ); + + gint i = 0; + while( tokens[i] != nullptr ) { + + // Remove any surrounding white space. + g_strstrip( tokens[i] ); + + if( get_active_row_from_text( this, tokens[i], true, true ) == -1 ) { + missing += tokens[i]; + missing += ", "; + } + ++i; + } + g_strfreev( tokens ); + + // Remove extra comma and space from end. + if( missing.size() >= 2 ) { + missing.resize( missing.size()-2 ); + } + return missing; +} + +// Callbacks --------------------------------------------------- + +void +ComboBoxEntryToolItem::combo_box_changed_cb( GtkComboBox* widget, gpointer data ) +{ + // Two things can happen to get here: + // An item is selected in the drop-down menu. + // Text is typed. + // We only react here if an item is selected. + + // Get action + auto action = reinterpret_cast<ComboBoxEntryToolItem *>( data ); + + // Check if item selected: + gint newActive = gtk_combo_box_get_active(widget); + if( newActive >= 0 && newActive != action->_active ) { + + action->_active = newActive; + + GtkTreeIter iter; + if( gtk_combo_box_get_active_iter( GTK_COMBO_BOX( action->_combobox ), &iter ) ) { + + gchar* text = nullptr; + gtk_tree_model_get( action->_model, &iter, 0, &text, -1 ); + gtk_entry_set_text( action->_entry, text ); + + g_free( action->_text ); + action->_text = text; + } + + // Now let the world know + action->_signal_changed.emit(); + } +} + +void +ComboBoxEntryToolItem::entry_activate_cb( GtkEntry *widget, + gpointer data ) +{ + // Get text from entry box.. check if it matches a menu entry. + + // Get action + auto action = reinterpret_cast<ComboBoxEntryToolItem*>( data ); + + // Get text + g_free( action->_text ); + action->_text = g_strdup( gtk_entry_get_text( widget ) ); + + // Get row + action->_active = + get_active_row_from_text( action, action->_text ); + + // Set active row + gtk_combo_box_set_active( GTK_COMBO_BOX( action->_combobox), action->_active ); + + // Now let the world know + action->_signal_changed.emit(); +} + +gboolean +ComboBoxEntryToolItem::match_selected_cb( GtkEntryCompletion* /*widget*/, GtkTreeModel* model, GtkTreeIter* iter, gpointer data ) +{ + // Get action + auto action = reinterpret_cast<ComboBoxEntryToolItem*>(data); + GtkEntry *entry = action->_entry; + + if( entry) { + gchar *family = nullptr; + gtk_tree_model_get(model, iter, 0, &family, -1); + + // Set text in GtkEntry + gtk_entry_set_text (GTK_ENTRY (entry), family ); + + // Set text in GtkAction + g_free( action->_text ); + action->_text = family; + + // Get row + action->_active = + get_active_row_from_text( action, action->_text ); + + // Set active row + gtk_combo_box_set_active( GTK_COMBO_BOX( action->_combobox), action->_active ); + + // Now let the world know + action->_signal_changed.emit(); + + return true; + } + return false; +} + +void +ComboBoxEntryToolItem::defocus() +{ + if ( _focusWidget ) { + gtk_widget_grab_focus( _focusWidget ); + } +} + +gboolean +ComboBoxEntryToolItem::keypress_cb( GtkWidget * /*widget*/, GdkEventKey *event, gpointer data ) +{ + gboolean wasConsumed = FALSE; /* default to report event not consumed */ + guint key = 0; + auto action = reinterpret_cast<ComboBoxEntryToolItem*>(data); + gdk_keymap_translate_keyboard_state( Gdk::Display::get_default()->get_keymap(), + event->hardware_keycode, (GdkModifierType)event->state, + 0, &key, nullptr, nullptr, nullptr ); + + switch ( key ) { + + // TODO Add bindings for Tab/LeftTab + case GDK_KEY_Escape: + { + //gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), action->private_data->lastVal ); + action->defocus(); + wasConsumed = TRUE; + } + break; + + case GDK_KEY_Return: + case GDK_KEY_KP_Enter: + { + action->defocus(); + //wasConsumed = TRUE; + } + break; + + + } + + return wasConsumed; +} + +} +} +} + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 : diff --git a/src/ui/widget/combo-box-entry-tool-item.h b/src/ui/widget/combo-box-entry-tool-item.h new file mode 100644 index 000000000..70c8e94e7 --- /dev/null +++ b/src/ui/widget/combo-box-entry-tool-item.h @@ -0,0 +1,155 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * A subclass of GtkAction that wraps a GtkComboBoxEntry. + * Features: + * Setting GtkEntryBox width in characters. + * Passing a function for formatting cells. + * Displaying a warning if text isn't in list. + * Setting names for GtkComboBoxEntry and GtkEntry (actionName_combobox, actionName_entry) + * to allow setting resources. + * + * Author(s): + * Tavmjong Bah + * Jon A. Cruz <jon@joncruz.org> + * + * Copyright (C) 2010 Authors + * + * Released under GNU GPL v2+, read the file 'COPYING' for more information. + */ + +#ifndef SEEN_INK_COMBOBOXENTRY_ACTION +#define SEEN_INK_COMBOBOXENTRY_ACTION + +#include <gtkmm/toolitem.h> + +namespace Inkscape { +namespace UI { +namespace Widget { + +/** + * Creates a Gtk::ToolItem subclass that wraps a Gtk::ComboBox object. + */ +class ComboBoxEntryToolItem : public Gtk::ToolItem { +private: + Glib::ustring _tooltip; + Glib::ustring _label; + GtkTreeModel *_model; ///< Tree Model + GtkComboBox *_combobox; + GtkEntry *_entry; + gint _entry_width;// Width of GtkEntry in characters. + gint _extra_width;// Extra Width of GtkComboBox.. to widen drop-down list in list mode. + gpointer _cell_data_func; // drop-down menu format + gpointer _separator_func; + gboolean _popup; // Do we pop-up an entry-completion dialog? + GtkEntryCompletion *_entry_completion; + GtkWidget *_focusWidget; ///< The widget to return focus to + + GtkWidget *_indicator; + gint _active; // Index of active menu item (-1 if not in list). + gchar *_text; // Text of active menu item or entry box. + gchar *_info; // Text for tooltip info about entry. + gpointer _info_cb; // Callback for clicking info icon. + gint _info_cb_id; + gboolean _info_cb_blocked; + gchar *_warning; // Text for tooltip warning that entry isn't in list. + gpointer _warning_cb; // Callback for clicking warning icon. + gint _warning_cb_id; + gboolean _warning_cb_blocked; + gchar *_altx_name; // Target for Alt-X keyboard shortcut. + + // Signals + sigc::signal<void> _signal_changed; + + void (*changed) (ComboBoxEntryToolItem* action); + void (*activated) (ComboBoxEntryToolItem* action); + + static gint get_active_row_from_text(ComboBoxEntryToolItem *action, + const gchar *target_text, + gboolean exclude = false, + gboolean ignore_case = false); + void defocus(); + + static void combo_box_changed_cb( GtkComboBox* widget, gpointer data ); + static void entry_activate_cb( GtkEntry *widget, + gpointer data ); + static gboolean match_selected_cb( GtkEntryCompletion *widget, + GtkTreeModel *model, + GtkTreeIter *iter, + gpointer data); + static gboolean keypress_cb( GtkWidget *widget, + GdkEventKey *event, + gpointer data ); + + Glib::ustring check_comma_separated_text(); + +public: + ComboBoxEntryToolItem(const Glib::ustring name, + const Glib::ustring label, + const Glib::ustring tooltip, + GtkTreeModel *model, + gint entry_width = -1, + gint extra_width = -1, + gpointer cell_data_func = nullptr, + gpointer separator_func = nullptr, + GtkWidget* focusWidget = nullptr); + + gchar* get_active_text(); + gboolean set_active_text(const gchar* text, int row=-1); + + void set_entry_width(gint entry_width); + void set_extra_width(gint extra_width); + + void popup_enable(); + void popup_disable(); + + void set_info( const gchar* info ); + void set_info_cb( gpointer info_cb ); + void set_warning( const gchar* warning_cb ); + void set_warning_cb(gpointer warning ); + void set_tooltip( const gchar* tooltip ); + + void set_altx_name( const gchar* altx_name ); + + // Accessor methods + decltype(_model) get_model() const {return _model;} + decltype(_combobox) get_combobox() const {return _combobox;} + decltype(_entry) get_entry() const {return _entry;} + decltype(_entry_width) get_entry_width() const {return _entry_width;} + decltype(_extra_width) get_extra_width() const {return _extra_width;} + decltype(_cell_data_func) get_cell_data_func() const {return _cell_data_func;} + decltype(_separator_func) get_separator_func() const {return _separator_func;} + decltype(_popup) get_popup() const {return _popup;} + decltype(_focusWidget) get_focus_widget() const {return _focusWidget;} + + decltype(_active) get_active() const {return _active;} + + decltype(_signal_changed) signal_changed() {return _signal_changed;} + + // Mutator methods + void set_model (decltype(_model) model) {_model = model;} + void set_combobox (decltype(_combobox) combobox) {_combobox = combobox;} + void set_entry (decltype(_entry) entry) {_entry = entry;} + void set_cell_data_func(decltype(_cell_data_func) cell_data_func) {_cell_data_func = cell_data_func;} + void set_separator_func(decltype(_separator_func) separator_func) {_separator_func = separator_func;} + void set_popup (decltype(_popup) popup) {_popup = popup;} + void set_focus_widget (decltype(_focusWidget) focus_widget) {_focusWidget = focus_widget;} + + // This doesn't seem right... surely we should set the active row in the Combobox too? + void set_active (decltype(_active) active) {_active = active;} +}; + +} +} +} +#endif /* SEEN_INK_COMBOBOXENTRY_ACTION */ + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 : diff --git a/src/ui/widget/combo-tool-item.cpp b/src/ui/widget/combo-tool-item.cpp index a6c44f7eb..b8638ba72 100644 --- a/src/ui/widget/combo-tool-item.cpp +++ b/src/ui/widget/combo-tool-item.cpp @@ -34,15 +34,17 @@ ComboToolItem* ComboToolItem::create(const Glib::ustring &group_label, const Glib::ustring &tooltip, const Glib::ustring &stock_id, - Glib::RefPtr<Gtk::ListStore> store ) + Glib::RefPtr<Gtk::ListStore> store, + bool has_entry) { - return new ComboToolItem(group_label, tooltip, stock_id, store); + return new ComboToolItem(group_label, tooltip, stock_id, store, has_entry); } ComboToolItem::ComboToolItem(Glib::ustring group_label, Glib::ustring tooltip, Glib::ustring stock_id, - Glib::RefPtr<Gtk::ListStore> store ) : + Glib::RefPtr<Gtk::ListStore> store, + bool has_entry) : _group_label(std::move( group_label )), _tooltip(std::move( tooltip )), _stock_id(std::move( stock_id )), @@ -63,9 +65,45 @@ ComboToolItem::ComboToolItem(Glib::ustring group_label, } // Create combobox - _combobox = Gtk::manage (new Gtk::ComboBox()); + _combobox = Gtk::manage (new Gtk::ComboBox(has_entry)); _combobox->set_model(_store); + populate_combobox(); + + _combobox->signal_changed().connect( + sigc::mem_fun(*this, &ComboToolItem::on_changed_combobox)); + + box->add (*_combobox); + + show_all(); +} + +void +ComboToolItem::use_label(bool use_label) +{ + _use_label = use_label; + populate_combobox(); +} + +void +ComboToolItem::use_icon(bool use_icon) +{ + _use_icon = use_icon; + populate_combobox(); +} + +void +ComboToolItem::use_pixbuf(bool use_pixbuf) +{ + _use_pixbuf = use_pixbuf; + populate_combobox(); +} + +void +ComboToolItem::populate_combobox() +{ + _combobox->clear(); + ComboToolItemColumns columns; if (_use_icon) { Gtk::CellRendererPixbuf *renderer = new Gtk::CellRendererPixbuf; @@ -89,13 +127,6 @@ ComboToolItem::ComboToolItem(Glib::ustring group_label, } _combobox->set_active (_active); - - _combobox->signal_changed().connect( - sigc::mem_fun(*this, &ComboToolItem::on_changed_combobox)); - - box->add (*_combobox); - - show_all(); } void diff --git a/src/ui/widget/combo-tool-item.h b/src/ui/widget/combo-tool-item.h index 1e4590163..d2ca874f0 100644 --- a/src/ui/widget/combo-tool-item.h +++ b/src/ui/widget/combo-tool-item.h @@ -54,12 +54,13 @@ public: static ComboToolItem* create(const Glib::ustring &label, const Glib::ustring &tooltip, const Glib::ustring &stock_id, - Glib::RefPtr<Gtk::ListStore> store ); + Glib::RefPtr<Gtk::ListStore> store, + bool has_entry = false); - /* Style of action */ - void use_label( bool use_label ) { _use_label = use_label; } - void use_icon( bool use_icon ) { _use_icon = use_icon; } - void use_pixbuf( bool use_pixbuf ) { _use_pixbuf = use_pixbuf; } + /* Style of combobox */ + void use_label( bool use_label ); + void use_icon( bool use_icon ); + void use_pixbuf( bool use_pixbuf ); void use_group_label( bool use_group_label ) { _use_group_label = use_group_label; } gint get_active() { return _active; } @@ -74,6 +75,7 @@ public: protected: bool on_create_menu_proxy() override; + void populate_combobox(); /* Signals */ sigc::signal<void, int> _changed; @@ -108,7 +110,8 @@ private: ComboToolItem(Glib::ustring group_label, Glib::ustring tooltip, Glib::ustring stock_id, - Glib::RefPtr<Gtk::ListStore> store ); + Glib::RefPtr<Gtk::ListStore> store, + bool has_entry = false); }; } } diff --git a/src/ui/widget/ink-select-one-action.cpp b/src/ui/widget/ink-select-one-action.cpp deleted file mode 100644 index 95f38b511..000000000 --- a/src/ui/widget/ink-select-one-action.cpp +++ /dev/null @@ -1,269 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-or-later -/* - * Authors: - * Tavmjong Bah <tavmjong@free.fr> - * - * Copyright (C) 2017 Tavmjong Bah - * - * Released under GNU GPL v2+, read the file 'COPYING' for more information. - */ - - -/** \file - An action (menu/toolbar item) that allows selecting one choice out of many. - - The choices may be displayed as: - - 1. A group of items in a toolbar with labels and/or icons. - 2. As a drop-down menu with a labels and/or icons. -*/ - -#include "ink-select-one-action.h" - -#include <iostream> -#include <utility> -#include <gtkmm/toolitem.h> -#include <gtkmm/menuitem.h> -#include <gtkmm/radioaction.h> -#include <gtkmm/radiomenuitem.h> -#include <gtkmm/combobox.h> -#include <gtkmm/menu.h> -#include <gtkmm/box.h> -#include <gtkmm/label.h> -#include <gtkmm/image.h> - -InkSelectOneAction* InkSelectOneAction::create(const Glib::ustring &name, - const Glib::ustring &group_label, - const Glib::ustring &tooltip, - const Glib::ustring &stock_id, - Glib::RefPtr<Gtk::ListStore> store ) { - - return new InkSelectOneAction(name, group_label, tooltip, stock_id, store); -} - -InkSelectOneAction::InkSelectOneAction (const Glib::ustring &name, - const Glib::ustring &group_label, - const Glib::ustring &tooltip, - const Glib::ustring &stock_id, - Glib::RefPtr<Gtk::ListStore> store ) : - Gtk::Action(name, stock_id, group_label, tooltip), - _name( name ), - _group_label( group_label ), - _tooltip( tooltip ), - _stock_id( stock_id ), - _store (std::move(store)), - _use_radio (true), - _use_label (true), - _use_icon (true), - _use_pixbuf (false), - _icon_size ( Gtk::ICON_SIZE_LARGE_TOOLBAR ), - _combobox (nullptr), - _radioaction (nullptr), - _menuitem (nullptr) -{ -} - -void InkSelectOneAction::set_active (gint active) { - - if (active < 0) { - std::cerr << "InkSelectOneAction::set_active: active < 0: " << active << std::endl; - return; - } - - if (_active != active) { - - _active = active; - - if (_combobox) { - _combobox->set_active (active); - } - - if (_radioaction) { - _radioaction->set_current_value (active); - } - - if (active < _radiomenuitems.size()) { - _radiomenuitems[ active ]->set_active(); - } - } -} - -Glib::ustring InkSelectOneAction::get_active_text () { - Gtk::TreeModel::Row row = _store->children()[_active]; - InkSelectOneActionColumns columns; - Glib::ustring label = row[columns.col_label]; - return label; -} - -Gtk::Widget* InkSelectOneAction::create_menu_item_vfunc() { - - if (_menuitem == nullptr) { - - _menuitem = Gtk::manage (new Gtk::MenuItem); - Gtk::Menu *menu = Gtk::manage (new Gtk::Menu); - - Gtk::RadioButton::Group group; - int index = 0; - auto children = _store->children(); - for (auto row : children) { - InkSelectOneActionColumns columns; - Glib::ustring label = row[columns.col_label ]; - Glib::ustring icon = row[columns.col_icon ]; - Glib::ustring tooltip = row[columns.col_tooltip ]; - bool sensitive = row[columns.col_sensitive ]; - - Gtk::RadioMenuItem* button = Gtk::manage(new Gtk::RadioMenuItem(group)); - button->set_label (label); - button->set_tooltip_text( tooltip ); - button->set_sensitive( sensitive ); - - button->signal_toggled().connect( sigc::bind<0>( - sigc::mem_fun(*this, &InkSelectOneAction::on_toggled_radiomenu), index++) - ); - - menu->add (*button); - - _radiomenuitems.push_back( button ); - } - - if ( _active < _radiomenuitems.size()) { - _radiomenuitems[ _active ]->set_active(); - } - - _menuitem->set_submenu (*menu); - _menuitem->show_all(); - } - - return _menuitem; -} - - -Gtk::Widget* InkSelectOneAction::create_tool_item_vfunc() { - // Either a group of radio actions or a combobox with labels and/or icons. - - Gtk::ToolItem *tool_item = new Gtk::ToolItem; - - Gtk::Box* box = Gtk::manage(new Gtk::Box()); - tool_item->add (*box); - - if (_use_group_label) { - Gtk::Label *group_label = Gtk::manage (new Gtk::Label( _group_label + ": " )); - box->add( *group_label ); - } - - if (_use_radio) { - // Create radio actions (note: these are not radio buttons). - - Gtk::RadioAction::Group group; - int index = 0; - auto children = _store->children(); - for (auto row : children) { - InkSelectOneActionColumns columns; - Glib::ustring label = row[columns.col_label ]; - Glib::ustring icon = row[columns.col_icon ]; - Glib::ustring tooltip = row[columns.col_tooltip ]; - bool sensitive = row[columns.col_sensitive]; - Glib::RefPtr<Gtk::RadioAction> action; - if (_use_icon) { - action = - Gtk::RadioAction::create_with_icon_name (group, "Anonymous", icon, label, tooltip); - } else { - action = - Gtk::RadioAction::create (group, "Anonymous", label, tooltip); - } - action->set_property( "value", index++ ); // To identify uniquely each radioaction. - action->set_sensitive( sensitive ); - - // Save first action for use in setting/getting active value. - if (!_radioaction) { - _radioaction = action; - } - - Gtk::ToolItem* item = action->create_tool_item(); - box->add (*item); - } - - if (_radioaction) { - _radioaction->set_current_value (_active); - } - - _radioaction->signal_changed().connect( sigc::mem_fun(*this, &InkSelectOneAction::on_changed_radioaction)); - - } else { - // Create combobox - - _combobox = Gtk::manage (new Gtk::ComboBox()); - _combobox->set_model(_store); - - InkSelectOneActionColumns columns; - if (_use_icon) { - Gtk::CellRendererPixbuf *renderer = new Gtk::CellRendererPixbuf; - renderer->set_property ("stock_size", Gtk::ICON_SIZE_LARGE_TOOLBAR); - _combobox->pack_start (*renderer, false); - _combobox->add_attribute (*renderer, "icon_name", columns.col_icon ); - } else if (_use_pixbuf) { - Gtk::CellRendererPixbuf *renderer = new Gtk::CellRendererPixbuf; - //renderer->set_property ("stock_size", Gtk::ICON_SIZE_LARGE_TOOLBAR); - _combobox->pack_start (*renderer, false); - _combobox->add_attribute (*renderer, "pixbuf", columns.col_pixbuf ); - } - - if (_use_label) { - _combobox->pack_start(columns.col_label); - } - - std::vector<Gtk::CellRenderer*> cells = _combobox->get_cells(); - for (auto & cell : cells) { - _combobox->add_attribute (*cell, "sensitive", columns.col_sensitive); - } - - _combobox->set_active (_active); - - _combobox->signal_changed().connect( - sigc::mem_fun(*this, &InkSelectOneAction::on_changed_combobox)); - - box->add (*_combobox); - } - - tool_item->show_all(); - - return tool_item; -} - -void InkSelectOneAction::on_changed_combobox() { - - int row = _combobox->get_active_row_number(); - if (row < 0) row = 0; // Happens when Gtk::ListStore reconstructed - set_active( row ); - _changed.emit (_active); - _changed_after.emit (_active); -} - -void InkSelectOneAction::on_changed_radioaction(const Glib::RefPtr<Gtk::RadioAction>& current) { - - set_active( current->get_current_value() ); - _changed.emit (_active); - _changed_after.emit (_active); -} - -void InkSelectOneAction::on_toggled_radiomenu(int n) { - - // toggled emitted twice, first for button toggled off, second for button toggled on. - // We want to react only to the button turned on. - if ( n < _radiomenuitems.size() &&_radiomenuitems[ n ]->get_active()) { - set_active ( n ); - _changed.emit (_active); - _changed_after.emit (_active); - } -} - -/* - Local Variables: - mode:c++ - c-file-style:"stroustrup" - c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) - indent-tabs-mode:nil - fill-column:99 - End: -*/ -// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 : diff --git a/src/ui/widget/ink-select-one-action.h b/src/ui/widget/ink-select-one-action.h deleted file mode 100644 index efe249da8..000000000 --- a/src/ui/widget/ink-select-one-action.h +++ /dev/null @@ -1,143 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-or-later -#ifndef SEEN_INK_SELECT_ONE_ACTION -#define SEEN_INK_SELECT_ONE_ACTION - -/* - * Authors: - * Tavmjong Bah <tavmjong@free.fr> - * - * Copyright (C) 2017 Tavmjong Bah - * - * Released under GNU GPL v2+, read the file 'COPYING' for more information. - */ - -/** - An action (menu/toolbar item) that allows selecting one choice out of many. - - The choices may be displayed as: - - 1. A group of items in a toolbar with labels and/or icons. - 2. As a drop-down menu with a labels and/or icons. -*/ - -#include <gtkmm/action.h> -#include <gtkmm/liststore.h> -#include <sigc++/sigc++.h> -#include <vector> - -namespace Gtk { -class ComboBox; -class RadioAction; -class MenuItem; -class RadioMenuItem; -} - -class InkSelectOneActionColumns : public Gtk::TreeModel::ColumnRecord { - -public: - InkSelectOneActionColumns() { - add (col_label); - add (col_icon); - add (col_pixbuf); - add (col_data); // Used to store a pointer - add (col_tooltip); - add (col_sensitive); - } - Gtk::TreeModelColumn<Glib::ustring> col_label; - Gtk::TreeModelColumn<Glib::ustring> col_icon; - Gtk::TreeModelColumn<Glib::RefPtr<Gdk::Pixbuf> > col_pixbuf; - Gtk::TreeModelColumn<void *> col_data; - Gtk::TreeModelColumn<Glib::ustring> col_tooltip; - Gtk::TreeModelColumn<bool> col_sensitive; -}; - - -class InkSelectOneAction : public Gtk::Action { - -public: - - static InkSelectOneAction* create(const Glib::ustring &name, - const Glib::ustring &label, - const Glib::ustring &tooltip, - const Glib::ustring &stock_id, - Glib::RefPtr<Gtk::ListStore> store ); - - /* Style of action */ - void use_radio( bool use_radio ) { _use_radio = use_radio; } - void use_label( bool use_label ) { _use_label = use_label; } - void use_icon( bool use_icon ) { _use_icon = use_icon; } - void use_pixbuf( bool use_pixbuf ) { _use_pixbuf = use_pixbuf; } - void use_group_label( bool use_group_label ) { _use_group_label = use_group_label; } - - gint get_active() { return _active; } - Glib::ustring get_active_text(); - void set_active( gint active ); - void set_icon_size( Gtk::BuiltinIconSize size ) { _icon_size = size; } - - Glib::RefPtr<Gtk::ListStore> get_store() { return _store; } - - sigc::signal<void, int> signal_changed() { return _changed; } - sigc::signal<void, int> signal_changed_after() { return _changed_after; } - -protected: - - Gtk::Widget* create_menu_item_vfunc() override; - Gtk::Widget* create_tool_item_vfunc() override; - - /* Signals */ - sigc::signal<void, int> _changed; - sigc::signal<void, int> _changed_after; // Needed for unit tracker which eats _changed. - -private: - - Glib::ustring _name; - Glib::ustring _group_label; - Glib::ustring _tooltip; - Glib::ustring _stock_id; - Glib::RefPtr<Gtk::ListStore> _store; - - gint _active; /* Active menu item/button */ - - /* Style */ - bool _use_radio; // Applies to tool item only - bool _use_label; - bool _use_icon; // Applies to menu item only - bool _use_pixbuf; - bool _use_group_label; // Applies to tool item only - Gtk::BuiltinIconSize _icon_size; - - /* Combobox in tool */ - Gtk::ComboBox* _combobox; - - /* Need to track one action to get active action. */ - Glib::RefPtr<Gtk::RadioAction> _radioaction; - - Gtk::MenuItem* _menuitem; - std::vector<Gtk::RadioMenuItem*> _radiomenuitems; - - /* Internal Callbacks */ - void on_changed_combobox(); - void on_changed_radioaction(const Glib::RefPtr<Gtk::RadioAction>& current); - void on_toggled_radiomenu(int n); - - InkSelectOneAction (const Glib::ustring &name, - const Glib::ustring &group_label, - const Glib::ustring &tooltip, - const Glib::ustring &stock_id, - Glib::RefPtr<Gtk::ListStore> store ); - -}; - - -#endif /* SEEN_INK_SELECT_ONE_ACTION */ - -/* - Local Variables: - mode:c++ - c-file-style:"stroustrup" - c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) - indent-tabs-mode:nil - fill-column:99 - End: -*/ -// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 : diff --git a/src/ui/widget/spin-button-tool-item.cpp b/src/ui/widget/spin-button-tool-item.cpp index f8c285344..e190d8dd2 100644 --- a/src/ui/widget/spin-button-tool-item.cpp +++ b/src/ui/widget/spin-button-tool-item.cpp @@ -3,6 +3,7 @@ #include "spin-button-tool-item.h" #include <gtkmm/box.h> +#include <gtkmm/image.h> #include <gtkmm/radiomenuitem.h> #include <gtkmm/toolbar.h> @@ -390,14 +391,28 @@ SpinButtonToolItem::SpinButtonToolItem(const Glib::ustring name, _btn->add_events(Gdk::KEY_PRESS_MASK); // Create a label - auto label = Gtk::manage(new Gtk::Label(label_text)); + _label = Gtk::manage(new Gtk::Label(label_text)); // Arrange the widgets in a horizontal box - auto hbox = Gtk::manage(new Gtk::Box()); - hbox->set_spacing(3); - hbox->pack_start(*label); - hbox->pack_start(*_btn); - add(*hbox); + _hbox = Gtk::manage(new Gtk::Box()); + _hbox->set_spacing(3); + _hbox->pack_start(*_label); + _hbox->pack_start(*_btn); + add(*_hbox); + show_all(); +} + +void +SpinButtonToolItem::set_icon(const Glib::ustring& icon_name) +{ + _hbox->remove(*_label); + _icon = Gtk::manage(new Gtk::Image(icon_name, Gtk::ICON_SIZE_SMALL_TOOLBAR)); + + if(_icon) { + _hbox->pack_start(*_icon); + _hbox->reorder_child(*_icon, 0); + } + show_all(); } diff --git a/src/ui/widget/spin-button-tool-item.h b/src/ui/widget/spin-button-tool-item.h index 1b33e8580..4386d4799 100644 --- a/src/ui/widget/spin-button-tool-item.h +++ b/src/ui/widget/spin-button-tool-item.h @@ -5,6 +5,7 @@ #include <gtkmm/toolitem.h> namespace Gtk { +class Box; class RadioButtonGroup; class RadioMenuItem; } @@ -29,6 +30,10 @@ private: double _last_val; ///< The last value of the adjustment bool _transfer_focus; ///< Whether or not to transfer focus + Gtk::Box *_hbox; ///< Horizontal box, to store widgets + Gtk::Widget *_label; ///< A text label to describe the setting + Gtk::Widget *_icon; ///< An icon to describe the setting + /** A widget that grabs focus when this one loses it */ Gtk::Widget * _focus_widget; @@ -72,6 +77,7 @@ public: void set_custom_numeric_menu_data(std::vector<double>& values, const std::vector<Glib::ustring>& labels = std::vector<Glib::ustring>()); Glib::RefPtr<Gtk::Adjustment> get_adjustment(); + void set_icon(const Glib::ustring& icon_name); }; } // namespace Widget } // namespace UI diff --git a/src/ui/widget/unit-tracker.cpp b/src/ui/widget/unit-tracker.cpp index 4abfaa9c8..0bdd3210a 100644 --- a/src/ui/widget/unit-tracker.cpp +++ b/src/ui/widget/unit-tracker.cpp @@ -19,7 +19,6 @@ #include "unit-tracker.h" -#include "ink-select-one-action.h" #include "combo-tool-item.h" #define COLUMN_STRING 0 @@ -41,7 +40,7 @@ UnitTracker::UnitTracker(UnitType unit_type) : { UnitTable::UnitMap m = unit_table.units(unit_type); - InkSelectOneActionColumns columns; + ComboToolItemColumns columns; _store = Gtk::ListStore::create(columns); Gtk::TreeModel::Row row; @@ -67,7 +66,6 @@ UnitTracker::UnitTracker(UnitType unit_type) : UnitTracker::~UnitTracker() { - _actionList.clear(); _combo_list.clear(); // Unhook weak references to GtkAdjustments @@ -91,7 +89,7 @@ void UnitTracker::setActiveUnit(Inkscape::Util::Unit const *unit) { if (unit) { - InkSelectOneActionColumns columns; + ComboToolItemColumns columns; int index = 0; for (auto& row: _store->children() ) { Glib::ustring storedUnit = row[columns.col_label]; @@ -122,7 +120,7 @@ void UnitTracker::addAdjustment(GtkAdjustment *adj) void UnitTracker::addUnit(Inkscape::Util::Unit const *u) { - InkSelectOneActionColumns columns; + ComboToolItemColumns columns; Gtk::TreeModel::Row row; row = *(_store->append()); @@ -134,7 +132,7 @@ void UnitTracker::addUnit(Inkscape::Util::Unit const *u) void UnitTracker::prependUnit(Inkscape::Util::Unit const *u) { - InkSelectOneActionColumns columns; + ComboToolItemColumns columns; Gtk::TreeModel::Row row; row = *(_store->prepend()); @@ -153,28 +151,6 @@ void UnitTracker::setFullVal(GtkAdjustment *adj, gdouble val) _priorValues[adj] = val; } -/** - * \deprecated Use create_tool_item instead - */ -InkSelectOneAction *UnitTracker::createAction(Glib::ustring const &name, - Glib::ustring const &label, - Glib::ustring const &tooltip) -{ - InkSelectOneAction* act = - InkSelectOneAction::create( name, label, tooltip, "NotUsed", _store); - - act->use_radio( false ); - act->use_label( true ); - act->use_icon( false ); - act->use_group_label( false ); - act->set_active( _active ); - - act->signal_changed().connect(sigc::mem_fun(*this, &UnitTracker::_unitChangedCB)); - _actionList.push_back(act); - - return act; -} - ComboToolItem * UnitTracker::create_tool_item(Glib::ustring const &label, Glib::ustring const &tooltip) @@ -192,14 +168,6 @@ void UnitTracker::_unitChangedCB(int active) _setActive(active); } -void UnitTracker::_actionFinalizedCB(gpointer data, GObject *where_the_object_was) -{ - if (data && where_the_object_was) { - UnitTracker *self = reinterpret_cast<UnitTracker *>(data); - self->_actionFinalized(where_the_object_was); - } -} - void UnitTracker::_adjustmentFinalizedCB(gpointer data, GObject *where_the_object_was) { if (data && where_the_object_was) { @@ -208,17 +176,6 @@ void UnitTracker::_adjustmentFinalizedCB(gpointer data, GObject *where_the_objec } } -void UnitTracker::_actionFinalized(GObject *where_the_object_was) -{ - InkSelectOneAction* act = (InkSelectOneAction*)(where_the_object_was); - auto it = std::find(_actionList.begin(),_actionList.end(), act); - if (it != _actionList.end()) { - _actionList.erase(it); - } else { - g_warning("Received a finalization callback for unknown object %p", where_the_object_was); - } -} - void UnitTracker::_adjustmentFinalized(GObject *where_the_object_was) { GtkAdjustment* adj = (GtkAdjustment*)(where_the_object_was); @@ -238,7 +195,7 @@ void UnitTracker::_setActive(gint active) if (_store) { // Find old and new units - InkSelectOneActionColumns columns; + ComboToolItemColumns columns; int index = 0; Glib::ustring oldAbbr( "NotFound" ); Glib::ustring newAbbr( "NotFound" ); @@ -274,10 +231,6 @@ void UnitTracker::_setActive(gint active) } _active = active; - for (auto act: _actionList) { - act->set_active (active); - } - for (auto combo : _combo_list) { if(combo) combo->set_active(active); } diff --git a/src/ui/widget/unit-tracker.h b/src/ui/widget/unit-tracker.h index c876d8224..1f16292ff 100644 --- a/src/ui/widget/unit-tracker.h +++ b/src/ui/widget/unit-tracker.h @@ -20,17 +20,13 @@ #include <vector> #include <gtkmm/liststore.h> -#include <gtkmm/action.h> #include "util/units.h" -class InkSelectOneAction; - using Inkscape::Util::Unit; using Inkscape::Util::UnitType; typedef struct _GObject GObject; -typedef struct _GtkAction GtkAction; typedef struct _GtkAdjustment GtkAdjustment; typedef struct _GtkListStore GtkListStore; @@ -55,10 +51,6 @@ public: void prependUnit(Inkscape::Util::Unit const *u); void setFullVal(GtkAdjustment *adj, gdouble val); - InkSelectOneAction *createAction(Glib::ustring const &name, - Glib::ustring const &label, - Glib::ustring const &tooltip); - ComboToolItem *create_tool_item(Glib::ustring const &label, Glib::ustring const &tooltip); @@ -68,14 +60,12 @@ protected: private: // Callbacks void _unitChangedCB(int active); - static void _actionFinalizedCB(gpointer data, GObject *where_the_object_was); static void _adjustmentFinalizedCB(gpointer data, GObject *where_the_object_was); void _setActive(gint index); void _fixupAdjustments(Inkscape::Util::Unit const *oldUnit, Inkscape::Util::Unit const *newUnit); // Cleanup - void _actionFinalized(GObject *where_the_object_was); void _adjustmentFinalized(GObject *where_the_object_was); gint _active; @@ -84,7 +74,6 @@ private: bool _activeUnitInitialized; Glib::RefPtr<Gtk::ListStore> _store; - std::vector<InkSelectOneAction*> _actionList; std::vector<ComboToolItem *> _combo_list; std::vector<GtkAdjustment*> _adjList; std::map <GtkAdjustment *, gdouble> _priorValues; |