From a474d31fbf1cadba254a237420bf3139b21ee7be Mon Sep 17 00:00:00 2001 From: Alex Valavanis Date: Sat, 20 Jun 2020 17:51:06 +0100 Subject: [PATCH 01/10] Rm explicit Gtk::Container return types and unused sp_search_by_value_recursive func --- src/live_effects/parameter/togglebutton.cpp | 2 +- src/ui/dialog/filedialogimpl-gtkmm.cpp | 2 +- src/ui/widget/dock-item.cpp | 2 +- src/ui/widget/dock.cpp | 2 +- src/widgets/desktop-widget.cpp | 10 ++++----- src/widgets/spw-utilities.cpp | 23 --------------------- src/widgets/spw-utilities.h | 1 - 7 files changed, 9 insertions(+), 33 deletions(-) diff --git a/src/live_effects/parameter/togglebutton.cpp b/src/live_effects/parameter/togglebutton.cpp index 4cd2927f07..75ab6a8377 100644 --- a/src/live_effects/parameter/togglebutton.cpp +++ b/src/live_effects/parameter/togglebutton.cpp @@ -149,7 +149,7 @@ ToggleButtonParam::refresh_button() if(!checkwdg){ return; } - Gtk::Container *box_button = dynamic_cast(checkwdg->get_child()); + auto box_button = dynamic_cast(checkwdg->get_child()); if(!box_button){ return; } diff --git a/src/ui/dialog/filedialogimpl-gtkmm.cpp b/src/ui/dialog/filedialogimpl-gtkmm.cpp index 5d205c94d8..7fe0348bd8 100644 --- a/src/ui/dialog/filedialogimpl-gtkmm.cpp +++ b/src/ui/dialog/filedialogimpl-gtkmm.cpp @@ -528,7 +528,7 @@ FileSaveDialogImplGtk::FileSaveDialogImplGtk(Gtk::Window &parentWindow, const Gl // Let's do some customization fileNameEntry = nullptr; - Gtk::Container *cont = get_toplevel(); + auto cont = get_toplevel(); std::vector entries; findEntryWidgets(cont, entries); // g_message("Found %d entry widgets\n", entries.size()); diff --git a/src/ui/widget/dock-item.cpp b/src/ui/widget/dock-item.cpp index db803d80e1..732804c5c4 100644 --- a/src/ui/widget/dock-item.cpp +++ b/src/ui/widget/dock-item.cpp @@ -461,7 +461,7 @@ Gtk::Window * DockItem::getWindow() { g_return_val_if_fail(_gdl_dock_item, 0); - Gtk::Container *parent = getWidget().get_parent(); + auto parent = getWidget().get_parent(); parent = (parent ? parent->get_parent() : nullptr); return (parent ? dynamic_cast(parent) : nullptr); } diff --git a/src/ui/widget/dock.cpp b/src/ui/widget/dock.cpp index 3aba481ec3..a564dc2b5f 100644 --- a/src/ui/widget/dock.cpp +++ b/src/ui/widget/dock.cpp @@ -155,7 +155,7 @@ Gtk::Widget &Dock::getWidget() Gtk::Paned *Dock::getParentPaned() { g_return_val_if_fail(_dock_box, 0); - Gtk::Container *parent = getWidget().get_parent(); + auto parent = getWidget().get_parent(); return (parent != nullptr ? dynamic_cast(parent) : nullptr); } diff --git a/src/widgets/desktop-widget.cpp b/src/widgets/desktop-widget.cpp index 408961cd05..e9fad15939 100644 --- a/src/widgets/desktop-widget.cpp +++ b/src/widgets/desktop-widget.cpp @@ -647,7 +647,7 @@ void SPDesktopWidget::on_realize() gchar *gtkThemeName; gboolean gtkApplicationPreferDarkTheme; GtkSettings *settings = gtk_settings_get_default(); - Gtk::Container *window = get_toplevel(); + auto window = get_toplevel(); if (settings && window) { g_object_get(settings, "gtk-theme-name", >kThemeName, NULL); g_object_get(settings, "gtk-application-prefer-dark-theme", >kApplicationPreferDarkTheme, NULL); @@ -887,7 +887,7 @@ SPDesktopWidget::shutdown() dialog.property_destroy_with_parent() = true; // fix for bug lp:168809 - Gtk::Container *ma = dialog.get_message_area(); + auto ma = dialog.get_message_area(); std::vector ma_labels = ma->get_children(); ma_labels[0]->set_can_focus(false); @@ -931,7 +931,7 @@ SPDesktopWidget::shutdown() dialog.property_destroy_with_parent() = true; // fix for bug lp:168809 - Gtk::Container *ma = dialog.get_message_area(); + auto ma = dialog.get_message_area(); std::vector ma_labels = ma->get_children(); ma_labels[0]->set_can_focus(false); @@ -1482,8 +1482,8 @@ void SPDesktopWidget::namedviewModified(SPObject *obj, guint flags) _canvas_grid->UpdateRulers(); /* This loops through all the grandchildren of aux toolbox, - * and for each that it finds, it performs an sp_search_by_data_recursive(), - * looking for widgets that hold some "tracker" data (this is used by + * and for each that it finds, it performs an sp_search_by_name_recursive(), + * looking for widgets that hold a widget named "unit-tracker" (this is used by * all toolboxes to refer to the unit selector). The default document units * is then selected within these unit selectors. * diff --git a/src/widgets/spw-utilities.cpp b/src/widgets/spw-utilities.cpp index 38759ef26e..fee89d77cb 100644 --- a/src/widgets/spw-utilities.cpp +++ b/src/widgets/spw-utilities.cpp @@ -125,29 +125,6 @@ sp_search_by_name_recursive(Gtk::Widget *parent, const Glib::ustring& name) return nullptr; } -/** - * Returns the descendant of w which has the given key and value pair, or NULL if there's none. - */ -GtkWidget *sp_search_by_value_recursive(GtkWidget *w, gchar *key, gchar *value) -{ - gchar *r = nullptr; - - if (w && G_IS_OBJECT(w)) { - r = (gchar *) g_object_get_data(G_OBJECT(w), key); - } - if (r && !strcmp (r, value)) return w; - - if (GTK_IS_CONTAINER(w)) { - std::vector children = Glib::wrap(GTK_CONTAINER(w))->get_children(); - for (auto i:children) { - GtkWidget *child = sp_search_by_value_recursive(GTK_WIDGET(i->gobj()), key, value); - if (child) return child; - } - } - - return nullptr; -} - /* Local Variables: mode:c++ diff --git a/src/widgets/spw-utilities.h b/src/widgets/spw-utilities.h index eae547772d..c6d647367c 100644 --- a/src/widgets/spw-utilities.h +++ b/src/widgets/spw-utilities.h @@ -34,7 +34,6 @@ Gtk::Label * spw_label(Gtk::Grid *table, gchar const *label_text, int col, int r Gtk::HBox * spw_hbox(Gtk::Grid *table, int width, int col, int row); gpointer sp_search_by_data_recursive(GtkWidget *w, gpointer data); -GtkWidget *sp_search_by_value_recursive(GtkWidget *w, gchar *key, gchar *value); Gtk::Widget * sp_search_by_name_recursive(Gtk::Widget *parent, const Glib::ustring& name); -- GitLab From 08abc4f757a0a822d1c7327cfdc15147013282ea Mon Sep 17 00:00:00 2001 From: Alex Valavanis Date: Sat, 20 Jun 2020 19:17:41 +0100 Subject: [PATCH 02/10] ColorNotebook: Gtkmmify --- src/ui/widget/color-notebook.cpp | 196 ++++++++++++++----------------- src/ui/widget/color-notebook.h | 30 +++-- src/ui/widget/paint-selector.cpp | 10 +- 3 files changed, 116 insertions(+), 120 deletions(-) diff --git a/src/ui/widget/color-notebook.cpp b/src/ui/widget/color-notebook.cpp index 474b4d2877..a4a2cde468 100644 --- a/src/ui/widget/color-notebook.cpp +++ b/src/ui/widget/color-notebook.cpp @@ -19,6 +19,7 @@ #define noDUMP_CHANGE_INFO #include +#include #include #include #include @@ -84,14 +85,6 @@ ColorNotebook::ColorNotebook(SelectedColor &color) _selected_color.signal_dragged.connect(sigc::mem_fun(this, &ColorNotebook::_onSelectedColorChanged)); } -ColorNotebook::~ColorNotebook() -{ - if (_buttons) { - delete[] _buttons; - _buttons = nullptr; - } -} - ColorNotebook::Page::Page(Inkscape::UI::ColorSelectorFactory *selector_factory, bool enabled_full) : selector_factory(selector_factory) , enabled_full(enabled_full) @@ -103,103 +96,100 @@ void ColorNotebook::_initUI() { guint row = 0; - Gtk::Notebook *notebook = Gtk::manage(new Gtk::Notebook); - notebook->show(); - notebook->set_show_border(false); - notebook->set_show_tabs(false); - _book = GTK_WIDGET(notebook->gobj()); + _book = Gtk::make_managed(); + _book->show(); + _book->set_show_border(false); + _book->set_show_tabs(false); - _buttonbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); - gtk_box_set_homogeneous(GTK_BOX(_buttonbox), TRUE); + _buttonbox = Gtk::make_managed(Gtk::ORIENTATION_HORIZONTAL, 2); + _buttonbox->set_homogeneous(true); - gtk_widget_show(_buttonbox); - _buttons = new GtkWidget *[_available_pages.size()]; + _buttonbox->show(); for (int i = 0; static_cast(i) < _available_pages.size(); i++) { _addPage(_available_pages[i]); } - gtk_widget_set_margin_start(_buttonbox, XPAD); - gtk_widget_set_margin_end(_buttonbox, XPAD); - gtk_widget_set_margin_top(_buttonbox, YPAD); - gtk_widget_set_margin_bottom(_buttonbox, YPAD); - gtk_widget_set_hexpand(_buttonbox, TRUE); - gtk_widget_set_valign(_buttonbox, GTK_ALIGN_CENTER); - attach(*Glib::wrap(_buttonbox), 0, row, 2, 1); + _buttonbox->set_margin_start( XPAD); + _buttonbox->set_margin_end( XPAD); + _buttonbox->set_margin_top( YPAD); + _buttonbox->set_margin_bottom(YPAD); + _buttonbox->set_hexpand(true); + _buttonbox->set_valign(Gtk::ALIGN_CENTER); + attach(*_buttonbox, 0, row, 2, 1); row++; - gtk_widget_set_margin_start(_book, XPAD * 2); - gtk_widget_set_margin_end(_book, XPAD * 2); - gtk_widget_set_margin_top(_book, YPAD); - gtk_widget_set_margin_bottom(_book, YPAD); - gtk_widget_set_hexpand(_book, TRUE); - gtk_widget_set_vexpand(_book, TRUE); - attach(*notebook, 0, row, 2, 1); + _book->set_margin_start( XPAD * 2); + _book->set_margin_end( XPAD * 2); + _book->set_margin_top( YPAD); + _book->set_margin_bottom(YPAD); + _book->set_hexpand(true); + _book->set_vexpand(true); + attach(*_book, 0, row, 2, 1); // restore the last active page Inkscape::Preferences *prefs = Inkscape::Preferences::get(); _setCurrentPage(prefs->getInt("/colorselector/page", 0)); row++; - GtkWidget *rgbabox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); + auto rgbabox = Gtk::make_managed(Gtk::ORIENTATION_HORIZONTAL, 0); #if defined(HAVE_LIBLCMS2) /* Create color management icons */ - _box_colormanaged = gtk_event_box_new(); - GtkWidget *colormanaged = sp_get_icon_image("color-management", GTK_ICON_SIZE_SMALL_TOOLBAR); - gtk_container_add(GTK_CONTAINER(_box_colormanaged), colormanaged); - gtk_widget_set_tooltip_text(_box_colormanaged, _("Color Managed")); - gtk_widget_set_sensitive(_box_colormanaged, false); - gtk_box_pack_start(GTK_BOX(rgbabox), _box_colormanaged, FALSE, FALSE, 2); - - _box_outofgamut = gtk_event_box_new(); - GtkWidget *outofgamut = sp_get_icon_image("out-of-gamut-icon", GTK_ICON_SIZE_SMALL_TOOLBAR); - gtk_container_add(GTK_CONTAINER(_box_outofgamut), outofgamut); - gtk_widget_set_tooltip_text(_box_outofgamut, _("Out of gamut!")); - gtk_widget_set_sensitive(_box_outofgamut, false); - gtk_box_pack_start(GTK_BOX(rgbabox), _box_outofgamut, FALSE, FALSE, 2); - - _box_toomuchink = gtk_event_box_new(); - GtkWidget *toomuchink = sp_get_icon_image("too-much-ink-icon", GTK_ICON_SIZE_SMALL_TOOLBAR); - gtk_container_add(GTK_CONTAINER(_box_toomuchink), toomuchink); - gtk_widget_set_tooltip_text(_box_toomuchink, _("Too much ink!")); - gtk_widget_set_sensitive(_box_toomuchink, false); - gtk_box_pack_start(GTK_BOX(rgbabox), _box_toomuchink, FALSE, FALSE, 2); + _box_colormanaged = Gtk::make_managed(); + auto colormanaged = Glib::wrap(sp_get_icon_image("color-management", GTK_ICON_SIZE_SMALL_TOOLBAR)); + _box_colormanaged->add(*colormanaged); + _box_colormanaged->set_tooltip_text(_("Color Managed")); + _box_colormanaged->set_sensitive(false); + rgbabox->pack_start(*_box_colormanaged, false, false, 2); + + _box_outofgamut = Gtk::make_managed(); + auto outofgamut = Glib::wrap(sp_get_icon_image("out-of-gamut-icon", GTK_ICON_SIZE_SMALL_TOOLBAR)); + _box_outofgamut->add(*outofgamut); + _box_outofgamut->set_tooltip_text(_("Out of gamut!")); + _box_outofgamut->set_sensitive(false); + rgbabox->pack_start(*_box_outofgamut, false, false, 2); + + _box_toomuchink = Gtk::make_managed(); + auto toomuchink = Glib::wrap(sp_get_icon_image("too-much-ink-icon", GTK_ICON_SIZE_SMALL_TOOLBAR)); + _box_toomuchink->add(*toomuchink); + _box_toomuchink->set_tooltip_text(_("Too much ink!")); + _box_toomuchink->set_sensitive(false); + rgbabox->pack_start(*_box_toomuchink, false, false, 2); #endif // defined(HAVE_LIBLCMS2) - /* Color picker */ - GtkWidget *picker = sp_get_icon_image("color-picker", GTK_ICON_SIZE_SMALL_TOOLBAR); - _btn_picker = gtk_button_new(); - gtk_button_set_relief(GTK_BUTTON(_btn_picker), GTK_RELIEF_NONE); - gtk_container_add(GTK_CONTAINER(_btn_picker), picker); - gtk_widget_set_tooltip_text(_btn_picker, _("Pick colors from image")); - gtk_box_pack_start(GTK_BOX(rgbabox), _btn_picker, FALSE, FALSE, 2); - g_signal_connect(G_OBJECT(_btn_picker), "clicked", G_CALLBACK(ColorNotebook::_onPickerClicked), this); + auto picker = Glib::wrap(sp_get_icon_image("color-picker", GTK_ICON_SIZE_SMALL_TOOLBAR)); + _btn_picker = Gtk::make_managed(); + _btn_picker->set_relief(Gtk::RELIEF_NONE); + _btn_picker->add(*picker); + _btn_picker->set_tooltip_text(_("Pick colors from image")); + rgbabox->pack_start(*_btn_picker, false, false, 2); + _btn_picker->signal_clicked().connect(sigc::mem_fun(*this, &ColorNotebook::_onPickerClicked)); /* Create RGBA entry and color preview */ - _rgbal = gtk_label_new_with_mnemonic(_("RGBA_:")); - gtk_widget_set_halign(_rgbal, GTK_ALIGN_END); - gtk_box_pack_start(GTK_BOX(rgbabox), _rgbal, TRUE, TRUE, 2); + _rgbal = Gtk::make_managed(_("RGBA_:"), true); + _rgbal->set_halign(Gtk::ALIGN_END); + rgbabox->pack_start(*_rgbal, true, true, 2); - ColorEntry *rgba_entry = Gtk::manage(new ColorEntry(_selected_color)); + auto rgba_entry = Gtk::make_managed(_selected_color); sp_dialog_defocus_on_enter(GTK_WIDGET(rgba_entry->gobj())); - gtk_box_pack_start(GTK_BOX(rgbabox), GTK_WIDGET(rgba_entry->gobj()), FALSE, FALSE, 0); - gtk_label_set_mnemonic_widget(GTK_LABEL(_rgbal), GTK_WIDGET(rgba_entry->gobj())); + rgbabox->pack_start(*rgba_entry, false, false, 0); + _rgbal->set_mnemonic_widget(*rgba_entry); - gtk_widget_show_all(rgbabox); + rgbabox->show_all(); #if defined(HAVE_LIBLCMS2) // the "too much ink" icon is initially hidden - gtk_widget_hide(GTK_WIDGET(_box_toomuchink)); + _box_toomuchink->hide(); #endif // defined(HAVE_LIBLCMS2) - gtk_widget_set_margin_start(rgbabox, XPAD); - gtk_widget_set_margin_end(rgbabox, XPAD); - gtk_widget_set_margin_top(rgbabox, YPAD); - gtk_widget_set_margin_bottom(rgbabox, YPAD); - attach(*Glib::wrap(rgbabox), 0, row, 2, 1); + rgbabox->set_margin_start( XPAD); + rgbabox->set_margin_end( XPAD); + rgbabox->set_margin_top( YPAD); + rgbabox->set_margin_bottom(YPAD); + attach(*rgbabox, 0, row, 2, 1); #ifdef SPCS_PREVIEW _p = sp_color_preview_new(0xffffffff); @@ -207,10 +197,10 @@ void ColorNotebook::_initUI() attach(*Glib::wrap(_p), 2, 3, row, row + 1, Gtk::FILL, Gtk::FILL, XPAD, YPAD); #endif - g_signal_connect(G_OBJECT(_book), "switch-page", G_CALLBACK(ColorNotebook::_onPageSwitched), this); + _book->signal_switch_page().connect(sigc::mem_fun(this, &ColorNotebook::_onPageSwitched)); } -void ColorNotebook::_onPickerClicked(GtkWidget * /*widget*/, ColorNotebook * /*colorbook*/) +void ColorNotebook::_onPickerClicked() { // Set the dropper into a "one click" mode, so it reverts to the previous tool after a click Inkscape::Preferences *prefs = Inkscape::Preferences::get(); @@ -218,24 +208,20 @@ void ColorNotebook::_onPickerClicked(GtkWidget * /*widget*/, ColorNotebook * /*c Inkscape::UI::Tools::sp_toggle_dropper(SP_ACTIVE_DESKTOP); } -void ColorNotebook::_onButtonClicked(GtkWidget *widget, ColorNotebook *nb) +void ColorNotebook::_onButtonClicked(int page_num) { - if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) { + if (!_buttons[page_num]->get_active()) { return; } - for (gint i = 0; i < gtk_notebook_get_n_pages(GTK_NOTEBOOK(nb->_book)); i++) { - if (nb->_buttons[i] == widget) { - gtk_notebook_set_current_page(GTK_NOTEBOOK(nb->_book), i); - } - } + _book->set_current_page(page_num); } void ColorNotebook::_onSelectedColorChanged() { _updateICCButtons(); } -void ColorNotebook::_onPageSwitched(GtkNotebook *notebook, GtkWidget *page, guint page_num, ColorNotebook *colorbook) +void ColorNotebook::_onPageSwitched(Gtk::Widget *page, guint page_num) { - if (colorbook->get_visible()) { + if (get_visible()) { // remember the page we switched to Inkscape::Preferences *prefs = Inkscape::Preferences::get(); prefs->setInt("/colorselector/page", page_num); @@ -253,23 +239,24 @@ void ColorNotebook::_updateICCButtons() #if defined(HAVE_LIBLCMS2) /* update color management icon*/ - gtk_widget_set_sensitive(_box_colormanaged, color.icc != nullptr); + _box_colormanaged->set_sensitive(color.icc != nullptr); /* update out-of-gamut icon */ - gtk_widget_set_sensitive(_box_outofgamut, false); + _box_outofgamut->set_sensitive(false); if (color.icc) { Inkscape::ColorProfile *target_profile = SP_ACTIVE_DOCUMENT->getProfileManager()->find(color.icc->colorProfile.c_str()); - if (target_profile) - gtk_widget_set_sensitive(_box_outofgamut, target_profile->GamutCheck(color)); + if (target_profile) { + _box_outofgamut->set_sensitive(target_profile->GamutCheck(color)); + } } /* update too-much-ink icon */ - gtk_widget_set_sensitive(_box_toomuchink, false); + _box_toomuchink->set_sensitive(false); if (color.icc) { Inkscape::ColorProfile *prof = SP_ACTIVE_DOCUMENT->getProfileManager()->find(color.icc->colorProfile.c_str()); if (prof && CMSSystem::isPrintColorSpace(prof)) { - gtk_widget_show(GTK_WIDGET(_box_toomuchink)); + _box_toomuchink->show(); double ink_sum = 0; for (double i : color.icc->colors) { ink_sum += i; @@ -280,11 +267,10 @@ void ColorNotebook::_updateICCButtons() which means the paper can get too wet due to an excessive amount of ink. This may lead to several issues such as misalignment and poor quality of printing in general.*/ - if (ink_sum > 3.2) - gtk_widget_set_sensitive(_box_toomuchink, true); + if (ink_sum > 3.2) _box_toomuchink->set_sensitive(true); } else { - gtk_widget_hide(GTK_WIDGET(_box_toomuchink)); + _box_toomuchink->hide(); } } #endif // defined(HAVE_LIBLCMS2) @@ -292,10 +278,10 @@ void ColorNotebook::_updateICCButtons() void ColorNotebook::_setCurrentPage(int i) { - gtk_notebook_set_current_page(GTK_NOTEBOOK(_book), i); + _book->set_current_page(i); - if (_buttons && (static_cast(i) < _available_pages.size())) { - gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_buttons[i]), TRUE); + if (!_buttons.empty() && (static_cast(i) < _available_pages.size())) { + _buttons[i]->set_active(true); } } @@ -310,19 +296,19 @@ void ColorNotebook::_addPage(Page &page) Glib::ustring mode_name = page.selector_factory->modeName(); Gtk::Widget *tab_label = Gtk::manage(new Gtk::Label(mode_name)); tab_label->set_name("ColorModeLabel"); - gint page_num = gtk_notebook_append_page(GTK_NOTEBOOK(_book), selector_widget->gobj(), tab_label->gobj()); + auto page_num = _book->append_page(*selector_widget, *tab_label); - _buttons[page_num] = gtk_radio_button_new_with_label(nullptr, mode_name.c_str()); - gtk_widget_set_name(_buttons[page_num], "ColorModeButton"); - gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(_buttons[page_num]), FALSE); + _buttons.push_back(Gtk::make_managed(mode_name)); + _buttons[page_num]->set_name("ColorModeButton"); + _buttons[page_num]->set_mode(false); if (page_num > 0) { - auto g = Glib::wrap(GTK_RADIO_BUTTON(_buttons[0]))->get_group(); - Glib::wrap(GTK_RADIO_BUTTON(_buttons[page_num]))->set_group(g); + auto g = _buttons[0]->get_group(); + _buttons[page_num]->set_group(g); } - gtk_widget_show(_buttons[page_num]); - gtk_box_pack_start(GTK_BOX(_buttonbox), _buttons[page_num], TRUE, TRUE, 0); + _buttons[page_num]->show(); + _buttonbox->pack_start(*_buttons[page_num], true, true, 0); - g_signal_connect(G_OBJECT(_buttons[page_num]), "clicked", G_CALLBACK(_onButtonClicked), this); + _buttons[page_num]->signal_clicked().connect(sigc::bind(sigc::mem_fun(this, &ColorNotebook::_onButtonClicked), page_num)); } } } diff --git a/src/ui/widget/color-notebook.h b/src/ui/widget/color-notebook.h index c7bc7b56b7..72e4d961dd 100644 --- a/src/ui/widget/color-notebook.h +++ b/src/ui/widget/color-notebook.h @@ -24,6 +24,15 @@ #include "color.h" #include "ui/selected-color.h" +namespace Gtk { + class Box; + class Button; + class EventBox; + class Label; + class Notebook; + class RadioButton; +} + namespace Inkscape { namespace UI { namespace Widget { @@ -33,7 +42,6 @@ class ColorNotebook { public: ColorNotebook(SelectedColor &color); - ~ColorNotebook() override; protected: struct Page { @@ -46,9 +54,9 @@ protected: virtual void _initUI(); void _addPage(Page &page); - static void _onButtonClicked(GtkWidget *widget, ColorNotebook *colorbook); - static void _onPickerClicked(GtkWidget *widget, ColorNotebook *colorbook); - static void _onPageSwitched(GtkNotebook *notebook, GtkWidget *page, guint page_num, ColorNotebook *colorbook); + void _onButtonClicked(int page_num); + void _onPickerClicked(); + void _onPageSwitched(Gtk::Widget *page, guint page_num); virtual void _onSelectedColorChanged(); void _updateICCButtons(); @@ -56,14 +64,16 @@ protected: Inkscape::UI::SelectedColor &_selected_color; gulong _entryId; - GtkWidget *_book; - GtkWidget *_buttonbox; - GtkWidget **_buttons; - GtkWidget *_rgbal; /* RGBA entry */ + Gtk::Notebook *_book; + Gtk::Box *_buttonbox; + std::vector _buttons; + Gtk::Label *_rgbal; /* RGBA entry */ #if defined(HAVE_LIBLCMS2) - GtkWidget *_box_outofgamut, *_box_colormanaged, *_box_toomuchink; + Gtk::EventBox *_box_outofgamut; + Gtk::EventBox *_box_colormanaged; + Gtk::EventBox *_box_toomuchink; #endif // defined(HAVE_LIBLCMS2) - GtkWidget *_btn_picker; + Gtk::Button *_btn_picker; GtkWidget *_p; /* Color preview */ boost::ptr_vector _available_pages; diff --git a/src/ui/widget/paint-selector.cpp b/src/ui/widget/paint-selector.cpp index 7c9875bfcd..4c5885fd06 100644 --- a/src/ui/widget/paint-selector.cpp +++ b/src/ui/widget/paint-selector.cpp @@ -172,15 +172,15 @@ PaintSelector::PaintSelector(FillOrStroke kind) _fillrulebox->set_homogeneous(false); _style->pack_end(*_fillrulebox, false, false, 0); - _evenodd = Gtk::manage(new FillRuleRadioButton()); + _evenodd = Gtk::make_managed(); _evenodd->set_relief(Gtk::RELIEF_NONE); _evenodd->set_mode(false); // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty _evenodd->set_tooltip_text( _("Any path self-intersections or subpaths create holes in the fill (fill-rule: evenodd)")); _evenodd->set_fillrule(PaintSelector::FILLRULE_EVENODD); - auto w = sp_get_icon_image("fill-rule-even-odd", GTK_ICON_SIZE_MENU); - gtk_container_add(GTK_CONTAINER(_evenodd->gobj()), w); + auto w = Glib::wrap(sp_get_icon_image("fill-rule-even-odd", GTK_ICON_SIZE_MENU)); + _evenodd->add(*w); _fillrulebox->pack_start(*_evenodd, false, false, 0); _evenodd->signal_toggled().connect( sigc::bind(sigc::mem_fun(*this, &PaintSelector::fillrule_toggled), _evenodd)); @@ -192,8 +192,8 @@ PaintSelector::PaintSelector(FillOrStroke kind) // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty _nonzero->set_tooltip_text(_("Fill is solid unless a subpath is counterdirectional (fill-rule: nonzero)")); _nonzero->set_fillrule(PaintSelector::FILLRULE_NONZERO); - w = sp_get_icon_image("fill-rule-nonzero", GTK_ICON_SIZE_MENU); - gtk_container_add(GTK_CONTAINER(_nonzero->gobj()), w); + w = Glib::wrap(sp_get_icon_image("fill-rule-nonzero", GTK_ICON_SIZE_MENU)); + _nonzero->add(*w); _fillrulebox->pack_start(*_nonzero, false, false, 0); _nonzero->signal_toggled().connect( sigc::bind(sigc::mem_fun(*this, &PaintSelector::fillrule_toggled), _nonzero)); -- GitLab From 71b214ecf448573d833f9d143d27e8b5476ce164 Mon Sep 17 00:00:00 2001 From: Alex Valavanis Date: Sun, 21 Jun 2020 21:53:52 +0100 Subject: [PATCH 03/10] PaintSelector: Gtkmmify --- src/ui/widget/paint-selector.cpp | 365 +++++++++++++------------------ src/ui/widget/paint-selector.h | 79 +++++-- 2 files changed, 212 insertions(+), 232 deletions(-) diff --git a/src/ui/widget/paint-selector.cpp b/src/ui/widget/paint-selector.cpp index 4c5885fd06..bdc4fd322e 100644 --- a/src/ui/widget/paint-selector.cpp +++ b/src/ui/widget/paint-selector.cpp @@ -58,6 +58,7 @@ #include "svg/svg-icc-color.h" #endif // SP_PS_VERBOSE +#include #include using Inkscape::UI::SelectedColor; @@ -210,7 +211,6 @@ PaintSelector::PaintSelector(FillOrStroke kind) _frame = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL)); _frame->set_homogeneous(false); _frame->show(); - // gtk_container_set_border_width(GTK_CONTAINER(psel->frame), 0); pack_start(*_frame, true, true, 0); @@ -242,8 +242,6 @@ PaintSelector::~PaintSelector() StyleToggleButton *PaintSelector::style_button_add(gchar const *pixmap, PaintSelector::Mode mode, gchar const *tip) { - GtkWidget *w; - auto b = Gtk::manage(new StyleToggleButton()); b->set_tooltip_text(tip); b->show(); @@ -252,8 +250,8 @@ StyleToggleButton *PaintSelector::style_button_add(gchar const *pixmap, PaintSel b->set_mode(false); b->set_style(mode); - w = sp_get_icon_image(pixmap, GTK_ICON_SIZE_BUTTON); - gtk_container_add(GTK_CONTAINER(b->gobj()), w); + auto w = Glib::wrap(sp_get_icon_image(pixmap, GTK_ICON_SIZE_BUTTON)); + b->add(*w); _style->pack_start(*b, false, false); b->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &PaintSelector::style_button_toggled), b)); @@ -478,7 +476,6 @@ void PaintSelector::clear_frame() // The widget is hidden first so it can recognize that it should not process signals from notebook child _selector->set_visible(false); remove(*_selector); - // gtk_widget_destroy(_selector); //_selector = nullptr; } } @@ -652,15 +649,11 @@ void PaintSelector::set_mode_gradient(PaintSelector::Mode mode) // ************************* MESH ************************ #ifdef WITH_MESH -void PaintSelector::mesh_destroy(GtkWidget *widget, PaintSelector * /*psel*/) +void PaintSelector::mesh_change() { - // drop our reference to the mesh menu widget - g_object_unref(G_OBJECT(widget)); + _signal_changed.emit(); } -void PaintSelector::mesh_change(GtkWidget * /*widget*/, PaintSelector *psel) { psel->_signal_changed.emit(); } - - /** * Returns a list of meshes in the defs of the given source document as a vector */ @@ -684,28 +677,27 @@ static std::vector ink_mesh_list_get(SPDocument *source) /** * Adds menu items for mesh list. */ -static void sp_mesh_menu_build(GtkWidget *combo, std::vector &mesh_list, SPDocument * /*source*/) +void PaintSelector::mesh_menu_build(std::vector &mesh_list, SPDocument * /*source*/) { - GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(combo))); - GtkTreeIter iter; - for (auto i : mesh_list) { - Inkscape::XML::Node *repr = i->getRepr(); gchar const *meshid = repr->attribute("id"); gchar const *label = meshid; // Only relevant if we supply a set of canned meshes. - gboolean stockid = false; + bool stockid = false; if (repr->attribute("inkscape:stockid")) { label = _(repr->attribute("inkscape:stockid")); stockid = true; } - gtk_list_store_append(store, &iter); - gtk_list_store_set(store, &iter, COMBO_COL_LABEL, label, COMBO_COL_STOCK, stockid, COMBO_COL_MESH, meshid, - COMBO_COL_SEP, FALSE, -1); + auto iter = _mesh_tree_model->append(); + auto row = *iter; + row[_mesh_cols._col_label] = label; + row[_mesh_cols._col_stock] = stockid; + row[_mesh_cols._col_mesh] = meshid; + row[_mesh_cols._col_sep] = false; } } @@ -713,15 +705,14 @@ static void sp_mesh_menu_build(GtkWidget *combo, std::vector & * Pick up all meshes from source, except those that are in * current_doc (if non-NULL), and add items to the mesh menu. */ -static void sp_mesh_list_from_doc(GtkWidget *combo, SPDocument * /*current_doc*/, SPDocument *source, - SPDocument * /*mesh_doc*/) +void PaintSelector::mesh_list_from_doc(SPDocument *source, SPDocument * /* mesh_doc */) { - std::vector pl = ink_mesh_list_get(source); - sp_mesh_menu_build(combo, pl, source); + auto pl = ink_mesh_list_get(source); + mesh_menu_build(pl, source); } -static void ink_mesh_menu_populate_menu(GtkWidget *combo, SPDocument *doc) +void PaintSelector::ink_mesh_menu_populate_menu(SPDocument *doc) { static SPDocument *meshes_doc = nullptr; @@ -737,56 +728,53 @@ static void ink_mesh_menu_populate_menu(GtkWidget *combo, SPDocument *doc) // } // suck in from current doc - sp_mesh_list_from_doc(combo, nullptr, doc, meshes_doc); + mesh_list_from_doc(doc, meshes_doc); // add separator // { - // GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(combo))); - // GtkTreeIter iter; - // gtk_list_store_append (store, &iter); - // gtk_list_store_set(store, &iter, - // COMBO_COL_LABEL, "", COMBO_COL_STOCK, false, COMBO_COL_MESH, "", COMBO_COL_SEP, true, -1); + // auto iter = _mesh_tree_model->append(); + // (*iter)[_mesh_cols._col_label] = ""; + // (*iter)[_mesh_cols._col_stock] = false; + // (*iter)[_mesh_cols._col_mesh] = ""; + // (*iter)[_mesh_cols._col_sep] = true; // } // suck in from meshes.svg // if (meshes_doc) { // doc->ensureUpToDate(); - // sp_mesh_list_from_doc ( combo, doc, meshes_doc, NULL ); + // mesh_list_from_doc(doc, meshes_doc); // } } -static GtkWidget *ink_mesh_menu(GtkWidget *combo) +void PaintSelector::ink_mesh_menu() { SPDocument *doc = SP_ACTIVE_DOCUMENT; - GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(combo))); - GtkTreeIter iter; - if (!doc) { - - gtk_list_store_append(store, &iter); - gtk_list_store_set(store, &iter, COMBO_COL_LABEL, _("No document selected"), COMBO_COL_STOCK, false, - COMBO_COL_MESH, "", COMBO_COL_SEP, false, -1); - gtk_widget_set_sensitive(combo, FALSE); - + auto iter = _mesh_tree_model->append(); + auto row = *iter; + row[_mesh_cols._col_label] = _("No document selected"); + row[_mesh_cols._col_stock] = false; + row[_mesh_cols._col_mesh] = ""; + row[_mesh_cols._col_sep] = false; + _meshmenu->set_sensitive(false); } else { - - ink_mesh_menu_populate_menu(combo, doc); - gtk_widget_set_sensitive(combo, TRUE); + ink_mesh_menu_populate_menu(doc); + _meshmenu->set_sensitive(true); } - // Select the first item that is not a separator - if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter)) { - gboolean sep = false; - gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, COMBO_COL_SEP, &sep, -1); + if (!_mesh_tree_model->children().empty()) { + // Select the first item that is not a separator + auto iter = _mesh_tree_model->children().begin(); + auto row = *iter; + auto sep = row[_mesh_cols._col_sep]; if (sep) { - gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter); + ++iter; } - gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo), &iter); - } - return combo; + _meshmenu->set_active(iter); + } } @@ -800,10 +788,9 @@ void PaintSelector::updateMeshList(SPMeshGradient *mesh) g_assert(_meshmenu != nullptr); /* Clear existing menu if any */ - GtkTreeModel *store = gtk_combo_box_get_model(GTK_COMBO_BOX(_meshmenu)); - gtk_list_store_clear(GTK_LIST_STORE(store)); + _mesh_tree_model->clear(); - ink_mesh_menu(_meshmenu); + ink_mesh_menu(); /* Set history */ @@ -812,26 +799,21 @@ void PaintSelector::updateMeshList(SPMeshGradient *mesh) gchar const *meshname = mesh->getRepr()->attribute("id"); // Find this mesh and set it active in the combo_box - GtkTreeIter iter; - gchar *meshid = nullptr; - bool valid = gtk_tree_model_get_iter_first(store, &iter); - if (!valid) { + auto iter = _mesh_tree_model->children().begin(); + if (!iter) { return; } - gtk_tree_model_get(store, &iter, COMBO_COL_MESH, &meshid, -1); - while (valid && strcmp(meshid, meshname) != 0) { - valid = gtk_tree_model_iter_next(store, &iter); - g_free(meshid); - meshid = nullptr; - gtk_tree_model_get(store, &iter, COMBO_COL_MESH, &meshid, -1); + Glib::ustring meshid = (*iter)[_mesh_cols._col_mesh]; + while (iter && strcmp(meshid.c_str(), meshname) != 0) { + ++iter; + meshid = (*iter)[_mesh_cols._col_mesh]; } - if (valid) { - gtk_combo_box_set_active_iter(GTK_COMBO_BOX(_meshmenu), &iter); + if (iter) { + _meshmenu->set_active(iter); } _meshmenu_update = false; - g_free(meshid); } } @@ -858,30 +840,21 @@ void PaintSelector::set_mode_mesh(PaintSelector::Mode mode) auto hb = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL, 1)); hb->set_homogeneous(false); - /** - * Create a combo_box and store with 4 columns, - * The label, a pointer to the mesh, is stockid or not, is a separator or not. - */ - GtkListStore *store = - gtk_list_store_new(COMBO_N_COLS, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_BOOLEAN); - GtkWidget *combo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store)); - gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(combo), PaintSelector::isSeparator, nullptr, nullptr); - - GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); - gtk_cell_renderer_set_padding(renderer, 2, 0); - gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer, TRUE); - gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), renderer, "text", COMBO_COL_LABEL, NULL); - - ink_mesh_menu(combo); - g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(PaintSelector::mesh_change), this); - g_signal_connect(G_OBJECT(combo), "destroy", G_CALLBACK(PaintSelector::mesh_destroy), this); - _meshmenu = combo; - g_object_ref(G_OBJECT(combo)); - - gtk_container_add(GTK_CONTAINER(hb->gobj()), combo); - _selector->pack_start(*hb, false, false, AUX_BETWEEN_BUTTON_GROUPS); + _mesh_tree_model = Gtk::ListStore::create(_mesh_cols); + _meshmenu = Gtk::make_managed(); + _meshmenu->set_model(_mesh_tree_model); + _meshmenu->set_row_separator_func(sigc::mem_fun(*this, &PaintSelector::isSeparator)); - g_object_unref(G_OBJECT(store)); + _mesh_cell_renderer = Gtk::make_managed(); + _mesh_cell_renderer->set_padding(2, 0); + _meshmenu->pack_start(*_mesh_cell_renderer, true); + _meshmenu->add_attribute(*_mesh_cell_renderer, "text", _mesh_cols._col_label); + + ink_mesh_menu(); + _meshmenu->signal_changed().connect(sigc::mem_fun(this, &PaintSelector::mesh_change)); + + hb->add(*_meshmenu); + _selector->pack_start(*hb, false, false, AUX_BETWEEN_BUTTON_GROUPS); } { @@ -914,34 +887,27 @@ SPMeshGradient *PaintSelector::getMeshGradient() if (_meshmenu == nullptr) { return nullptr; } - GtkTreeModel *store = gtk_combo_box_get_model(GTK_COMBO_BOX(_meshmenu)); /* Get the selected mesh */ - GtkTreeIter iter; - if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(_meshmenu), &iter) || - !gtk_list_store_iter_is_valid(GTK_LIST_STORE(store), &iter)) { + auto iter = _meshmenu->get_active(); + if (!iter) { return nullptr; } - gchar *meshid = nullptr; - gboolean stockid = FALSE; - // gchar *label = nullptr; - gtk_tree_model_get(store, &iter, COMBO_COL_STOCK, &stockid, COMBO_COL_MESH, &meshid, -1); - // gtk_tree_model_get (store, &iter, COMBO_COL_LABEL, &label, COMBO_COL_STOCK, &stockid, COMBO_COL_MESH, &meshid, - // -1); std::cout << " .. meshid: " << (meshid?meshid:"null") << " label: " << (label?label:"null") << std::endl; - // g_free(label); + Glib::ustring meshid = (*iter)[_mesh_cols._col_mesh]; + auto stockid = (*iter)[_mesh_cols._col_stock]; + if (meshid == nullptr) { return nullptr; } SPMeshGradient *mesh = nullptr; - if (strcmp(meshid, "none")) { - + if (strcmp(meshid.c_str(), "none")) { gchar *mesh_name; if (stockid) { - mesh_name = g_strconcat("urn:inkscape:mesh:", meshid, NULL); + mesh_name = g_strconcat("urn:inkscape:mesh:", meshid.c_str(), NULL); } else { - mesh_name = g_strdup(meshid); + mesh_name = g_strdup(meshid.c_str()); } SPObject *mesh_obj = get_stock_item(mesh_name); @@ -953,8 +919,6 @@ SPMeshGradient *PaintSelector::getMeshGradient() std::cerr << "PaintSelector::getMeshGradient: Unexpected meshid value." << std::endl; } - g_free(meshid); - return mesh; } @@ -975,14 +939,11 @@ void PaintSelector::set_style_buttons(Gtk::ToggleButton *active) _unset->set_active(active == _unset); } -void PaintSelector::pattern_destroy(GtkWidget *widget, PaintSelector * /*psel*/) +void PaintSelector::pattern_change() { - // drop our reference to the pattern menu widget - g_object_unref(G_OBJECT(widget)); + _signal_changed.emit(); } -void PaintSelector::pattern_change(GtkWidget * /*widget*/, PaintSelector *psel) { psel->_signal_changed.emit(); } - /** * Returns a list of patterns in the defs of the given source document as a vector @@ -1007,11 +968,8 @@ static std::vector ink_pattern_list_get(SPDocument *source) * Adds menu items for pattern list - derived from marker code, left hb etc in to make addition of previews easier at * some point. */ -static void sp_pattern_menu_build(GtkWidget *combo, std::vector &pl, SPDocument * /*source*/) +void PaintSelector::pattern_menu_build(std::vector &pl, SPDocument * /*source*/) { - GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(combo))); - GtkTreeIter iter; - for (auto i = pl.rbegin(); i != pl.rend(); ++i) { Inkscape::XML::Node *repr = (*i)->getRepr(); @@ -1031,9 +989,12 @@ static void sp_pattern_menu_build(GtkWidget *combo, std::vector &pl stockid = true; } - gtk_list_store_append(store, &iter); - gtk_list_store_set(store, &iter, COMBO_COL_LABEL, label, COMBO_COL_STOCK, stockid, COMBO_COL_PATTERN, patid, - COMBO_COL_SEP, FALSE, -1); + auto iter = _pattern_tree_model->append(); + auto row = *iter; + row[_pattern_cols._col_label] = label; + row[_pattern_cols._col_stock] = stockid; + row[_pattern_cols._col_pattern] = patid; + row[_pattern_cols._col_sep] = false; } } @@ -1041,15 +1002,16 @@ static void sp_pattern_menu_build(GtkWidget *combo, std::vector &pl * Pick up all patterns from source, except those that are in * current_doc (if non-NULL), and add items to the pattern menu. */ -static void sp_pattern_list_from_doc(GtkWidget *combo, SPDocument * /*current_doc*/, SPDocument *source, - SPDocument * /*pattern_doc*/) +void PaintSelector::pattern_list_from_doc(SPDocument * /* current_doc */, + SPDocument *source, + SPDocument * /*pattern_doc */) { - std::vector pl = ink_pattern_list_get(source); - sp_pattern_menu_build(combo, pl, source); + auto pl = ink_pattern_list_get(source); + pattern_menu_build(pl, source); } -static void ink_pattern_menu_populate_menu(GtkWidget *combo, SPDocument *doc) +void PaintSelector::ink_pattern_menu_populate_menu(SPDocument *doc) { static SPDocument *patterns_doc = nullptr; @@ -1063,56 +1025,53 @@ static void ink_pattern_menu_populate_menu(GtkWidget *combo, SPDocument *doc) } // suck in from current doc - sp_pattern_list_from_doc(combo, nullptr, doc, patterns_doc); + pattern_list_from_doc(nullptr, doc, patterns_doc); // add separator { - GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(combo))); - GtkTreeIter iter; - gtk_list_store_append(store, &iter); - gtk_list_store_set(store, &iter, COMBO_COL_LABEL, "", COMBO_COL_STOCK, false, COMBO_COL_PATTERN, "", - COMBO_COL_SEP, true, -1); + auto iter = _pattern_tree_model->append(); + auto row = *iter; + row[_pattern_cols._col_label] = ""; + row[_pattern_cols._col_stock] = false; + row[_pattern_cols._col_pattern] = ""; + row[_pattern_cols._col_sep] = true; } // suck in from patterns.svg if (patterns_doc) { doc->ensureUpToDate(); - sp_pattern_list_from_doc(combo, doc, patterns_doc, nullptr); + pattern_list_from_doc(doc, patterns_doc, nullptr); } } -static GtkWidget *ink_pattern_menu(GtkWidget *combo) +void PaintSelector::ink_pattern_menu() { SPDocument *doc = SP_ACTIVE_DOCUMENT; - GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(combo))); - GtkTreeIter iter; - if (!doc) { - - gtk_list_store_append(store, &iter); - gtk_list_store_set(store, &iter, COMBO_COL_LABEL, _("No document selected"), COMBO_COL_STOCK, false, - COMBO_COL_PATTERN, "", COMBO_COL_SEP, false, -1); - gtk_widget_set_sensitive(combo, FALSE); - + auto iter = _pattern_tree_model->append(); + auto row = *iter; + row[_pattern_cols._col_label] = _("No document selected"); + row[_pattern_cols._col_stock] = false; + row[_pattern_cols._col_pattern] = ""; + row[_pattern_cols._col_sep] = false; + _patternmenu->set_sensitive(false); } else { - - ink_pattern_menu_populate_menu(combo, doc); - gtk_widget_set_sensitive(combo, TRUE); + ink_pattern_menu_populate_menu(doc); + _patternmenu->set_sensitive(true); } // Select the first item that is not a separator - if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter)) { - gboolean sep = false; - gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, COMBO_COL_SEP, &sep, -1); + if (!_pattern_tree_model->children().empty()) { + auto iter = _pattern_tree_model->children().begin(); + auto row = *iter; + auto sep = row[_pattern_cols._col_sep]; if (sep) { - gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter); + ++iter; } - gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo), &iter); + _patternmenu->set_active(iter); } - - return combo; } @@ -1125,10 +1084,9 @@ void PaintSelector::updatePatternList(SPPattern *pattern) g_assert(_patternmenu != nullptr); /* Clear existing menu if any */ - auto store = gtk_combo_box_get_model(GTK_COMBO_BOX(_patternmenu)); - gtk_list_store_clear(GTK_LIST_STORE(store)); + _pattern_tree_model->clear(); - ink_pattern_menu(_patternmenu); + ink_pattern_menu(); /* Set history */ @@ -1137,23 +1095,18 @@ void PaintSelector::updatePatternList(SPPattern *pattern) gchar const *patname = pattern->getRepr()->attribute("id"); // Find this pattern and set it active in the combo_box - GtkTreeIter iter; - gchar *patid = nullptr; - bool valid = gtk_tree_model_get_iter_first(store, &iter); - if (!valid) { + auto iter = _pattern_tree_model->children().begin(); + if (!iter) { return; } - gtk_tree_model_get(store, &iter, COMBO_COL_PATTERN, &patid, -1); - while (valid && strcmp(patid, patname) != 0) { - valid = gtk_tree_model_iter_next(store, &iter); - g_free(patid); - patid = nullptr; - gtk_tree_model_get(store, &iter, COMBO_COL_PATTERN, &patid, -1); + Glib::ustring patid = (*iter)[_pattern_cols._col_pattern]; + while (iter && strcmp(patid.c_str(), patname) != 0) { + ++iter; + patid = (*iter)[_pattern_cols._col_pattern]; } - g_free(patid); - if (valid) { - gtk_combo_box_set_active_iter(GTK_COMBO_BOX(_patternmenu), &iter); + if (iter) { + _patternmenu->set_active(iter); } _patternmenu_update = false; @@ -1182,30 +1135,21 @@ void PaintSelector::set_mode_pattern(PaintSelector::Mode mode) auto hb = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL, 1)); hb->set_homogeneous(false); - /** - * Create a combo_box and store with 4 columns, - * The label, a pointer to the pattern, is stockid or not, is a separator or not. - */ - GtkListStore *store = - gtk_list_store_new(COMBO_N_COLS, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_BOOLEAN); - _patternmenu = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store)); - gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(_patternmenu), PaintSelector::isSeparator, nullptr, - nullptr); - - GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); - gtk_cell_renderer_set_padding(renderer, 2, 0); - gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(_patternmenu), renderer, TRUE); - gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(_patternmenu), renderer, "text", COMBO_COL_LABEL, NULL); - - ink_pattern_menu(_patternmenu); - g_signal_connect(G_OBJECT(_patternmenu), "changed", G_CALLBACK(PaintSelector::pattern_change), this); - g_signal_connect(G_OBJECT(_patternmenu), "destroy", G_CALLBACK(PaintSelector::pattern_destroy), this); - g_object_ref(G_OBJECT(_patternmenu)); - - gtk_container_add(GTK_CONTAINER(hb->gobj()), _patternmenu); - _selector->pack_start(*hb, false, false, AUX_BETWEEN_BUTTON_GROUPS); + _pattern_tree_model = Gtk::ListStore::create(_pattern_cols); + _patternmenu = Gtk::make_managed(); + _patternmenu->set_model(_pattern_tree_model); + _patternmenu->set_row_separator_func(sigc::mem_fun(*this, &PaintSelector::isSeparator)); + + _pattern_cell_renderer = Gtk::make_managed(); + _pattern_cell_renderer->set_padding(2, 0); + _patternmenu->pack_start(*_pattern_cell_renderer, true); + _patternmenu->add_attribute(*_pattern_cell_renderer, "text", _pattern_cols._col_label); - g_object_unref(G_OBJECT(store)); + ink_pattern_menu(); + _patternmenu->signal_changed().connect(sigc::mem_fun(this, &PaintSelector::pattern_change)); + + hb->add(*_patternmenu); + _selector->pack_start(*hb, false, false, AUX_BETWEEN_BUTTON_GROUPS); } { @@ -1251,12 +1195,10 @@ void PaintSelector::set_mode_hatch(PaintSelector::Mode mode) #endif } -gboolean PaintSelector::isSeparator(GtkTreeModel *model, GtkTreeIter *iter, gpointer /*data*/) +bool PaintSelector::isSeparator(const Glib::RefPtr &model, + const Gtk::TreeModel::iterator &iter) { - - gboolean sep = FALSE; - gtk_tree_model_get(model, iter, COMBO_COL_SEP, &sep, -1); - return sep; + return (*iter)[_mesh_cols._col_sep]; } SPPattern *PaintSelector::getPattern() @@ -1269,33 +1211,26 @@ SPPattern *PaintSelector::getPattern() return nullptr; } - auto store = gtk_combo_box_get_model(GTK_COMBO_BOX(_patternmenu)); - /* Get the selected pattern */ - GtkTreeIter iter; - if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(_patternmenu), &iter) || - !gtk_list_store_iter_is_valid(GTK_LIST_STORE(store), &iter)) { + auto iter = _patternmenu->get_active(); + if (!iter) { return nullptr; } - gchar *patid = nullptr; - gboolean stockid = FALSE; - // gchar *label = nullptr; - gtk_tree_model_get(store, &iter, - // COMBO_COL_LABEL, &label, - COMBO_COL_STOCK, &stockid, COMBO_COL_PATTERN, &patid, -1); - // g_free(label); - if (patid == nullptr) { + Glib::ustring patid = (*iter)[_pattern_cols._col_pattern]; + auto stockid = (*iter)[_pattern_cols._col_stock]; + + if (patid.empty()) { return nullptr; } - if (strcmp(patid, "none") != 0) { + if (strcmp(patid.c_str(), "none") != 0) { gchar *paturn; if (stockid) { - paturn = g_strconcat("urn:inkscape:pattern:", patid, NULL); + paturn = g_strconcat("urn:inkscape:pattern:", patid.c_str(), NULL); } else { - paturn = g_strdup(patid); + paturn = g_strdup(patid.c_str()); } SPObject *pat_obj = get_stock_item(paturn); if (pat_obj) { @@ -1311,8 +1246,6 @@ SPPattern *PaintSelector::getPattern() } } - g_free(patid); - return pat; } diff --git a/src/ui/widget/paint-selector.h b/src/ui/widget/paint-selector.h index d4cabb5a4f..16acfbb267 100644 --- a/src/ui/widget/paint-selector.h +++ b/src/ui/widget/paint-selector.h @@ -16,6 +16,7 @@ #include "fill-or-stroke.h" #include #include +#include #include "object/sp-gradient-spread.h" #include "object/sp-gradient-units.h" @@ -31,7 +32,10 @@ class SPPattern; class SPStyle; namespace Gtk { +class CellRendererText; +class ComboBox; class Label; +class ListStore; class RadioButton; class ToggleButton; } // namespace Gtk @@ -91,11 +95,52 @@ class PaintSelector : public Gtk::Box { Gtk::Box *_frame; Gtk::Box *_selector = nullptr; Gtk::Label *_label; - GtkWidget *_patternmenu = nullptr; + Gtk::ComboBox *_patternmenu = nullptr; bool _patternmenu_update = false; + + class PatternModelColumns : public Gtk::TreeModel::ColumnRecord { + public: + PatternModelColumns() + { + add(_col_label); + add(_col_stock); + add(_col_pattern); + add(_col_sep); + } + + Gtk::TreeModelColumn _col_label; ///< Label for the mesh + Gtk::TreeModelColumn _col_stock; ///< Stock-ID or not + Gtk::TreeModelColumn _col_pattern; ///< Pointer to the pattern + Gtk::TreeModelColumn _col_sep; ///< Separator or not + }; + + PatternModelColumns _pattern_cols; + Glib::RefPtr _pattern_tree_model; + Gtk::CellRendererText *_pattern_cell_renderer; + #ifdef WITH_MESH - GtkWidget *_meshmenu = nullptr; + Gtk::ComboBox *_meshmenu = nullptr; bool _meshmenu_update = false; + + class MeshModelColumns : public Gtk::TreeModel::ColumnRecord { + public: + MeshModelColumns() + { + add(_col_label); + add(_col_stock); + add(_col_mesh); + add(_col_sep); + } + + Gtk::TreeModelColumn _col_label; ///< Label for the mesh + Gtk::TreeModelColumn _col_stock; ///< Stock-ID or not + Gtk::TreeModelColumn _col_mesh; ///< Pointer to the mesh + Gtk::TreeModelColumn _col_sep; ///< Separator or not + }; + + MeshModelColumns _mesh_cols; + Glib::RefPtr _mesh_tree_model; + Gtk::CellRendererText *_mesh_cell_renderer; #endif Inkscape::UI::SelectedColor *_selected_color; @@ -129,8 +174,23 @@ class PaintSelector : public Gtk::Box { void set_mode_unset(); void set_mode_color(PaintSelector::Mode mode); void set_mode_gradient(PaintSelector::Mode mode); + void ink_pattern_menu(); + void ink_pattern_menu_populate_menu(SPDocument *doc); + void pattern_list_from_doc(SPDocument *current_doc, + SPDocument *source, + SPDocument *pattern_doc); + void pattern_menu_build(std::vector &pl, SPDocument *source); #ifdef WITH_MESH void set_mode_mesh(PaintSelector::Mode mode); + void ink_mesh_menu(); + void ink_mesh_menu_populate_menu(SPDocument *doc); + void mesh_list_from_doc(SPDocument *source, + SPDocument *mesh_doc); + void mesh_menu_build(std::vector &mesh_list, SPDocument *source); + bool isSeparator(const Glib::RefPtr &model, + const Gtk::TreeModel::iterator &iter); + + void mesh_change(); #endif void set_mode_pattern(PaintSelector::Mode mode); void set_mode_hatch(PaintSelector::Mode mode); @@ -141,11 +201,7 @@ class PaintSelector : public Gtk::Box { void gradient_released(); void gradient_changed(SPGradient *gr); - static void mesh_change(GtkWidget *widget, PaintSelector *psel); - static void mesh_destroy(GtkWidget *widget, PaintSelector *psel); - - static void pattern_change(GtkWidget *widget, PaintSelector *psel); - static void pattern_destroy(GtkWidget *widget, PaintSelector *psel); + void pattern_change(); public: PaintSelector(FillOrStroke kind); @@ -187,15 +243,6 @@ class PaintSelector : public Gtk::Box { SPPattern *getPattern(); }; -enum { - COMBO_COL_LABEL = 0, - COMBO_COL_STOCK = 1, - COMBO_COL_PATTERN = 2, - COMBO_COL_MESH = COMBO_COL_PATTERN, - COMBO_COL_SEP = 3, - COMBO_N_COLS = 4 -}; - } // namespace Widget } // namespace UI } // namespace Inkscape -- GitLab From 61c719aa46fe217805929049adc2705e5f8b8f5c Mon Sep 17 00:00:00 2001 From: Alex Valavanis Date: Mon, 22 Jun 2020 11:21:27 +0100 Subject: [PATCH 04/10] ColorScales: Gtkmmify --- src/ui/widget/color-scales.cpp | 144 ++++++++++++++++----------------- src/ui/widget/color-scales.h | 12 ++- 2 files changed, 80 insertions(+), 76 deletions(-) diff --git a/src/ui/widget/color-scales.cpp b/src/ui/widget/color-scales.cpp index c10d14eca6..8806691d8b 100644 --- a/src/ui/widget/color-scales.cpp +++ b/src/ui/widget/color-scales.cpp @@ -10,11 +10,15 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ -#include +#include "ui/widget/color-scales.h" + #include +#include +#include +#include + #include "ui/dialog-events.h" -#include "ui/widget/color-scales.h" #include "ui/widget/color-slider.h" #define CSC_CHANNEL_R (1 << 0) @@ -77,26 +81,22 @@ ColorScales::~ColorScales() void ColorScales::_initUI(SPColorScalesMode mode) { - gint i; - _updating = FALSE; _dragging = FALSE; - GtkWidget *t = GTK_WIDGET(gobj()); - /* Create components */ - for (i = 0; i < 5; i++) { + for (int i = 0; i < 5; i++) { /* Label */ - _l[i] = gtk_label_new(""); + _l[i] = Gtk::make_managed(""); - gtk_widget_set_halign(_l[i], GTK_ALIGN_START); - gtk_widget_show(_l[i]); + _l[i]->set_halign(Gtk::ALIGN_START); + _l[i]->show(); - gtk_widget_set_margin_start(_l[i], XPAD); - gtk_widget_set_margin_end(_l[i], XPAD); - gtk_widget_set_margin_top(_l[i], YPAD); - gtk_widget_set_margin_bottom(_l[i], YPAD); - gtk_grid_attach(GTK_GRID(t), _l[i], 0, i, 1, 1); + _l[i]->set_margin_start( XPAD); + _l[i]->set_margin_end( XPAD); + _l[i]->set_margin_top( YPAD); + _l[i]->set_margin_bottom(YPAD); + attach(*_l[i], 0, i, 1, 1); /* Adjustment */ _a.push_back(Gtk::Adjustment::create(0.0, 0.0, _rangeLimit, 1.0, 10.0, 10.0)); @@ -109,21 +109,21 @@ void ColorScales::_initUI(SPColorScalesMode mode) _s[i]->set_margin_top(YPAD); _s[i]->set_margin_bottom(YPAD); _s[i]->set_hexpand(true); - gtk_grid_attach(GTK_GRID(t), _s[i]->gobj(), 1, i, 1, 1); + attach(*_s[i], 1, i, 1, 1); /* Spinbutton */ - _b[i] = gtk_spin_button_new(GTK_ADJUSTMENT(_a[i]->gobj()), 1.0, 0); - sp_dialog_defocus_on_enter(_b[i]); - gtk_label_set_mnemonic_widget(GTK_LABEL(_l[i]), _b[i]); - gtk_widget_show(_b[i]); - - gtk_widget_set_margin_start(_b[i], XPAD); - gtk_widget_set_margin_end(_b[i], XPAD); - gtk_widget_set_margin_top(_b[i], YPAD); - gtk_widget_set_margin_bottom(_b[i], YPAD); - gtk_widget_set_halign(_b[i], GTK_ALIGN_END); - gtk_widget_set_valign(_b[i], GTK_ALIGN_CENTER); - gtk_grid_attach(GTK_GRID(t), _b[i], 2, i, 1, 1); + _b[i] = Gtk::make_managed(_a[i], 1.0, 0); + sp_dialog_defocus_on_enter(GTK_WIDGET(_b[i]->gobj())); + _l[i]->set_mnemonic_widget(*_b[i]); + _b[i]->show(); + + _b[i]->set_margin_start( XPAD); + _b[i]->set_margin_end( XPAD); + _b[i]->set_margin_top( YPAD); + _b[i]->set_margin_bottom(YPAD); + _b[i]->set_halign(Gtk::ALIGN_END); + _b[i]->set_valign(Gtk::ALIGN_CENTER); + attach(*_b[i], 2, i, 1, 1); /* Signals */ _a[i]->signal_value_changed().connect(sigc::bind(sigc::mem_fun(this, &ColorScales::adjustment_changed),i)); @@ -133,9 +133,9 @@ void ColorScales::_initUI(SPColorScalesMode mode) } //Prevent 5th bar from being shown by PanelDialog::show_all_children - gtk_widget_set_no_show_all(_l[4], TRUE); + _l[4]->set_no_show_all(true); _s[4]->set_no_show_all(true); - gtk_widget_set_no_show_all(_b[4], TRUE); + _b[4]->set_no_show_all(true); /* Initial mode is none, so it works */ setMode(mode); @@ -357,22 +357,22 @@ void ColorScales::setMode(SPColorScalesMode mode) case SP_COLOR_SCALES_MODE_RGB: _setRangeLimit(255.0); _a[3]->set_upper(100.0); - gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[0]), _("_R:")); + _l[0]->set_markup_with_mnemonic(_("_R:")); _s[0]->set_tooltip_text(_("Red")); - gtk_widget_set_tooltip_text(_b[0], _("Red")); - gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[1]), _("_G:")); + _b[0]->set_tooltip_text(_("Red")); + _l[1]->set_markup_with_mnemonic(_("_G:")); _s[1]->set_tooltip_text(_("Green")); - gtk_widget_set_tooltip_text(_b[1], _("Green")); - gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[2]), _("_B:")); + _b[1]->set_tooltip_text(_("Green")); + _l[2]->set_markup_with_mnemonic(_("_B:")); _s[2]->set_tooltip_text(_("Blue")); - gtk_widget_set_tooltip_text(_b[2], _("Blue")); - gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[3]), _("_A:")); + _b[2]->set_tooltip_text(_("Blue")); + _l[3]->set_markup_with_mnemonic(_("_A:")); _s[3]->set_tooltip_text(_("Alpha (opacity)")); - gtk_widget_set_tooltip_text(_b[3], _("Alpha (opacity)")); + _b[3]->set_tooltip_text(_("Alpha (opacity)")); _s[0]->setMap(nullptr); - gtk_widget_hide(_l[4]); + _l[4]->hide(); _s[4]->hide(); - gtk_widget_hide(_b[4]); + _b[4]->hide(); _updating = TRUE; setScaled(_a[0], rgba[0]); setScaled(_a[1], rgba[1]); @@ -384,26 +384,26 @@ void ColorScales::setMode(SPColorScalesMode mode) case SP_COLOR_SCALES_MODE_HSL: _setRangeLimit(100.0); - gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[0]), _("_H:")); + _l[0]->set_markup_with_mnemonic(_("_H:")); _s[0]->set_tooltip_text(_("Hue")); - gtk_widget_set_tooltip_text(_b[0], _("Hue")); + _b[0]->set_tooltip_text(_("Hue")); _a[0]->set_upper(360.0); - gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[1]), _("_S:")); + _l[1]->set_markup_with_mnemonic(_("_S:")); _s[1]->set_tooltip_text(_("Saturation")); - gtk_widget_set_tooltip_text(_b[1], _("Saturation")); + _b[1]->set_tooltip_text(_("Saturation")); - gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[2]), _("_L:")); + _l[2]->set_markup_with_mnemonic(_("_L:")); _s[2]->set_tooltip_text(_("Lightness")); - gtk_widget_set_tooltip_text(_b[2], _("Lightness")); + _b[2]->set_tooltip_text(_("Lightness")); - gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[3]), _("_A:")); + _l[3]->set_markup_with_mnemonic(_("_A:")); _s[3]->set_tooltip_text(_("Alpha (opacity)")); - gtk_widget_set_tooltip_text(_b[3], _("Alpha (opacity)")); + _b[3]->set_tooltip_text(_("Alpha (opacity)")); _s[0]->setMap((guchar *)(sp_color_scales_hue_map())); - gtk_widget_hide(_l[4]); + _l[4]->hide(); _s[4]->hide(); - gtk_widget_hide(_b[4]); + _b[4]->hide(); _updating = TRUE; c[0] = 0.0; @@ -420,26 +420,26 @@ void ColorScales::setMode(SPColorScalesMode mode) case SP_COLOR_SCALES_MODE_HSV: _setRangeLimit(100.0); - gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[0]), _("_H:")); + _l[0]->set_markup_with_mnemonic(_("_H:")); _s[0]->set_tooltip_text(_("Hue")); - gtk_widget_set_tooltip_text(_b[0], _("Hue")); + _b[0]->set_tooltip_text(_("Hue")); _a[0]->set_upper(360.0); - gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[1]), _("_S:")); + _l[1]->set_markup_with_mnemonic(_("_S:")); _s[1]->set_tooltip_text(_("Saturation")); - gtk_widget_set_tooltip_text(_b[1], _("Saturation")); + _b[1]->set_tooltip_text(_("Saturation")); - gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[2]), _("_V:")); + _l[2]->set_markup_with_mnemonic(_("_V:")); _s[2]->set_tooltip_text(_("Value")); - gtk_widget_set_tooltip_text(_b[2], _("Value")); + _b[2]->set_tooltip_text(_("Value")); - gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[3]), _("_A:")); + _l[3]->set_markup_with_mnemonic(_("_A:")); _s[3]->set_tooltip_text(_("Alpha (opacity)")); - gtk_widget_set_tooltip_text(_b[3], _("Alpha (opacity)")); + _b[3]->set_tooltip_text(_("Alpha (opacity)")); _s[0]->setMap((guchar *)(sp_color_scales_hue_map())); - gtk_widget_hide(_l[4]); + _l[4]->hide(); _s[4]->hide(); - gtk_widget_hide(_b[4]); + _b[4]->hide(); _updating = TRUE; c[0] = 0.0; @@ -455,25 +455,25 @@ void ColorScales::setMode(SPColorScalesMode mode) break; case SP_COLOR_SCALES_MODE_CMYK: _setRangeLimit(100.0); - gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[0]), _("_C:")); + _l[0]->set_markup_with_mnemonic(_("_C:")); _s[0]->set_tooltip_text(_("Cyan")); - gtk_widget_set_tooltip_text(_b[0], _("Cyan")); - gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[1]), _("_M:")); + _b[0]->set_tooltip_text(_("Cyan")); + _l[1]->set_markup_with_mnemonic(_("_M:")); _s[1]->set_tooltip_text(_("Magenta")); - gtk_widget_set_tooltip_text(_b[1], _("Magenta")); - gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[2]), _("_Y:")); + _b[1]->set_tooltip_text(_("Magenta")); + _l[2]->set_markup_with_mnemonic(_("_Y:")); _s[2]->set_tooltip_text(_("Yellow")); - gtk_widget_set_tooltip_text(_b[2], _("Yellow")); - gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[3]), _("_K:")); + _b[2]->set_tooltip_text(_("Yellow")); + _l[3]->set_markup_with_mnemonic(_("_K:")); _s[3]->set_tooltip_text(_("Black")); - gtk_widget_set_tooltip_text(_b[3], _("Black")); - gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[4]), _("_A:")); + _b[3]->set_tooltip_text(_("Black")); + _l[4]->set_markup_with_mnemonic(_("_A:")); _s[4]->set_tooltip_text(_("Alpha (opacity)")); - gtk_widget_set_tooltip_text(_b[4], _("Alpha (opacity)")); + _b[4]->set_tooltip_text(_("Alpha (opacity)")); _s[0]->setMap(nullptr); - gtk_widget_show(_l[4]); + _l[4]->show(); _s[4]->show(); - gtk_widget_show(_b[4]); + _b[4]->show(); _updating = TRUE; SPColor::rgb_to_cmyk_floatv(c, rgba[0], rgba[1], rgba[2]); diff --git a/src/ui/widget/color-scales.h b/src/ui/widget/color-scales.h index 36702f6dfd..782ac85cee 100644 --- a/src/ui/widget/color-scales.h +++ b/src/ui/widget/color-scales.h @@ -14,6 +14,11 @@ #include "ui/selected-color.h" +namespace Gtk { +class Label; +class SpinButton; +} + namespace Inkscape { namespace UI { namespace Widget { @@ -28,8 +33,7 @@ enum SPColorScalesMode { SP_COLOR_SCALES_MODE_HSV = 4 }; -class ColorScales - : public Gtk::Grid +class ColorScales : public Gtk::Grid { public: static const gchar *SUBMODE_NAMES[]; @@ -70,8 +74,8 @@ protected: gboolean _dragging : 1; std::vector> _a; /* Channel adjustments */ Inkscape::UI::Widget::ColorSlider *_s[5]; /* Channel sliders */ - GtkWidget *_b[5]; /* Spinbuttons */ - GtkWidget *_l[5]; /* Labels */ + Gtk::SpinButton *_b[5]; ///< Spinbuttons + Gtk::Label *_l[5]; ///< Labels private: // By default, disallow copy constructor and assignment operator -- GitLab From e6db1bef2fed3b8f405c41d820c857e5a41e6d00 Mon Sep 17 00:00:00 2001 From: Alex Valavanis Date: Mon, 22 Jun 2020 11:40:41 +0100 Subject: [PATCH 05/10] GradientSelector: Gtkmmify --- src/ui/widget/gradient-selector.cpp | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/ui/widget/gradient-selector.cpp b/src/ui/widget/gradient-selector.cpp index 109ed593c2..14972fb321 100644 --- a/src/ui/widget/gradient-selector.cpp +++ b/src/ui/widget/gradient-selector.cpp @@ -42,9 +42,9 @@ namespace Widget { void GradientSelector::style_button(Gtk::Button *btn, char const *iconName) { - GtkWidget *child = sp_get_icon_image(iconName, GTK_ICON_SIZE_SMALL_TOOLBAR); - gtk_widget_show(child); - btn->add(*manage(Glib::wrap(child))); + auto child = Glib::wrap(sp_get_icon_image(iconName, GTK_ICON_SIZE_SMALL_TOOLBAR)); + child->show(); + btn->add(*child); btn->set_relief(Gtk::RELIEF_NONE); } @@ -153,7 +153,6 @@ GradientSelector::GradientSelector() void GradientSelector::setSpread(SPGradientSpread spread) { _gradientSpread = spread; - // gtk_combo_box_set_active (GTK_COMBO_BOX(this->spread), gradientSpread); } void GradientSelector::setMode(SelectorMode mode) -- GitLab From 2dea80be19b406e461018894bb724ecc292a41f9 Mon Sep 17 00:00:00 2001 From: Alex Valavanis Date: Mon, 22 Jun 2020 12:34:37 +0100 Subject: [PATCH 06/10] ColorICCSelector: Gtkmmify --- src/ui/widget/color-icc-selector.cpp | 233 +++++++++++++-------------- 1 file changed, 112 insertions(+), 121 deletions(-) diff --git a/src/ui/widget/color-icc-selector.cpp b/src/ui/widget/color-icc-selector.cpp index a8046a678a..14cc430575 100644 --- a/src/ui/widget/color-icc-selector.cpp +++ b/src/ui/widget/color-icc-selector.cpp @@ -15,6 +15,11 @@ #include #include +#include +#include +#include +#include + #include #include "colorspace.h" @@ -83,24 +88,24 @@ std::set knownColorspaces; /** * Helper function to handle GTK2/GTK3 attachment #ifdef code. */ -void attachToGridOrTable(GtkWidget *parent, GtkWidget *child, guint left, guint top, guint width, guint height, +void attachToGridOrTable(GtkWidget *parent, Gtk::Widget *child, guint left, guint top, guint width, guint height, bool hexpand = false, bool centered = false, guint xpadding = XPAD, guint ypadding = YPAD) { - gtk_widget_set_margin_start(child, xpadding); - gtk_widget_set_margin_end(child, xpadding); - gtk_widget_set_margin_top(child, ypadding); - gtk_widget_set_margin_bottom(child, ypadding); + child->set_margin_start( xpadding); + child->set_margin_end( xpadding); + child->set_margin_top( ypadding); + child->set_margin_bottom(ypadding); if (hexpand) { - gtk_widget_set_hexpand(child, TRUE); + child->set_hexpand(true); } if (centered) { - gtk_widget_set_halign(child, GTK_ALIGN_CENTER); - gtk_widget_set_valign(child, GTK_ALIGN_CENTER); + child->set_halign(Gtk::ALIGN_CENTER); + child->set_valign(Gtk::ALIGN_CENTER); } - gtk_grid_attach(GTK_GRID(parent), child, left, top, width, height); + gtk_grid_attach(GTK_GRID(parent), child->gobj(), left, top, width, height); } } // namespace @@ -218,8 +223,6 @@ class ComponentUI { : _component() , _adj(nullptr) , _slider(nullptr) - , _btn(nullptr) - , _label(nullptr) , _map(nullptr) { } @@ -228,8 +231,6 @@ class ComponentUI { : _component(std::move(component)) , _adj(nullptr) , _slider(nullptr) - , _btn(nullptr) - , _label(nullptr) , _map(nullptr) { } @@ -237,8 +238,8 @@ class ComponentUI { colorspace::Component _component; Glib::RefPtr _adj; // Component adjustment Inkscape::UI::Widget::ColorSlider *_slider; - GtkWidget *_btn; // spinbutton - GtkWidget *_label; // Label + Gtk::SpinButton *_btn = nullptr; ///< spinbutton + Gtk::Label *_label = nullptr; ///< Label guchar *_map; }; @@ -249,16 +250,14 @@ class ColorICCSelectorImpl { public: ColorICCSelectorImpl(ColorICCSelector *owner, SelectedColor &color); - ~ColorICCSelectorImpl(); - void _adjustmentChanged(Glib::RefPtr &adjustment); void _sliderGrabbed(); void _sliderReleased(); void _sliderChanged(); - static void _profileSelected(GtkWidget *src, gpointer data); - static void _fixupHit(GtkWidget *src, gpointer data); + void _profileSelected(); + void _fixupHit(); #if defined(HAVE_LIBLCMS2) void _setProfile(SVGICCColor *profile); @@ -274,21 +273,37 @@ class ColorICCSelectorImpl { gboolean _dragging : 1; guint32 _fixupNeeded; - GtkWidget *_fixupBtn; - GtkWidget *_profileSel; + Gtk::Button *_fixupBtn = nullptr; + + Gtk::ComboBox *_profileSel = nullptr; + + class ProfileColumns : public Gtk::TreeModel::ColumnRecord { + public: + ProfileColumns() + { + add(_col_label); + add(_col_name); + } + + Gtk::TreeModelColumn _col_label; + Gtk::TreeModelColumn _col_name; + }; + + ProfileColumns _profile_cols; + Glib::RefPtr _profile_store; std::vector _compUI; Glib::RefPtr _adj; // Channel adjustment Inkscape::UI::Widget::ColorSlider *_slider; - GtkWidget *_sbtn; // Spinbutton - GtkWidget *_label; // Label + Gtk::SpinButton *_sbtn = nullptr; ///< Spinbutton + Gtk::Label *_label = nullptr; ///< Label #if defined(HAVE_LIBLCMS2) std::string _profileName; Inkscape::ColorProfile *_prof; guint _profChannelCount; - gulong _profChangedID; + sigc::connection _profChangedID; #endif // defined(HAVE_LIBLCMS2) }; @@ -321,28 +336,17 @@ ColorICCSelectorImpl::ColorICCSelectorImpl(ColorICCSelector *owner, SelectedColo , _updating(FALSE) , _dragging(FALSE) , _fixupNeeded(0) - , _fixupBtn(nullptr) - , _profileSel(nullptr) , _compUI() , _adj(nullptr) , _slider(nullptr) - , _sbtn(nullptr) - , _label(nullptr) #if defined(HAVE_LIBLCMS2) , _profileName() , _prof(nullptr) , _profChannelCount(0) - , _profChangedID(0) #endif // defined(HAVE_LIBLCMS2) { } -ColorICCSelectorImpl::~ColorICCSelectorImpl() -{ - _sbtn = nullptr; - _label = nullptr; -} - void ColorICCSelector::init() { gint row = 0; @@ -358,37 +362,36 @@ void ColorICCSelector::init() row = 0; - _impl->_fixupBtn = gtk_button_new_with_label(_("Fix")); - g_signal_connect(G_OBJECT(_impl->_fixupBtn), "clicked", G_CALLBACK(ColorICCSelectorImpl::_fixupHit), - (gpointer)_impl); - gtk_widget_set_sensitive(_impl->_fixupBtn, FALSE); - gtk_widget_set_tooltip_text(_impl->_fixupBtn, _("Fix RGB fallback to match icc-color() value.")); - gtk_widget_show(_impl->_fixupBtn); + _impl->_fixupBtn = Gtk::make_managed(_("Fix")); + _impl->_fixupBtn->signal_clicked().connect(sigc::mem_fun(*_impl, &ColorICCSelectorImpl::_fixupHit)); + _impl->_fixupBtn->set_sensitive(false); + _impl->_fixupBtn->set_tooltip_text(_("Fix RGB fallback to match icc-color() value.")); + _impl->_fixupBtn->show(); attachToGridOrTable(t, _impl->_fixupBtn, 0, row, 1, 1); // Combobox and store with 2 columns : label (0) and full name (1) - GtkListStore *store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); - _impl->_profileSel = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store)); + _impl->_profile_store = Gtk::ListStore::create(_impl->_profile_cols); + _impl->_profileSel = Gtk::make_managed(); + _impl->_profileSel->set_model(_impl->_profile_store); - GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); - gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(_impl->_profileSel), renderer, TRUE); - gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(_impl->_profileSel), renderer, "text", 0, NULL); + auto renderer = Gtk::make_managed(); + _impl->_profileSel->pack_start(*renderer, true); + _impl->_profileSel->add_attribute(*renderer, "text", _impl->_profile_cols._col_label); - GtkTreeIter iter; - gtk_list_store_append(store, &iter); - gtk_list_store_set(store, &iter, 0, _(""), 1, _(""), -1); + auto iter = _impl->_profile_store->append(); + (*iter)[_impl->_profile_cols._col_label] = _(""); + (*iter)[_impl->_profile_cols._col_name] = _(""); - gtk_widget_show(_impl->_profileSel); - gtk_combo_box_set_active(GTK_COMBO_BOX(_impl->_profileSel), 0); + _impl->_profileSel->show(); + _impl->_profileSel->set_active(0); attachToGridOrTable(t, _impl->_profileSel, 1, row, 1, 1); #if defined(HAVE_LIBLCMS2) - _impl->_profChangedID = g_signal_connect(G_OBJECT(_impl->_profileSel), "changed", - G_CALLBACK(ColorICCSelectorImpl::_profileSelected), (gpointer)_impl); + _impl->_profChangedID = _impl->_profileSel->signal_changed().connect(sigc::mem_fun(*_impl, &ColorICCSelectorImpl::_profileSelected)); #else - gtk_widget_set_sensitive(_impl->_profileSel, false); + _impl->_profileSel->set_sensitive(false); #endif // defined(HAVE_LIBLCMS2) @@ -415,11 +418,11 @@ void ColorICCSelector::init() std::string labelStr = "."; #endif - _impl->_compUI[i]._label = gtk_label_new_with_mnemonic(labelStr.c_str()); + _impl->_compUI[i]._label = Gtk::make_managed(labelStr, true); - gtk_widget_set_halign(_impl->_compUI[i]._label, GTK_ALIGN_END); - gtk_widget_show(_impl->_compUI[i]._label); - gtk_widget_set_no_show_all(_impl->_compUI[i]._label, TRUE); + _impl->_compUI[i]._label->set_halign(Gtk::ALIGN_END); + _impl->_compUI[i]._label->show(); + _impl->_compUI[i]._label->set_no_show_all(true); attachToGridOrTable(t, _impl->_compUI[i]._label, 0, row, 1, 1); @@ -441,18 +444,18 @@ void ColorICCSelector::init() _impl->_compUI[i]._slider->show(); _impl->_compUI[i]._slider->set_no_show_all(); - attachToGridOrTable(t, _impl->_compUI[i]._slider->gobj(), 1, row, 1, 1, true); + attachToGridOrTable(t, _impl->_compUI[i]._slider, 1, row, 1, 1, true); - _impl->_compUI[i]._btn = gtk_spin_button_new(_impl->_compUI[i]._adj->gobj(), step, digits); + _impl->_compUI[i]._btn = Gtk::make_managed(_impl->_compUI[i]._adj, step, digits); #if defined(HAVE_LIBLCMS2) - gtk_widget_set_tooltip_text(_impl->_compUI[i]._btn, (i < things.size()) ? things[i].tip.c_str() : ""); + _impl->_compUI[i]._btn->set_tooltip_text((i < things.size()) ? things[i].tip.c_str() : ""); #else - gtk_widget_set_tooltip_text(_impl->_compUI[i]._btn, "."); + _impl->_compUI[i]._btn->set_tooltip_text("."); #endif // defined(HAVE_LIBLCMS2) - sp_dialog_defocus_on_enter(_impl->_compUI[i]._btn); - gtk_label_set_mnemonic_widget(GTK_LABEL(_impl->_compUI[i]._label), _impl->_compUI[i]._btn); - gtk_widget_show(_impl->_compUI[i]._btn); - gtk_widget_set_no_show_all(_impl->_compUI[i]._btn, TRUE); + sp_dialog_defocus_on_enter(GTK_WIDGET(_impl->_compUI[i]._btn->gobj())); + _impl->_compUI[i]._label->set_mnemonic_widget(*_impl->_compUI[i]._btn); + _impl->_compUI[i]._btn->show(); + _impl->_compUI[i]._btn->set_no_show_all(true); attachToGridOrTable(t, _impl->_compUI[i]._btn, 2, row, 1, 1, false, true); @@ -473,10 +476,10 @@ void ColorICCSelector::init() } // Label - _impl->_label = gtk_label_new_with_mnemonic(_("_A:")); + _impl->_label = Gtk::make_managed(_("_A:"), true); - gtk_widget_set_halign(_impl->_label, GTK_ALIGN_END); - gtk_widget_show(_impl->_label); + _impl->_label->set_halign(Gtk::ALIGN_END); + _impl->_label->show(); attachToGridOrTable(t, _impl->_label, 0, row, 1, 1); @@ -488,18 +491,18 @@ void ColorICCSelector::init() _impl->_slider->set_tooltip_text(_("Alpha (opacity)")); _impl->_slider->show(); - attachToGridOrTable(t, _impl->_slider->gobj(), 1, row, 1, 1, true); + attachToGridOrTable(t, _impl->_slider, 1, row, 1, 1, true); _impl->_slider->setColors(SP_RGBA32_F_COMPOSE(1.0, 1.0, 1.0, 0.0), SP_RGBA32_F_COMPOSE(1.0, 1.0, 1.0, 0.5), SP_RGBA32_F_COMPOSE(1.0, 1.0, 1.0, 1.0)); // Spinbutton - _impl->_sbtn = gtk_spin_button_new(_impl->_adj->gobj(), 1.0, 0); - gtk_widget_set_tooltip_text(_impl->_sbtn, _("Alpha (opacity)")); - sp_dialog_defocus_on_enter(_impl->_sbtn); - gtk_label_set_mnemonic_widget(GTK_LABEL(_impl->_label), _impl->_sbtn); - gtk_widget_show(_impl->_sbtn); + _impl->_sbtn = Gtk::make_managed(_impl->_adj, 1.0, 0); + _impl->_sbtn->set_tooltip_text(_("Alpha (opacity)")); + sp_dialog_defocus_on_enter(GTK_WIDGET(_impl->_sbtn->gobj())); + _impl->_label->set_mnemonic_widget(*_impl->_sbtn); + _impl->_sbtn->show(); attachToGridOrTable(t, _impl->_sbtn, 2, row, 1, 1, false, true); @@ -513,28 +516,20 @@ void ColorICCSelector::init() gtk_widget_show(t); } -void ColorICCSelectorImpl::_fixupHit(GtkWidget * /*src*/, gpointer data) +void ColorICCSelectorImpl::_fixupHit() { - ColorICCSelectorImpl *self = reinterpret_cast(data); - gtk_widget_set_sensitive(self->_fixupBtn, FALSE); - self->_adjustmentChanged(self->_compUI[0]._adj); + _fixupBtn->set_sensitive(false); + _adjustmentChanged(_compUI[0]._adj); } #if defined(HAVE_LIBLCMS2) -void ColorICCSelectorImpl::_profileSelected(GtkWidget * /*src*/, gpointer data) +void ColorICCSelectorImpl::_profileSelected() { - ColorICCSelectorImpl *self = reinterpret_cast(data); - - GtkTreeIter iter; - if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(self->_profileSel), &iter)) { - GtkTreeModel *store = gtk_combo_box_get_model(GTK_COMBO_BOX(self->_profileSel)); - gchar *name = nullptr; - - gtk_tree_model_get(store, &iter, 1, &name, -1); - self->_switchToProfile(name); - gtk_widget_set_tooltip_text(self->_profileSel, name); - - g_free(name); + auto iter = _profileSel->get_active(); + if (iter) { + Glib::ustring name = (*iter)[_profile_cols._col_name]; + _switchToProfile(name.c_str()); + _profileSel->set_tooltip_text(name); } } #endif // defined(HAVE_LIBLCMS2) @@ -617,7 +612,7 @@ void ColorICCSelectorImpl::_switchToProfile(gchar const *name) delete tmp.icc; tmp.icc = nullptr; dirty = true; - _fixupHit(nullptr, this); + _fixupHit(); } else { #ifdef DEBUG_LCMS @@ -661,18 +656,15 @@ struct static_caster { To * operator () (From * value) const { return static_cas void ColorICCSelectorImpl::_profilesChanged(std::string const &name) { - GtkComboBox *combo = GTK_COMBO_BOX(_profileSel); - - g_signal_handler_block(G_OBJECT(_profileSel), _profChangedID); + _profChangedID.block(); - GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(combo)); - gtk_list_store_clear(store); + _profile_store->clear(); - GtkTreeIter iter; - gtk_list_store_append(store, &iter); - gtk_list_store_set(store, &iter, 0, _(""), 1, _(""), -1); + auto iter = _profile_store->append(); + (*iter)[_profile_cols._col_label] = _(""); + (*iter)[_profile_cols._col_name] = _(""); - gtk_combo_box_set_active(combo, 0); + _profileSel->set_active(0); int index = 1; std::vector current = SP_ACTIVE_DOCUMENT->getResourceList("iccprofile"); @@ -686,18 +678,19 @@ void ColorICCSelectorImpl::_profilesChanged(std::string const &name) for (auto &it: _current) { Inkscape::ColorProfile *prof = it; - gtk_list_store_append(store, &iter); - gtk_list_store_set(store, &iter, 0, ink_ellipsize_text(prof->name, 25).c_str(), 1, prof->name, -1); + iter = _profile_store->append(); + (*iter)[_profile_cols._col_label] = ink_ellipsize_text(prof->name, 25); + (*iter)[_profile_cols._col_name] = prof->name; if (name == prof->name) { - gtk_combo_box_set_active(combo, index); - gtk_widget_set_tooltip_text(_profileSel, prof->name); + _profileSel->set_active(index); + _profileSel->set_tooltip_text(prof->name); } index++; } - g_signal_handler_unblock(G_OBJECT(_profileSel), _profChangedID); + _profChangedID.unblock(); } #else void ColorICCSelectorImpl::_profilesChanged(std::string const & /*name*/) {} @@ -732,7 +725,7 @@ void ColorICCSelector::_colorChanged() #if defined(HAVE_LIBLCMS2) _impl->_setProfile(_impl->_color.color().icc); _impl->_fixupNeeded = 0; - gtk_widget_set_sensitive(_impl->_fixupBtn, FALSE); + _impl->_fixupBtn->set_sensitive(false); if (_impl->_prof) { if (_impl->_prof->getTransfToSRGB8()) { @@ -758,7 +751,7 @@ void ColorICCSelector::_colorChanged() guint32 other = SP_RGBA32_U_COMPOSE(post[0], post[1], post[2], 255); if (other != _impl->_color.color().toRGBA32(255)) { _impl->_fixupNeeded = other; - gtk_widget_set_sensitive(_impl->_fixupBtn, TRUE); + _impl->_fixupBtn->set_sensitive(true); #ifdef DEBUG_LCMS g_message("Color needs to change 0x%06x to 0x%06x", _color.toRGBA32(255) >> 8, other >> 8); #endif // DEBUG_LCMS @@ -797,9 +790,9 @@ void ColorICCSelectorImpl::_setProfile(SVGICCColor *profile) } for (auto & i : _compUI) { - gtk_widget_hide(i._label); + i._label->hide(); i._slider->hide(); - gtk_widget_hide(i._btn); + i._btn->hide(); } if (profile) { @@ -817,11 +810,10 @@ void ColorICCSelectorImpl::_setProfile(SVGICCColor *profile) } for (guint i = 0; i < _profChannelCount; i++) { - gtk_label_set_text_with_mnemonic(GTK_LABEL(_compUI[i]._label), - (i < things.size()) ? things[i].name.c_str() : ""); + _compUI[i]._label->set_text_with_mnemonic((i < things.size()) ? things[i].name.c_str() : ""); _compUI[i]._slider->set_tooltip_text((i < things.size()) ? things[i].tip.c_str() : ""); - gtk_widget_set_tooltip_text(_compUI[i]._btn, (i < things.size()) ? things[i].tip.c_str() : ""); + _compUI[i]._btn->set_tooltip_text((i < things.size()) ? things[i].tip.c_str() : ""); _compUI[i]._slider->setColors(SPColor(0.0, 0.0, 0.0).toRGBA32(0xff), SPColor(0.5, 0.5, 0.5).toRGBA32(0xff), @@ -834,20 +826,19 @@ void ColorICCSelectorImpl::_setProfile(SVGICCColor *profile) sp_color_slider_set_adjustment( SP_COLOR_SLIDER(_compUI[i]._slider), _compUI[i]._adj ); - gtk_spin_button_set_adjustment( GTK_SPIN_BUTTON(_compUI[i]._btn), - _compUI[i]._adj ); - gtk_spin_button_set_digits( GTK_SPIN_BUTTON(_compUI[i]._btn), digits ); + _compUI[i]._btn->set_adjustment(_compUI[i]._adj); + _compUI[i]._btn->set_digits(digits); */ - gtk_widget_show(_compUI[i]._label); + _compUI[i]._label->show(); _compUI[i]._slider->show(); - gtk_widget_show(_compUI[i]._btn); + _compUI[i]._btn->show(); // gtk_adjustment_set_value( _compUI[i]._adj, 0.0 ); // gtk_adjustment_set_value( _compUI[i]._adj, val ); } for (size_t i = _profChannelCount; i < _compUI.size(); i++) { - gtk_widget_hide(_compUI[i]._label); + _compUI[i]._label->hide(); _compUI[i]._slider->hide(); - gtk_widget_hide(_compUI[i]._btn); + _compUI[i]._btn->hide(); } } } -- GitLab From 083106eb3b75d08c586c62aa14cb2fd47d5d9681 Mon Sep 17 00:00:00 2001 From: Alex Valavanis Date: Mon, 22 Jun 2020 12:47:44 +0100 Subject: [PATCH 07/10] ColorICCSelector: Gtkmmify --- src/ui/widget/color-icc-selector.cpp | 82 +++++++++++----------------- src/ui/widget/color-icc-selector.h | 17 +++++- 2 files changed, 46 insertions(+), 53 deletions(-) diff --git a/src/ui/widget/color-icc-selector.cpp b/src/ui/widget/color-icc-selector.cpp index 14cc430575..c5a2611342 100644 --- a/src/ui/widget/color-icc-selector.cpp +++ b/src/ui/widget/color-icc-selector.cpp @@ -68,10 +68,6 @@ extern guint update_in_progress; } #endif // DEBUG_LCMS - -#define XPAD 4 -#define YPAD 1 - namespace { size_t maxColorspaceComponentCount = 0; @@ -85,28 +81,6 @@ std::set knownColorspaces; #endif -/** - * Helper function to handle GTK2/GTK3 attachment #ifdef code. - */ -void attachToGridOrTable(GtkWidget *parent, Gtk::Widget *child, guint left, guint top, guint width, guint height, - bool hexpand = false, bool centered = false, guint xpadding = XPAD, guint ypadding = YPAD) -{ - child->set_margin_start( xpadding); - child->set_margin_end( xpadding); - child->set_margin_top( ypadding); - child->set_margin_bottom(ypadding); - - if (hexpand) { - child->set_hexpand(true); - } - - if (centered) { - child->set_halign(Gtk::ALIGN_CENTER); - child->set_valign(Gtk::ALIGN_CENTER); - } - - gtk_grid_attach(GTK_GRID(parent), child->gobj(), left, top, width, height); -} } // namespace @@ -347,6 +321,29 @@ ColorICCSelectorImpl::ColorICCSelectorImpl(ColorICCSelector *owner, SelectedColo { } +/** + * Helper function to handle attachment of child widget to the grid. + */ +void ColorICCSelector::attachToGrid(Gtk::Widget *child, guint left, guint top, guint width, guint height, + bool hexpand, bool centered, guint xpadding, guint ypadding) +{ + child->set_margin_start( xpadding); + child->set_margin_end( xpadding); + child->set_margin_top( ypadding); + child->set_margin_bottom(ypadding); + + if (hexpand) { + child->set_hexpand(true); + } + + if (centered) { + child->set_halign(Gtk::ALIGN_CENTER); + child->set_valign(Gtk::ALIGN_CENTER); + } + + attach(*child, left, top, width, height); +} + void ColorICCSelector::init() { gint row = 0; @@ -354,8 +351,6 @@ void ColorICCSelector::init() _impl->_updating = FALSE; _impl->_dragging = FALSE; - GtkWidget *t = GTK_WIDGET(gobj()); - _impl->_compUI.clear(); // Create components @@ -368,7 +363,7 @@ void ColorICCSelector::init() _impl->_fixupBtn->set_tooltip_text(_("Fix RGB fallback to match icc-color() value.")); _impl->_fixupBtn->show(); - attachToGridOrTable(t, _impl->_fixupBtn, 0, row, 1, 1); + attachToGrid(_impl->_fixupBtn, 0, row, 1, 1); // Combobox and store with 2 columns : label (0) and full name (1) _impl->_profile_store = Gtk::ListStore::create(_impl->_profile_cols); @@ -386,7 +381,7 @@ void ColorICCSelector::init() _impl->_profileSel->show(); _impl->_profileSel->set_active(0); - attachToGridOrTable(t, _impl->_profileSel, 1, row, 1, 1); + attachToGrid(_impl->_profileSel, 1, row, 1, 1); #if defined(HAVE_LIBLCMS2) _impl->_profChangedID = _impl->_profileSel->signal_changed().connect(sigc::mem_fun(*_impl, &ColorICCSelectorImpl::_profileSelected)); @@ -424,7 +419,7 @@ void ColorICCSelector::init() _impl->_compUI[i]._label->show(); _impl->_compUI[i]._label->set_no_show_all(true); - attachToGridOrTable(t, _impl->_compUI[i]._label, 0, row, 1, 1); + attachToGrid(_impl->_compUI[i]._label, 0, row, 1, 1); // Adjustment guint scaleValue = _impl->_compUI[i]._component.scale; @@ -444,7 +439,7 @@ void ColorICCSelector::init() _impl->_compUI[i]._slider->show(); _impl->_compUI[i]._slider->set_no_show_all(); - attachToGridOrTable(t, _impl->_compUI[i]._slider, 1, row, 1, 1, true); + attachToGrid(_impl->_compUI[i]._slider, 1, row, 1, 1, true); _impl->_compUI[i]._btn = Gtk::make_managed(_impl->_compUI[i]._adj, step, digits); #if defined(HAVE_LIBLCMS2) @@ -457,7 +452,7 @@ void ColorICCSelector::init() _impl->_compUI[i]._btn->show(); _impl->_compUI[i]._btn->set_no_show_all(true); - attachToGridOrTable(t, _impl->_compUI[i]._btn, 2, row, 1, 1, false, true); + attachToGrid(_impl->_compUI[i]._btn, 2, row, 1, 1, false, true); _impl->_compUI[i]._map = g_new(guchar, 4 * 1024); memset(_impl->_compUI[i]._map, 0x0ff, 1024 * 4); @@ -481,7 +476,7 @@ void ColorICCSelector::init() _impl->_label->set_halign(Gtk::ALIGN_END); _impl->_label->show(); - attachToGridOrTable(t, _impl->_label, 0, row, 1, 1); + attachToGrid(_impl->_label, 0, row, 1, 1); // Adjustment _impl->_adj = Gtk::Adjustment::create(0.0, 0.0, 100.0, 1.0, 10.0, 10.0); @@ -491,7 +486,7 @@ void ColorICCSelector::init() _impl->_slider->set_tooltip_text(_("Alpha (opacity)")); _impl->_slider->show(); - attachToGridOrTable(t, _impl->_slider, 1, row, 1, 1, true); + attachToGrid(_impl->_slider, 1, row, 1, 1, true); _impl->_slider->setColors(SP_RGBA32_F_COMPOSE(1.0, 1.0, 1.0, 0.0), SP_RGBA32_F_COMPOSE(1.0, 1.0, 1.0, 0.5), SP_RGBA32_F_COMPOSE(1.0, 1.0, 1.0, 1.0)); @@ -504,7 +499,7 @@ void ColorICCSelector::init() _impl->_label->set_mnemonic_widget(*_impl->_sbtn); _impl->_sbtn->show(); - attachToGridOrTable(t, _impl->_sbtn, 2, row, 1, 1, false, true); + attachToGrid(_impl->_sbtn, 2, row, 1, 1, false, true); // Signals _impl->_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_adjustmentChanged), _impl->_adj)); @@ -513,7 +508,7 @@ void ColorICCSelector::init() _impl->_slider->signal_released.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderReleased)); _impl->_slider->signal_value_changed.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderChanged)); - gtk_widget_show(t); + show(); } void ColorICCSelectorImpl::_fixupHit() @@ -818,22 +813,9 @@ void ColorICCSelectorImpl::_setProfile(SVGICCColor *profile) _compUI[i]._slider->setColors(SPColor(0.0, 0.0, 0.0).toRGBA32(0xff), SPColor(0.5, 0.5, 0.5).toRGBA32(0xff), SPColor(1.0, 1.0, 1.0).toRGBA32(0xff)); - /* - _compUI[i]._adj = GTK_ADJUSTMENT( gtk_adjustment_new( val, 0.0, _fooScales[i], - step, page, page ) ); - g_signal_connect( G_OBJECT( _compUI[i]._adj ), "value_changed", G_CALLBACK( - _adjustmentChanged ), _csel ); - - sp_color_slider_set_adjustment( SP_COLOR_SLIDER(_compUI[i]._slider), - _compUI[i]._adj ); - _compUI[i]._btn->set_adjustment(_compUI[i]._adj); - _compUI[i]._btn->set_digits(digits); - */ _compUI[i]._label->show(); _compUI[i]._slider->show(); _compUI[i]._btn->show(); - // gtk_adjustment_set_value( _compUI[i]._adj, 0.0 ); - // gtk_adjustment_set_value( _compUI[i]._adj, val ); } for (size_t i = _profChannelCount; i < _compUI.size(); i++) { _compUI[i]._label->hide(); diff --git a/src/ui/widget/color-icc-selector.h b/src/ui/widget/color-icc-selector.h index 2c5ec419b4..cec7aa957a 100644 --- a/src/ui/widget/color-icc-selector.h +++ b/src/ui/widget/color-icc-selector.h @@ -24,9 +24,7 @@ namespace Widget { class ColorICCSelectorImpl; -class ColorICCSelector - : public Gtk::Grid - { +class ColorICCSelector : public Gtk::Grid { public: static const gchar *MODE_NAME; @@ -49,6 +47,19 @@ class ColorICCSelector ColorICCSelector(const ColorICCSelector &obj); ColorICCSelector &operator=(const ColorICCSelector &obj); + static const guint XPAD = 4; + static const guint YPAD = 4; + + void attachToGrid(Gtk::Widget *child, + guint left, + guint top, + guint width, + guint height, + bool hexpand = false, + bool centered = false, + guint xpadding = XPAD, + guint ypadding = YPAD); + ColorICCSelectorImpl *_impl; }; -- GitLab From 0dd5dd30c392f25d5c60d8d6a52fe8f24202d25e Mon Sep 17 00:00:00 2001 From: Alex Valavanis Date: Mon, 22 Jun 2020 19:24:22 +0100 Subject: [PATCH 08/10] SelectedStyle: Gtkmmify --- src/ui/widget/selected-style.cpp | 105 ++++++++++++------------------- src/ui/widget/selected-style.h | 21 ++++--- 2 files changed, 53 insertions(+), 73 deletions(-) diff --git a/src/ui/widget/selected-style.cpp b/src/ui/widget/selected-style.cpp index 33326a4da3..a1739f4d65 100644 --- a/src/ui/widget/selected-style.cpp +++ b/src/ui/widget/selected-style.cpp @@ -14,6 +14,7 @@ #include +#include #include @@ -96,29 +97,11 @@ namespace Inkscape { namespace UI { namespace Widget { - struct DropTracker { SelectedStyle* parent; int item; }; -/* Drag and Drop */ -enum ui_drop_target_info { - APP_OSWB_COLOR -}; - -//TODO: warning: deprecated conversion from string constant to ‘gchar*’ -// -//Turn out to be warnings that we should probably leave in place. The -// pointers/types used need to be read-only. So until we correct the using -// code, those warnings are actually desired. They say "Hey! Fix this". We -// definitely don't want to hide/ignore them. --JonCruz -static const GtkTargetEntry ui_drop_target_entries [] = { - {g_strdup("application/x-oswb-color"), 0, APP_OSWB_COLOR} -}; - -static guint nui_drop_target_entries = G_N_ELEMENTS(ui_drop_target_entries); - /* convenience function */ static Dialog::FillAndStroke *get_fill_and_stroke_panel(SPDesktop *desktop); @@ -148,6 +131,8 @@ SelectedStyle::SelectedStyle(bool /*layout*/) _drop[0] = _drop[1] = nullptr; _dropEnabled[0] = _dropEnabled[1] = false; + ui_drop_target_entries.push_back(Gtk::TargetEntry("application/x-oswb-color")); + _fill_label.set_halign(Gtk::ALIGN_START); _fill_label.set_valign(Gtk::ALIGN_CENTER); _fill_label.set_margin_top(0); @@ -397,15 +382,8 @@ SelectedStyle::SelectedStyle(bool /*layout*/) ((DropTracker*)_drop[SS_STROKE])->parent = this; ((DropTracker*)_drop[SS_STROKE])->item = SS_STROKE; - g_signal_connect(_stroke_place.gobj(), - "drag_data_received", - G_CALLBACK(dragDataReceived), - _drop[SS_STROKE]); - - g_signal_connect(_fill_place.gobj(), - "drag_data_received", - G_CALLBACK(dragDataReceived), - _drop[SS_FILL]); + _stroke_place.signal_drag_data_received().connect(sigc::bind(sigc::mem_fun(this, &SelectedStyle::dragDataReceived), _drop[SS_STROKE])); + _fill_place.signal_drag_data_received().connect(sigc::bind(sigc::mem_fun(*this, &SelectedStyle::dragDataReceived), _drop[SS_FILL])); _fill_place.signal_button_release_event().connect(sigc::mem_fun(*this, &SelectedStyle::on_fill_click)); _stroke_place.signal_button_release_event().connect(sigc::mem_fun(*this, &SelectedStyle::on_stroke_click)); @@ -471,25 +449,22 @@ SelectedStyle::setDesktop(SPDesktop *desktop) } } -void SelectedStyle::dragDataReceived( GtkWidget */*widget*/, - GdkDragContext */*drag_context*/, - gint /*x*/, gint /*y*/, - GtkSelectionData *data, - guint /*info*/, - guint /*event_time*/, - gpointer user_data ) +void SelectedStyle::dragDataReceived(const Glib::RefPtr & /*drag_context*/, + int /*x*/, int /*y*/, + const Gtk::SelectionData &data, + guint /*info*/, + guint /*event_time*/, + DropTracker *tracker) { - DropTracker* tracker = (DropTracker*)user_data; - // copied from drag-and-drop.cpp, case APP_OSWB_COLOR bool worked = false; Glib::ustring colorspec; - if (gtk_selection_data_get_format(data) == 8) { + if (data.get_format() == 8) { ege::PaintDef color; worked = color.fromMIMEData("application/x-oswb-color", - reinterpret_cast(gtk_selection_data_get_data(data)), - gtk_selection_data_get_length(data), - gtk_selection_data_get_format(data)); + reinterpret_cast(data.get_data()), + data.get_length(), + data.get_format()); if (worked) { if (color.getType() == ege::PaintDef::CLEAR) { colorspec = ""; // TODO check if this is sufficient @@ -922,7 +897,11 @@ SelectedStyle::update() place->set_tooltip_text(__na[i]); _mode[i] = SS_NA; if ( _dropEnabled[i] ) { - gtk_drag_dest_unset( GTK_WIDGET((i==SS_FILL) ? _fill_place.gobj():_stroke_place.gobj()) ); + if (i == SS_FILL) { + _fill_place.drag_dest_unset(); + } else { + _stroke_place.drag_dest_unset(); + } _dropEnabled[i] = false; } break; @@ -930,11 +909,15 @@ SelectedStyle::update() case QUERY_STYLE_MULTIPLE_AVERAGED: case QUERY_STYLE_MULTIPLE_SAME: if ( !_dropEnabled[i] ) { - gtk_drag_dest_set( GTK_WIDGET( (i==SS_FILL) ? _fill_place.gobj():_stroke_place.gobj()), - GTK_DEST_DEFAULT_ALL, - ui_drop_target_entries, - nui_drop_target_entries, - GdkDragAction(GDK_ACTION_COPY | GDK_ACTION_MOVE) ); + if (i == SS_FILL) { + _fill_place.drag_dest_set(ui_drop_target_entries, + Gtk::DEST_DEFAULT_ALL, + Gdk::ACTION_COPY | Gdk::ACTION_MOVE); + } else { + _stroke_place.drag_dest_set(ui_drop_target_entries, + Gtk::DEST_DEFAULT_ALL, + Gdk::ACTION_COPY | Gdk::ACTION_MOVE); + } _dropEnabled[i] = true; } SPIPaint *paint; @@ -1256,25 +1239,23 @@ RotateableSwatch::do_motion(double by, guint modifier) { return; if (!scrolling && !cr_set) { - GtkWidget *w = GTK_WIDGET(gobj()); - GdkPixbuf *pixbuf = nullptr; + Glib::RefPtr pixbuf = Glib::RefPtr(); if (modifier == 2) { // saturation - pixbuf = gdk_pixbuf_new_from_xpm_data((const gchar **)cursor_adj_s_xpm); + pixbuf = Gdk::Pixbuf::create_from_xpm_data((const gchar **)cursor_adj_s_xpm); } else if (modifier == 1) { // lightness - pixbuf = gdk_pixbuf_new_from_xpm_data((const gchar **)cursor_adj_l_xpm); + pixbuf = Gdk::Pixbuf::create_from_xpm_data((const gchar **)cursor_adj_l_xpm); } else if (modifier == 3) { // alpha - pixbuf = gdk_pixbuf_new_from_xpm_data((const gchar **)cursor_adj_a_xpm); + pixbuf = Gdk::Pixbuf::create_from_xpm_data((const gchar **)cursor_adj_a_xpm); } else { // hue - pixbuf = gdk_pixbuf_new_from_xpm_data((const gchar **)cursor_adj_h_xpm); + pixbuf = Gdk::Pixbuf::create_from_xpm_data((const gchar **)cursor_adj_h_xpm); } - if (pixbuf != nullptr) { - cr = gdk_cursor_new_from_pixbuf(gdk_display_get_default(), pixbuf, 16, 16); - g_object_unref(pixbuf); - gdk_window_set_cursor(gtk_widget_get_window(w), cr); - g_object_unref(cr); - cr = nullptr; + if (pixbuf) { + auto display = Gdk::Display::get_default(); + cr = Gdk::Cursor::create(display, pixbuf, 16, 16); + auto window = get_window(); + window->set_cursor(cr); cr_set = true; } } @@ -1334,12 +1315,8 @@ RotateableSwatch::do_release(double by, guint modifier) { color_adjust(hsla, by, startcolor, modifier); if (cr_set) { - GtkWidget *w = GTK_WIDGET(gobj()); - gdk_window_set_cursor(gtk_widget_get_window(w), nullptr); - if (cr) { - g_object_unref(cr); - cr = nullptr; - } + auto window = get_window(); + window->set_cursor(); cr_set = false; } diff --git a/src/ui/widget/selected-style.h b/src/ui/widget/selected-style.h index 52674a9c13..026452e84e 100644 --- a/src/ui/widget/selected-style.h +++ b/src/ui/widget/selected-style.h @@ -61,6 +61,8 @@ enum { SS_STROKE }; +struct DropTracker; + class GradientImage; class SelectedStyle; @@ -85,7 +87,7 @@ private: gchar const *undokey; - GdkCursor *cr; + Glib::RefPtr cr; bool cr_set; }; @@ -207,13 +209,14 @@ protected: sigc::connection *selection_modified_connection; sigc::connection *subselection_changed_connection; - static void dragDataReceived( GtkWidget *widget, - GdkDragContext *drag_context, - gint x, gint y, - GtkSelectionData *data, - guint info, - guint event_time, - gpointer user_data ); + std::vector ui_drop_target_entries; + + void dragDataReceived(const Glib::RefPtr &drag_context, + int x, int y, + const Gtk::SelectionData &data, + guint info, + guint event_time, + DropTracker *tracker); bool on_fill_click(GdkEventButton *event); bool on_stroke_click(GdkEventButton *event); @@ -274,7 +277,7 @@ protected: void on_popup_preset(int i); Gtk::MenuItem _popup_sw_remove; - void *_drop[2]; + DropTracker *_drop[2]; bool _dropEnabled[2]; }; -- GitLab From d80d77c1a0b3c8e6d43d364ec01104552d057c80 Mon Sep 17 00:00:00 2001 From: Alex Valavanis Date: Tue, 23 Jun 2020 19:09:40 +0100 Subject: [PATCH 09/10] UnitTracker: Gtkmmify --- src/ui/toolbar/arc-toolbar.cpp | 5 ++-- src/ui/toolbar/node-toolbar.cpp | 4 +-- src/ui/toolbar/paintbucket-toolbar.cpp | 2 +- src/ui/toolbar/rect-toolbar.cpp | 8 +++--- src/ui/toolbar/select-toolbar.cpp | 16 +++++------ src/ui/widget/unit-tracker.cpp | 37 +++++--------------------- src/ui/widget/unit-tracker.h | 18 +++++-------- 7 files changed, 31 insertions(+), 59 deletions(-) diff --git a/src/ui/toolbar/arc-toolbar.cpp b/src/ui/toolbar/arc-toolbar.cpp index 4fadbb9e74..7e680b6d99 100644 --- a/src/ui/toolbar/arc-toolbar.cpp +++ b/src/ui/toolbar/arc-toolbar.cpp @@ -95,7 +95,7 @@ ArcToolbar::ArcToolbar(SPDesktop *desktop) : _rx_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("arc-rx", _("Rx:"), _rx_adj)); _rx_item->set_tooltip_text(_("Horizontal radius of the circle, ellipse, or arc")); _rx_item->set_custom_numeric_menu_data(values); - _tracker->addAdjustment(_rx_adj->gobj()); + _tracker->addAdjustment(_rx_adj); _rx_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); _rx_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*this, &ArcToolbar::value_changed), _rx_adj, "rx")); @@ -111,7 +111,7 @@ ArcToolbar::ArcToolbar(SPDesktop *desktop) : _ry_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("arc-ry", _("Ry:"), _ry_adj)); _ry_item->set_tooltip_text(_("Vertical radius of the circle, ellipse, or arc")); _ry_item->set_custom_numeric_menu_data(values); - _tracker->addAdjustment(_ry_adj->gobj()); + _tracker->addAdjustment(_ry_adj); _ry_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); _ry_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*this, &ArcToolbar::value_changed), _ry_adj, "ry")); @@ -242,7 +242,6 @@ ArcToolbar::value_changed(Glib::RefPtr& adj, g_return_if_fail(unit != nullptr); SPDocument* document = _desktop->getDocument(); - Geom::Scale scale = document->getDocumentScale(); if (DocumentUndo::getUndoSensitive(document)) { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); diff --git a/src/ui/toolbar/node-toolbar.cpp b/src/ui/toolbar/node-toolbar.cpp index 9aa83286a2..58defa9767 100644 --- a/src/ui/toolbar/node-toolbar.cpp +++ b/src/ui/toolbar/node-toolbar.cpp @@ -262,7 +262,7 @@ NodeToolbar::NodeToolbar(SPDesktop *desktop) _nodes_x_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("node-x", _("X:"), _nodes_x_adj)); _nodes_x_item->set_tooltip_text(_("X coordinate of selected node(s)")); _nodes_x_item->set_custom_numeric_menu_data(values); - _tracker->addAdjustment(_nodes_x_adj->gobj()); + _tracker->addAdjustment(_nodes_x_adj); _nodes_x_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); _nodes_x_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*this, &NodeToolbar::value_changed), Geom::X)); _nodes_x_item->set_sensitive(false); @@ -277,7 +277,7 @@ NodeToolbar::NodeToolbar(SPDesktop *desktop) _nodes_y_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("node-y", _("Y:"), _nodes_y_adj)); _nodes_y_item->set_tooltip_text(_("Y coordinate of selected node(s)")); _nodes_y_item->set_custom_numeric_menu_data(values); - _tracker->addAdjustment(_nodes_y_adj->gobj()); + _tracker->addAdjustment(_nodes_y_adj); _nodes_y_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); _nodes_y_adj->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*this, &NodeToolbar::value_changed), Geom::Y)); _nodes_y_item->set_sensitive(false); diff --git a/src/ui/toolbar/paintbucket-toolbar.cpp b/src/ui/toolbar/paintbucket-toolbar.cpp index 151171ff5e..23ad0bfa9a 100644 --- a/src/ui/toolbar/paintbucket-toolbar.cpp +++ b/src/ui/toolbar/paintbucket-toolbar.cpp @@ -103,7 +103,7 @@ PaintbucketToolbar::PaintbucketToolbar(SPDesktop *desktop) _offset_adj = Gtk::Adjustment::create(offset_val, -1e4, 1e4, 0.1, 0.5); auto offset_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("inkscape:paintbucket-offset", _("Grow/shrink by:"), _offset_adj, 1, 2)); offset_item->set_tooltip_text(_("The amount to grow (positive) or shrink (negative) the created fill path")); - _tracker->addAdjustment(_offset_adj->gobj()); + _tracker->addAdjustment(_offset_adj); offset_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); _offset_adj->signal_value_changed().connect(sigc::mem_fun(*this, &PaintbucketToolbar::offset_changed)); add(*offset_item); diff --git a/src/ui/toolbar/rect-toolbar.cpp b/src/ui/toolbar/rect-toolbar.cpp index 0a612c348c..c4ca002ab8 100644 --- a/src/ui/toolbar/rect-toolbar.cpp +++ b/src/ui/toolbar/rect-toolbar.cpp @@ -99,7 +99,7 @@ RectToolbar::RectToolbar(SPDesktop *desktop) _width_adj, "width", &SPRect::setVisibleWidth)); - _tracker->addAdjustment(_width_adj->gobj()); + _tracker->addAdjustment(_width_adj); _width_item->set_sensitive(false); std::vector values = {1, 2, 3, 5, 10, 20, 50, 100, 200, 500}; @@ -115,7 +115,7 @@ RectToolbar::RectToolbar(SPDesktop *desktop) _height_adj, "height", &SPRect::setVisibleHeight)); - _tracker->addAdjustment(_height_adj->gobj()); + _tracker->addAdjustment(_height_adj); std::vector values = { 1, 2, 3, 5, 10, 20, 50, 100, 200, 500}; _height_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("rect-height", _("H:"), _height_adj)); @@ -135,7 +135,7 @@ RectToolbar::RectToolbar(SPDesktop *desktop) _rx_adj, "rx", &SPRect::setVisibleRx)); - _tracker->addAdjustment(_rx_adj->gobj()); + _tracker->addAdjustment(_rx_adj); _rx_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("rect-rx", _("Rx:"), _rx_adj)); _rx_item->set_all_tooltip_text(_("Horizontal radius of rounded corners")); _rx_item->set_focus_widget(Glib::wrap(GTK_WIDGET(_desktop->canvas))); @@ -152,7 +152,7 @@ RectToolbar::RectToolbar(SPDesktop *desktop) _ry_adj, "ry", &SPRect::setVisibleRy)); - _tracker->addAdjustment(_ry_adj->gobj()); + _tracker->addAdjustment(_ry_adj); _ry_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("rect-ry", _("Ry:"), _ry_adj)); _ry_item->set_all_tooltip_text(_("Vertical radius of rounded corners")); _ry_item->set_focus_widget(Glib::wrap(GTK_WIDGET(_desktop->canvas))); diff --git a/src/ui/toolbar/select-toolbar.cpp b/src/ui/toolbar/select-toolbar.cpp index 6bdea6b6d5..55ee8209ba 100644 --- a/src/ui/toolbar/select-toolbar.cpp +++ b/src/ui/toolbar/select-toolbar.cpp @@ -106,7 +106,7 @@ SelectToolbar::SelectToolbar(SPDesktop *desktop) : auto x_val = prefs->getDouble("/tools/select/X", 0.0); _adj_x = Gtk::Adjustment::create(x_val, -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP); _adj_x->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*this, &SelectToolbar::any_value_changed), _adj_x)); - _tracker->addAdjustment(_adj_x->gobj()); + _tracker->addAdjustment(_adj_x); auto x_btn = Gtk::manage(new UI::Widget::SpinButtonToolItem("select-x", C_("Select toolbar", "X:"), @@ -121,7 +121,7 @@ SelectToolbar::SelectToolbar(SPDesktop *desktop) : auto y_val = prefs->getDouble("/tools/select/Y", 0.0); _adj_y = Gtk::Adjustment::create(y_val, -1e6, 1e6, SPIN_STEP, SPIN_PAGE_STEP); _adj_y->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*this, &SelectToolbar::any_value_changed), _adj_y)); - _tracker->addAdjustment(_adj_y->gobj()); + _tracker->addAdjustment(_adj_y); auto y_btn = Gtk::manage(new UI::Widget::SpinButtonToolItem("select-y", C_("Select toolbar", "Y:"), @@ -136,7 +136,7 @@ SelectToolbar::SelectToolbar(SPDesktop *desktop) : auto w_val = prefs->getDouble("/tools/select/width", 0.0); _adj_w = Gtk::Adjustment::create(w_val, 0.0, 1e6, SPIN_STEP, SPIN_PAGE_STEP); _adj_w->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*this, &SelectToolbar::any_value_changed), _adj_w)); - _tracker->addAdjustment(_adj_w->gobj()); + _tracker->addAdjustment(_adj_w); auto w_btn = Gtk::manage(new UI::Widget::SpinButtonToolItem("select-width", C_("Select toolbar", "W:"), @@ -158,7 +158,7 @@ SelectToolbar::SelectToolbar(SPDesktop *desktop) : auto h_val = prefs->getDouble("/tools/select/height", 0.0); _adj_h = Gtk::Adjustment::create(h_val, 0.0, 1e6, SPIN_STEP, SPIN_PAGE_STEP); _adj_h->signal_value_changed().connect(sigc::bind(sigc::mem_fun(*this, &SelectToolbar::any_value_changed), _adj_h)); - _tracker->addAdjustment(_adj_h->gobj()); + _tracker->addAdjustment(_adj_h); auto h_btn = Gtk::manage(new UI::Widget::SpinButtonToolItem("select-height", C_("Select toolbar", "H:"), @@ -400,10 +400,10 @@ SelectToolbar::layout_widget_update(Inkscape::Selection *sel) _adj_y->set_value(val); _adj_w->set_value(val); _adj_h->set_value(val); - _tracker->setFullVal( _adj_x->gobj(), keyval[0].val ); - _tracker->setFullVal( _adj_y->gobj(), keyval[1].val ); - _tracker->setFullVal( _adj_w->gobj(), keyval[2].val ); - _tracker->setFullVal( _adj_h->gobj(), keyval[3].val ); + _tracker->setFullVal( _adj_x, keyval[0].val ); + _tracker->setFullVal( _adj_y, keyval[1].val ); + _tracker->setFullVal( _adj_w, keyval[2].val ); + _tracker->setFullVal( _adj_h, keyval[3].val ); } else { _adj_x->set_value(Quantity::convert(keyval[0].val, "px", unit)); _adj_y->set_value(Quantity::convert(keyval[1].val, "px", unit)); diff --git a/src/ui/widget/unit-tracker.cpp b/src/ui/widget/unit-tracker.cpp index 252fd8c862..a315922e6f 100644 --- a/src/ui/widget/unit-tracker.cpp +++ b/src/ui/widget/unit-tracker.cpp @@ -14,10 +14,12 @@ * Released under GNU GPL v2+, read the file 'COPYING' for more information. */ +#include "unit-tracker.h" + #include #include -#include "unit-tracker.h" +#include #include "combo-tool-item.h" @@ -68,11 +70,6 @@ UnitTracker::UnitTracker(UnitType unit_type) : UnitTracker::~UnitTracker() { _combo_list.clear(); - - // Unhook weak references to GtkAdjustments - for (auto i : _adjList) { - g_object_weak_unref(G_OBJECT(i), _adjustmentFinalizedCB, this); - } _adjList.clear(); } @@ -118,10 +115,9 @@ void UnitTracker::setActiveUnitByAbbr(gchar const *abbr) setActiveUnit(u); } -void UnitTracker::addAdjustment(GtkAdjustment *adj) +void UnitTracker::addAdjustment(Glib::RefPtr &adj) { if (std::find(_adjList.begin(),_adjList.end(),adj) == _adjList.end()) { - g_object_weak_ref(G_OBJECT(adj), _adjustmentFinalizedCB, this); _adjList.push_back(adj); } else { std::cerr << "UnitTracker::addAjustment: Adjustment already added!" << std::endl; @@ -158,7 +154,7 @@ void UnitTracker::prependUnit(Inkscape::Util::Unit const *u) } -void UnitTracker::setFullVal(GtkAdjustment *adj, gdouble val) +void UnitTracker::setFullVal(Glib::RefPtr &adj, gdouble val) { _priorValues[adj] = val; } @@ -180,25 +176,6 @@ void UnitTracker::_unitChangedCB(int active) _setActive(active); } -void UnitTracker::_adjustmentFinalizedCB(gpointer data, GObject *where_the_object_was) -{ - if (data && where_the_object_was) { - UnitTracker *self = reinterpret_cast(data); - self->_adjustmentFinalized(where_the_object_was); - } -} - -void UnitTracker::_adjustmentFinalized(GObject *where_the_object_was) -{ - GtkAdjustment* adj = (GtkAdjustment*)(where_the_object_was); - auto it = std::find(_adjList.begin(),_adjList.end(), adj); - if (it != _adjList.end()) { - _adjList.erase(it); - } else { - g_warning("Received a finalization callback for unknown object %p", where_the_object_was); - } -} - void UnitTracker::_setActive(gint active) { if ( active != _active || !_activeUnitInitialized ) { @@ -255,7 +232,7 @@ void UnitTracker::_fixupAdjustments(Inkscape::Util::Unit const *oldUnit, Inkscap { _isUpdating = true; for ( auto adj : _adjList ) { - gdouble oldVal = gtk_adjustment_get_value(adj); + auto oldVal = adj->get_value(); gdouble val = oldVal; if ( (oldUnit->type != Inkscape::Util::UNIT_TYPE_DIMENSIONLESS) @@ -273,7 +250,7 @@ void UnitTracker::_fixupAdjustments(Inkscape::Util::Unit const *oldUnit, Inkscap val = Inkscape::Util::Quantity::convert(oldVal, oldUnit, newUnit); } - gtk_adjustment_set_value(adj, val); + adj->set_value(val); } _isUpdating = false; } diff --git a/src/ui/widget/unit-tracker.h b/src/ui/widget/unit-tracker.h index b85da0623a..19c4cf9c36 100644 --- a/src/ui/widget/unit-tracker.h +++ b/src/ui/widget/unit-tracker.h @@ -26,9 +26,9 @@ using Inkscape::Util::Unit; using Inkscape::Util::UnitType; -typedef struct _GObject GObject; -typedef struct _GtkAdjustment GtkAdjustment; -typedef struct _GtkListStore GtkListStore; +namespace Gtk { +class Adjustment; +} namespace Inkscape { namespace UI { @@ -47,9 +47,9 @@ public: Inkscape::Util::Unit const * getActiveUnit() const; void addUnit(Inkscape::Util::Unit const *u); - void addAdjustment(GtkAdjustment *adj); + void addAdjustment(Glib::RefPtr &adj); void prependUnit(Inkscape::Util::Unit const *u); - void setFullVal(GtkAdjustment *adj, gdouble val); + void setFullVal(Glib::RefPtr &adj, gdouble val); void changeLabel(Glib::ustring new_label, gint pos, bool onlylabel = false); ComboToolItem *create_tool_item(Glib::ustring const &label, @@ -61,14 +61,10 @@ protected: private: // Callbacks void _unitChangedCB(int active); - 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 _adjustmentFinalized(GObject *where_the_object_was); - gint _active; bool _isUpdating; Inkscape::Util::Unit const *_activeUnit; @@ -76,8 +72,8 @@ private: Glib::RefPtr _store; std::vector _combo_list; - std::vector _adjList; - std::map _priorValues; + std::vector> _adjList; + std::map , gdouble> _priorValues; }; } // namespace Widget -- GitLab From 6ff98331a312c719c75bb3d40d697a8e9a89db81 Mon Sep 17 00:00:00 2001 From: Alex Valavanis Date: Tue, 23 Jun 2020 20:00:13 +0100 Subject: [PATCH 10/10] CalligraphyToolbar: Gtkmmify --- src/ui/toolbar/calligraphy-toolbar.cpp | 96 ++++++++++++++------------ src/ui/toolbar/calligraphy-toolbar.h | 2 +- 2 files changed, 52 insertions(+), 46 deletions(-) diff --git a/src/ui/toolbar/calligraphy-toolbar.cpp b/src/ui/toolbar/calligraphy-toolbar.cpp index 6bf51c73a8..0f6b473b70 100644 --- a/src/ui/toolbar/calligraphy-toolbar.cpp +++ b/src/ui/toolbar/calligraphy-toolbar.cpp @@ -92,13 +92,12 @@ CalligraphyToolbar::CalligraphyToolbar(SPDesktop *desktop) std::vector values = { 1, 3, 5, 10, 15, 20, 30, 50, 75, 100}; auto width_val = prefs->getDouble("/tools/calligraphic/width", 15); _width_adj = Gtk::Adjustment::create(width_val, 1, 100, 1.0, 10.0); - auto width_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("calligraphy-width", _("Width:"), _width_adj, 1, 0)); + auto width_item = Gtk::make_managed("calligraphy-width", _("Width:"), _width_adj, 1, 0); width_item->set_tooltip_text(_("The width of the calligraphic pen (relative to the visible canvas area)")); width_item->set_custom_numeric_menu_data(values, labels); width_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); _width_adj->signal_value_changed().connect(sigc::mem_fun(*this, &CalligraphyToolbar::width_value_changed)); - _widget_map["width"] = G_OBJECT(_width_adj->gobj()); - // ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); + _widget_map["width"] = width_item; add(*width_item); width_item->set_sensitive(true); } @@ -108,7 +107,7 @@ CalligraphyToolbar::CalligraphyToolbar(SPDesktop *desktop) _usepressure = add_toggle_button(_("Pressure"), _("Use the pressure of the input device to alter the width of the pen")); _usepressure->set_icon_name(INKSCAPE_ICON("draw-use-pressure")); - _widget_map["usepressure"] = G_OBJECT(_usepressure->gobj()); + _widget_map["usepressure"] = _usepressure; _usepressure_pusher.reset(new SimplePrefPusher(_usepressure, "/tools/calligraphic/usepressure")); _usepressure->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &CalligraphyToolbar::on_pref_toggled), _usepressure, @@ -120,7 +119,7 @@ CalligraphyToolbar::CalligraphyToolbar(SPDesktop *desktop) _tracebackground = add_toggle_button(_("Trace Background"), _("Trace the lightness of the background by the width of the pen (white - minimum width, black - maximum width)")); _tracebackground->set_icon_name(INKSCAPE_ICON("draw-trace-background")); - _widget_map["tracebackground"] = G_OBJECT(_tracebackground->gobj()); + _widget_map["tracebackground"] = _tracebackground; _tracebackground_pusher.reset(new SimplePrefPusher(_tracebackground, "/tools/calligraphic/tracebackground")); _tracebackground->signal_toggled().connect(sigc::bind(sigc::mem_fun(*this, &CalligraphyToolbar::on_pref_toggled), _tracebackground, @@ -133,17 +132,17 @@ CalligraphyToolbar::CalligraphyToolbar(SPDesktop *desktop) std::vector values = { -100, -40, -20, -10, 0, 10, 20, 40, 100}; auto thinning_val = prefs->getDouble("/tools/calligraphic/thinning", 10); _thinning_adj = Gtk::Adjustment::create(thinning_val, -100, 100, 1, 10.0); - auto thinning_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("calligraphy-thinning", _("Thinning:"), _thinning_adj, 1, 0)); + auto thinning_item = Gtk::make_managed("calligraphy-thinning", _("Thinning:"), _thinning_adj, 1, 0); thinning_item->set_tooltip_text(("How much velocity thins the stroke (> 0 makes fast strokes thinner, < 0 makes them broader, 0 makes width independent of velocity)")); thinning_item->set_custom_numeric_menu_data(values, labels); thinning_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); _thinning_adj->signal_value_changed().connect(sigc::mem_fun(*this, &CalligraphyToolbar::velthin_value_changed)); - _widget_map["thinning"] = G_OBJECT(_thinning_adj->gobj()); + _widget_map["thinning"] = thinning_item; add(*thinning_item); thinning_item->set_sensitive(true); } - add(* Gtk::manage(new Gtk::SeparatorToolItem())); + add(* Gtk::make_managed()); { /* Angle */ @@ -151,12 +150,12 @@ CalligraphyToolbar::CalligraphyToolbar(SPDesktop *desktop) std::vector values = { -90, -60, -30, 0, 30, 60, 90}; auto angle_val = prefs->getDouble("/tools/calligraphic/angle", 30); _angle_adj = Gtk::Adjustment::create(angle_val, -90.0, 90.0, 1.0, 10.0); - _angle_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("calligraphy-angle", _("Angle:"), _angle_adj, 1, 0)); + _angle_item = Gtk::make_managed("calligraphy-angle", _("Angle:"), _angle_adj, 1, 0); _angle_item->set_tooltip_text(_("The angle of the pen's nib (in degrees; 0 = horizontal; has no effect if fixation = 0)")); _angle_item->set_custom_numeric_menu_data(values, labels); _angle_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); _angle_adj->signal_value_changed().connect(sigc::mem_fun(*this, &CalligraphyToolbar::angle_value_changed)); - _widget_map["angle"] = G_OBJECT(_angle_adj->gobj()); + _widget_map["angle"] = _angle_item; add(*_angle_item); _angle_item->set_sensitive(true); } @@ -166,7 +165,7 @@ CalligraphyToolbar::CalligraphyToolbar(SPDesktop *desktop) _usetilt = add_toggle_button(_("Tilt"), _("Use the tilt of the input device to alter the angle of the pen's nib")); _usetilt->set_icon_name(INKSCAPE_ICON("draw-use-tilt")); - _widget_map["usetilt"] = G_OBJECT(_usetilt->gobj()); + _widget_map["usetilt"] = _usetilt; _usetilt_pusher.reset(new SimplePrefPusher(_usetilt, "/tools/calligraphic/usetilt")); _usetilt->signal_toggled().connect(sigc::mem_fun(*this, &CalligraphyToolbar::tilt_state_changed)); _angle_item->set_sensitive(!prefs->getBool("/tools/calligraphic/usetilt", true)); @@ -179,17 +178,17 @@ CalligraphyToolbar::CalligraphyToolbar(SPDesktop *desktop) std::vector values = { 0, 20, 40, 60, 90, 100}; auto flatness_val = prefs->getDouble("/tools/calligraphic/flatness", 90); _fixation_adj = Gtk::Adjustment::create(flatness_val, 0.0, 100, 1.0, 10.0); - auto flatness_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("calligraphy-fixation", _("Fixation:"), _fixation_adj, 1, 0)); + auto flatness_item = Gtk::make_managed("calligraphy-fixation", _("Fixation:"), _fixation_adj, 1, 0); flatness_item->set_tooltip_text(_("Angle behavior (0 = nib always perpendicular to stroke direction, 100 = fixed angle)")); flatness_item->set_custom_numeric_menu_data(values, labels); flatness_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); _fixation_adj->signal_value_changed().connect(sigc::mem_fun(*this, &CalligraphyToolbar::flatness_value_changed)); - _widget_map["flatness"] = G_OBJECT(_fixation_adj->gobj()); + _widget_map["flatness"] = flatness_item; add(*flatness_item); flatness_item->set_sensitive(true); } - add(* Gtk::manage(new Gtk::SeparatorToolItem())); + add(* Gtk::make_managed()); { /* Cap Rounding */ @@ -197,19 +196,19 @@ CalligraphyToolbar::CalligraphyToolbar(SPDesktop *desktop) std::vector values = { 0, 0.3, 0.5, 1.0, 1.4, 5.0}; auto cap_rounding_val = prefs->getDouble("/tools/calligraphic/cap_rounding", 0.0); _cap_rounding_adj = Gtk::Adjustment::create(cap_rounding_val, 0.0, 5.0, 0.01, 0.1); - auto cap_rounding_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("calligraphy-cap-rounding", _("Caps:"), _cap_rounding_adj, 0.01, 2)); + auto cap_rounding_item = Gtk::make_managed("calligraphy-cap-rounding", _("Caps:"), _cap_rounding_adj, 0.01, 2); // TRANSLATORS: "cap" means "end" (both start and finish) here cap_rounding_item->set_tooltip_text(_("Increase to make caps at the ends of strokes protrude more (0 = no caps, 1 = round caps)")); cap_rounding_item->set_custom_numeric_menu_data(values, labels); cap_rounding_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); _cap_rounding_adj->signal_value_changed().connect(sigc::mem_fun(*this, &CalligraphyToolbar::cap_rounding_value_changed)); - _widget_map["cap_rounding"] = G_OBJECT(_cap_rounding_adj->gobj()); + _widget_map["cap_rounding"] = cap_rounding_item; add(*cap_rounding_item); cap_rounding_item->set_sensitive(true); } - add(* Gtk::manage(new Gtk::SeparatorToolItem())); + add(* Gtk::make_managed()); { /* Tremor */ @@ -217,12 +216,12 @@ CalligraphyToolbar::CalligraphyToolbar(SPDesktop *desktop) std::vector values = { 0, 10, 20, 40, 60, 100}; auto tremor_val = prefs->getDouble("/tools/calligraphic/tremor", 0.0); _tremor_adj = Gtk::Adjustment::create(tremor_val, 0.0, 100, 1, 10.0); - auto tremor_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("calligraphy-tremor", _("Tremor:"), _tremor_adj, 1, 0)); + auto tremor_item = Gtk::make_managed("calligraphy-tremor", _("Tremor:"), _tremor_adj, 1, 0); tremor_item->set_tooltip_text(_("Increase to make strokes rugged and trembling")); tremor_item->set_custom_numeric_menu_data(values, labels); tremor_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); _tremor_adj->signal_value_changed().connect(sigc::mem_fun(*this, &CalligraphyToolbar::tremor_value_changed)); - _widget_map["tremor"] = G_OBJECT(_tremor_adj->gobj()); + _widget_map["tremor"] = tremor_item; // ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); add(*tremor_item); tremor_item->set_sensitive(true); @@ -234,12 +233,12 @@ CalligraphyToolbar::CalligraphyToolbar(SPDesktop *desktop) std::vector values = { 0, 20, 40, 60, 100}; auto wiggle_val = prefs->getDouble("/tools/calligraphic/wiggle", 0.0); _wiggle_adj = Gtk::Adjustment::create(wiggle_val, 0.0, 100, 1, 10.0); - auto wiggle_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("calligraphy-wiggle", _("Wiggle:"), _wiggle_adj, 1, 0)); + auto wiggle_item = Gtk::make_managed("calligraphy-wiggle", _("Wiggle:"), _wiggle_adj, 1, 0); wiggle_item->set_tooltip_text(_("Increase to make the pen waver and wiggle")); wiggle_item->set_custom_numeric_menu_data(values, labels); wiggle_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); _wiggle_adj->signal_value_changed().connect(sigc::mem_fun(*this, &CalligraphyToolbar::wiggle_value_changed)); - _widget_map["wiggle"] = G_OBJECT(_wiggle_adj->gobj()); + _widget_map["wiggle"] = wiggle_item; // ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); add(*wiggle_item); wiggle_item->set_sensitive(true); @@ -251,12 +250,12 @@ CalligraphyToolbar::CalligraphyToolbar(SPDesktop *desktop) std::vector values = { 0.0, 2, 10, 20, 50, 100}; auto mass_val = prefs->getDouble("/tools/calligraphic/mass", 2.0); _mass_adj = Gtk::Adjustment::create(mass_val, 0.0, 100, 1, 10.0); - auto mass_item = Gtk::manage(new UI::Widget::SpinButtonToolItem("calligraphy-mass", _("Mass:"), _mass_adj, 1, 0)); + auto mass_item = Gtk::make_managed("calligraphy-mass", _("Mass:"), _mass_adj, 1, 0); mass_item->set_tooltip_text(_("Increase to make the pen drag behind, as if slowed by inertia")); mass_item->set_custom_numeric_menu_data(values, labels); mass_item->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas))); _mass_adj->signal_value_changed().connect(sigc::mem_fun(*this, &CalligraphyToolbar::mass_value_changed)); - _widget_map["mass"] = G_OBJECT(_mass_adj->gobj()); + _widget_map["mass"] = mass_item; // ege_adjustment_action_set_appearance( eact, TOOLBAR_SLIDER_HINT ); add(*mass_item); mass_item->set_sensitive(true); @@ -366,21 +365,24 @@ CalligraphyToolbar::update_presets_list() continue; } - void *widget = _widget_map[entry_name.data()]; + auto widget = _widget_map[entry_name.data()]; + if (widget) { - if (GTK_IS_ADJUSTMENT(widget)) { + auto sb = dynamic_cast(widget); + auto tb = dynamic_cast(widget); + + if (sb) { double v = j.getDouble(); - GtkAdjustment* adj = static_cast(widget); - //std::cout << "compared adj " << attr_name << gtk_adjustment_get_value(adj) << " to " << v << "\n"; - if (fabs(gtk_adjustment_get_value(adj) - v) > 1e-6) { + auto adj = sb->get_adjustment(); + //std::cout << "compared adj " << attr_name << adj->get_value() << " to " << v << "\n"; + if (fabs(adj->get_value() - v) > 1e-6) { match = false; break; } - } else if (GTK_IS_TOGGLE_TOOL_BUTTON(widget)) { + } else if (tb) { bool v = j.getBool(); - auto toggle = GTK_TOGGLE_TOOL_BUTTON(widget); - //std::cout << "compared toggle " << attr_name << gtk_toggle_action_get_active(toggle) << " to " << v << "\n"; - if ( static_cast(gtk_toggle_tool_button_get_active(toggle)) != v ) { + //std::cout << "compared toggle " << attr_name << tb->get_active() << " to " << v << "\n"; + if ( static_cast(tb->get_active()) != v ) { match = false; break; } @@ -462,15 +464,18 @@ CalligraphyToolbar::change_profile() if (entry_name == "id" || entry_name == "name") { continue; } - void *widget = _widget_map[entry_name.data()]; + + auto widget = _widget_map[entry_name.data()]; + if (widget) { - if (GTK_IS_ADJUSTMENT(widget)) { - GtkAdjustment* adj = static_cast(widget); - gtk_adjustment_set_value(adj, i.getDouble()); + auto sb = dynamic_cast(widget); + auto tb = dynamic_cast(widget); + if (sb) { + auto adj = sb->get_adjustment(); + adj->set_value(i.getDouble()); //std::cout << "set adj " << attr_name << " to " << v << "\n"; - } else if (GTK_IS_TOGGLE_TOOL_BUTTON(widget)) { - auto toggle = GTK_TOGGLE_TOOL_BUTTON(widget); - gtk_toggle_tool_button_set_active(toggle, i.getBool()); + } else if (tb) { + tb->set_active(i.getBool()); //std::cout << "set toggle " << attr_name << " to " << v << "\n"; } else { g_warning("Unknown widget type for preset: %s\n", entry_name.data()); @@ -560,13 +565,14 @@ CalligraphyToolbar::save_profile(GtkWidget * /*widget*/) auto widget = map_item.second; if (widget) { - if (GTK_IS_ADJUSTMENT(widget)) { - GtkAdjustment* adj = GTK_ADJUSTMENT(widget); - prefs->setDouble(save_path + "/" + widget_name, gtk_adjustment_get_value(adj)); + auto sb = dynamic_cast(widget); + auto tb = dynamic_cast(widget); + if (sb) { + auto adj = sb->get_adjustment(); + prefs->setDouble(save_path + "/" + widget_name, adj->get_value()); //std::cout << "wrote adj " << widget_name << ": " << v << "\n"; - } else if (GTK_IS_TOGGLE_TOOL_BUTTON(widget)) { - auto toggle = GTK_TOGGLE_TOOL_BUTTON(widget); - prefs->setBool(save_path + "/" + widget_name, gtk_toggle_tool_button_get_active(toggle)); + } else if (tb) { + prefs->setBool(save_path + "/" + widget_name, tb->get_active()); //std::cout << "wrote tog " << widget_name << ": " << v << "\n"; } else { g_warning("Unknown widget type for preset: %s\n", widget_name.c_str()); diff --git a/src/ui/toolbar/calligraphy-toolbar.h b/src/ui/toolbar/calligraphy-toolbar.h index d2168888c3..7fc6b20fb0 100644 --- a/src/ui/toolbar/calligraphy-toolbar.h +++ b/src/ui/toolbar/calligraphy-toolbar.h @@ -54,7 +54,7 @@ private: UI::Widget::SpinButtonToolItem *_angle_item; Gtk::ComboBoxText *_profile_selector_combo; - std::map _widget_map; + std::map _widget_map; Glib::RefPtr _width_adj; Glib::RefPtr _mass_adj; -- GitLab